STY: Apply ruff/flake8-bugbear rule B007

B007 Loop control variable not used within loop body

Co-authored-by: Chris Markiewicz <[email protected]>

Author: DimitriPapadopoulos

nipype/algorithms/mesh.py

@@ -244,7 +244,7 @@ def _run_interface(self, runtime):
         if self.inputs.weighting == "area":
             faces = vtk1.polys.to_array().reshape(-1, 4).astype(int)[:, 1:]
 
-            for i, p1 in enumerate(points2):
+            for i, _ in enumerate(points2):
                 # compute surfaces, set in weight
                 w = 0.0
                 point_faces = faces[(faces[:, :] == i).any(axis=1)]

nipype/algorithms/modelgen.py

@@ -389,7 +389,7 @@ def _generate_standard_design(
             if hasattr(info, "conditions") and info.conditions is not None:
                 for cid, cond in enumerate(info.conditions):
                     sessinfo[i]["cond"].insert(cid, dict())
-                    sessinfo[i]["cond"][cid]["name"] = info.conditions[cid]
+                    sessinfo[i]["cond"][cid]["name"] = cond
                     scaled_onset = scale_timings(
                         info.onsets[cid],
                         self.inputs.input_units,
@@ -434,12 +434,11 @@ def _generate_standard_design(
                         sessinfo[i]["regress"][j]["name"] = info.regressor_names[j]
                     else:
                         sessinfo[i]["regress"][j]["name"] = "UR%d" % (j + 1)
-                    sessinfo[i]["regress"][j]["val"] = info.regressors[j]
+                    sessinfo[i]["regress"][j]["val"] = r
             sessinfo[i]["scans"] = functional_runs[i]
 
         if realignment_parameters is not None:
-            for i, rp in enumerate(realignment_parameters):
-                mc = realignment_parameters[i]
+            for i, mc in enumerate(realignment_parameters):
                 for col in range(mc.shape[1]):
                     colidx = len(sessinfo[i]["regress"])
                     sessinfo[i]["regress"].insert(colidx, dict(name="", val=[]))
@@ -597,14 +596,14 @@ def _concatenate_info(self, infolist):
         for i, info in enumerate(infolist[1:]):
             # info.[conditions, tmod] remain the same
             if info.onsets:
-                for j, val in enumerate(info.onsets):
+                for j, onsets in enumerate(info.onsets):
                     if self.inputs.input_units == "secs":
-                        onsets = np.array(
-                            info.onsets[j]
-                        ) + self.inputs.time_repetition * sum(nscans[0 : (i + 1)])
+                        onsets = np.array(onsets) + self.inputs.time_repetition * sum(
+                            nscans[0 : (i + 1)]
+                        )
                         infoout.onsets[j].extend(onsets.tolist())
                     else:
-                        onsets = np.array(info.onsets[j]) + sum(nscans[0 : (i + 1)])
+                        onsets = np.array(onsets) + sum(nscans[0 : (i + 1)])
                         infoout.onsets[j].extend(onsets.tolist())
 
                 for j, val in enumerate(info.durations):
@@ -621,8 +620,8 @@ def _concatenate_info(self, infolist):
                         )
 
                 if hasattr(info, "amplitudes") and info.amplitudes:
-                    for j, val in enumerate(info.amplitudes):
-                        infoout.amplitudes[j].extend(info.amplitudes[j])
+                    for j, amplitudes in enumerate(info.amplitudes):
+                        infoout.amplitudes[j].extend(amplitudes)
 
                 if hasattr(info, "pmod") and info.pmod:
                     for j, val in enumerate(info.pmod):
@@ -633,8 +632,8 @@ def _concatenate_info(self, infolist):
             if hasattr(info, "regressors") and info.regressors:
                 # assumes same ordering of regressors across different
                 # runs and the same names for the regressors
-                for j, v in enumerate(info.regressors):
-                    infoout.regressors[j].extend(info.regressors[j])
+                for j, regressors in enumerate(info.regressors):
+                    infoout.regressors[j].extend(regressors)
 
             # insert session regressors
             if not hasattr(infoout, "regressors") or not infoout.regressors:

nipype/interfaces/cmtk/nx.py

@@ -351,7 +351,7 @@ def add_node_data(node_array, ntwk):
 def add_edge_data(edge_array, ntwk, above=0, below=0):
     edge_ntwk = ntwk.copy()
     data = {}
-    for x, row in enumerate(edge_array):
+    for x, row in enumerate(edge_array):  # noqa: B007
         for y in range(np.max(np.shape(edge_array[x]))):
             if edge_array[x, y] != 0:
                 data["value"] = edge_array[x, y]
@@ -550,14 +550,14 @@ def _run_interface(self, runtime):
         # stacks them together, and saves them in a MATLAB .mat file via Scipy
         global dicts
         dicts = list()
-        for idx, key in enumerate(dict_measures.keys()):
-            for idxd, keyd in enumerate(dict_measures[key].keys()):
+        for key, value in dict_measures.items():
+            for idxd, keyd in enumerate(value.keys()):
                 if idxd == 0:
                     nparraykeys = np.array(keyd)
-                    nparrayvalues = np.array(dict_measures[key][keyd])
+                    nparrayvalues = np.array(value[keyd])
                 else:
                     nparraykeys = np.append(nparraykeys, np.array(keyd))
-                    values = np.array(dict_measures[key][keyd])
+                    values = np.array(value[keyd])
                     nparrayvalues = np.append(nparrayvalues, values)
             nparray = np.vstack((nparraykeys, nparrayvalues))
             out_file = op.abspath(self._gen_outfilename(key, "mat"))

nipype/interfaces/cmtk/parcellation.py

@@ -598,7 +598,7 @@ def create_wm_mask(subject_id, subjects_dir, fs_dir, parcellation_name):
     roid = np.asanyarray(roi.dataobj)
     assert roid.shape[0] == wmmask.shape[0]
     pg = nx.read_graphml(pgpath)
-    for brk, brv in pg.nodes(data=True):
+    for brk, brv in pg.nodes(data=True):  # noqa: B007
         if brv["dn_region"] == "cortical":
             iflogger.info(
                 "Subtracting region %s with intensity value %s",

nipype/interfaces/dcmstack.py

@@ -186,7 +186,7 @@ def _run_interface(self, runtime):
         stacks = dcmstack.parse_and_stack(src_paths)
 
         self.out_list = []
-        for key, stack in list(stacks.items()):
+        for stack in stacks.values():
             nw = NiftiWrapper(stack.to_nifti(embed_meta=True))
             const_meta = nw.meta_ext.get_class_dict(("global", "const"))
             out_path = self._get_out_path(const_meta)

nipype/interfaces/dipy/simulate.py

@@ -208,7 +208,7 @@ def _run_interface(self, runtime):
                 dirs = np.hstack((dirs, fd[msk > 0]))
 
         # Add random directions for isotropic components
-        for d in range(nballs):
+        for _ in range(nballs):
             fd = np.random.randn(nvox, 3)
             w = np.linalg.norm(fd, axis=1)
             fd[w < np.finfo(float).eps, ...] = np.array([1.0, 0.0, 0.0])
@@ -341,7 +341,7 @@ def _generate_gradients(ndirs=64, values=[1000, 3000], nb0s=1):
         bvecs = np.vstack((bvecs, vertices))
         bvals = np.hstack((bvals, v * np.ones(vertices.shape[0])))
 
-    for i in range(nb0s):
+    for _ in range(nb0s):
         bvals = bvals.tolist()
         bvals.insert(0, 0)
 

nipype/interfaces/fsl/model.py

@@ -199,8 +199,8 @@ def _create_ev_files(
         # generate sections for conditions and other nuisance
         # regressors
         num_evs = [0, 0]
-        for field in ["cond", "regress"]:
-            for i, cond in enumerate(runinfo[field]):
+        for field in ("cond", "regress"):
+            for cond in runinfo[field]:
                 name = cond["name"]
                 evname.append(name)
                 evfname = os.path.join(
@@ -279,9 +279,7 @@ def _create_ev_files(
             contrastmask_element = load_template("feat_contrastmask_element.tcl")
             # add t/f contrast info
             ev_txt += contrast_header.substitute()
-            con_names = []
-            for j, con in enumerate(contrasts):
-                con_names.append(con[0])
+            con_names = [con[0] for con in contrasts]
             con_map = {}
             ftest_idx = []
             ttest_idx = []
@@ -365,7 +363,7 @@ def _run_interface(self, runtime):
         n_tcon = 0
         n_fcon = 0
         if isdefined(self.inputs.contrasts):
-            for i, c in enumerate(self.inputs.contrasts):
+            for c in self.inputs.contrasts:
                 if c[1] == "T":
                     n_tcon += 1
                 elif c[1] == "F":
@@ -422,7 +420,7 @@ def _list_outputs(self):
             outputs["ev_files"].insert(runno, [])
             evname = []
             for field in ["cond", "regress"]:
-                for i, cond in enumerate(runinfo[field]):
+                for cond in runinfo[field]:
                     name = cond["name"]
                     evname.append(name)
                     evfname = os.path.join(
@@ -1389,8 +1387,7 @@ def _run_interface(self, runtime):
             "",
             "/Matrix",
         ]
-        for i in range(self.inputs.num_copes):
-            mat_txt += ["1"]
+        grp_txt.extend(["1"] * self.inputs.num_copes)
         mat_txt = "\n".join(mat_txt)
 
         con_txt = [
@@ -1412,16 +1409,15 @@ def _run_interface(self, runtime):
             "",
             "/Matrix",
         ]
-        for i in range(self.inputs.num_copes):
-            grp_txt += ["1"]
+        grp_txt.extend(["1"] * self.inputs.num_copes)
         grp_txt = "\n".join(grp_txt)
 
         txt = {"design.mat": mat_txt, "design.con": con_txt, "design.grp": grp_txt}
 
         # write design files
-        for i, name in enumerate(["design.mat", "design.con", "design.grp"]):
+        for name, name_txt in txt.items():
             with open(os.path.join(cwd, name), "w") as f:
-                f.write(txt[name])
+                f.write(name_txt)
 
         return runtime
 
@@ -1560,7 +1556,7 @@ def _run_interface(self, runtime):
                 "",
                 "/Matrix",
             ]
-            for conidx, con in enumerate(self.inputs.contrasts):
+            for con in self.inputs.contrasts:
                 if con[1] == "F":
                     convals = np.zeros((ntcons, 1))
                     for tcon in con[2]:

nipype/interfaces/fsl/preprocess.py

@@ -416,63 +416,52 @@ def _list_outputs(self):
 
         outputs["tissue_class_map"] = self._gen_fname(suffix="_seg", **_gen_fname_opts)
         if self.inputs.segments:
-            outputs["tissue_class_files"] = []
-            for i in range(nclasses):
-                outputs["tissue_class_files"].append(
-                    self._gen_fname(suffix="_seg_%d" % i, **_gen_fname_opts)
-                )
+            outputs["tissue_class_files"] = [
+                self._gen_fname(suffix=f"_seg_{i}", **_gen_fname_opts)
+                for i in range(nclasses)
+            ]
         if isdefined(self.inputs.output_biascorrected):
-            outputs["restored_image"] = []
             if len(self.inputs.in_files) > 1:
                 # for multi-image segmentation there is one corrected image
                 # per input
-                for val, f in enumerate(self.inputs.in_files):
-                    # image numbering is 1-based
-                    outputs["restored_image"].append(
-                        self._gen_fname(
-                            suffix="_restore_%d" % (val + 1), **_gen_fname_opts
-                        )
-                    )
+                outputs["restored_image"] = [
+                    self._gen_fname(suffix=f"_restore_{i}", **_gen_fname_opts)
+                    for i in range(1, len(self.inputs.in_files) + 1)
+                ]
             else:
                 # single image segmentation has unnumbered output image
-                outputs["restored_image"].append(
+                outputs["restored_image"] = [
                     self._gen_fname(suffix="_restore", **_gen_fname_opts)
-                )
+                ]
 
         outputs["mixeltype"] = self._gen_fname(suffix="_mixeltype", **_gen_fname_opts)
         if not self.inputs.no_pve:
             outputs["partial_volume_map"] = self._gen_fname(
                 suffix="_pveseg", **_gen_fname_opts
             )
-            outputs["partial_volume_files"] = []
-            for i in range(nclasses):
-                outputs["partial_volume_files"].append(
-                    self._gen_fname(suffix="_pve_%d" % i, **_gen_fname_opts)
-                )
+            outputs["partial_volume_files"] = [
+                self._gen_fname(suffix=f"_pve_{i}", **_gen_fname_opts)
+                for i in range(nclasses)
+            ]
         if self.inputs.output_biasfield:
-            outputs["bias_field"] = []
             if len(self.inputs.in_files) > 1:
                 # for multi-image segmentation there is one bias field image
                 # per input
-                for val, f in enumerate(self.inputs.in_files):
-                    # image numbering is 1-based
-                    outputs["bias_field"].append(
-                        self._gen_fname(
-                            suffix="_bias_%d" % (val + 1), **_gen_fname_opts
-                        )
-                    )
+                outputs["bias_field"] = [
+                    self._gen_fname(suffix=f"_bias_{i}", **_gen_fname_opts)
+                    for i in range(1, len(self.inputs.in_files) + 1)
+                ]
             else:
                 # single image segmentation has unnumbered output image
-                outputs["bias_field"].append(
+                outputs["bias_field"] = [
                     self._gen_fname(suffix="_bias", **_gen_fname_opts)
-                )
+                ]
 
         if self.inputs.probability_maps:
-            outputs["probability_maps"] = []
-            for i in range(nclasses):
-                outputs["probability_maps"].append(
-                    self._gen_fname(suffix="_prob_%d" % i, **_gen_fname_opts)
-                )
+            outputs["probability_maps"] = [
+                self._gen_fname(suffix="_prob_{i}", **_gen_fname_opts)
+                for i in range(nclasses)
+            ]
         return outputs
 
 

nipype/interfaces/io.py

@@ -609,7 +609,7 @@ def _upload_to_s3(self, bucket, src, dst):
         # If src is a directory, collect files (this assumes dst is a dir too)
         if os.path.isdir(src):
             src_files = []
-            for root, dirs, files in os.walk(src):
+            for root, dirs, files in os.walk(src):  # noqa: B007
                 src_files.extend([os.path.join(root, fil) for fil in files])
             # Make the dst files have the dst folder as base dir
             dst_files = [os.path.join(dst, src_f.split(src)[1]) for src_f in src_files]
@@ -1393,7 +1393,7 @@ def __init__(self, templates, **kwargs):
 
         # Infer the infields and outfields from the template
         infields = []
-        for name, template in list(templates.items()):
+        for template in templates.values():
             for _, field_name, _, _ in string.Formatter().parse(template):
                 if field_name is not None:
                     field_name = re.match(r"\w+", field_name).group()

nipype/interfaces/mrtrix/convert.py

@@ -100,9 +100,10 @@ def points_per_track(offset):
         ]  # Converts numpy array to list, removes the last value
         for idx, value in enumerate(nonfinite_list):
             if idx == 0:
-                track_points.append(nonfinite_list[idx])
+                track_points.append(value)
             else:
-                track_points.append(nonfinite_list[idx] - nonfinite_list[idx - 1] - 1)
+                track_points.append(value - last_value - 1)
+            last_value = value
         return track_points, nonfinite_list
 
     def track_gen(track_points):