Ruff format

Author: schnellerhase

ffcx/codegeneration/C/__init__.py

@@ -1,3 +1,5 @@
 """Generation of C code."""
-from ffcx.codegeneration.C import form, expressions, integrals, file # noqa
+
+from ffcx.codegeneration.C import form, expressions, integrals, file  # noqa
+
 suffixes = (".h", ".c")

ffcx/codegeneration/codegeneration.py

@@ -37,9 +37,9 @@ class CodeBlocks(typing.NamedTuple):
     file_post: list[tuple[str, str]]
 
 
-def generate_code(ir: DataIR,
-                  options: dict[str, int | float | npt.DTypeLike]) -> tuple[CodeBlocks,
-                                                                            tuple[str, str]]:
+def generate_code(
+    ir: DataIR, options: dict[str, int | float | npt.DTypeLike]
+) -> tuple[CodeBlocks, tuple[str, str]]:
     """Generate code blocks from intermediate representation."""
     logger.info(79 * "*")
     logger.info("Compiler stage 3: Generating code")

ffcx/codegeneration/cpp/__init__.py

@@ -1,3 +1,3 @@
-from . import form, expressions, integrals, file # noqa
+from . import form, expressions, integrals, file  # noqa
 
 suffixes = (".hpp", None)

ffcx/codegeneration/cpp/cpp_implementation.py

@@ -33,7 +33,8 @@
     "bessel_j": "std::cyl_bessel_j",
     "conj": "std::conj",
     "real": "std::real",
-    "imag": "std::imag"}
+    "imag": "std::imag",
+}
 
 
 def build_initializer_lists(values):
@@ -49,6 +50,7 @@ def build_initializer_lists(values):
 
 class CppFormatter:
     """C++ formatter."""
+
     def __init__(self, scalar) -> None:
         """Initialise."""
         self.scalar_type = "T"

ffcx/codegeneration/cpp/expressions.py

@@ -41,14 +41,12 @@ def generator(ir, options):
     d["tabulate_expression"] = CF.c_format(parts)
 
     if len(ir.original_coefficient_positions) > 0:
-        d[
-            "original_coefficient_positions"
-        ] = f"original_coefficient_positions_{ir.name}"
+        d["original_coefficient_positions"] = f"original_coefficient_positions_{ir.name}"
         n = len(ir.original_coefficient_positions)
         originals = ", ".join(str(i) for i in ir.original_coefficient_positions)
-        d[
-            "original_coefficient_positions_init"
-        ] = f"static int original_coefficient_positions_{ir.name}[{n}] = {{{originals}}};"
+        d["original_coefficient_positions_init"] = (
+            f"static int original_coefficient_positions_{ir.name}[{n}] = {{{originals}}};"
+        )
 
     else:
         d["original_coefficient_positions"] = "NULL"
@@ -78,9 +76,9 @@ def generator(ir, options):
     if len(ir.coefficient_names) > 0:
         names = ", ".join(f'"{name}"' for name in ir.coefficient_names)
         n = len(ir.coefficient_names)
-        d[
-            "coefficient_names_init"
-        ] = f"static const char* coefficient_names_{ir.name}[{n}] = {{{names}}};"
+        d["coefficient_names_init"] = (
+            f"static const char* coefficient_names_{ir.name}[{n}] = {{{names}}};"
+        )
 
         d["coefficient_names"] = f"coefficient_names_{ir.name}"
     else:
@@ -90,9 +88,9 @@ def generator(ir, options):
     if len(ir.constant_names) > 0:
         names = ", ".join(f'"{name}"' for name in ir.constant_names)
         n = len(ir.constant_names)
-        d[
-            "constant_names_init"
-        ] = f"static const char* constant_names_{ir.name}[{n}] = {{{names}}};"
+        d["constant_names_init"] = (
+            f"static const char* constant_names_{ir.name}[{n}] = {{{names}}};"
+        )
         d["constant_names"] = f"constant_names_{ir.name}"
     else:
         d["constant_names_init"] = ""
@@ -103,9 +101,7 @@ def generator(ir, options):
     # FIXME: Should be handled differently, revise how
     # ufcx_function_space is generated (also for ufcx_form)
     for name, (element, dofmap, cmap_family, cmap_degree) in ir.function_spaces.items():
-        code += [
-            f"static ufcx_function_space function_space_{name}_{ir.name_from_uflfile} ="
-        ]
+        code += [f"static ufcx_function_space function_space_{name}_{ir.name_from_uflfile} ="]
         code += ["{"]
         code += [f".finite_element = &{element},"]
         code += [f".dofmap = &{dofmap},"]
@@ -123,24 +119,18 @@ def generator(ir, options):
             for (name, _) in ir.function_spaces.items()
         )
         n = len(ir.function_spaces.items())
-        d[
-            "function_spaces_init"
-        ] = f"ufcx_function_space* function_spaces_{ir.name}[{n}] = {{{fs_list}}};"
+        d["function_spaces_init"] = (
+            f"ufcx_function_space* function_spaces_{ir.name}[{n}] = {{{fs_list}}};"
+        )
     else:
         d["function_spaces"] = "NULL"
         d["function_spaces_init"] = ""
 
     # Check that no keys are redundant or have been missed
     from string import Formatter
 
-    fields = [
-        fname
-        for _, fname, _, _ in Formatter().parse(expressions_template.factory)
-        if fname
-    ]
-    assert set(fields) == set(
-        d.keys()
-    ), "Mismatch between keys in template and in formatting dict"
+    fields = [fname for _, fname, _, _ in Formatter().parse(expressions_template.factory) if fname]
+    assert set(fields) == set(d.keys()), "Mismatch between keys in template and in formatting dict"
 
     # Format implementation code
     implementation = expressions_template.factory.format_map(d)

ffcx/codegeneration/cpp/file.py

@@ -29,9 +29,7 @@ def generator(options):
     extra_includes = []
     if "_Complex" in options["scalar_type"]:
         extra_includes += ["complex"]
-    d["extra_includes"] = "\n".join(
-        f"#include <{header}>" for header in extra_includes
-    )
+    d["extra_includes"] = "\n".join(f"#include <{header}>" for header in extra_includes)
 
     # Format declaration code
     code_pre = (

ffcx/codegeneration/cpp/integrals.py

@@ -21,7 +21,6 @@ def generator(ir, options):
     logger.info(f"--- type: {ir.expression.integral_type}")
     logger.info(f"--- name: {ir.expression.name}")
 
-
     factory_name = ir.expression.name
 
     # Format declaration

ffcx/codegeneration/numba/__init__.py

@@ -1,3 +1,3 @@
-from ffcx.codegeneration.numba import form, expressions, integrals, file # noqa
+from ffcx.codegeneration.numba import form, expressions, integrals, file  # noqa
 
 suffixes = (None, "_numba.py")

ffcx/codegeneration/numba/expressions.py

@@ -83,9 +83,7 @@ def generator(ir, options):
     # FIXME: Should be handled differently, revise how
     # ufcx_function_space is generated (also for ufcx_form)
     for name, (element, dofmap, cmap_family, cmap_degree) in ir.function_spaces.items():
-        code += [
-            f"static ufcx_function_space function_space_{name}_{ir.name_from_uflfile} ="
-        ]
+        code += [f"static ufcx_function_space function_space_{name}_{ir.name_from_uflfile} ="]
         code += ["{"]
         code += [f".finite_element = &{element},"]
         code += [f".dofmap = &{dofmap},"]
@@ -103,9 +101,9 @@ def generator(ir, options):
             for (name, _) in ir.function_spaces.items()
         )
         n = len(ir.function_spaces.items())
-        d[
-            "function_spaces_init"
-        ] = f"ufcx_function_space* function_spaces_{ir.name}[{n}] = {{{fs_list}}};"
+        d["function_spaces_init"] = (
+            f"ufcx_function_space* function_spaces_{ir.name}[{n}] = {{{fs_list}}};"
+        )
     else:
         d["function_spaces"] = "NULL"
         d["function_spaces_init"] = ""

ffcx/codegeneration/numba/file.py

@@ -8,7 +8,6 @@
 # old implementation in FFC
 """Generate file output for numba."""
 
-
 import logging
 import pprint
 import textwrap

ffcx/codegeneration/numba/form.py

@@ -29,7 +29,7 @@ def generator(ir, options):
     d["num_coefficients"] = ir.num_coefficients
     d["num_constants"] = ir.num_constants
 
-    orig_coeff = ', '.join(str(i) for i in ir.original_coefficient_positions)
+    orig_coeff = ", ".join(str(i) for i in ir.original_coefficient_positions)
     d["original_coefficient_position"] = f"[{orig_coeff}]"
 
     cnames = ir.coefficient_names
@@ -59,9 +59,7 @@ def generator(ir, options):
     # Check that no keys are redundant or have been missed
     from string import Formatter
 
-    fields = [
-        fname for _, fname, _, _ in Formatter().parse(form_template.factory) if fname
-    ]
+    fields = [fname for _, fname, _, _ in Formatter().parse(form_template.factory) if fname]
 
     for f in fields:
         if f not in d.keys():

ffcx/codegeneration/numba/numba_implementation.py

@@ -1,4 +1,5 @@
 """Numba implementation for output."""
+
 import ffcx.codegeneration.lnodes as L
 
 
@@ -15,6 +16,7 @@ def build_initializer_lists(values):
 
 class NumbaFormatter:
     """Implementation for numba output backend."""
+
     def __init__(self, scalar) -> None:
         """Initialise."""
         self.scalar_type = scalar
@@ -185,9 +187,16 @@ def format_symbol(self, s):
 
     def format_mathfunction(self, f):
         """Format a math function."""
-        function_map = {"ln": "log", "acos": "arccos", "asin": "arcsin",
-                        "atan": "arctan", "atan2": "arctan2", "acosh": "arccosh",
-                        "asinh": "arcsinh", "atanh": "arctanh"}
+        function_map = {
+            "ln": "log",
+            "acos": "arccos",
+            "asin": "arcsin",
+            "atan": "arctan",
+            "atan2": "arctan2",
+            "acosh": "arccosh",
+            "asinh": "arcsinh",
+            "atanh": "arctanh",
+        }
         function = function_map.get(f.function, f.function)
         args = [self.c_format(arg) for arg in f.args]
         if "bessel" in function: