Satisfy flake8-comprehensions

Author: inducer

loopy/codegen/control.py

@@ -452,8 +452,7 @@ def gen_code(inner_codegen_state):
                 def gen_code(inner_codegen_state):  # noqa pylint:disable=function-redefined
                     condition_exprs = [
                             constraint_to_cond_expr(cns)
-                            for cns in bounds_checks] + [
-                                pred_chk for pred_chk in pred_checks]
+                            for cns in bounds_checks] + list(pred_checks)
 
                     prev_result = prev_gen_code(inner_codegen_state)
 

loopy/kernel/creation.py

@@ -2567,7 +2567,7 @@ def make_function(domains, instructions, kernel_data=None, **kwargs):
 
 def make_kernel(*args, **kwargs):
     tunit = make_function(*args, **kwargs)
-    name, = [name for name in tunit.callables_table]
+    name, = tunit.callables_table
     return tunit.with_entrypoints(name)
 
 

loopy/kernel/instruction.py

@@ -1244,7 +1244,7 @@ class CInstruction(InstructionBase):
 
     def __init__(self,
             iname_exprs, code,
-            read_variables=frozenset(), assignees=tuple(),
+            read_variables=frozenset(), assignees=(),
             id=None, depends_on=None, depends_on_is_final=None,
             groups=None, conflicts_with_groups=None,
             no_sync_with=None,

loopy/schedule/__init__.py

@@ -1333,11 +1333,8 @@ def insn_sort_key(insn_id):
                 - sched_state.ilp_inames
                 - sched_state.vec_inames
                 )
-            priority_tiers = [t for t in
-                              get_priority_tiers(wanted,
-                                                 sched_state.kernel.loop_priority
-                                                 )
-                              ]
+            priority_tiers = list(
+                    get_priority_tiers(wanted, sched_state.kernel.loop_priority))
 
             # Update the loop priority set, because some constraints may have
             # have been contradictary.
@@ -1750,8 +1747,7 @@ def _insn_ids_reaching_end(schedule, kind, reverse):
                     sched_item.synchronization_kind, kind):
                 insn_ids_alive_at_scope[-1].clear()
         else:
-            insn_ids_alive_at_scope[-1] |= {
-                    insn_id for insn_id in sched_item_to_insn_id(sched_item)}
+            insn_ids_alive_at_scope[-1] |= set(sched_item_to_insn_id(sched_item))
 
     assert len(insn_ids_alive_at_scope) == 1
     return insn_ids_alive_at_scope[-1]

loopy/statistics.py

@@ -81,7 +81,7 @@
 
 def get_kernel_parameter_space(kernel):
     return isl.Space.create_from_names(kernel.isl_context,
-            set=[], params=sorted(list(kernel.outer_params()))).params()
+            set=[], params=sorted(kernel.outer_params())).params()
 
 
 def get_kernel_zero_pwqpolynomial(kernel):

loopy/symbolic.py

@@ -611,7 +611,7 @@ def __getinitargs__(self):
         return (self.child, self.dtype, self.prefix)
 
     def get_extra_properties(self):
-        return dict(dtype=self.dtype)
+        return {"dtype": self.dtype}
 
 
 class TypeAnnotation(LoopyExpressionBase):

loopy/target/c/c_execution.py

@@ -131,14 +131,9 @@ def handle_alloc(
         strides = get_strides(arg)
         order = "'C'" if (arg.shape == () or strides[-1] == 1) else "'F'"
 
-        gen("%(name)s = _lpy_np.empty(%(shape)s, "
-                "%(dtype)s, order=%(order)s)"
-                % dict(
-                    name=arg.name,
-                    shape=strify(sym_shape),
-                    dtype=self.python_dtype_str(
-                        gen, arg.dtype.numpy_dtype),
-                    order=order))
+        gen(f"{arg.name} = _lpy_np.empty({strify(sym_shape)}, "
+                f"{self.python_dtype_str(gen, arg.dtype.numpy_dtype)}, "
+                f"order={order})")
 
         expected_strides = tuple(
                 var("_lpy_expected_strides_%s" % i)
@@ -152,12 +147,9 @@ def handle_alloc(
                     [strify(s) for s in sym_shape],
                     [strify(s) for s in sym_strides],
                     [strify(s) for s in expected_strides])
-            gen("assert %(strides_check)s, "
-                    "'Strides of loopy created array %(name)s, "
-                    "do not match expected.'" %
-                    dict(strides_check=strides_check_expr,
-                         name=arg.name,
-                         strides=strify(sym_strides)))
+            gen(f"assert {strides_check_expr}, "
+                    f"'Strides of loopy created array {arg.name}, "
+                    "do not match expected.'")
             for i in range(num_axes):
                 gen("del _lpy_shape_%d" % i)
                 gen("del _lpy_strides_%d" % i)

loopy/target/cuda.py

@@ -86,10 +86,10 @@ def _create_vector_types():
                 titles.extend((len(names)-len(titles))*[None])
 
             try:
-                dtype = np.dtype(dict(
-                    names=names,
-                    formats=[base_type]*count,
-                    titles=titles))
+                dtype = np.dtype({
+                    "names": names,
+                    "formats": [base_type]*count,
+                    "titles": titles})
             except NotImplementedError:
                 try:
                     dtype = np.dtype([((n, title), base_type)

loopy/target/execution.py

@@ -729,15 +729,14 @@ def __init__(self, t_unit: TranslationUnit, entrypoint: str):
         self.entrypoint = entrypoint
 
         kernel = self.t_unit[entrypoint]
-        self.output_names = set(arg.name for arg in kernel.args if arg.is_output)
+        self.output_names = {arg.name for arg in kernel.args if arg.is_output}
 
         from loopy import ArrayArg
-        self.input_array_names = set(
+        self.input_array_names = {
             arg.name for arg in kernel.args
-            if arg.is_input and isinstance(arg, ArrayArg))
+            if arg.is_input and isinstance(arg, ArrayArg)}
 
-        self.has_runtime_typed_args = any(
-            arg.dtype is None for arg in kernel.args)
+        self.has_runtime_typed_args = any(arg.dtype is None for arg in kernel.args)
 
         # We're doing this ahead of time to learn about array separation.
         # This will be done again as part of preprocessing below, and we're

loopy/target/opencl.py

@@ -129,10 +129,10 @@ def _create_vector_types():
                 titles.extend((len(names)-len(titles))*[None])
 
             try:
-                dtype = np.dtype(dict(
-                    names=names,
-                    formats=[base_type]*padded_count,
-                    titles=titles))
+                dtype = np.dtype({
+                    "names": names,
+                    "formats": [base_type]*padded_count,
+                    "titles": titles})
             except NotImplementedError:
                 try:
                     dtype = np.dtype([((n, title), base_type)
@@ -492,12 +492,12 @@ def opencl_preamble_generator(preamble_info):
     from loopy.tools import remove_common_indentation
     kernel = preamble_info.kernel
 
+    idx_ctype = kernel.target.dtype_to_typename(kernel.index_dtype)
     yield ("00_declare_gid_lid",
-            remove_common_indentation("""
-                #define lid(N) ((%(idx_ctype)s) get_local_id(N))
-                #define gid(N) ((%(idx_ctype)s) get_group_id(N))
-                """ % dict(idx_ctype=kernel.target.dtype_to_typename(
-                    kernel.index_dtype))))
+            remove_common_indentation(f"""
+                #define lid(N) (({idx_ctype}) get_local_id(N))
+                #define gid(N) (({idx_ctype}) get_group_id(N))
+                """))
 
     for func in preamble_info.seen_functions:
         if func.name == "pow" and func.c_name == "powf32":