Fix ruff C409 failures

Author: inducer

arraycontext/container/arithmetic.py

@@ -579,9 +579,8 @@ def is_numpy_array(arg):
             for i, bct in enumerate(bcast_container_types):
                 gen(f"from {bct.__module__} import {bct.__qualname__} as _bctype{i}")
             gen("")
-        outer_bcast_type_names = tuple([
-                f"_bctype{i}" for i in range(len(bcast_container_types))
-                ])
+        outer_bcast_type_names = tuple(
+                f"_bctype{i}" for i in range(len(bcast_container_types)))
         if bcast_number:
             outer_bcast_type_names += ("Number",)
 

arraycontext/context.py

@@ -475,7 +475,7 @@ def einsum(self,
         :return: the output of the einsum :mod:`loopy` program
         """
         if arg_names is None:
-            arg_names = tuple([f"arg{i}" for i in range(len(args))])
+            arg_names = tuple(f"arg{i}" for i in range(len(args)))
 
         prg = self._get_einsum_prg(spec, arg_names, tagged)
         out_ary = self.call_loopy(

arraycontext/impl/pytato/compile.py

@@ -214,18 +214,19 @@ def _get_f_placeholder_args(arg, kw, arg_id_to_name, actx):
     :attr:`BaseLazilyCompilingFunctionCaller.f`.
     """
     if np.isscalar(arg):
-        name = arg_id_to_name[(kw,)]
+        name = arg_id_to_name[kw,]
         return pt.make_placeholder(name, (), np.dtype(type(arg)))
     elif isinstance(arg, pt.Array):
-        name = arg_id_to_name[(kw,)]
+        name = arg_id_to_name[kw,]
         # Transform the DAG to give metadata inference a chance to do its job
         arg = _to_input_for_compiled(arg, actx)
         return pt.make_placeholder(name, arg.shape, arg.dtype,
                                    axes=arg.axes,
                                    tags=arg.tags)
     elif is_array_container_type(arg.__class__):
         def _rec_to_placeholder(keys, ary):
-            name = arg_id_to_name[(kw, *keys)]
+            index = (kw, *keys)
+            name = arg_id_to_name[index]
             # Transform the DAG to give metadata inference a chance to do its job
             ary = _to_input_for_compiled(ary, actx)
             return pt.make_placeholder(name,

arraycontext/pytest.py

@@ -396,7 +396,7 @@ def inner(metafunc):
 
         # NOTE: sorts the args so that parallel pytest works
         arg_value_tuples = sorted([
-                tuple([arg_dict[name] for name in arg_names])
+                tuple(arg_dict[name] for name in arg_names)
                 for arg_dict in arg_values_with_actx
                 ], key=lambda x: str(x))
 

arraycontext/version.py

@@ -8,7 +8,7 @@ def _parse_version(version: str) -> Tuple[Tuple[int, ...], str]:
     m = re.match("^([0-9.]+)([a-z0-9]*?)$", VERSION_TEXT)
     assert m is not None
 
-    return tuple([int(nr) for nr in m.group(1).split(".")]), m.group(2)
+    return tuple(int(nr) for nr in m.group(1).split(".")), m.group(2)
 
 
 VERSION_TEXT = metadata.version("arraycontext")

test/test_arraycontext.py

@@ -173,11 +173,11 @@ def size(self):
 
     @property
     def real(self):
-        return DOFArray(self.array_context, tuple([subary.real for subary in self]))
+        return DOFArray(self.array_context, tuple(subary.real for subary in self))
 
     @property
     def imag(self):
-        return DOFArray(self.array_context, tuple([subary.imag for subary in self]))
+        return DOFArray(self.array_context, tuple(subary.imag for subary in self))
 
 
 @serialize_container.register(DOFArray)
@@ -261,9 +261,8 @@ def _get_test_containers(actx, ambient_dim=2, shapes=50_000):
     if isinstance(shapes, (Number, tuple)):
         shapes = [shapes]
 
-    x = DOFArray(actx, tuple([
-        actx.from_numpy(randn(shape, np.float64))
-        for shape in shapes]))
+    x = DOFArray(actx, tuple(actx.from_numpy(randn(shape, np.float64))
+        for shape in shapes))
 
     # pylint: disable=unexpected-keyword-arg, no-value-for-parameter
     dataclass_of_dofs = MyContainer(
@@ -1084,13 +1083,11 @@ def test_flatten_array_container(actx_factory, shapes):
     if isinstance(shapes, (int, tuple)):
         shapes = [shapes]
 
-    ary = DOFArray(actx, tuple([
-        actx.from_numpy(randn(shape, np.float64))
-        for shape in shapes]))
+    ary = DOFArray(actx, tuple(actx.from_numpy(randn(shape, np.float64))
+        for shape in shapes))
 
-    template = DOFArray(actx, tuple([
-        actx.from_numpy(randn(shape, np.complex128))
-        for shape in shapes]))
+    template = DOFArray(actx, tuple(actx.from_numpy(randn(shape, np.complex128))
+        for shape in shapes))
 
     flat = flatten(ary, actx)
     ary_roundtrip = unflatten(template, flat, actx, strict=False)