chore(sty): black nitransforms/

Author: oesteban

nitransforms/__init__.py

@@ -23,16 +23,17 @@
     from ._version import __version__
 except ModuleNotFoundError:
     from pkg_resources import get_distribution, DistributionNotFound
+
     try:
-        __version__ = get_distribution('nitransforms').version
+        __version__ = get_distribution("nitransforms").version
     except DistributionNotFound:
-        __version__ = 'unknown'
+        __version__ = "unknown"
     del get_distribution
     del DistributionNotFound
 
 
 __all__ = [
-    'Affine',
-    'DisplacementsFieldTransform',
-    '__version__',
+    "Affine",
+    "DisplacementsFieldTransform",
+    "__version__",
 ]

nitransforms/base.py

@@ -39,7 +39,7 @@ def factory(dataset):
 class SampledSpatialData:
     """Represent sampled spatial data: regularly gridded (images) and surfaces."""
 
-    __slots__ = ['_ndim', '_coords', '_npoints', '_shape']
+    __slots__ = ["_ndim", "_coords", "_npoints", "_shape"]
 
     def __init__(self, dataset):
         """Create a sampling reference."""
@@ -53,19 +53,20 @@ def __init__(self, dataset):
         if isinstance(dataset, (str, Path)):
             dataset = _nbload(str(dataset))
 
-        if hasattr(dataset, 'numDA'):  # Looks like a Gifti file
-            _das = dataset.get_arrays_from_intent(INTENT_CODES['pointset'])
+        if hasattr(dataset, "numDA"):  # Looks like a Gifti file
+            _das = dataset.get_arrays_from_intent(INTENT_CODES["pointset"])
             if not _das:
                 raise TypeError(
-                    'Input Gifti file does not contain reference coordinates.')
+                    "Input Gifti file does not contain reference coordinates."
+                )
             self._coords = np.vstack([da.data for da in _das])
             self._npoints, self._ndim = self._coords.shape
             return
 
         if isinstance(dataset, Cifti2Image):
             raise NotImplementedError
 
-        raise ValueError('Dataset could not be interpreted as an irregular sample.')
+        raise ValueError("Dataset could not be interpreted as an irregular sample.")
 
     @property
     def npoints(self):
@@ -91,7 +92,7 @@ def shape(self):
 class ImageGrid(SampledSpatialData):
     """Class to represent spaces of gridded data (images)."""
 
-    __slots__ = ['_affine', '_inverse', '_ndindex']
+    __slots__ = ["_affine", "_inverse", "_ndindex"]
 
     def __init__(self, image):
         """Create a gridded sampling reference."""
@@ -101,17 +102,15 @@ def __init__(self, image):
         self._affine = image.affine
         self._shape = image.shape
 
-        self._ndim = getattr(image, 'ndim', len(image.shape))
+        self._ndim = getattr(image, "ndim", len(image.shape))
         if self._ndim == 4:
             self._shape = image.shape[:3]
             self._ndim = 3
 
-        self._npoints = getattr(image, 'npoints',
-                                np.prod(self._shape))
+        self._npoints = getattr(image, "npoints", np.prod(self._shape))
         self._ndindex = None
         self._coords = None
-        self._inverse = getattr(image, 'inverse',
-                                np.linalg.inv(image.affine))
+        self._inverse = getattr(image, "inverse", np.linalg.inv(image.affine))
 
     @property
     def affine(self):
@@ -128,8 +127,9 @@ def ndindex(self):
         """List the indexes corresponding to the space grid."""
         if self._ndindex is None:
             indexes = tuple([np.arange(s) for s in self._shape])
-            self._ndindex = np.array(np.meshgrid(
-                *indexes, indexing='ij')).reshape(self._ndim, self._npoints)
+            self._ndindex = np.array(np.meshgrid(*indexes, indexing="ij")).reshape(
+                self._ndim, self._npoints
+            )
         return self._ndindex
 
     @property
@@ -139,7 +139,7 @@ def ndcoords(self):
             self._coords = np.tensordot(
                 self._affine,
                 np.vstack((self.ndindex, np.ones((1, self._npoints)))),
-                axes=1
+                axes=1,
             )[:3, ...]
         return self._coords
 
@@ -152,15 +152,17 @@ def index(self, x):
         return _apply_affine(x, self._inverse, self._ndim)
 
     def _to_hdf5(self, group):
-        group.attrs['Type'] = 'image'
-        group.attrs['ndim'] = self.ndim
-        group.create_dataset('affine', data=self.affine)
-        group.create_dataset('shape', data=self.shape)
+        group.attrs["Type"] = "image"
+        group.attrs["ndim"] = self.ndim
+        group.create_dataset("affine", data=self.affine)
+        group.create_dataset("shape", data=self.shape)
 
     def __eq__(self, other):
         """Overload equals operator."""
-        return (np.allclose(self.affine, other.affine, rtol=EQUALITY_TOL)
-                and self.shape == other.shape)
+        return (
+            np.allclose(self.affine, other.affine, rtol=EQUALITY_TOL)
+            and self.shape == other.shape
+        )
 
     def __ne__(self, other):
         """Overload not equal operator."""
@@ -170,7 +172,7 @@ def __ne__(self, other):
 class TransformBase:
     """Abstract image class to represent transforms."""
 
-    __slots__ = ('_reference', )
+    __slots__ = ("_reference",)
 
     def __init__(self, reference=None):
         """Instantiate a transform."""
@@ -195,13 +197,14 @@ def __add__(self, b):
 
         """
         from .manip import TransformChain
+
         return TransformChain(transforms=[self, b])
 
     @property
     def reference(self):
         """Access a reference space where data will be resampled onto."""
         if self._reference is None:
-            warnings.warn('Reference space not set')
+            warnings.warn("Reference space not set")
         return self._reference
 
     @reference.setter
@@ -213,8 +216,16 @@ def ndim(self):
         """Access the dimensions of the reference space."""
         return self.reference.ndim
 
-    def apply(self, spatialimage, reference=None,
-              order=3, mode='constant', cval=0.0, prefilter=True, output_dtype=None):
+    def apply(
+        self,
+        spatialimage,
+        reference=None,
+        order=3,
+        mode="constant",
+        cval=0.0,
+        prefilter=True,
+        output_dtype=None,
+    ):
         """
         Apply a transformation to an image, resampling on the reference spatial object.
 
@@ -252,17 +263,18 @@ def apply(self, spatialimage, reference=None,
         if reference is not None and isinstance(reference, (str, Path)):
             reference = _nbload(str(reference))
 
-        _ref = self.reference if reference is None \
-            else SpatialReference.factory(reference)
+        _ref = (
+            self.reference if reference is None else SpatialReference.factory(reference)
+        )
 
         if isinstance(spatialimage, (str, Path)):
             spatialimage = _nbload(str(spatialimage))
 
         data = np.asanyarray(spatialimage.dataobj)
         output_dtype = output_dtype or data.dtype
         targets = ImageGrid(spatialimage).index(  # data should be an image
-            _as_homogeneous(self.map(_ref.ndcoords.T),
-                            dim=_ref.ndim))
+            _as_homogeneous(self.map(_ref.ndcoords.T), dim=_ref.ndim)
+        )
 
         resampled = ndi.map_coordinates(
             data,
@@ -276,8 +288,8 @@ def apply(self, spatialimage, reference=None,
 
         if isinstance(_ref, ImageGrid):  # If reference is grid, reshape
             moved = spatialimage.__class__(
-                resampled.reshape(_ref.shape),
-                _ref.affine, spatialimage.header)
+                resampled.reshape(_ref.shape), _ref.affine, spatialimage.header
+            )
             moved.header.set_data_dtype(output_dtype)
             return moved
 
@@ -304,12 +316,12 @@ def map(self, x, inverse=False):
         """
         return x
 
-    def to_filename(self, filename, fmt='X5'):
+    def to_filename(self, filename, fmt="X5"):
         """Store the transform in BIDS-Transforms HDF5 file format (.x5)."""
-        with h5py.File(filename, 'w') as out_file:
-            out_file.attrs['Format'] = 'X5'
-            out_file.attrs['Version'] = np.uint16(1)
-            root = out_file.create_group('/0')
+        with h5py.File(filename, "w") as out_file:
+            out_file.attrs["Format"] = "X5"
+            out_file.attrs["Version"] = np.uint16(1)
+            root = out_file.create_group("/0")
             self._to_hdf5(root)
 
         return filename
@@ -319,7 +331,7 @@ def _to_hdf5(self, x5_root):
         raise NotImplementedError
 
 
-def _as_homogeneous(xyz, dtype='float32', dim=3):
+def _as_homogeneous(xyz, dtype="float32", dim=3):
     """
     Convert 2D and 3D coordinates into homogeneous coordinates.
 

nitransforms/cli.py

@@ -18,13 +18,13 @@ def cli_apply(pargs):
         $ nt apply warp.nii.gz moving.nii.gz --fmt afni --nonlinear
 
     """
-    fmt = pargs.fmt or pargs.transform.split('.')[-1]
-    if fmt in ('tfm', 'mat', 'h5', 'x5'):
-        fmt = 'itk'
-    elif fmt == 'lta':
-        fmt = 'fs'
+    fmt = pargs.fmt or pargs.transform.split(".")[-1]
+    if fmt in ("tfm", "mat", "h5", "x5"):
+        fmt = "itk"
+    elif fmt == "lta":
+        fmt = "fs"
 
-    if fmt not in ('fs', 'itk', 'fsl', 'afni', 'x5'):
+    if fmt not in ("fs", "itk", "fsl", "afni", "x5"):
         raise ValueError(
             "Cannot determine transformation format, manually set format with the `--fmt` flag"
         )
@@ -42,28 +42,28 @@ def cli_apply(pargs):
         order=pargs.order,
         mode=pargs.mode,
         cval=pargs.cval,
-        prefilter=pargs.prefilter
-    )
-    moved.to_filename(
-        pargs.out or "nt_{}".format(os.path.basename(pargs.moving))
+        prefilter=pargs.prefilter,
     )
+    moved.to_filename(pargs.out or "nt_{}".format(os.path.basename(pargs.moving)))
 
 
 def get_parser():
-    desc = dedent("""
+    desc = dedent(
+        """
         NiTransforms command-line utility.
 
         Commands:
 
             apply       Apply a transformation to an image
 
         For command specific information, use 'nt <command> -h'.
-    """)
+    """
+    )
 
     parser = ArgumentParser(
         description=desc, formatter_class=RawDescriptionHelpFormatter
     )
-    subparsers = parser.add_subparsers(dest='command')
+    subparsers = parser.add_subparsers(dest="command")
 
     def _add_subparser(name, description):
         subp = subparsers.add_parser(
@@ -73,51 +73,51 @@ def _add_subparser(name, description):
         )
         return subp
 
-    applyp = _add_subparser('apply', cli_apply.__doc__)
+    applyp = _add_subparser("apply", cli_apply.__doc__)
     applyp.set_defaults(func=cli_apply)
-    applyp.add_argument('transform', help='The transform file')
-    applyp.add_argument(
-        'moving', help='The image containing the data to be resampled'
-    )
-    applyp.add_argument('--ref', help='The reference space to resample onto')
+    applyp.add_argument("transform", help="The transform file")
+    applyp.add_argument("moving", help="The image containing the data to be resampled")
+    applyp.add_argument("--ref", help="The reference space to resample onto")
     applyp.add_argument(
-        '--fmt',
-        choices=('itk', 'fsl', 'afni', 'fs', 'x5'),
-        help='Format of transformation. If no option is passed, nitransforms will '
-        'estimate based on the transformation file extension.'
+        "--fmt",
+        choices=("itk", "fsl", "afni", "fs", "x5"),
+        help="Format of transformation. If no option is passed, nitransforms will "
+        "estimate based on the transformation file extension.",
     )
     applyp.add_argument(
-        '--out', help="The transformed image. If not set, will be set to `nt_{moving}`"
+        "--out", help="The transformed image. If not set, will be set to `nt_{moving}`"
     )
     applyp.add_argument(
-        '--nonlinear', action='store_true', help='Transformation is nonlinear (default: False)'
+        "--nonlinear",
+        action="store_true",
+        help="Transformation is nonlinear (default: False)",
     )
-    applykwargs = applyp.add_argument_group('Apply customization')
+    applykwargs = applyp.add_argument_group("Apply customization")
     applykwargs.add_argument(
-        '--order',
+        "--order",
         type=int,
         default=3,
         choices=range(6),
-        help='The order of the spline transformation (default: 3)'
+        help="The order of the spline transformation (default: 3)",
     )
     applykwargs.add_argument(
-        '--mode',
-        choices=('constant', 'reflect', 'nearest', 'mirror', 'wrap'),
-        default='constant',
-        help='Determines how the input image is extended when the resampling overflows a border '
-        '(default: constant)'
+        "--mode",
+        choices=("constant", "reflect", "nearest", "mirror", "wrap"),
+        default="constant",
+        help="Determines how the input image is extended when the resampling overflows a border "
+        "(default: constant)",
     )
     applykwargs.add_argument(
-        '--cval',
+        "--cval",
         type=float,
         default=0.0,
-        help='Constant used when using "constant" mode (default: 0.0)'
+        help='Constant used when using "constant" mode (default: 0.0)',
     )
     applykwargs.add_argument(
-        '--prefilter',
-        action='store_false',
+        "--prefilter",
+        action="store_false",
         help="Determines if the image's data array is prefiltered with a spline filter before "
-        "interpolation (default: True)"
+        "interpolation (default: True)",
     )
     return parser, subparsers
 
@@ -131,4 +131,4 @@ def main(pargs=None):
     except Exception as e:
         subparser = subparsers.choices[pargs.command]
         subparser.print_help()
-        raise(e)
+        raise (e)