Fix lint formatting

var/exp_repo/experiments/amg2023/experiment.py

@@ -40,23 +40,23 @@ def make_experiment_strong_scaling(self):
         app_name = self.spec.name
         variables = {}
 
-        #TODO: Use variant for px, py, pz
+        # TODO: Use variant for px, py, pz
         p = 2
         p_list = self.generate_strong_scaling_parameters([p,p,p])
         variables["px"] = p_list[0]
         variables["py"] = p_list[1]
         variables["pz"] = p_list[2]
 
-        #TODO: Use variant for nx, ny, nz
+        # TODO: Use variant for nx, ny, nz
         n = 10
         variables["nx"] = n
         variables["ny"] = n
         variables["nz"] = n
 
-        #TODO: Use allocation modifier here???
+        # TODO: Use allocation modifier here???
         if self.spec.satisfies("programming_model=openmp"):
             variables["n_ranks"] = "{px}*{py}*{pz}"
-            variables["n_threads_per_proc"] = '1'
+            variables["n_threads_per_proc"] = "1"
             exp_name = f"{app_name}_openmp_strong_{self.workload}_{{n_nodes}}_{{n_ranks}}_{{n_threads_per_proc}}_{{px}}_{{py}}_{{pz}}_{{nx}}_{{ny}}_{{nz}}"
         elif self.spec.satisfies("programming_model=cuda"):
             variables["n_gpus"] = "{px}*{py}*{pz}"
@@ -88,13 +88,13 @@ def make_experiment_weak_scaling(self):
         app_name = self.spec.name
         variables = {}
 
-        #TODO: Use variant for px, py, pz
+        # TODO: Use variant for px, py, pz
         p = 2
 
-        #TODO: Use variant for nx, ny, nz
+        # TODO: Use variant for nx, ny, nz
         n = 10
 
-        p_list, n_list = self.generate_weak_scaling_parameters([p,p,p], [n,n,n])
+        p_list, n_list = self.generate_weak_scaling_parameters([p, p, p], [n, n, n])
         variables["px"] = p_list[0]
         variables["py"] = p_list[1]
         variables["pz"] = p_list[2]
@@ -103,10 +103,10 @@ def make_experiment_weak_scaling(self):
         variables["ny"] = n_list[1]
         variables["nz"] = n_list[2]
 
-        #TODO: Use allocation modifier here???
+        # TODO: Use allocation modifier here???
         if self.spec.satisfies("programming_model=openmp"):
             variables["n_ranks"] = "{px}*{py}*{pz}"
-            variables["n_threads_per_proc"] = '1'
+            variables["n_threads_per_proc"] = "1"
             exp_name = f"{app_name}_openmp_weak_{self.workload}_{{n_nodes}}_{{n_ranks}}_{{n_threads_per_proc}}_{{px}}_{{py}}_{{pz}}_{{nx}}_{{ny}}_{{nz}}"
         elif self.spec.satisfies("programming_model=cuda"):
             variables["n_gpus"] = "{px}*{py}*{pz}"

var/exp_repo/experiments/kripke/experiment.py

@@ -71,7 +71,11 @@ def compute_applications_section(self):
             if self.spec.satisfies("scaling=weak"):
                 input_params[(npx, npy, npz)] = initial_np
                 input_params[(nzx, nzy, nzz)] = initial_nz
-            variables |= self.scale_experiment_variables(input_params, int(self.spec.variants['scaling-factor'][0]), int(self.spec.variants['scaling-iterations'][0]))
+            variables |= self.scale_experiment_variables(
+                input_params,
+                int(self.spec.variants["scaling-factor"][0]),
+                int(self.spec.variants["scaling-iterations"][0]),
+            )
 
         experiment_name_template = f"kripke_{self.spec.variants['programming_model'][0]}_{self.spec.variants['scaling'][0]}"
         experiment_name_template += "_{n_nodes}_{n_ranks}_{n_threads_per_proc}_{ngroups}_{gs}_{nquad}_{ds}_{lorder}_{nzx}_{nzy}_{nzz}_{npx}_{npy}_{npz}"

var/exp_repo/experiments/scalingexperiment/experiment.py

@@ -24,7 +24,7 @@ class ScalingExperiment(object):
     # the number of dimensions in an (ascending) round-robin order
     #
     # output:
-    # scaling_order: list[int]. list of num_exprs values, one for each dimension, 
+    # scaling_order: list[int]. list of num_exprs values, one for each dimension,
     # starting with the minimum value of the first element in input_variables arranged
     # in an ascending round-robin order
     def configure_scaling_policy(self, input_variables):
@@ -71,9 +71,7 @@ def scale_experiment_variables(self, input_variables, scaling_factor, num_exprs)
         for k, v in input_variables.items():
             if isinstance(k, str):
                 if not isinstance(v, int):
-                    raise RuntimeError(
-                        "Invalid key-value pair. Expected type str->int"
-                    )
+                    raise RuntimeError("Invalid key-value pair. Expected type str->int")
             elif isinstance(k, tuple) and all(isinstance(s, str) for s in k):
                 if isinstance(v, list) and all(isinstance(i, int) for i in v):
                     if len(k) != len(v):
@@ -92,24 +90,29 @@ def scale_experiment_variables(self, input_variables, scaling_factor, num_exprs)
                         "Invalid key-value pair. Expected type tuple(str)->list[int]"
                     )
             else:
-                raise RuntimeError(
-                    "Invalid key. Expected type str or tuple(str)"
-                )
+                raise RuntimeError("Invalid key. Expected type str or tuple(str)")
 
         # compute the scaling order based on the ordering_param
         scaling_order_index = self.configure_scaling_policy(input_variables)
 
         scaled_variables = {}
         for key, val in input_variables.items():
-            scaled_variables[key] = [[v] for v in val] if isinstance(val, list) else [[val]] 
+            scaled_variables[key] = (
+                [[v] for v in val] if isinstance(val, list) else [[val]]
+            )
 
         for exp_num in range(num_exprs - 1):
             for param in scaled_variables.values():
                 if len(param) == 1:
-                    param[0].append(param[0][-1]*scaling_factor)
+                    param[0].append(param[0][-1] * scaling_factor)
                 else:
                     for p_idx, p_val in enumerate(param):
-                        p_val.append(p_val[-1]*scaling_factor if p_idx == scaling_order_index[exp_num%len(scaling_order_index)] else p_val[-1])
+                        p_val.append(
+                            p_val[-1] * scaling_factor
+                            if p_idx
+                            == scaling_order_index[exp_num % len(scaling_order_index)]
+                            else p_val[-1]
+                        )
 
         output_variables = {}
         for k, v in scaled_variables.items():