Code linting

the-lay · the-lay · Dec 14, 2021 · Sep 27, 2021 · Sep 29, 2021 · Nov 8, 2021
commit f0b1f9beb5dbde0005f81078bcf84ef2228ffec5
diff --git a/tests/test_merger.py b/tests/test_merger.py
@@ -253,10 +253,10 @@ def test_merge(self):
 
         # Unmatching dtype should raise an exception
         with self.assertRaises(ValueError):
-            merger.add(0, np.zeros((12, ), dtype=np.int64))
+            merger.add(0, np.zeros((12,), dtype=np.int64))
 
         # Test without normalization by weights
-        window = np.ones((12, )) * 2
+        window = np.ones((12,)) * 2
         merger = Merger(tiler, window=window)
         for t_id, t in tiler(self.data):
             merger.add(t_id, t)

diff --git a/tests/test_tiler.py b/tests/test_tiler.py
@@ -402,8 +402,13 @@ def test_overlap(self):
         # Float overlap + channel dimension
         c_data = np.expand_dims(self.data, 0)
         tiler = Tiler(
-            data_shape=c_data.shape, tile_shape=(1, tile_size,),
-            overlap=overlap, channel_dimension=0
+            data_shape=c_data.shape,
+            tile_shape=(
+                1,
+                tile_size,
+            ),
+            overlap=overlap,
+            channel_dimension=0,
         )
         expected_split = np.expand_dims(expected_split, 0)
         calculated_split = np.expand_dims(calculated_split, 0)
@@ -557,16 +562,14 @@ def test_tile_bbox_position(self):
 
     def test_apply_padding(self):
 
-        t1 = Tiler(data_shape=self.data.shape,
-                   tile_shape=(3,),
-                   mode="reflect")
+        t1 = Tiler(data_shape=self.data.shape, tile_shape=(3,), mode="reflect")
 
         # without apply padding the padding is done based on data in the tile
         # last tile has only one 99, but when reflect padded becomes 99, 99, 99
         np.testing.assert_equal(t1.get_tile(self.data, 0), [0, 1, 2])
         np.testing.assert_equal(t1.get_tile(self.data, len(t1) - 1), [99, 99, 99])
 
-        # padding should now be correctly applied,
+        # with apply padding, padding should now correctly take into account data outside the tile
         data = t1.apply_padding(self.data, mode="reflect")
         np.testing.assert_equal(t1.get_tile(data, 0), [1, 0, 1])
         np.testing.assert_equal(t1.get_tile(data, len(t1) - 1), [98, 99, 98])

diff --git a/tiler/merger.py b/tiler/merger.py
@@ -249,7 +249,9 @@ def add(self, tile_id: int, data: np.ndarray) -> None:
 
         # Check for dtype mismatch
         if self.dtype != data.dtype:
-            raise ValueError(f"Passed data dtype ({data.dtype}) must match Merger initialized dtype ({self.dtype}).")
+            raise ValueError(
+                f"Passed data dtype ({data.dtype}) must match Merger initialized dtype ({self.dtype})."
+            )
 
         # Select coordinates for data
         shape_diff = expected_tile_shape - data_shape
@@ -304,11 +306,12 @@ def add_batch(self, batch_id: int, batch_size: int, data: np.ndarray) -> None:
         ):
             self.add(tile_i, data[data_i])
 
-    def merge(self,
-              unpad: bool = True,
-              argmax: bool = False,
-              normalize_by_weights: bool = True,
-              ) -> np.ndarray:
+    def merge(
+        self,
+        unpad: bool = True,
+        argmax: bool = False,
+        normalize_by_weights: bool = True,
+    ) -> np.ndarray:
         """Returns merged data array obtained from added tiles.
 
         Args:
@@ -331,13 +334,16 @@ def merge(self,
             # TODO check which way is better
             #  ignoring should be more precise without atol
             #  but can hide other errors
-            with np.errstate(divide='ignore', invalid='ignore'):
+            with np.errstate(divide="ignore", invalid="ignore"):
                 data = np.nan_to_num(data / self.weights_sum)
 
         if unpad:
-            sl = [slice(pad_from, shape - pad_to)
-                  for shape, (pad_from, pad_to)
-                  in zip(self.tiler.data_shape, self.tiler._padding)]
+            sl = [
+                slice(pad_from, shape - pad_to)
+                for shape, (pad_from, pad_to) in zip(
+                    self.tiler.data_shape, self.tiler._padding
+                )
+            ]
 
             # if merger has logits dimension, add another slicing in front
             if self.logits:

diff --git a/tiler/tiler.py b/tiler/tiler.py
@@ -71,18 +71,19 @@ def __init__(
                 Default is `0.0`.
         """
 
-        self._recalculate(data_shape, tile_shape,
-                          overlap, channel_dimension,
-                          mode, constant_value)
-
-    def _recalculate(self,
-                     data_shape: Union[Tuple, List, np.ndarray],
-                     tile_shape: Union[Tuple, List, np.ndarray],
-                     overlap: Union[int, float, Tuple, List, np.ndarray] = 0,
-                     channel_dimension: Optional[int] = None,
-                     mode: str = "constant",
-                     constant_value: float = 0.0,
-                     ) -> None:
+        self._recalculate(
+            data_shape, tile_shape, overlap, channel_dimension, mode, constant_value
+        )
+
+    def _recalculate(
+        self,
+        data_shape: Union[Tuple, List, np.ndarray],
+        tile_shape: Union[Tuple, List, np.ndarray],
+        overlap: Union[int, float, Tuple, List, np.ndarray] = 0,
+        channel_dimension: Optional[int] = None,
+        mode: str = "constant",
+        constant_value: float = 0.0,
+    ) -> None:
 
         # Data and tile shapes
         self.data_shape = np.asarray(data_shape).astype(int)
@@ -94,9 +95,11 @@ def _recalculate(self,
                 "Tile and data shapes must be tuple or lists of positive numbers."
             )
         if self.tile_shape.size != self.data_shape.size:
-            raise ValueError("Tile and data shapes must have the same length. "
-                             "Hint: if you require tiles with less dimensions than data, put 1 in sliced dimensions, "
-                             "e.g. to get 1d 64px lines of 2d 64x64px image would mean tile_shape of (64, 1).")
+            raise ValueError(
+                "Tile and data shapes must have the same length. "
+                "Hint: if you require tiles with less dimensions than data, put 1 in sliced dimensions, "
+                "e.g. to get 1d 64px lines of 2d 64x64px image would mean tile_shape of (64, 1)."
+            )
 
         # Tiling mode
         self.mode = mode
@@ -151,7 +154,11 @@ def _recalculate(self,
             if self.channel_dimension is not None:
                 self._tile_overlap[self.channel_dimension] = 0
 
-        elif isinstance(self.overlap, list) or isinstance(self.overlap, tuple) or isinstance(self.overlap, np.ndarray):
+        elif (
+            isinstance(self.overlap, list)
+            or isinstance(self.overlap, tuple)
+            or isinstance(self.overlap, np.ndarray)
+        ):
             if np.any(np.array(self.overlap) < 0) or np.any(
                 self.overlap >= self.tile_shape
             ):
@@ -489,10 +496,11 @@ def get_mosaic_shape(self, with_channel_dim: bool = False) -> np.ndarray:
             ]
         return self._indexing_shape
 
-    def apply_padding(self,
-                      data: np.ndarray,
-                      mode: str = "reflect",
-                      ) -> np.ndarray:
+    def apply_padding(
+        self,
+        data: np.ndarray,
+        mode: str = "reflect",
+    ) -> np.ndarray:
         """Applies difference between required data shape and original data shape as padding around data.
         Automatically adjusts Tiler parameters and returns padded data.
         Moreover, Merger (with `unpad=True`) will automatically remove padding created with this method.
@@ -530,18 +538,21 @@ def apply_padding(self,
 
         # If user provided data that is different from initialized data shape, raise an error
         if np.not_equal(self.data_shape, data.shape).any():
-            raise ValueError(f"Provided data has a different shape (data.shape={data.shape}) than what Tiler "
-                             f"was initialized with (self.data_shape={self.data_shape}).")
+            raise ValueError(
+                f"Provided data has a different shape (data.shape={data.shape}) than what Tiler "
+                f"was initialized with (self.data_shape={self.data_shape})."
+            )
 
         # Split shape diff in two and use those values as frame padding for data
         pre_pad = self._shape_diff // 2
         post_pad = (self._shape_diff // 2) + np.mod(self._shape_diff, 2)
 
         # Adjust parameters for new data shape and
-        self._recalculate(self._new_shape,
-                          self.tile_shape,
-                          self.overlap,
-                          )
+        self._recalculate(
+            self._new_shape,
+            self.tile_shape,
+            self.overlap,
+        )
         self._padding = list(zip(pre_pad, post_pad))
 
         # Return padded input data