lint

Author: leo-collins

test/test_unique_domain_extractor.py

@@ -1,33 +1,33 @@
+import pytest
 from utils import FiniteElement, LagrangeElement, MixedElement
 
-import pytest
 from ufl import (
+    Action,
+    Adjoint,
     Coefficient,
+    Constant,
+    FacetNormal,
     FunctionSpace,
+    Interpolate,
+    Matrix,
+    Measure,
     Mesh,
     MeshSequence,
     SpatialCoordinate,
-    Measure,
-    Constant,
-    TrialFunction,
     TestFunction,
-    split,
-    triangle,
+    TrialFunction,
     cos,
-    inner,
     div,
-    FacetNormal,
     grad,
-    Action,
-    Matrix,
-    Adjoint,
-    Interpolate
+    inner,
+    split,
+    triangle,
 )
-
 from ufl.domain import extract_unique_domain
 from ufl.pullback import contravariant_piola, identity_pullback
 from ufl.sobolevspace import L2, HDiv
 
+
 def test_extract_unique_domain():
     cell = triangle
     elem0 = LagrangeElement(cell, 1)
@@ -103,57 +103,57 @@ def test_extract_unique_domain_single_mesh():
     """Test domain extraction for standard function spaces on a single mesh."""
     cell = triangle
     mesh = Mesh(LagrangeElement(cell, 1, (2,)), ufl_id=200)
-    
+
     # Test scalar elements
     P1 = LagrangeElement(cell, 1)
     V_scalar = FunctionSpace(mesh, P1)
     u_scalar = TrialFunction(V_scalar)
     f_scalar = Coefficient(V_scalar)
-    
+
     assert extract_unique_domain(u_scalar) == mesh
     assert extract_unique_domain(f_scalar) == mesh
-    
+
     P1_vec = LagrangeElement(cell, 1, (2,))
     V_vector = FunctionSpace(mesh, P1_vec)
     u_vector = TrialFunction(V_vector)
     f_vector = Coefficient(V_vector)
-    
+
     assert extract_unique_domain(u_vector) == mesh
     assert extract_unique_domain(f_vector) == mesh
-    
+
     assert extract_unique_domain(u_vector[0]) == mesh
     assert extract_unique_domain(u_vector[1]) == mesh
     assert extract_unique_domain(f_vector[0]) == mesh
     assert extract_unique_domain(f_vector[1]) == mesh
-    
+
     P1_tensor = LagrangeElement(cell, 1, (2, 2))
     V_tensor = FunctionSpace(mesh, P1_tensor)
     u_tensor = TrialFunction(V_tensor)
     f_tensor = Coefficient(V_tensor)
-    
+
     assert extract_unique_domain(u_tensor) == mesh
     assert extract_unique_domain(f_tensor) == mesh
     assert extract_unique_domain(u_tensor[0, 0]) == mesh
     assert extract_unique_domain(u_tensor[1, 1]) == mesh
     assert extract_unique_domain(f_tensor[0, 1]) == mesh
-    
+
     x, y = SpatialCoordinate(mesh)
     expr1 = u_scalar + f_scalar
     expr2 = u_vector[0] + x
     expr3 = inner(u_vector, f_vector)
-    
+
     assert extract_unique_domain(expr1) == mesh
     assert extract_unique_domain(expr2) == mesh
     assert extract_unique_domain(expr3) == mesh
-    
+
     # Test forms
     dx = Measure("dx", mesh)
     form = inner(u_scalar, f_scalar) * dx
     assert extract_unique_domain(form) == mesh
 
 
 def test_extract_unique_domain_mixed_scalar_vector_tensor():
-    """Test domain extraction for mixed function spaces 
+    """Test domain extraction for mixed function spaces
     with scalar, vector, and tensor elements."""
     cell = triangle
     mesh1 = Mesh(LagrangeElement(cell, 1, (2,)), ufl_id=400)
@@ -177,16 +177,16 @@ def test_extract_unique_domain_mixed_scalar_vector_tensor():
         assert extract_unique_domain(u_i) == domain[i]
     for i, f_i in enumerate((f_scalar, f_vector, f_tensor)):
         assert extract_unique_domain(f_i) == domain[i]
-    
+
     for i in range(2):
         assert extract_unique_domain(u_vector[i]) == mesh2
         assert extract_unique_domain(f_vector[i]) == mesh2
-    
+
     for i in range(2):
         for j in range(2):
             assert extract_unique_domain(u_tensor[i, j]) == mesh3
             assert extract_unique_domain(f_tensor[i, j]) == mesh3
-    
+
     x1, y1 = SpatialCoordinate(mesh1)
     x2, y2 = SpatialCoordinate(mesh2)
     x3, y3 = SpatialCoordinate(mesh3)
@@ -269,7 +269,7 @@ def test_extract_unique_domain_baseform():
 
     V1 = FunctionSpace(mesh1, scalar_elem)
     V2 = FunctionSpace(mesh2, scalar_elem)
-    
+
     A = Matrix(V1, V2)
     assert extract_unique_domain(A) == mesh1
 
@@ -298,4 +298,4 @@ def test_extract_unique_domain_baseform():
     assert extract_unique_domain(formsum) is mesh2
 
     two_form = interp * v * dx
-    assert extract_unique_domain(two_form) is mesh2
+    assert extract_unique_domain(two_form) is mesh2

ufl/argument.py

@@ -285,6 +285,7 @@ def Arguments(function_space, number):
     Returns a tuple with the function components corresponding to the subelements.
     """
     from ufl.split_functions import split
+
     if isinstance(function_space, MixedFunctionSpace):
         return [
             Argument(function_space.ufl_sub_space(i), number, i)

ufl/checks.py

@@ -40,6 +40,7 @@ def is_cellwise_constant(expr):
 def is_scalar_constant_expression(expr):
     """Check if an expression is a globally constant scalar expression."""
     from ufl.geometry import GeometricQuantity
+
     if is_python_scalar(expr):
         return True
     if expr.ufl_shape:

ufl/constant.py

@@ -8,8 +8,8 @@
 
 from ufl.core.terminal import Terminal
 from ufl.core.ufl_type import ufl_type
-from ufl.utils.counted import Counted
 from ufl.domain import as_domain
+from ufl.utils.counted import Counted
 
 
 @ufl_type()
@@ -21,6 +21,7 @@ class Constant(Terminal, Counted):
     def __init__(self, domain, shape=(), count=None):
         """Initalise."""
         from ufl.domain import as_domain
+
         Terminal.__init__(self)
         Counted.__init__(self, count, Constant)
 

ufl/corealg/dag_traverser.py

@@ -1,6 +1,7 @@
 """Base class for dag traversers."""
 
 from __future__ import annotations  # avoid circular import
+
 from functools import singledispatchmethod, wraps
 from typing import TYPE_CHECKING, Union, overload
 

ufl/domain.py

@@ -10,23 +10,23 @@
 
 import numbers
 from collections.abc import Iterable, Sequence
-from typing import TYPE_CHECKING
 from functools import singledispatchmethod
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ufl.core.expr import Expr
     from ufl.finiteelement import AbstractFiniteElement  # To avoid cyclic import when type-hinting.
     from ufl.form import Form
 from ufl.cell import AbstractCell
+from ufl.core.base_form_operator import BaseFormOperator
+from ufl.core.operator import Operator
+from ufl.core.terminal import Terminal
 from ufl.core.ufl_id import attach_ufl_id
 from ufl.core.ufl_type import UFLObject
-from ufl.corealg.traversal import traverse_unique_terminals
-from ufl.sobolevspace import H1
 from ufl.corealg.dag_traverser import DAGTraverser
-from ufl.core.operator import Operator
-from ufl.core.terminal import Terminal
+from ufl.corealg.traversal import traverse_unique_terminals
 from ufl.indexed import Indexed
-from ufl.core.base_form_operator import BaseFormOperator
+from ufl.sobolevspace import H1
 
 # Export list for ufl.classes
 __all_classes__ = ["AbstractDomain", "Mesh", "MeshView"]
@@ -463,13 +463,14 @@ def process(self, o: Expr) -> Expr:
     def _(self, o: Expr, *operand_results) -> AbstractDomain:
         """Process Indexed object by extracting the domain corresponding to the index."""
         from ufl.functionspace import FunctionSpace
+
         expression, multiindex = o.ufl_operands
         expression_domain = operand_results[0]
 
         if isinstance(expression_domain, MeshSequence):
             index = multiindex[0]._value
             element = expression.ufl_element()
-            if hasattr(element, 'sub_elements'):
+            if hasattr(element, "sub_elements"):
                 # Need to do this in case we have sub elements which are vector or tensor valued
                 j = 0
                 for i, sub_element in enumerate(element.sub_elements):
@@ -489,10 +490,11 @@ def _(self, o: Expr, *operand_results) -> AbstractDomain:
     @process.register(Terminal)
     @DAGTraverser.postorder
     def _(self, o: Expr) -> AbstractDomain:
-        from ufl.coefficient import Coefficient
         from ufl.argument import Argument
-        from ufl.geometry import GeometricQuantity
+        from ufl.coefficient import Coefficient
         from ufl.constant import Constant
+        from ufl.geometry import GeometricQuantity
+
         if isinstance(o, (Coefficient, Argument)):
             fs = o.ufl_function_space()
             return fs.ufl_domain()
@@ -522,12 +524,12 @@ def _(self, o: Expr, *operand_results) -> AbstractDomain:
                 raise ValueError(
                     f"Cannot extract unique domain from expression {o!r} with differing domains: {domains!r}"
                 )
-    
+
     @process.register(BaseFormOperator)
     @DAGTraverser.postorder
     def _(self, o: Expr, *operand_results) -> AbstractDomain:
         fs = o.ufl_function_space()
-        return fs.ufl_domain() 
+        return fs.ufl_domain()
 
 
 def extract_unique_domain(expr: Expr | Form) -> AbstractDomain:
@@ -542,8 +544,8 @@ def extract_unique_domain(expr: Expr | Form) -> AbstractDomain:
     Returns:
         AbstractDomain: The unique domain extracted from the expression.
     """
-    from ufl.form import Form, BaseForm
     from ufl.core.expr import Expr
+    from ufl.form import BaseForm, Form
 
     if isinstance(expr, Form):
         domains = set()

ufl/form.py

@@ -17,7 +17,6 @@
 from itertools import chain
 
 from ufl.checks import is_scalar_constant_expression
-
 from ufl.constantvalue import Zero
 from ufl.core.expr import Expr, ufl_err_str
 from ufl.core.terminal import FormArgument
@@ -40,6 +39,7 @@ def _sorted_integrals(integrals):
     stable signature computation.
     """
     from ufl.domain import sort_domains
+
     # Group integrals in multilevel dict by keys
     # [domain][integral_type][subdomain_id]
     integrals_dict = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
@@ -400,6 +400,7 @@ def constants(self):
     def constant_numbering(self):
         """Return a contiguous numbering of constants in a mapping ``{constant:number}``."""
         from ufl.constant import Constant
+
         if self._constant_numbering is None:
             self._constant_numbering = {
                 expr: num
@@ -595,7 +596,7 @@ def __repr__(self):
 
     def _analyze_domains(self):
         """Analyze domains."""
-        from ufl.domain import join_domains, sort_domains, extract_unique_domain
+        from ufl.domain import extract_unique_domain, join_domains, sort_domains
 
         # Collect integration domains.
         self._integration_domains = sort_domains(

ufl/functionspace.py

@@ -311,6 +311,7 @@ def ufl_element(self):
     def ufl_domains(self):
         """Return ufl domains."""
         from ufl.domain import join_domains
+
         domainlist = []
         for s in self._ufl_function_spaces:
             domainlist.extend(s.ufl_domains())

ufl/integral.py

@@ -32,7 +32,6 @@ class Integral:
 
     def __init__(self, integrand, integral_type, domain, subdomain_id, metadata, subdomain_data):
         """Initialise."""
-        from ufl.domain import sort_domains
         if not isinstance(integrand, Expr):
             raise ValueError("Expecting integrand to be an Expr instance.")
         self._integrand = integrand

ufl/matrix.py

@@ -64,6 +64,7 @@ def ufl_function_spaces(self):
     def _analyze_form_arguments(self):
         """Define arguments of a matrix when considered as a form."""
         from ufl.argument import Argument
+
         self._arguments = (
             Argument(self._ufl_function_spaces[0], 0),
             Argument(self._ufl_function_spaces[1], 1),