STY: pyflakes and some pep8 in algorithms

Author: agramfort

nipype/algorithms/misc.py

@@ -75,8 +75,8 @@ def _get_brodmann_area(self):
             labels = [self.inputs.labels]
         else:
             labels = self.inputs.labels
-        for label in labels:
-            newdata[origdata == label] = 1
+        for lab in labels:
+            newdata[origdata == lab] = 1
         if self.inputs.hemi == 'right':
             newdata[floor(float(origdata.shape[0]) / 2):, :, :] = 0
         elif self.inputs.hemi == 'left':

nipype/algorithms/modelgen.py

@@ -7,29 +7,30 @@
 from nibabel import Nifti1Image
 import numpy as np
 
-from nipype.testing import (assert_equal, assert_false, assert_true,
+from nipype.testing import (assert_equal,
                             assert_raises, assert_almost_equal)
 from nipype.interfaces.base import Bunch, TraitError
 from nipype.algorithms.modelgen import (SpecifyModel, SpecifySparseModel,
                                         SpecifySPMModel)
 
+
 def test_modelgen1():
     tempdir = mkdtemp()
-    filename1 = os.path.join(tempdir,'test1.nii')
-    filename2 = os.path.join(tempdir,'test2.nii')
-    Nifti1Image(np.random.rand(10,10,10,200), np.eye(4)).to_filename(filename1)
-    Nifti1Image(np.random.rand(10,10,10,200), np.eye(4)).to_filename(filename2)
+    filename1 = os.path.join(tempdir, 'test1.nii')
+    filename2 = os.path.join(tempdir, 'test2.nii')
+    Nifti1Image(np.random.rand(10, 10, 10, 200), np.eye(4)).to_filename(filename1)
+    Nifti1Image(np.random.rand(10, 10, 10, 200), np.eye(4)).to_filename(filename2)
     s = SpecifyModel()
     s.inputs.input_units = 'scans'
-    set_output_units = lambda : setattr(s.inputs, 'output_units', 'scans')
+    set_output_units = lambda: setattr(s.inputs, 'output_units', 'scans')
     yield assert_raises, TraitError, set_output_units
     s.inputs.functional_runs = [filename1, filename2]
     s.inputs.time_repetition = 6
     s.inputs.high_pass_filter_cutoff = 128.
     info = [Bunch(conditions=['cond1'], onsets=[[2, 50, 100, 180]], durations=[[1]], amplitudes=None,
-                  pmod=None, regressors = None, regressor_names = None, tmod=None),
+                  pmod=None, regressors=None, regressor_names=None, tmod=None),
             Bunch(conditions=['cond1'], onsets=[[30, 40, 100, 150]], durations=[[1]], amplitudes=None,
-                  pmod=None, regressors = None, regressor_names = None, tmod=None)]
+                  pmod=None, regressors=None, regressor_names=None, tmod=None)]
     s.inputs.subject_info = info
     res = s.run()
     yield assert_equal, len(res.outputs.session_info), 2
@@ -38,12 +39,13 @@ def test_modelgen1():
     yield assert_almost_equal, np.array(res.outputs.session_info[0]['cond'][0]['onset']), np.array([12, 300, 600, 1080])
     rmtree(tempdir)
 
+
 def test_modelgen_spm_concat():
     tempdir = mkdtemp()
-    filename1 = os.path.join(tempdir,'test1.nii')
-    filename2 = os.path.join(tempdir,'test2.nii')
-    Nifti1Image(np.random.rand(10,10,10,50), np.eye(4)).to_filename(filename1)
-    Nifti1Image(np.random.rand(10,10,10,50), np.eye(4)).to_filename(filename2)
+    filename1 = os.path.join(tempdir, 'test1.nii')
+    filename2 = os.path.join(tempdir, 'test2.nii')
+    Nifti1Image(np.random.rand(10, 10, 10, 50), np.eye(4)).to_filename(filename1)
+    Nifti1Image(np.random.rand(10, 10, 10, 50), np.eye(4)).to_filename(filename2)
     s = SpecifySPMModel()
     s.inputs.input_units = 'secs'
     s.inputs.output_units = 'scans'
@@ -54,9 +56,9 @@ def test_modelgen_spm_concat():
     s.inputs.time_repetition = 6
     s.inputs.high_pass_filter_cutoff = 128.
     info = [Bunch(conditions=['cond1'], onsets=[[2, 50, 100, 180]], durations=[[1]], amplitudes=None,
-                  pmod=None, regressors = None, regressor_names = None, tmod=None),
+                  pmod=None, regressors=None, regressor_names=None, tmod=None),
             Bunch(conditions=['cond1'], onsets=[[30, 40, 100, 150]], durations=[[1]], amplitudes=None,
-                  pmod=None, regressors = None, regressor_names = None, tmod=None)]
+                  pmod=None, regressors=None, regressor_names=None, tmod=None)]
     s.inputs.subject_info = info
     res = s.run()
     yield assert_equal, len(res.outputs.session_info), 1
@@ -65,12 +67,13 @@ def test_modelgen_spm_concat():
     yield assert_almost_equal, np.array(res.outputs.session_info[0]['cond'][0]['onset']), np.array([2.0, 50.0, 100.0, 180.0, 330.0, 340.0, 400.0, 450.0])
     rmtree(tempdir)
 
+
 def test_modelgen_sparse():
     tempdir = mkdtemp()
-    filename1 = os.path.join(tempdir,'test1.nii')
-    filename2 = os.path.join(tempdir,'test2.nii')
-    Nifti1Image(np.random.rand(10,10,10,50), np.eye(4)).to_filename(filename1)
-    Nifti1Image(np.random.rand(10,10,10,50), np.eye(4)).to_filename(filename2)
+    filename1 = os.path.join(tempdir, 'test1.nii')
+    filename2 = os.path.join(tempdir, 'test2.nii')
+    Nifti1Image(np.random.rand(10, 10, 10, 50), np.eye(4)).to_filename(filename1)
+    Nifti1Image(np.random.rand(10, 10, 10, 50), np.eye(4)).to_filename(filename2)
     s = SpecifySparseModel()
     s.inputs.input_units = 'secs'
     s.inputs.functional_runs = [filename1, filename2]

nipype/algorithms/rapidart.py

@@ -1,99 +1,106 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 from nipype.testing import (assert_equal, assert_false, assert_true,
-                            assert_raises, assert_almost_equal)
+                            assert_almost_equal)
 import nipype.algorithms.rapidart as ra
 from nipype.interfaces.base import Bunch
-from tempfile import mkdtemp
-import os
-from shutil import rmtree
 import numpy as np
 
+
 def test_artifactdetect():
-    input_map = dict(intersect_mask = dict(),
-                     mask_file = dict(),
-                     mask_threshold = dict(),
-                     mask_type = dict(),
-                     norm_threshold = dict(),
-                     parameter_source = dict(mandatory=True,),
-                     realigned_files = dict(mandatory=True,),
-                     realignment_parameters = dict(),
-                     rotation_threshold = dict(),
-                     translation_threshold = dict(),
-                     use_differences = dict(usedefault=True,),
-                     use_norm = dict(usedefault=True,),
-                     zintensity_threshold = dict(),
+    input_map = dict(intersect_mask=dict(),
+                     mask_file=dict(),
+                     mask_threshold=dict(),
+                     mask_type=dict(),
+                     norm_threshold=dict(),
+                     parameter_source=dict(mandatory=True,),
+                     realigned_files=dict(mandatory=True,),
+                     realignment_parameters=dict(),
+                     rotation_threshold=dict(),
+                     translation_threshold=dict(),
+                     use_differences=dict(usedefault=True,),
+                     use_norm=dict(usedefault=True,),
+                     zintensity_threshold=dict(),
                      )
     instance = ra.ArtifactDetect()
     for key, metadata in input_map.items():
         for metakey, value in metadata.items():
             yield assert_equal, getattr(instance.inputs.traits()[key], metakey), value
 
+
 def test_stimuluscorrelation():
-    input_map = dict(concatenated_design = dict(mandatory=True,),
-                     intensity_values = dict(mandatory=True,),
-                     realignment_parameters = dict(mandatory=True,),
-                     spm_mat_file = dict(mandatory=True,),
+    input_map = dict(concatenated_design=dict(mandatory=True,),
+                     intensity_values=dict(mandatory=True,),
+                     realignment_parameters=dict(mandatory=True,),
+                     spm_mat_file=dict(mandatory=True,),
                      )
     instance = ra.StimulusCorrelation()
     for key, metadata in input_map.items():
         for metakey, value in metadata.items():
             yield assert_equal, getattr(instance.inputs.traits()[key], metakey), value
 
+
 def test_ad_init():
-    ad = ra.ArtifactDetect(use_differences=[True,False])
+    ad = ra.ArtifactDetect(use_differences=[True, False])
     yield assert_true, ad.inputs.use_differences[0]
     yield assert_false, ad.inputs.use_differences[1]
 
+
 def test_ad_output_filenames():
     ad = ra.ArtifactDetect()
     outputdir = '/tmp'
     f = 'motion.nii'
-    outlierfile,intensityfile,statsfile,normfile,plotfile = ad._get_output_filenames(f,outputdir)
+    outlierfile, intensityfile, statsfile, normfile, plotfile = ad._get_output_filenames(f, outputdir)
     yield assert_equal, outlierfile, '/tmp/art.motion_outliers.txt'
     yield assert_equal, intensityfile, '/tmp/global_intensity.motion.txt'
     yield assert_equal, statsfile, '/tmp/stats.motion.txt'
     yield assert_equal, normfile, '/tmp/norm.motion.txt'
     yield assert_equal, plotfile, '/tmp/plot.motion.png'
 
+
 def test_ad_get_affine_matrix():
     ad = ra.ArtifactDetect()
     matrix = ad._get_affine_matrix(np.array([0]))
     yield assert_equal, matrix, np.eye(4)
     # test translation
-    params = [1,2,3]
+    params = [1, 2, 3]
     matrix = ad._get_affine_matrix(params)
     out = np.eye(4)
-    out[0:3,3] = params
+    out[0:3, 3] = params
     yield assert_equal, matrix, out
     # test rotation
-    params = np.array([0,0,0,np.pi/2,np.pi/2,np.pi/2])
+    params = np.array([0, 0, 0, np.pi / 2, np.pi / 2, np.pi / 2])
     matrix = ad._get_affine_matrix(params)
-    out = np.array([0,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,1]).reshape((4,4))
+    out = np.array([0, 0, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]).reshape((4, 4))
     yield assert_almost_equal, matrix, out
     # test scaling
-    params = np.array([0,0,0,0,0,0,1,2,3])
+    params = np.array([0, 0, 0, 0, 0, 0, 1, 2, 3])
     matrix = ad._get_affine_matrix(params)
-    out = np.array([1,0,0,0,0,2,0,0,0,0,3,0,0,0,0,1]).reshape((4,4))
+    out = np.array([1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1]).reshape((4, 4))
     yield assert_equal, matrix, out
     # test shear
-    params = np.array([0,0,0,0,0,0,1,1,1,1,2,3])
+    params = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 3])
     matrix = ad._get_affine_matrix(params)
-    out = np.array([1,1,2,0,0,1,3,0,0,0,1,0,0,0,0,1]).reshape((4,4))
+    out = np.array([1, 1, 2, 0, 0, 1, 3, 0, 0, 0, 1, 0, 0, 0, 0, 1]).reshape((4, 4))
     yield assert_equal, matrix, out
 
+
 def test_ad_get_norm():
     ad = ra.ArtifactDetect()
-    params = np.array([0,0,0,0,0,0,0,0,0,np.pi/4,np.pi/4,np.pi/4,0,0,0,-np.pi/4,-np.pi/4,-np.pi/4]).reshape((3,6))
-    norm = ad._calc_norm(params,False)
-    yield assert_almost_equal, norm, np.array([18.86436316, 37.74610158,  31.29780829])
-    norm = ad._calc_norm(params,True)
-    yield assert_almost_equal, norm, np.array([   0.        ,  143.72192614,  173.92527131])
+    params = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, np.pi / 4, np.pi / 4,
+                       np.pi / 4, 0, 0, 0, -np.pi / 4,
+                       -np.pi / 4, -np.pi / 4]).reshape((3, 6))
+    norm = ad._calc_norm(params, False)
+    yield assert_almost_equal, norm, np.array([18.86436316, 37.74610158, 31.29780829])
+    norm = ad._calc_norm(params, True)
+    yield assert_almost_equal, norm, np.array([0., 143.72192614, 173.92527131])
+
 
 def test_sc_init():
     sc = ra.StimulusCorrelation(concatenated_design=True)
     yield assert_true, sc.inputs.concatenated_design
 
+
 def test_sc_populate_inputs():
     sc = ra.StimulusCorrelation()
     inputs = Bunch(realignment_parameters=None,
@@ -102,10 +109,10 @@ def test_sc_populate_inputs():
                    concatenated_design=None)
     yield assert_equal, sc.inputs.__dict__.keys(), inputs.__dict__.keys()
 
+
 def test_sc_output_filenames():
     sc = ra.StimulusCorrelation()
     outputdir = '/tmp'
     f = 'motion.nii'
-    corrfile = sc._get_output_filenames(f,outputdir)
+    corrfile = sc._get_output_filenames(f, outputdir)
     yield assert_equal, corrfile, '/tmp/qa.motion_stimcorr.txt'
-

nipype/algorithms/tests/test_modelgen.py

@@ -772,7 +772,7 @@ def _gen_outfilename(self):
             _, name, ext = split_filename(self.inputs.parcstats_file)
         elif isdefined(self.inputs.label_file):
             _, name, ext = split_filename(self.inputs.label_file)
-        elif isdefied(self.inputs.scalarcurv_file):
+        elif isdefined(self.inputs.scalarcurv_file):
             _, name, ext = split_filename(self.inputs.scalarcurv_file)
         elif isdefined(self.inputs.functional_file):
             _, name, ext = split_filename(self.inputs.functional_file)

nipype/algorithms/tests/test_rapidart.py

@@ -253,7 +253,7 @@ def _run_interface(self, runtime):
         self._z_maps = []
         for contrast_def in self.inputs.contrasts:
             name = contrast_def[0]
-            type = contrast_def[1]
+            _ = contrast_def[1]
             contrast = np.zeros(len(reg_names))
 
             for i, reg_name in enumerate(reg_names):

nipype/interfaces/freesurfer/utils.py

@@ -25,17 +25,19 @@ class ComputeMaskInputSpec(BaseInterfaceInputSpec):
     M = traits.Float(desc="upper fraction of the histogram to be discarded")
     cc = traits.Bool(desc="if True, only the largest connect component is kept")
 
+
 class ComputeMaskOutputSpec(TraitedSpec):
     brain_mask = File(exists=True)
 
+
 class ComputeMask(BaseInterface):
     input_spec = ComputeMaskInputSpec
     output_spec = ComputeMaskOutputSpec
 
     def _run_interface(self, runtime):
 
         args = {}
-        for key in [k for k,_ in self.inputs.items() if k not in BaseInterfaceInputSpec().trait_names()]:
+        for key in [k for k, _ in self.inputs.items() if k not in BaseInterfaceInputSpec().trait_names()]:
             value = getattr(self.inputs, key)
             if isdefined(value):
                 if key in ['mean_volume', 'reference_volume']:
@@ -54,5 +56,3 @@ def _list_outputs(self):
         outputs = self._outputs().get()
         outputs["brain_mask"] = self._brain_mask_path
         return outputs
-
-

nipype/interfaces/nipy/model.py

@@ -16,10 +16,9 @@
 from nipype.utils.misc import package_check
 package_check('matplotlib')
 
-from nipype.interfaces.base import (TraitedSpec, File, InputMultiPath,
-                                    OutputMultiPath, Undefined, traits,
+from nipype.interfaces.base import (TraitedSpec, File, Undefined, traits,
                                     BaseInterface, isdefined,
-    BaseInterfaceInputSpec)
+                                    BaseInterfaceInputSpec)
 
 from nipype.utils.filemanip import fname_presuffix
 

nipype/interfaces/nipy/preprocess.py

@@ -28,7 +28,7 @@
 from nipype.interfaces.spm.base import (SPMCommand, SPMCommandInputSpec,
                                         scans_for_fnames)
 from nipype.utils.filemanip import (filename_to_list, list_to_filename,
-                                    loadflat, split_filename)
+                                    split_filename)
 
 logger = logging.getLogger('spmlogger')