Lighter switch to ruff

.github/workflows/ccpp.yml

@@ -60,24 +60,15 @@ jobs:
           python3 -m pip install git+https://github.com/FEniCS/basix.git@${{ github.event.inputs.basix_ref }}
           python3 -m pip install git+https://github.com/FEniCS/ffcx.git@${{ github.event.inputs.ffcx_ref }}
 
-      - name: Flake8 checks
-        run: |
-          cd cpp/
-          python3 -m flake8 cmake
-          python3 -m flake8 demo
-          python3 -m flake8 test
-          cd ..
-          cd python/
-          python3 -m flake8 dolfinx
-          python3 -m flake8 demo
-          python3 -m flake8 test
-      - name: isort checks (non-blocking)
-        continue-on-error: true
+      - name: ruff and isort C++ .py file checks
         run: |
           cd cpp/
+          ruff check .
           python3 -m isort --check .
-          cd ..
+      - name: ruff and isort Python interface checks
+        run: |
           cd python/
+          ruff check .
           python3 -m isort --check .
       - name: mypy checks
         run: |

cpp/ruff.toml

@@ -0,0 +1 @@
+extend = "../python/pyproject.toml"

python/demo/demo_lagrange_variants.py

@@ -18,6 +18,7 @@
 # We begin this demo by importing the required modules.
 
 import typing
+
 from mpi4py import MPI
 
 # +
@@ -26,7 +27,7 @@
 
 import basix
 import basix.ufl
-import ufl   # type: ignore
+import ufl  # type: ignore
 from dolfinx import default_scalar_type, fem, mesh
 from dolfinx.fem.petsc import LinearProblem
 from ufl import ds, dx, grad, inner

python/demo/demo_static-condensation.py

@@ -42,7 +42,8 @@
 from dolfinx.io import XDMFFile
 from dolfinx.jit import ffcx_jit
 from dolfinx.mesh import locate_entities_boundary, meshtags
-from ffcx.codegeneration.utils import numba_ufcx_kernel_signature as ufcx_signature
+from ffcx.codegeneration.utils import \
+    numba_ufcx_kernel_signature as ufcx_signature
 
 if default_real_type == np.float32:
     print("float32 not yet supported for this demo.")

python/demo/demo_tnt-elements.py

@@ -23,7 +23,7 @@
 from mpi4py import MPI
 
 # +
-import matplotlib
+import matplotlib as mpl
 import matplotlib.pylab as plt
 import numpy as np
 
@@ -34,7 +34,7 @@
 from ufl import (SpatialCoordinate, TestFunction, TrialFunction, cos, div, dx,
                  grad, inner, sin)
 
-matplotlib.use('agg')
+mpl.use('agg')
 # -
 
 # ## Defining a degree 1 TNT element

python/dolfinx/__init__.py

@@ -20,7 +20,8 @@
 
 from dolfinx import common
 from dolfinx import cpp as _cpp
-from dolfinx import fem, geometry, graph, io, jit, la, log, mesh, nls, plot, utils
+from dolfinx import (fem, geometry, graph, io, jit, la, log, mesh, nls, plot,
+                     utils)
 # Initialise logging
 from dolfinx.common import (TimingType, git_commit_hash, has_debug, has_kahip,
                             has_parmetis, list_timings, timing)

python/dolfinx/fem/assemble.py

@@ -213,7 +213,7 @@ def _assemble_vector_array(b: np.ndarray, L: Form, constants=None, coeffs=None):
 
 
 @functools.singledispatch
-def assemble_matrix(a: typing.Any, bcs: typing.Optional[typing.List[DirichletBC]] = None,
+def assemble_matrix(a: typing.Any, bcs: typing.Optional[list[DirichletBC]] = None,
                     diagonal: float = 1.0, constants=None, coeffs=None,
                     block_mode: typing.Optional[la.BlockMode] = None):
     """Assemble bilinear form into a matrix.
@@ -246,7 +246,7 @@ def assemble_matrix(a: typing.Any, bcs: typing.Optional[typing.List[DirichletBC]
 
 
 @assemble_matrix.register
-def _assemble_matrix_csr(A: la.MatrixCSR, a: Form, bcs: typing.Optional[typing.List[DirichletBC]] = None,
+def _assemble_matrix_csr(A: la.MatrixCSR, a: Form, bcs: typing.Optional[list[DirichletBC]] = None,
                          diagonal: float = 1.0, constants=None, coeffs=None) -> la.MatrixCSR:
     """Assemble bilinear form into a matrix.
 
@@ -284,9 +284,9 @@ def _assemble_matrix_csr(A: la.MatrixCSR, a: Form, bcs: typing.Optional[typing.L
 # -- Modifiers for Dirichlet conditions ---------------------------------------
 
 
-def apply_lifting(b: np.ndarray, a: typing.List[Form],
-                  bcs: typing.List[typing.List[DirichletBC]],
-                  x0: typing.Optional[typing.List[np.ndarray]] = None,
+def apply_lifting(b: np.ndarray, a: list[Form],
+                  bcs: list[list[DirichletBC]],
+                  x0: typing.Optional[list[np.ndarray]] = None,
                   scale: float = 1.0, constants=None, coeffs=None) -> None:
     """Modify RHS vector b for lifting of Dirichlet boundary conditions.
 
@@ -316,7 +316,7 @@ def apply_lifting(b: np.ndarray, a: typing.List[Form],
     _cpp.fem.apply_lifting(b, _a, constants, coeffs, _bcs, x0, scale)
 
 
-def set_bc(b: np.ndarray, bcs: typing.List[DirichletBC],
+def set_bc(b: np.ndarray, bcs: list[DirichletBC],
            x0: typing.Optional[np.ndarray] = None, scale: float = 1.0) -> None:
     """Insert boundary condition values into vector.
 

python/dolfinx/fem/bcs.py

@@ -185,7 +185,7 @@ def dirichletbc(value: typing.Union[Function, Constant, np.ndarray],
 
 
 def bcs_by_block(spaces: typing.Iterable[typing.Union[dolfinx.fem.FunctionSpace, None]],
-                 bcs: typing.Iterable[DirichletBC]) -> typing.List[typing.List[DirichletBC]]:
+                 bcs: typing.Iterable[DirichletBC]) -> list[list[DirichletBC]]:
     """Arrange Dirichlet boundary conditions by the function space that
     they constrain.
 

python/dolfinx/fem/forms.py

@@ -62,7 +62,7 @@ def rank(self) -> int:
         return self._cpp_object.rank  # type: ignore
 
     @property
-    def function_spaces(self) -> typing.List[FunctionSpace]:
+    def function_spaces(self) -> list[FunctionSpace]:
         """Function spaces on which this form is defined"""
         return self._cpp_object.function_spaces  # type: ignore
 

python/dolfinx/fem/function.py

@@ -455,7 +455,7 @@ def sub(self, i: int) -> Function:
             returned `Function` should be stored by the caller to avoid
             repeated re-computation of the subspac.
         """
-        return Function(self._V.sub(i), self.x, name=f"{str(self)}_{i}")
+        return Function(self._V.sub(i), self.x, name=f"{self!s}_{i}")
 
     def split(self) -> tuple[Function, ...]:
         """Extract (any) sub-functions.
@@ -492,13 +492,13 @@ class ElementMetaData(typing.NamedTuple):
     """
     family: str
     degree: int
-    shape: typing.Optional[typing.Tuple[int, ...]] = None
+    shape: typing.Optional[tuple[int, ...]] = None
     symmetry: typing.Optional[bool] = None
 
 
 def functionspace(mesh: Mesh,
                   element: typing.Union[ufl.FiniteElementBase, ElementMetaData,
-                                        typing.Tuple[str, int, typing.Tuple, bool]],
+                                        tuple[str, int, tuple, bool]],
                   form_compiler_options: typing.Optional[dict[str, typing.Any]] = None,
                   jit_options: typing.Optional[dict[str, typing.Any]] = None) -> FunctionSpace:
     """Create a finite element function space.

python/dolfinx/fem/petsc.py

@@ -43,7 +43,7 @@
            "LinearProblem", "NonlinearProblem"]
 
 
-def _extract_function_spaces(a: typing.List[typing.List[Form]]):
+def _extract_function_spaces(a: list[list[Form]]):
     """From a rectangular array of bilinear forms, extract the function
     spaces for each block row and block column.
 
@@ -58,8 +58,8 @@ def fn(form):
     Vblock: typing.Iterable = map(partial(map, fn), a)
 
     # Compute spaces for each row/column block
-    rows: typing.List[typing.Set] = [set() for i in range(len(a))]
-    cols: typing.List[typing.Set] = [set() for i in range(len(a[0]))]
+    rows: list[set] = [set() for i in range(len(a))]
+    cols: list[set] = [set() for i in range(len(a[0]))]
     for i, Vrow in enumerate(Vblock):
         for j, V in enumerate(Vrow):
             if V is not None:
@@ -90,7 +90,7 @@ def create_vector(L: Form) -> PETSc.Vec:
     return create_petsc_vector(dofmap.index_map, dofmap.index_map_bs)
 
 
-def create_vector_block(L: typing.List[Form]) -> PETSc.Vec:
+def create_vector_block(L: list[Form]) -> PETSc.Vec:
     """Create a PETSc vector (blocked) that is compaible with a list of linear forms.
 
     Args:
@@ -105,7 +105,7 @@ def create_vector_block(L: typing.List[Form]) -> PETSc.Vec:
     return _cpp.fem.petsc.create_vector_block(maps)
 
 
-def create_vector_nest(L: typing.List[Form]) -> PETSc.Vec:
+def create_vector_nest(L: list[Form]) -> PETSc.Vec:
     """Create a PETSc nested vector (``VecNest``) that is compatible with a list of linear forms.
 
     Args:
@@ -140,7 +140,7 @@ def create_matrix(a: Form, mat_type=None) -> PETSc.Mat:
         return _cpp.fem.petsc.create_matrix(a._cpp_object, mat_type)
 
 
-def create_matrix_block(a: typing.List[typing.List[Form]]) -> PETSc.Mat:
+def create_matrix_block(a: list[list[Form]]) -> PETSc.Mat:
     """Create a PETSc matrix that is compatible with a rectangular array of bilinear forms.
 
     Args:
@@ -155,7 +155,7 @@ def create_matrix_block(a: typing.List[typing.List[Form]]) -> PETSc.Mat:
     return _cpp.fem.petsc.create_matrix_block(_a)
 
 
-def create_matrix_nest(a: typing.List[typing.List[Form]]) -> PETSc.Mat:
+def create_matrix_nest(a: list[list[Form]]) -> PETSc.Mat:
     """Create a PETSc matrix (``MatNest``) that is compatible with a rectangular array of bilinear forms.
 
     Args:
@@ -232,7 +232,7 @@ def assemble_vector_nest(L: typing.Any, constants=None, coeffs=None) -> PETSc.Ve
 
 
 @assemble_vector_nest.register
-def _assemble_vector_nest_vec(b: PETSc.Vec, L: typing.List[Form], constants=None, coeffs=None) -> PETSc.Vec:
+def _assemble_vector_nest_vec(b: PETSc.Vec, L: list[Form], constants=None, coeffs=None) -> PETSc.Vec:
     """Assemble linear forms into a nested PETSc (``VecNest``) vector. The
     vector is not zeroed before assembly and it is not finalised, i.e.
     ghost values are not accumulated on the owning processes.
@@ -248,9 +248,9 @@ def _assemble_vector_nest_vec(b: PETSc.Vec, L: typing.List[Form], constants=None
 
 # FIXME: Revise this interface
 @functools.singledispatch
-def assemble_vector_block(L: typing.List[Form],
-                          a: typing.List[typing.List[Form]],
-                          bcs: typing.List[DirichletBC] = [],
+def assemble_vector_block(L: list[Form],
+                          a: list[list[Form]],
+                          bcs: list[DirichletBC] = [],
                           x0: typing.Optional[PETSc.Vec] = None,
                           scale: float = 1.0,
                           constants_L=None, coeffs_L=None,
@@ -270,9 +270,9 @@ def assemble_vector_block(L: typing.List[Form],
 
 @assemble_vector_block.register
 def _assemble_vector_block_vec(b: PETSc.Vec,
-                               L: typing.List[Form],
-                               a: typing.List[typing.List[Form]],
-                               bcs: typing.List[DirichletBC] = [],
+                               L: list[Form],
+                               a: list[list[Form]],
+                               bcs: list[DirichletBC] = [],
                                x0: typing.Optional[PETSc.Vec] = None,
                                scale: float = 1.0,
                                constants_L=None, coeffs_L=None,
@@ -330,7 +330,7 @@ def _assemble_vector_block_vec(b: PETSc.Vec,
 
 # -- Matrix assembly ---------------------------------------------------------
 @functools.singledispatch
-def assemble_matrix(a: typing.Any, bcs: typing.List[DirichletBC] = [],
+def assemble_matrix(a: typing.Any, bcs: list[DirichletBC] = [],
                     diagonal: float = 1.0, constants=None, coeffs=None):
     """Assemble bilinear form into a matrix. The returned matrix is not
     finalised, i.e. ghost values are not accumulated.
@@ -357,7 +357,7 @@ def assemble_matrix(a: typing.Any, bcs: typing.List[DirichletBC] = [],
 
 
 @assemble_matrix.register
-def assemble_matrix_mat(A: PETSc.Mat, a: Form, bcs: typing.List[DirichletBC] = [],
+def assemble_matrix_mat(A: PETSc.Mat, a: Form, bcs: list[DirichletBC] = [],
                         diagonal: float = 1.0, constants=None, coeffs=None) -> PETSc.Mat:
     """Assemble bilinear form into a matrix. The returned matrix is not
     finalised, i.e. ghost values are not accumulated.
@@ -376,8 +376,8 @@ def assemble_matrix_mat(A: PETSc.Mat, a: Form, bcs: typing.List[DirichletBC] = [
 
 # FIXME: Revise this interface
 @functools.singledispatch
-def assemble_matrix_nest(a: typing.List[typing.List[Form]],
-                         bcs: typing.List[DirichletBC] = [], mat_types=[],
+def assemble_matrix_nest(a: list[list[Form]],
+                         bcs: list[DirichletBC] = [], mat_types=[],
                          diagonal: float = 1.0, constants=None, coeffs=None) -> PETSc.Mat:
     """Create a nested matrix and assembled bilinear forms into the matrix.
 
@@ -402,8 +402,8 @@ def assemble_matrix_nest(a: typing.List[typing.List[Form]],
 
 
 @assemble_matrix_nest.register
-def _assemble_matrix_nest_mat(A: PETSc.Mat, a: typing.List[typing.List[Form]],
-                              bcs: typing.List[DirichletBC] = [], diagonal: float = 1.0,
+def _assemble_matrix_nest_mat(A: PETSc.Mat, a: list[list[Form]],
+                              bcs: list[DirichletBC] = [], diagonal: float = 1.0,
                               constants=None, coeffs=None) -> PETSc.Mat:
     """Assemble bilinear forms into a nested matrix
 
@@ -445,8 +445,8 @@ def _assemble_matrix_nest_mat(A: PETSc.Mat, a: typing.List[typing.List[Form]],
 
 # FIXME: Revise this interface
 @functools.singledispatch
-def assemble_matrix_block(a: typing.List[typing.List[Form]],
-                          bcs: typing.List[DirichletBC] = [],
+def assemble_matrix_block(a: list[list[Form]],
+                          bcs: list[DirichletBC] = [],
                           diagonal: float = 1.0,
                           constants=None, coeffs=None) -> PETSc.Mat:  # type: ignore
     """Assemble bilinear forms into a blocked matrix."""
@@ -456,8 +456,8 @@ def assemble_matrix_block(a: typing.List[typing.List[Form]],
 
 
 @assemble_matrix_block.register
-def _assemble_matrix_block_mat(A: PETSc.Mat, a: typing.List[typing.List[Form]],
-                               bcs: typing.List[DirichletBC] = [], diagonal: float = 1.0,
+def _assemble_matrix_block_mat(A: PETSc.Mat, a: list[list[Form]],
+                               bcs: list[DirichletBC] = [], diagonal: float = 1.0,
                                constants=None, coeffs=None) -> PETSc.Mat:
     """Assemble bilinear forms into a blocked matrix."""
     constants = [[_pack_constants(form._cpp_object) if form is not None else np.array(
@@ -503,9 +503,9 @@ def _assemble_matrix_block_mat(A: PETSc.Mat, a: typing.List[typing.List[Form]],
 
 # -- Modifiers for Dirichlet conditions ---------------------------------------
 
-def apply_lifting(b: PETSc.Vec, a: typing.List[Form],
-                  bcs: typing.List[typing.List[DirichletBC]],
-                  x0: typing.List[PETSc.Vec] = [],
+def apply_lifting(b: PETSc.Vec, a: list[Form],
+                  bcs: list[list[DirichletBC]],
+                  x0: list[PETSc.Vec] = [],
                   scale: float = 1.0, constants=None, coeffs=None) -> None:
     """Apply the function :func:`dolfinx.fem.apply_lifting` to a PETSc Vector."""
     with contextlib.ExitStack() as stack:
@@ -515,8 +515,8 @@ def apply_lifting(b: PETSc.Vec, a: typing.List[Form],
         _assemble.apply_lifting(b_local.array_w, a, bcs, x0_r, scale, constants, coeffs)
 
 
-def apply_lifting_nest(b: PETSc.Vec, a: typing.List[typing.List[Form]],
-                       bcs: typing.List[DirichletBC],
+def apply_lifting_nest(b: PETSc.Vec, a: list[list[Form]],
+                       bcs: list[DirichletBC],
                        x0: typing.Optional[PETSc.Vec] = None,
                        scale: float = 1.0, constants=None, coeffs=None) -> PETSc.Vec:
     """Apply the function :func:`dolfinx.fem.apply_lifting` to each sub-vector in a nested PETSc Vector."""
@@ -532,15 +532,15 @@ def apply_lifting_nest(b: PETSc.Vec, a: typing.List[typing.List[Form]],
     return b
 
 
-def set_bc(b: PETSc.Vec, bcs: typing.List[DirichletBC],
+def set_bc(b: PETSc.Vec, bcs: list[DirichletBC],
            x0: typing.Optional[PETSc.Vec] = None, scale: float = 1.0) -> None:
     """Apply the function :func:`dolfinx.fem.set_bc` to a PETSc Vector."""
     if x0 is not None:
         x0 = x0.array_r
     _assemble.set_bc(b.array_w, bcs, x0, scale)
 
 
-def set_bc_nest(b: PETSc.Vec, bcs: typing.List[typing.List[DirichletBC]],
+def set_bc_nest(b: PETSc.Vec, bcs: list[list[DirichletBC]],
                 x0: typing.Optional[PETSc.Vec] = None, scale: float = 1.0) -> None:
     """Apply the function :func:`dolfinx.fem.set_bc` to each sub-vector of a nested PETSc Vector."""
     _b = b.getNestSubVecs()
@@ -557,7 +557,7 @@ class LinearProblem:
 
     """
 
-    def __init__(self, a: ufl.Form, L: ufl.Form, bcs: typing.List[DirichletBC] = [],
+    def __init__(self, a: ufl.Form, L: ufl.Form, bcs: list[DirichletBC] = [],
                  u: typing.Optional[_Function] = None,
                  petsc_options: typing.Optional[dict] = None,
                  form_compiler_options: typing.Optional[dict] = None,
@@ -691,7 +691,7 @@ class NonlinearProblem:
 
     """
 
-    def __init__(self, F: ufl.form.Form, u: _Function, bcs: typing.List[DirichletBC] = [],
+    def __init__(self, F: ufl.form.Form, u: _Function, bcs: list[DirichletBC] = [],
                  J: ufl.form.Form = None, form_compiler_options: typing.Optional[dict] = None,
                  jit_options: typing.Optional[dict] = None):
         """Initialize solver for solving a non-linear problem using Newton's method, :math:`(dF/du)(u) du = -F(u)`.