STY: Apply ruff/pyupgrade rule UP032

UP032 Use f-string instead of `format` call

Author: DimitriPapadopoulos

nipype/algorithms/confounds.py

@@ -608,13 +608,8 @@ def _run_interface(self, runtime):
 
         if len(imgseries.shape) != 4:
             raise ValueError(
-                "{} expected a 4-D nifti file. Input {} has "
-                "{} dimensions (shape {})".format(
-                    self._header,
-                    self.inputs.realigned_file,
-                    len(imgseries.shape),
-                    imgseries.shape,
-                )
+                f"{self._header} expected a 4-D nifti file. Input {self.inputs.realigned_file} has "
+                f"{len(imgseries.shape)} dimensions (shape {imgseries.shape})"
             )
 
         if len(mask_images) == 0:
@@ -648,8 +643,8 @@ def _run_interface(self, runtime):
 
                 if TR == 0:
                     raise ValueError(
-                        "{} cannot detect repetition time from image - "
-                        "Set the repetition_time input".format(self._header)
+                        f"{self._header} cannot detect repetition time from image - "
+                        "Set the repetition_time input"
                     )
 
         if isdefined(self.inputs.variance_threshold):
@@ -753,8 +748,8 @@ def _run_interface(self, runtime):
                 f.write("\t".join(["component"] + list(metadata.keys())) + "\n")
                 for i in zip(components_names, *metadata.values()):
                     f.write(
-                        "{0[0]}\t{0[1]}\t{0[2]:.10f}\t"
-                        "{0[3]:.10f}\t{0[4]:.10f}\t{0[5]}\n".format(i)
+                        f"{i[0]}\t{i[1]}\t{i[2]:.10f}\t"
+                        f"{i[3]:.10f}\t{i[4]:.10f}\t{i[5]}\n"
                     )
 
         return runtime
@@ -1398,9 +1393,7 @@ def compute_noise_components(
         if imgseries.shape[:3] != mask.shape:
             raise ValueError(
                 "Inputs for CompCor, timeseries and mask, do not have "
-                "matching spatial dimensions ({} and {}, respectively)".format(
-                    imgseries.shape[:3], mask.shape
-                )
+                f"matching spatial dimensions ({imgseries.shape[:3]} and {mask.shape}, respectively)"
             )
 
         voxel_timecourses = imgseries[mask, :]

nipype/caching/memory.py

@@ -86,12 +86,7 @@ def __call__(self, **kwargs):
         return out
 
     def __repr__(self):
-        return "{}({}.{}), base_dir={})".format(
-            self.__class__.__name__,
-            self.interface.__module__,
-            self.interface.__name__,
-            self.base_dir,
-        )
+        return f"{self.__class__.__name__}({self.interface.__module__}.{self.interface.__name__}), base_dir={self.base_dir})"
 
 
 ###############################################################################

nipype/interfaces/ants/registration.py

@@ -204,11 +204,7 @@ def _transformation_constructor(self):
         return "".join(retval)
 
     def _regularization_constructor(self):
-        return "--regularization {}[{},{}]".format(
-            self.inputs.regularization,
-            self.inputs.regularization_gradient_field_sigma,
-            self.inputs.regularization_deformation_field_sigma,
-        )
+        return f"--regularization {self.inputs.regularization}[{self.inputs.regularization_gradient_field_sigma},{self.inputs.regularization_deformation_field_sigma}]"
 
     def _affine_gradient_descent_option_constructor(self):
         values = self.inputs.affine_gradient_descent_option
@@ -1242,10 +1238,7 @@ def _format_winsorize_image_intensities(self):
                 )
             )
         self._quantilesDone = True
-        return "--winsorize-image-intensities [ {}, {} ]".format(
-            self.inputs.winsorize_lower_quantile,
-            self.inputs.winsorize_upper_quantile,
-        )
+        return f"--winsorize-image-intensities [ {self.inputs.winsorize_lower_quantile}, {self.inputs.winsorize_upper_quantile} ]"
 
     def _get_initial_transform_filenames(self):
         n_transforms = len(self.inputs.initial_moving_transform)
@@ -1269,10 +1262,7 @@ def _get_initial_transform_filenames(self):
     def _format_arg(self, opt, spec, val):
         if opt == "fixed_image_mask":
             if isdefined(self.inputs.moving_image_mask):
-                return "--masks [ {}, {} ]".format(
-                    self.inputs.fixed_image_mask,
-                    self.inputs.moving_image_mask,
-                )
+                return f"--masks [ {self.inputs.fixed_image_mask}, {self.inputs.moving_image_mask} ]"
             else:
                 return "--masks %s" % self.inputs.fixed_image_mask
         elif opt == "transforms":
@@ -1309,16 +1299,9 @@ def _format_arg(self, opt, spec, val):
             out_filename = self._get_outputfilenames(inverse=False)
             inv_out_filename = self._get_outputfilenames(inverse=True)
             if out_filename and inv_out_filename:
-                return "--output [ {}, {}, {} ]".format(
-                    self.inputs.output_transform_prefix,
-                    out_filename,
-                    inv_out_filename,
-                )
+                return f"--output [ {self.inputs.output_transform_prefix}, {out_filename}, {inv_out_filename} ]"
             elif out_filename:
-                return "--output [ {}, {} ]".format(
-                    self.inputs.output_transform_prefix,
-                    out_filename,
-                )
+                return f"--output [ {self.inputs.output_transform_prefix}, {out_filename} ]"
             else:
                 return "--output %s" % self.inputs.output_transform_prefix
         elif opt == "winsorize_upper_quantile" or opt == "winsorize_lower_quantile":
@@ -1590,29 +1573,16 @@ class MeasureImageSimilarity(ANTSCommand):
 
     def _metric_constructor(self):
         retval = (
-            '--metric {metric}["{fixed_image}","{moving_image}",{metric_weight},'
-            "{radius_or_number_of_bins},{sampling_strategy},{sampling_percentage}]".format(
-                metric=self.inputs.metric,
-                fixed_image=self.inputs.fixed_image,
-                moving_image=self.inputs.moving_image,
-                metric_weight=self.inputs.metric_weight,
-                radius_or_number_of_bins=self.inputs.radius_or_number_of_bins,
-                sampling_strategy=self.inputs.sampling_strategy,
-                sampling_percentage=self.inputs.sampling_percentage,
-            )
+            f'--metric {self.inputs.metric}["{self.inputs.fixed_image}","{self.inputs.moving_image}",{self.inputs.metric_weight},'
+            f"{self.inputs.radius_or_number_of_bins},{self.inputs.sampling_strategy},{self.inputs.sampling_percentage}]"
         )
         return retval
 
     def _mask_constructor(self):
         if self.inputs.moving_image_mask:
-            retval = '--masks ["{fixed_image_mask}","{moving_image_mask}"]'.format(
-                fixed_image_mask=self.inputs.fixed_image_mask,
-                moving_image_mask=self.inputs.moving_image_mask,
-            )
+            retval = f'--masks ["{self.inputs.fixed_image_mask}","{self.inputs.moving_image_mask}"]'
         else:
-            retval = '--masks "{fixed_image_mask}"'.format(
-                fixed_image_mask=self.inputs.fixed_image_mask
-            )
+            retval = f'--masks "{self.inputs.fixed_image_mask}"'
         return retval
 
     def _format_arg(self, opt, spec, val):
@@ -1871,9 +1841,7 @@ def _list_outputs(self):
                 f"00_{self.inputs.output_prefix}_AffineTransform.mat"
             )
             outputs["displacement_field"] = os.path.abspath(
-                "01_{}_DisplacementFieldTransform.nii.gz".format(
-                    self.inputs.output_prefix
-                )
+                f"01_{self.inputs.output_prefix}_DisplacementFieldTransform.nii.gz"
             )
         if self.inputs.process == "assemble":
             outputs["out_file"] = os.path.abspath(self.inputs.out_file)

nipype/interfaces/base/core.py

@@ -849,8 +849,8 @@ def _filename_from_source(self, name, chain=None):
 
             if not isinstance(ns, (str, bytes)):
                 raise ValueError(
-                    "name_source of '{}' trait should be an input trait "
-                    "name, but a type {} object was found".format(name, type(ns))
+                    f"name_source of '{name}' trait should be an input trait "
+                    f"name, but a type {type(ns)} object was found"
                 )
 
             if isdefined(getattr(self.inputs, ns)):

nipype/interfaces/base/specs.py

@@ -141,10 +141,7 @@ def _deprecated_warn(self, obj, name, old, new):
                 raise TraitError(msg)
             else:
                 if trait_spec.new_name:
-                    msg += "Unsetting old value {}; setting new value {}.".format(
-                        name,
-                        trait_spec.new_name,
-                    )
+                    msg += f"Unsetting old value {name}; setting new value {trait_spec.new_name}."
                 warn(msg)
                 if trait_spec.new_name:
                     self.trait_set(

nipype/interfaces/base/tests/test_resource_monitor.py

@@ -55,7 +55,9 @@ class UseResources(CommandLine):
 
 @pytest.mark.skip(reason="inconsistent readings")
 @pytest.mark.skipif(os.getenv("CI_SKIP_TEST", False), reason="disabled in CI tests")
-@pytest.mark.parametrize(("mem_gb", "n_procs"), [(0.5, 3), (2.2, 8), (0.8, 4), (1.5, 1)])
+@pytest.mark.parametrize(
+    ("mem_gb", "n_procs"), [(0.5, 3), (2.2, 8), (0.8, 4), (1.5, 1)]
+)
 def test_cmdline_profiling(tmpdir, mem_gb, n_procs, use_resource_monitor):
     """
     Test runtime profiler correctly records workflow RAM/CPUs consumption
@@ -80,7 +82,9 @@ def test_cmdline_profiling(tmpdir, mem_gb, n_procs, use_resource_monitor):
 @pytest.mark.skipif(
     True, reason="test disabled temporarily, until function profiling works"
 )
-@pytest.mark.parametrize(("mem_gb", "n_procs"), [(0.5, 3), (2.2, 8), (0.8, 4), (1.5, 1)])
+@pytest.mark.parametrize(
+    ("mem_gb", "n_procs"), [(0.5, 3), (2.2, 8), (0.8, 4), (1.5, 1)]
+)
 def test_function_profiling(tmpdir, mem_gb, n_procs, use_resource_monitor):
     """
     Test runtime profiler correctly records workflow RAM/CPUs consumption

nipype/interfaces/cmtk/parcellation.py

@@ -315,15 +315,10 @@ def create_annot_label(subject_id, subjects_dir, fs_dir, parcellation_name):
     )
     runCmd(mri_cmd, log)
     runCmd("mris_volmask %s" % subject_id, log)
-    mri_cmd = 'mri_convert -i "{}/mri/ribbon.mgz" -o "{}/mri/ribbon.nii.gz"'.format(
-        op.join(subjects_dir, subject_id),
-        op.join(subjects_dir, subject_id),
-    )
+    subject_path = op.join(subjects_dir, subject_id)
+    mri_cmd = f'mri_convert -i "{subject_path}/mri/ribbon.mgz" -o "{subject_path}/mri/ribbon.nii.gz"'
     runCmd(mri_cmd, log)
-    mri_cmd = 'mri_convert -i "{}/mri/aseg.mgz" -o "{}/mri/aseg.nii.gz"'.format(
-        op.join(subjects_dir, subject_id),
-        op.join(subjects_dir, subject_id),
-    )
+    mri_cmd = f'mri_convert -i "{subject_path}/mri/aseg.mgz" -o "{subject_path}/mri/aseg.nii.gz"'
     runCmd(mri_cmd, log)
 
     iflogger.info("[ DONE ]")

nipype/interfaces/dtitk/base.py

@@ -42,11 +42,10 @@ def __init__(self, *args, **kwargs):
         rename_idx = classes.index("DTITKRenameMixin")
         new_name = classes[rename_idx + 1]
         warnings.warn(
-            "The {} interface has been renamed to {}\n"
+            f"The {dep_name} interface has been renamed to {new_name}\n"
             "Please see the documentation for DTI-TK "
             "interfaces, as some inputs have been "
-            "added or renamed for clarity."
-            "".format(dep_name, new_name),
+            "added or renamed for clarity.",
             DeprecationWarning,
         )
         super().__init__(*args, **kwargs)

nipype/interfaces/freesurfer/preprocess.py

@@ -729,10 +729,7 @@ def cmdline(self):
         outdir = self._get_outdir()
         cmd = []
         if not os.path.exists(outdir):
-            cmdstr = "{} -c \"import os; os.makedirs('{}')\"".format(
-                op.basename(sys.executable),
-                outdir,
-            )
+            cmdstr = f"{op.basename(sys.executable)} -c \"import os; os.makedirs('{outdir}')\""
             cmd.extend([cmdstr])
         infofile = os.path.join(outdir, "shortinfo.txt")
         if not os.path.exists(infofile):
@@ -741,12 +738,7 @@ def cmdline(self):
         files = self._get_filelist(outdir)
         for infile, outfile in files:
             if not os.path.exists(outfile):
-                single_cmd = "{}{} {} {}".format(
-                    self._cmd_prefix,
-                    self.cmd,
-                    infile,
-                    os.path.join(outdir, outfile),
-                )
+                single_cmd = f"{self._cmd_prefix}{self.cmd} {infile} {os.path.join(outdir, outfile)}"
                 cmd.extend([single_cmd])
         return "; ".join(cmd)
 

nipype/interfaces/freesurfer/tests/test_preprocess.py

@@ -65,11 +65,7 @@ def test_fitmsparams(create_files_in_directory):
     # .inputs based parameters setting
     fit.inputs.in_files = filelist
     fit.inputs.out_dir = outdir
-    assert fit.cmdline == "mri_ms_fitparms  {} {} {}".format(
-        filelist[0],
-        filelist[1],
-        outdir,
-    )
+    assert fit.cmdline == f"mri_ms_fitparms  {filelist[0]} {filelist[1]} {outdir}"
 
     # constructor based parameter setting
     fit2 = freesurfer.FitMSParams(
@@ -184,9 +180,7 @@ def test_bbregister(create_files_in_directory):
         base, _ = os.path.splitext(base)
 
     assert bbr.cmdline == (
-        "bbregister --t2 --init-fsl "
-        "--reg {base}_bbreg_fsaverage.dat "
-        "--mov {full} --s fsaverage".format(full=filelist[0], base=base)
+        f"bbregister --t2 --init-fsl --reg {base}_bbreg_fsaverage.dat --mov {filelist[0]} --s fsaverage"
     )