STY: Style fixes

Author: moloney

nibabel/nicom/dicomwrappers.py

@@ -470,9 +470,7 @@ def __init__(self, dcm_data):
         # Try to determine slice order and minimal image position patient
         self._frame_slc_ord = self._ipp = None
         try:
-            frame_ipps = [
-                f.PlanePositionSequence[0].ImagePositionPatient for f in self.frames
-            ]
+            frame_ipps = [f.PlanePositionSequence[0].ImagePositionPatient for f in self.frames]
         except AttributeError:
             try:
                 frame_ipps = [self.shared.PlanePositionSequence[0].ImagePositionPatient]
@@ -483,7 +481,9 @@ def __init__(self, dcm_data):
             frame_slc_pos = [np.inner(ipp, self.slice_normal) for ipp in frame_ipps]
             rnd_slc_pos = np.round(frame_slc_pos, 4)
             uniq_slc_pos = np.unique(rnd_slc_pos)
-            pos_ord_map = {val: order for val, order in zip(uniq_slc_pos, np.argsort(uniq_slc_pos))}
+            pos_ord_map = {
+                val: order for val, order in zip(uniq_slc_pos, np.argsort(uniq_slc_pos))
+            }
             self._frame_slc_ord = [pos_ord_map[pos] for pos in rnd_slc_pos]
             self._ipp = frame_ipps[np.argmin(frame_slc_pos)]
         self._shape = None
@@ -592,35 +592,32 @@ def image_shape(self):
             # Replace slice indices with order determined from slice positions along normal
             if row_idx == slice_dim_idx:
                 if len(shape) > 2:
-                    raise WrapperError("Non-singular index precedes the slice index")
+                    raise WrapperError('Non-singular index precedes the slice index')
                 row = self._frame_slc_ord
                 frame_indices.T[row_idx, :] = row
                 unique = np.unique(row)
                 if len(unique) != count:
                     raise WrapperError("Number of slice indices and positions don't match")
             elif count == n_frames:
-                if shape[-1] == "remaining":
-                    raise WrapperError("At most one index have ambiguous size")
-                shape.append("remaining")
+                if shape[-1] == 'remaining':
+                    raise WrapperError('At most one index have ambiguous size')
+                shape.append('remaining')
                 continue
             new_parts, leftover = divmod(curr_parts, count)
             expected = new_parts * frames_per_part
-            if (
-                leftover != 0 or 
-                any(np.count_nonzero(row == val) != expected for val in unique)
-            ):
+            if leftover != 0 or any(np.count_nonzero(row == val) != expected for val in unique):
                 if row_idx == slice_dim_idx:
-                    raise WrapperError("Missing slices from multiframe")
+                    raise WrapperError('Missing slices from multiframe')
                 del_indices[row_idx] = count
                 continue
-            if shape[-1] == "remaining":
+            if shape[-1] == 'remaining':
                 shape[-1] = new_parts
                 frames_per_part *= shape[-1]
                 new_parts = 1
             frames_per_part *= count
             shape.append(count)
             curr_parts = new_parts
-        if shape[-1] == "remaining":
+        if shape[-1] == 'remaining':
             if curr_parts > 1:
                 shape[-1] = curr_parts
                 curr_parts = 1
@@ -633,7 +630,7 @@ def image_shape(self):
                 if len(ns_failed) > 1:
                     # If some indices weren't used yet but we still have unaccounted for
                     # partitions, try combining indices into single tuple and using that
-                    tup_dtype = np.dtype(','.join(["I"] * len(ns_failed)))
+                    tup_dtype = np.dtype(','.join(['I'] * len(ns_failed)))
                     row = [tuple(x for x in vals) for vals in frame_indices[:, ns_failed]]
                     row = np.array(row, dtype=tup_dtype)
             frame_indices = np.delete(frame_indices, np.array(list(del_indices.keys())), axis=1)
@@ -642,18 +639,19 @@ def image_shape(self):
                 count = len(unique)
                 new_parts, rem = divmod(curr_parts, count)
                 allowed_val_counts = [new_parts * frames_per_part, n_frames]
-                if (
-                    rem == 0 and 
-                    all(np.count_nonzero(row == val) in allowed_val_counts for val in unique)
+                if rem == 0 and all(
+                    np.count_nonzero(row == val) in allowed_val_counts for val in unique
                 ):
                     shape.append(count)
                     curr_parts = new_parts
                     ord_vals = np.argsort(unique)
                     order = {tuple(unique[i]): ord_vals[i] for i in range(count)}
                     ord_row = np.array([order[tuple(v)] for v in row])
-                    frame_indices = np.hstack([frame_indices, np.array(ord_row).reshape((n_frames, 1))])
+                    frame_indices = np.hstack(
+                        [frame_indices, np.array(ord_row).reshape((n_frames, 1))]
+                    )
         if curr_parts > 1:
-            raise WrapperError("Unable to determine sorting of final dimension(s)")
+            raise WrapperError('Unable to determine sorting of final dimension(s)')
         # Store frame indices
         self._frame_indices = frame_indices
         return tuple(shape)

nibabel/nicom/tests/test_dicomwrappers.py

@@ -398,11 +398,11 @@ class Fake:
 
 
 def fake_shape_dependents(
-    div_seq, 
-    sid_seq=None, 
-    sid_dim=None, 
-    ipp_seq=None, 
-    slice_dim=None, 
+    div_seq,
+    sid_seq=None,
+    sid_dim=None,
+    ipp_seq=None,
+    slice_dim=None,
     flip_ipp_idx_corr=False,
 ):
     """Make a fake dictionary of data that ``image_shape`` is dependent on.
@@ -431,7 +431,7 @@ def __repr__(self):
             attr_strs = []
             for attr in dir(self):
                 if attr[0].isupper():
-                    attr_strs.append(f"{attr}={getattr(self, attr)}")
+                    attr_strs.append(f'{attr}={getattr(self, attr)}')
             return f"{self.__class__.__name__}({', '.join(attr_strs)})"
 
     class DimIdxSeqElem(PrintBase):
@@ -444,11 +444,11 @@ class FrmContSeqElem(PrintBase):
         def __init__(self, div, sid):
             self.DimensionIndexValues = div
             self.StackID = sid
-    
+
     class PlnPosSeqElem(PrintBase):
         def __init__(self, ipp):
             self.ImagePositionPatient = ipp
-    
+
     class PlnOrientSeqElem(PrintBase):
         def __init__(self, iop):
             self.ImageOrientationPatient = iop
@@ -466,27 +466,25 @@ def __init__(self, div, sid, ipp, iop):
         if sid_dim is None:
             sid_dim = 0
         sid_seq = [div[sid_dim] for div in div_seq]
-    # Dertermine slice_dim and create per-slice ipp information
+    # Determine slice_dim and create per-slice ipp information
     if slice_dim is None:
         slice_dim = 1 if sid_dim == 0 else 0
     num_of_frames = len(div_seq)
     frame_slc_indices = np.array(div_seq)[:, slice_dim]
     uniq_slc_indices = np.unique(frame_slc_indices)
     n_slices = len(uniq_slc_indices)
     assert num_of_frames % n_slices == 0
-    n_vols = num_of_frames // n_slices
-    iop_seq = [(0., 1., 0., 1., 0., 0.) for _ in range(num_of_frames)]
+    iop_seq = [(0.0, 1.0, 0.0, 1.0, 0.0, 0.0) for _ in range(num_of_frames)]
     if ipp_seq is None:
-        slc_locs = np.linspace(-1., 1., n_slices)
+        slc_locs = np.linspace(-1.0, 1.0, n_slices)
         if flip_ipp_idx_corr:
             slc_locs = slc_locs[::-1]
         slc_idx_loc = {
-            div_idx : slc_locs[arr_idx] 
-            for arr_idx, div_idx in enumerate(np.sort(uniq_slc_indices))
+            div_idx: slc_locs[arr_idx] for arr_idx, div_idx in enumerate(np.sort(uniq_slc_indices))
         }
-        ipp_seq = [(-1., -1., slc_idx_loc[idx]) for idx in frame_slc_indices]
+        ipp_seq = [(-1.0, -1.0, slc_idx_loc[idx]) for idx in frame_slc_indices]
     else:
-        assert flip_ipp_idx_corr is False # caller can flip it themselves
+        assert flip_ipp_idx_corr is False  # caller can flip it themselves
         assert len(ipp_seq) == num_of_frames
     # create the DimensionIndexSequence
     dim_idx_seq = [DimIdxSeqElem()] * n_indices
@@ -500,7 +498,7 @@ def __init__(self, div, sid, ipp, iop):
         dim_idx_seq[sid_dim] = DimIdxSeqElem(sid_tag, fcs_tag)
     # create the PerFrameFunctionalGroupsSequence
     frames = [
-        PerFrmFuncGrpSeqElem(div, sid, ipp, iop) 
+        PerFrmFuncGrpSeqElem(div, sid, ipp, iop)
         for div, sid, ipp, iop in zip(div_seq, sid_seq, ipp_seq, iop_seq)
     ]
     return {
@@ -618,9 +616,14 @@ def test_shape(self):
         assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
         # Test with combo indices, here with the last two needing to be combined into
         # a single index corresponding to [(1, 1), (1, 1), (2, 1), (2, 1), (2, 2), (2, 2)]
-        div_seq = ((1, 1, 1, 1), (1, 2, 1, 1), 
-                   (1, 1, 2, 1), (1, 2, 2, 1), 
-                   (1, 1, 2, 2), (1, 2, 2, 2))
+        div_seq = (
+            (1, 1, 1, 1),
+            (1, 2, 1, 1),
+            (1, 1, 2, 1),
+            (1, 2, 2, 1),
+            (1, 1, 2, 2),
+            (1, 2, 2, 2),
+        )
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
         assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
         # Test invalid 4D indices
@@ -636,13 +639,20 @@ def test_shape(self):
         div_seq = ((1, 1, 1), (1, 2, 2), (1, 1, 3), (1, 2, 4), (1, 1, 5), (1, 2, 6))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
         assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
-        div_seq = ((1, 1, 1, 1), (1, 2, 2, 1), 
-                   (1, 1, 3, 1), (1, 2, 4, 1),
-                   (1, 1, 5, 1), (1, 2, 6, 1),
-                   (1, 1, 7, 2), (1, 2, 8, 2),
-                   (1, 1, 9, 2), (1, 2, 10, 2),
-                   (1, 1, 11, 2), (1, 2, 12, 2),
-                  )
+        div_seq = (
+            (1, 1, 1, 1),
+            (1, 2, 2, 1),
+            (1, 1, 3, 1),
+            (1, 2, 4, 1),
+            (1, 1, 5, 1),
+            (1, 2, 6, 1),
+            (1, 1, 7, 2),
+            (1, 2, 8, 2),
+            (1, 1, 9, 2),
+            (1, 2, 10, 2),
+            (1, 1, 11, 2),
+            (1, 2, 12, 2),
+        )
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
         assert MFW(fake_mf).image_shape == (32, 64, 2, 3, 2)
 
@@ -713,9 +723,7 @@ def test_image_position(self):
             dw.image_position
         # Make a fake frame
         iop = [0, 1, 0, 1, 0, 0]
-        frames = fake_frames(
-            'PlaneOrientationSequence', 'ImageOrientationPatient', [iop]
-        )
+        frames = fake_frames('PlaneOrientationSequence', 'ImageOrientationPatient', [iop])
         frames = fake_frames(
             'PlanePositionSequence', 'ImagePositionPatient', [[-2.0, 3.0, 7]], frames
         )
@@ -733,13 +741,9 @@ def test_image_position(self):
         assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 7])
         assert MFW(fake_mf).image_position.dtype == float
         # We should get minimum along slice normal with multiple frames
-        frames = fake_frames(
-            'PlaneOrientationSequence', 'ImageOrientationPatient', [iop] * 2
-        )
+        frames = fake_frames('PlaneOrientationSequence', 'ImageOrientationPatient', [iop] * 2)
         ipps = [[-2.0, 3.0, 7], [-2.0, 3.0, 6]]
-        frames = fake_frames(
-            'PlanePositionSequence', 'ImagePositionPatient', ipps, frames
-        )
+        frames = fake_frames('PlanePositionSequence', 'ImagePositionPatient', ipps, frames)
         fake_mf['PerFrameFunctionalGroupsSequence'] = frames
         assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 6])