Match min required version to min CI version

Author: garth-wells

ffcx/analysis.py

@@ -26,20 +26,18 @@ class UFLData(typing.NamedTuple):
     """UFL data."""
 
     # Tuple of ufl form data
-    form_data: typing.Tuple[ufl.algorithms.formdata.FormData, ...]
+    form_data: tuple[ufl.algorithms.formdata.FormData, ...]
     # List of unique elements
-    unique_elements: typing.List[basix.ufl._ElementBase]
+    unique_elements: list[basix.ufl._ElementBase]
     # Lookup table from each unique element to its index in `unique_elements`
-    element_numbers: typing.Dict[basix.ufl._ElementBase, int]
+    element_numbers: dict[basix.ufl._ElementBase, int]
     # List of unique coordinate elements
-    unique_coordinate_elements: typing.List[basix.ufl._ElementBase]
+    unique_coordinate_elements: list[basix.ufl._ElementBase]
     # List of ufl Expressions as tuples (expression, points, original_expression)
-    expressions: typing.List[
-        typing.Tuple[ufl.core.expr.Expr, npt.NDArray[np.float64], ufl.core.expr.Expr]
-    ]
+    expressions: list[tuple[ufl.core.expr.Expr, npt.NDArray[np.float64], ufl.core.expr.Expr]]
 
 
-def analyze_ufl_objects(ufl_objects: typing.List, options: typing.Dict) -> UFLData:
+def analyze_ufl_objects(ufl_objects: list, options: dict) -> UFLData:
     """Analyze ufl object(s).
 
     Args:
@@ -112,7 +110,7 @@ def analyze_ufl_objects(ufl_objects: typing.List, options: typing.Dict) -> UFLDa
     )
 
 
-def _analyze_expression(expression: ufl.core.expr.Expr, options: typing.Dict):
+def _analyze_expression(expression: ufl.core.expr.Expr, options: dict):
     """Analyzes and preprocesses expressions."""
     preserve_geometry_types = (ufl.classes.Jacobian,)
     expression = ufl.algorithms.apply_algebra_lowering.apply_algebra_lowering(expression)
@@ -134,7 +132,7 @@ def _analyze_expression(expression: ufl.core.expr.Expr, options: typing.Dict):
     return expression
 
 
-def _analyze_form(form: ufl.form.Form, options: typing.Dict) -> ufl.algorithms.formdata.FormData:
+def _analyze_form(form: ufl.form.Form, options: dict) -> ufl.algorithms.formdata.FormData:
     """Analyzes UFL form and attaches metadata.
 
     Args:

ffcx/codegeneration/codegeneration.py

@@ -30,13 +30,13 @@ class CodeBlocks(typing.NamedTuple):
     and start and end of file output
     """
 
-    file_pre: typing.List[typing.Tuple[str, str]]
-    elements: typing.List[typing.Tuple[str, str]]
-    dofmaps: typing.List[typing.Tuple[str, str]]
-    integrals: typing.List[typing.Tuple[str, str]]
-    forms: typing.List[typing.Tuple[str, str]]
-    expressions: typing.List[typing.Tuple[str, str]]
-    file_post: typing.List[typing.Tuple[str, str]]
+    file_pre: list[tuple[str, str]]
+    elements: list[tuple[str, str]]
+    dofmaps: list[tuple[str, str]]
+    integrals: list[tuple[str, str]]
+    forms: list[tuple[str, str]]
+    expressions: list[tuple[str, str]]
+    file_post: list[tuple[str, str]]
 
 
 def generate_code(ir, options) -> CodeBlocks:

ffcx/codegeneration/definitions.py

@@ -6,7 +6,7 @@
 """FFCx/UFC specific variable definitions."""
 
 import logging
-from typing import List, Union
+from typing import Union
 
 import ufl
 
@@ -86,7 +86,7 @@ def get(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Return definition code for a terminal."""
         # Call appropriate handler, depending on the type of terminal
         terminal = mt.terminal
@@ -111,7 +111,7 @@ def coefficient(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Return definition code for coefficients."""
         # For applying tensor product to coefficients, we need to know if the coefficient
         # has a tensor factorisation and if the quadrature rule has a tensor factorisation.
@@ -146,7 +146,7 @@ def coefficient(
             mt.terminal, (ic.global_index) * bs + begin
         )
 
-        declaration: List[L.Declaration] = [L.VariableDecl(access, 0.0)]
+        declaration: list[L.Declaration] = [L.VariableDecl(access, 0.0)]
         body = [L.AssignAdd(access, dof_access * FE)]
         code = [L.create_nested_for_loops([ic], body)]
 
@@ -167,7 +167,7 @@ def _define_coordinate_dofs_lincomb(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Define x or J as a linear combination of coordinate dofs with given table data."""
         # Get properties of domain
         domain = ufl.domain.extract_unique_domain(mt.terminal)
@@ -222,7 +222,7 @@ def spatial_coordinate(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Return definition code for the physical spatial coordinates.
 
         If physical coordinates are given:
@@ -248,7 +248,7 @@ def jacobian(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Return definition code for the Jacobian of x(X)."""
         return self._define_coordinate_dofs_lincomb(mt, tabledata, quadrature_rule, access)
 
@@ -258,6 +258,6 @@ def pass_through(
         tabledata: UniqueTableReferenceT,
         quadrature_rule: QuadratureRule,
         access: L.Symbol,
-    ) -> Union[L.Section, List]:
+    ) -> Union[L.Section, list]:
         """Return definition code for pass through terminals."""
         return []

ffcx/codegeneration/expression_generator.py

@@ -8,7 +8,7 @@
 import collections
 import logging
 from itertools import product
-from typing import Any, DefaultDict, Dict, Set
+from typing import Any
 
 import ufl
 
@@ -31,10 +31,10 @@ def __init__(self, ir: ExpressionIR, backend: FFCXBackend):
 
         self.ir = ir
         self.backend = backend
-        self.scope: Dict[Any, LNode] = {}
-        self._ufl_names: Set[Any] = set()
-        self.symbol_counters: DefaultDict[Any, int] = collections.defaultdict(int)
-        self.shared_symbols: Dict[Any, Any] = {}
+        self.scope: dict[Any, LNode] = {}
+        self._ufl_names: set[Any] = set()
+        self.symbol_counters: collections.defaultdict[Any, int] = collections.defaultdict(int)
+        self.shared_symbols: dict[Any, Any] = {}
         self.quadrature_rule = list(self.ir.integrand.keys())[0]
 
     def generate(self):
@@ -65,7 +65,7 @@ def generate_geometry_tables(self):
         ufl_geometry = {
             ufl.geometry.ReferenceCellVolume: "reference_cell_volume",
         }
-        cells: Dict[Any, Set[Any]] = {t: set() for t in ufl_geometry.keys()}  # type: ignore
+        cells: dict[Any, set[Any]] = {t: set() for t in ufl_geometry.keys()}  # type: ignore
 
         for integrand in self.ir.integrand.values():
             for attr in integrand["factorization"].nodes.values():

ffcx/codegeneration/integral_generator.py

@@ -8,7 +8,7 @@
 import collections
 import logging
 from numbers import Integral
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any
 
 import ufl
 
@@ -23,7 +23,7 @@
 logger = logging.getLogger("ffcx")
 
 
-def extract_dtype(v, vops: List[Any]):
+def extract_dtype(v, vops: list[Any]):
     """Extract dtype from ufl expression v and its operands."""
     dtypes = []
     for op in vops:
@@ -201,7 +201,7 @@ def generate_geometry_tables(self):
             ufl.geometry.ReferenceNormal: "reference_facet_normals",
             ufl.geometry.FacetOrientation: "facet_orientation",
         }
-        cells: Dict[Any, Set[Any]] = {t: set() for t in ufl_geometry.keys()}  # type: ignore
+        cells: dict[Any, set[Any]] = {t: set() for t in ufl_geometry.keys()}  # type: ignore
 
         for integrand in self.ir.integrand.values():
             for attr in integrand["factorization"].nodes.values():
@@ -418,7 +418,7 @@ def get_arg_factors(self, blockdata, block_rank, quadrature_rule, iq, indices):
         return arg_factors, tables
 
     def generate_block_parts(
-        self, quadrature_rule: QuadratureRule, blockmap: Tuple, blocklist: List[BlockDataT]
+        self, quadrature_rule: QuadratureRule, blockmap: tuple, blocklist: list[BlockDataT]
     ):
         """Generate and return code parts for a given block.
 
@@ -429,8 +429,8 @@ def generate_block_parts(
         quadloop-independent blocks.
         """
         # The parts to return
-        quadparts: List[L.LNode] = []
-        intermediates: List[L.LNode] = []
+        quadparts: list[L.LNode] = []
+        intermediates: list[L.LNode] = []
         tables = []
         vars = []
 
@@ -526,7 +526,7 @@ def generate_block_parts(
         for indices in rhs_expressions:
             keep[indices] = rhs_expressions[indices]
 
-        body: List[L.LNode] = []
+        body: list[L.LNode] = []
 
         A = self.backend.symbols.element_tensor
         A_shape = self.ir.tensor_shape

ffcx/codegeneration/lnodes.py

@@ -24,9 +24,9 @@
 """
 
 import numbers
-import typing
+from collections.abc import Sequence
 from enum import Enum
-from typing import List, Optional, Sequence
+from typing import Optional
 
 import numpy as np
 import ufl
@@ -114,7 +114,7 @@ class DataType(Enum):
     NONE = 4
 
 
-def merge_dtypes(dtypes: typing.List[DataType]):
+def merge_dtypes(dtypes: list[DataType]):
     """Promote dtype to SCALAR or REAL if either argument matches."""
     if DataType.NONE in dtypes:
         raise ValueError(f"Invalid DataType in LNodes {dtypes}")
@@ -865,11 +865,11 @@ class Section(LNode):
     def __init__(
         self,
         name: str,
-        statements: List[LNode],
+        statements: list[LNode],
         declarations: Sequence[Declaration],
-        input: Optional[List[Symbol]] = None,
-        output: Optional[List[Symbol]] = None,
-        annotations: Optional[List[Annotation]] = None,
+        input: Optional[list[Symbol]] = None,
+        output: Optional[list[Symbol]] = None,
+        annotations: Optional[list[Annotation]] = None,
     ):
         """Initialise."""
         self.name = name
@@ -1127,7 +1127,7 @@ def ufl_to_lnodes(operator, *args):
         raise RuntimeError(f"Missing lookup for expr type {optype}.")
 
 
-def create_nested_for_loops(indices: List[MultiIndex], body):
+def create_nested_for_loops(indices: list[MultiIndex], body):
     """Create nested for loops over list of indices.
 
     The depth of the nested for loops is equal to the sub-indices for all

ffcx/codegeneration/optimizer.py

@@ -1,12 +1,12 @@
 """Optimizer."""
 from collections import defaultdict
-from typing import List, Union
+from typing import Union
 
 import ffcx.codegeneration.lnodes as L
 from ffcx.ir.representationutils import QuadratureRule
 
 
-def optimize(code: List[L.LNode], quadrature_rule: QuadratureRule) -> List[L.LNode]:
+def optimize(code: list[L.LNode], quadrature_rule: QuadratureRule) -> list[L.LNode]:
     """Optimize code.
 
     Args:
@@ -30,7 +30,7 @@ def optimize(code: List[L.LNode], quadrature_rule: QuadratureRule) -> List[L.LNo
     return code
 
 
-def fuse_sections(code: List[L.LNode], name) -> List[L.LNode]:
+def fuse_sections(code: list[L.LNode], name) -> list[L.LNode]:
     """Fuse sections with the same name.
 
     Args:
@@ -40,12 +40,12 @@ def fuse_sections(code: List[L.LNode], name) -> List[L.LNode]:
     Returns:
         Fused list of LNodes.
     """
-    statements: List[L.LNode] = []
-    indices: List[int] = []
-    input: List[L.Symbol] = []
-    output: List[L.Symbol] = []
-    declarations: List[L.Declaration] = []
-    annotations: List[L.Annotation] = []
+    statements: list[L.LNode] = []
+    indices: list[int] = []
+    input: list[L.Symbol] = []
+    output: list[L.Symbol] = []
+    declarations: list[L.Declaration] = []
+    annotations: list[L.Annotation] = []
 
     for i, section in enumerate(code):
         if isinstance(section, L.Section):
@@ -98,7 +98,7 @@ def fuse_loops(code: L.Section) -> L.Section:
     return L.Section(code.name, output_code, code.declarations, code.input, code.output)
 
 
-def get_statements(statement: Union[L.Statement, L.StatementList]) -> List[L.LNode]:
+def get_statements(statement: Union[L.Statement, L.StatementList]) -> list[L.LNode]:
     """Get statements from a statement list.
 
     Args:
@@ -177,7 +177,7 @@ def licm(section: L.Section, quadrature_rule: QuadratureRule) -> L.Section:
             assert isinstance(lhs, L.ArrayAccess)  # Expecting ArrayAccess
             expressions[lhs].append(rhs)
 
-    pre_loop: List[L.LNode] = []
+    pre_loop: list[L.LNode] = []
     for lhs, rhs in expressions.items():
         for r in rhs:
             hoist_candidates = []

ffcx/compiler.py

@@ -80,10 +80,10 @@ def _print_timing(stage: int, timing: float):
 
 
 def compile_ufl_objects(
-    ufl_objects: typing.List[typing.Any],
-    object_names: typing.Dict = {},
+    ufl_objects: list[typing.Any],
+    object_names: dict = {},
     prefix: typing.Optional[str] = None,
-    options: typing.Dict = {},
+    options: dict = {},
     visualise: bool = False,
 ):
     """Generate UFC code for a given UFL objects.

ffcx/element_interface.py

@@ -5,22 +5,20 @@
 # SPDX-License-Identifier:    LGPL-3.0-or-later
 """Finite element interface."""
 
-import typing
-
 import basix
 import basix.ufl
 import numpy as np
 import numpy.typing as npt
 
 
-def basix_index(indices: typing.Tuple[int]) -> int:
+def basix_index(indices: tuple[int]) -> int:
     """Get the Basix index of a derivative."""
     return basix.index(*indices)
 
 
 def create_quadrature(
-    cellname: str, degree: int, rule: str, elements: typing.List[basix.ufl._ElementBase]
-) -> typing.Tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    cellname: str, degree: int, rule: str, elements: list[basix.ufl._ElementBase]
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """Create a quadrature rule."""
     if cellname == "vertex":
         return (np.ones((1, 0), dtype=np.float64), np.ones(1, dtype=np.float64))

ffcx/ir/analysis/modified_terminals.py

@@ -37,10 +37,10 @@ def __init__(
         reference_value: bool,
         base_shape,
         base_symmetry,
-        component: typing.Tuple[int, ...],
+        component: tuple[int, ...],
         flat_component: int,
-        global_derivatives: typing.Tuple[int, ...],
-        local_derivatives: typing.Tuple[int, ...],
+        global_derivatives: tuple[int, ...],
+        local_derivatives: tuple[int, ...],
         averaged: typing.Union[None, str],
         restriction: typing.Union[None, str],
     ):