Style: Run black formatter

Signed-off-by: karllandheer <[email protected]>

Author: karllandheer

monai/transforms/intensity/array.py

@@ -488,7 +488,9 @@ class StdShiftIntensity(Transform):
 
     backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
 
-    def __init__(self, factor: float, nonzero: bool = False, channel_wise: bool = False, dtype: DtypeLike = np.float32) -> None:
+    def __init__(
+        self, factor: float, nonzero: bool = False, channel_wise: bool = False, dtype: DtypeLike = np.float32
+    ) -> None:
         self.factor = factor
         self.nonzero = nonzero
         self.channel_wise = channel_wise
@@ -578,7 +580,9 @@ def __call__(self, img: NdarrayOrTensor, randomize: bool = True) -> NdarrayOrTen
         if not self._do_transform:
             return img
 
-        shifter = StdShiftIntensity(factor=self.factor, nonzero=self.nonzero, channel_wise=self.channel_wise, dtype=self.dtype)
+        shifter = StdShiftIntensity(
+            factor=self.factor, nonzero=self.nonzero, channel_wise=self.channel_wise, dtype=self.dtype
+        )
         return shifter(img=img)
 
 
@@ -1268,16 +1272,12 @@ def _clip(self, img: NdarrayOrTensor) -> NdarrayOrTensor:
                     (
                         lower_percentile
                         if lower_percentile is None
-                        else lower_percentile.item()
-                        if hasattr(lower_percentile, "item")
-                        else lower_percentile
+                        else lower_percentile.item() if hasattr(lower_percentile, "item") else lower_percentile
                     ),
                     (
                         upper_percentile
                         if upper_percentile is None
-                        else upper_percentile.item()
-                        if hasattr(upper_percentile, "item")
-                        else upper_percentile
+                        else upper_percentile.item() if hasattr(upper_percentile, "item") else upper_percentile
                     ),
                 )
             )
@@ -1401,7 +1401,9 @@ def __init__(
 
         if isinstance(gamma, (int, float)):
             if gamma <= 0.5:
-                raise ValueError(f"if gamma is a number, must greater than 0.5 and value is picked from (0.5, gamma), got {gamma}")
+                raise ValueError(
+                    f"if gamma is a number, must greater than 0.5 and value is picked from (0.5, gamma), got {gamma}"
+                )
             self.gamma = (0.5, gamma)
         elif len(gamma) != 2:
             raise ValueError("gamma should be a number or pair of numbers.")
@@ -1412,7 +1414,9 @@ def __init__(
         self.invert_image: bool = invert_image
         self.retain_stats: bool = retain_stats
 
-        self.adjust_contrast = AdjustContrast(self.gamma_value, invert_image=self.invert_image, retain_stats=self.retain_stats)
+        self.adjust_contrast = AdjustContrast(
+            self.gamma_value, invert_image=self.invert_image, retain_stats=self.retain_stats
+        )
 
     def randomize(self, data: Any | None = None) -> None:
         super().randomize(None)
@@ -1538,7 +1542,9 @@ def _normalize(self, img: NdarrayOrTensor) -> NdarrayOrTensor:
             b_min = ((self.b_max - self.b_min) * (self.lower / 100.0)) + self.b_min
             b_max = ((self.b_max - self.b_min) * (self.upper / 100.0)) + self.b_min
 
-        scalar = ScaleIntensityRange(a_min=a_min, a_max=a_max, b_min=b_min, b_max=b_max, clip=self.clip, dtype=self.dtype)
+        scalar = ScaleIntensityRange(
+            a_min=a_min, a_max=a_max, b_min=b_min, b_max=b_max, clip=self.clip, dtype=self.dtype
+        )
         img = scalar(img)
         img = convert_to_tensor(img, track_meta=False)
         return img
@@ -1861,7 +1867,8 @@ def __call__(self, img: NdarrayTensor) -> NdarrayTensor:
         img_t, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float32)
 
         gf1, gf2 = (
-            GaussianFilter(img_t.ndim - 1, sigma, approx=self.approx).to(img_t.device) for sigma in (self.sigma1, self.sigma2)
+            GaussianFilter(img_t.ndim - 1, sigma, approx=self.approx).to(img_t.device)
+            for sigma in (self.sigma1, self.sigma2)
         )
         blurred_f = gf1(img_t.unsqueeze(0))
         filter_blurred_f = gf2(blurred_f)
@@ -2219,7 +2226,9 @@ def __init__(self, loc: tuple | Sequence[tuple], k_intensity: Sequence[float] |
         # assert one-to-one relationship between factors and locations
         if isinstance(k_intensity, Sequence):
             if not isinstance(loc[0], Sequence):
-                raise ValueError("If a sequence is passed to k_intensity, then a sequence of locations must be passed to loc")
+                raise ValueError(
+                    "If a sequence is passed to k_intensity, then a sequence of locations must be passed to loc"
+                )
             if len(k_intensity) != len(loc):
                 raise ValueError("There must be one intensity_factor value for each tuple of indices in loc.")
         if isinstance(self.loc[0], Sequence) and k_intensity is not None and not isinstance(self.k_intensity, Sequence):
@@ -2559,7 +2568,9 @@ def __init__(
         max_spatial_size: Sequence[int] | int | None = None,
         prob: float = 0.1,
     ) -> None:
-        super().__init__(holes=holes, spatial_size=spatial_size, max_holes=max_holes, max_spatial_size=max_spatial_size, prob=prob)
+        super().__init__(
+            holes=holes, spatial_size=spatial_size, max_holes=max_holes, max_spatial_size=max_spatial_size, prob=prob
+        )
         self.dropout_holes = dropout_holes
         if isinstance(fill_value, (tuple, list)):
             if len(fill_value) != 2:
@@ -2772,7 +2783,10 @@ def __call__(self, img: torch.Tensor) -> torch.Tensor:
         if self._do_transform:
             if self.channel_wise:
                 img = torch.stack(
-                    [IntensityRemap(self.kernel_size, self.R.choice([-self.slope, self.slope]))(img[i]) for i in range(len(img))]
+                    [
+                        IntensityRemap(self.kernel_size, self.R.choice([-self.slope, self.slope]))(img[i])
+                        for i in range(len(img))
+                    ]
                 )
             else:
                 img = IntensityRemap(self.kernel_size, self.R.choice([-self.slope, self.slope]))(img)
@@ -2828,7 +2842,9 @@ def __init__(
 
         self.thresholds = {k: v for k, v in self.thresholds.items() if v is not None}
         if self.thresholds.keys().isdisjoint(set("RGBHSV")):
-            raise ValueError(f"Threshold for at least one channel of RGB or HSV needs to be set. {self.thresholds} is provided.")
+            raise ValueError(
+                f"Threshold for at least one channel of RGB or HSV needs to be set. {self.thresholds} is provided."
+            )
         self.invert = invert
 
     def _set_threshold(self, threshold, mode):
@@ -2839,7 +2855,9 @@ def _set_threshold(self, threshold, mode):
         elif isinstance(threshold, (float, int)):
             self.thresholds[mode] = float(threshold)
         else:
-            raise ValueError(f"`threshold` should be either a callable, string, or float number, {type(threshold)} was given.")
+            raise ValueError(
+                f"`threshold` should be either a callable, string, or float number, {type(threshold)} was given."
+            )
 
     def _get_threshold(self, image, mode):
         threshold = self.thresholds.get(mode)
@@ -2961,7 +2979,9 @@ def __init__(
             raise ValueError(f"Unknown mode: {self.mode}. Supported modes are 'B' and 'RF'.")
 
         if self.sink_mode not in ["all", "mid", "min", "mask"]:
-            raise ValueError(f"Unknown sink mode: {self.sink_mode}. Supported modes are 'all', 'mid', 'min' and 'mask'.")
+            raise ValueError(
+                f"Unknown sink mode: {self.sink_mode}. Supported modes are 'all', 'mid', 'min' and 'mask'."
+            )
 
         self._compute_conf_map = UltrasoundConfidenceMap(
             self.alpha, self.beta, self.gamma, self.mode, self.sink_mode, self.use_cg, self.cg_tol, self.cg_maxiter

monai/transforms/intensity/dictionary.py

@@ -211,7 +211,9 @@ def __init__(
         RandomizableTransform.__init__(self, prob)
         self.rand_gaussian_noise = RandGaussianNoise(mean=mean, std=std, prob=1.0, dtype=dtype, sample_std=sample_std)
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandGaussianNoised:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandGaussianNoised:
         super().set_random_state(seed, state)
         self.rand_gaussian_noise.set_random_state(seed, state)
         return self
@@ -293,7 +295,9 @@ def __init__(
             dtype=dtype,
         )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandNonCentralChiNoised:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandNonCentralChiNoised:
         super().set_random_state(seed, state)
         self.rand_non_central_chi_noise.set_random_state(seed, state)
         return self
@@ -496,7 +500,9 @@ def __init__(
         self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
         self.shifter = RandShiftIntensity(offsets=offsets, safe=safe, prob=1.0, channel_wise=channel_wise)
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandShiftIntensityd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandShiftIntensityd:
         super().set_random_state(seed, state)
         self.shifter.set_random_state(seed, state)
         return self
@@ -595,9 +601,13 @@ def __init__(
         """
         MapTransform.__init__(self, keys, allow_missing_keys)
         RandomizableTransform.__init__(self, prob)
-        self.shifter = RandStdShiftIntensity(factors=factors, nonzero=nonzero, channel_wise=channel_wise, dtype=dtype, prob=1.0)
+        self.shifter = RandStdShiftIntensity(
+            factors=factors, nonzero=nonzero, channel_wise=channel_wise, dtype=dtype, prob=1.0
+        )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandStdShiftIntensityd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandStdShiftIntensityd:
         super().set_random_state(seed, state)
         self.shifter.set_random_state(seed, state)
         return self
@@ -694,7 +704,9 @@ def __init__(
         RandomizableTransform.__init__(self, prob)
         self.scaler = RandScaleIntensity(factors=factors, dtype=dtype, prob=1.0, channel_wise=channel_wise)
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandScaleIntensityd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandScaleIntensityd:
         super().set_random_state(seed, state)
         self.scaler.set_random_state(seed, state)
         return self
@@ -764,7 +776,9 @@ def __init__(
             factors=factors, fixed_mean=self.fixed_mean, preserve_range=preserve_range, dtype=dtype, prob=1.0
         )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandScaleIntensityFixedMeand:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandScaleIntensityFixedMeand:
         super().set_random_state(seed, state)
         self.scaler.set_random_state(seed, state)
         return self
@@ -1074,7 +1088,9 @@ def __init__(
         self.adjuster = RandAdjustContrast(gamma=gamma, prob=1.0, invert_image=invert_image, retain_stats=retain_stats)
         self.invert_image = invert_image
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandAdjustContrastd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandAdjustContrastd:
         super().set_random_state(seed, state)
         self.adjuster.set_random_state(seed, state)
         return self
@@ -1310,9 +1326,13 @@ def __init__(
     ) -> None:
         MapTransform.__init__(self, keys, allow_missing_keys)
         RandomizableTransform.__init__(self, prob)
-        self.rand_smooth = RandGaussianSmooth(sigma_x=sigma_x, sigma_y=sigma_y, sigma_z=sigma_z, approx=approx, prob=1.0)
+        self.rand_smooth = RandGaussianSmooth(
+            sigma_x=sigma_x, sigma_y=sigma_y, sigma_z=sigma_z, approx=approx, prob=1.0
+        )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandGaussianSmoothd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandGaussianSmoothd:
         super().set_random_state(seed, state)
         self.rand_smooth.set_random_state(seed, state)
         return self
@@ -1427,7 +1447,9 @@ def __init__(
             prob=1.0,
         )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandGaussianSharpend:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandGaussianSharpend:
         super().set_random_state(seed, state)
         self.rand_sharpen.set_random_state(seed, state)
         return self
@@ -1475,7 +1497,9 @@ def __init__(
         RandomizableTransform.__init__(self, prob)
         self.shifter = RandHistogramShift(num_control_points=num_control_points, prob=1.0)
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandHistogramShiftd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandHistogramShiftd:
         super().set_random_state(seed, state)
         self.shifter.set_random_state(seed, state)
         return self
@@ -1702,7 +1726,9 @@ def __init__(
         RandomizableTransform.__init__(self, prob=prob)
         self.rand_noise = RandKSpaceSpikeNoise(prob=1.0, intensity_range=intensity_range, channel_wise=channel_wise)
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandKSpaceSpikeNoised:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandKSpaceSpikeNoised:
         super().set_random_state(seed, state)
         self.rand_noise.set_random_state(seed, state)
         return self
@@ -1778,7 +1804,9 @@ def __init__(
             prob=1.0,
         )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandCoarseDropoutd:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandCoarseDropoutd:
         super().set_random_state(seed, state)
         self.dropper.set_random_state(seed, state)
         return self
@@ -1849,7 +1877,9 @@ def __init__(
             holes=holes, spatial_size=spatial_size, max_holes=max_holes, max_spatial_size=max_spatial_size, prob=1.0
         )
 
-    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandCoarseShuffled:
+    def set_random_state(
+        self, seed: int | None = None, state: np.random.RandomState | None = None
+    ) -> RandCoarseShuffled:
         super().set_random_state(seed, state)
         self.shuffle.set_random_state(seed, state)
         return self