careamics 0.0.14__py3-none-any.whl → 0.0.16__py3-none-any.whl

careamics/config/data/data_model.py

@@ -6,7 +6,7 @@ import os
 import sys
 from collections.abc import Sequence
 from pprint import pformat
-from typing import Annotated, Any, Literal, Optional, Union
+from typing import Annotated, Any, Literal, Self, Union
 from warnings import warn
 
 import numpy as np
@@ -19,7 +19,6 @@ from pydantic import (
     field_validator,
     model_validator,
 )
-from typing_extensions import Self
 
 from ..transformations import XYFlipModel, XYRandomRotate90Model
 from ..validators import check_axes_validity, patch_size_ge_than_8_power_of_2
@@ -109,22 +108,16 @@ class DataConfig(BaseModel):
     """Batch size for training."""
 
     # Optional fields
-    image_means: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    image_means: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Means of the data across channels, used for normalization."""
 
-    image_stds: Optional[list[Float]] = Field(default=None, min_length=0, max_length=32)
+    image_stds: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Standard deviations of the data across channels, used for normalization."""
 
-    target_means: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    target_means: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Means of the target data across channels, used for normalization."""
 
-    target_stds: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    target_stds: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Standard deviations of the target data across channels, used for
     normalization."""
 
@@ -388,8 +381,8 @@ class DataConfig(BaseModel):
         self,
         image_means: Union[NDArray, tuple, list, None],
         image_stds: Union[NDArray, tuple, list, None],
-        target_means: Optional[Union[NDArray, tuple, list, None]] = None,
-        target_stds: Optional[Union[NDArray, tuple, list, None]] = None,
+        target_means: Union[NDArray, tuple, list, None] | None = None,
+        target_stds: Union[NDArray, tuple, list, None] | None = None,
     ) -> None:
         """
         Set mean and standard deviation of the data across channels.

careamics/config/data/ng_data_model.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from pprint import pformat
-from typing import Annotated, Any, Literal, Optional, Union
+from typing import Annotated, Any, Literal, Self, Union
 from warnings import warn
 
 import numpy as np
@@ -17,7 +17,6 @@ from pydantic import (
     field_validator,
     model_validator,
 )
-from typing_extensions import Self
 
 from ..transformations import XYFlipModel, XYRandomRotate90Model
 from ..validators import check_axes_validity
@@ -106,22 +105,16 @@ class NGDataConfig(BaseModel):
     batch_size: int = Field(default=1, ge=1, validate_default=True)
     """Batch size for training."""
 
-    image_means: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    image_means: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Means of the data across channels, used for normalization."""
 
-    image_stds: Optional[list[Float]] = Field(default=None, min_length=0, max_length=32)
+    image_stds: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Standard deviations of the data across channels, used for normalization."""
 
-    target_means: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    target_means: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Means of the target data across channels, used for normalization."""
 
-    target_stds: Optional[list[Float]] = Field(
-        default=None, min_length=0, max_length=32
-    )
+    target_stds: list[Float] | None = Field(default=None, min_length=0, max_length=32)
     """Standard deviations of the target data across channels, used for
     normalization."""
 
@@ -148,7 +141,7 @@ class NGDataConfig(BaseModel):
     test_dataloader_params: dict[str, Any] = Field(default={})
     """Dictionary of PyTorch test dataloader parameters."""
 
-    seed: Optional[int] = Field(default=None, gt=0)
+    seed: int | None = Field(default=None, gt=0)
     """Random seed for reproducibility."""
 
     @field_validator("axes")
@@ -330,8 +323,8 @@ class NGDataConfig(BaseModel):
         self,
         image_means: Union[NDArray, tuple, list, None],
         image_stds: Union[NDArray, tuple, list, None],
-        target_means: Optional[Union[NDArray, tuple, list, None]] = None,
-        target_stds: Optional[Union[NDArray, tuple, list, None]] = None,
+        target_means: Union[NDArray, tuple, list, None] | None = None,
+        target_stds: Union[NDArray, tuple, list, None] | None = None,
     ) -> None:
         """
         Set mean and standard deviation of the data across channels.

careamics/config/data/patching_strategies/_overlapping_patched_model.py

@@ -1,7 +1,6 @@
 """Sequential patching Pydantic model."""
 
 from collections.abc import Sequence
-from typing import Optional
 
 from pydantic import Field, ValidationInfo, field_validator
 
@@ -24,7 +23,7 @@ class _OverlappingPatchedModel(_PatchedModel):
         dimension, and the number of dimensions be either 2 or 3.
     """
 
-    overlaps: Optional[Sequence[int]] = Field(
+    overlaps: Sequence[int] | None = Field(
         default=None,
         min_length=2,
         max_length=3,
@@ -37,8 +36,8 @@ class _OverlappingPatchedModel(_PatchedModel):
     @field_validator("overlaps")
     @classmethod
     def overlap_smaller_than_patch_size(
-        cls, overlaps: Optional[Sequence[int]], values: ValidationInfo
-    ) -> Optional[Sequence[int]]:
+        cls, overlaps: Sequence[int] | None, values: ValidationInfo
+    ) -> Sequence[int] | None:
         """
         Validate overlap.
 
@@ -78,7 +77,7 @@ class _OverlappingPatchedModel(_PatchedModel):
 
     @field_validator("overlaps")
     @classmethod
-    def overlap_even(cls, overlaps: Optional[Sequence[int]]) -> Optional[Sequence[int]]:
+    def overlap_even(cls, overlaps: Sequence[int] | None) -> Sequence[int] | None:
         """
         Validate overlaps.
 

careamics/config/inference_model.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal, Self, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
-from typing_extensions import Self
 
 from .validators import check_axes_validity, patch_size_ge_than_8_power_of_2
 
@@ -18,12 +17,10 @@ class InferenceConfig(BaseModel):
     data_type: Literal["array", "tiff", "czi", "custom"]  # As defined in SupportedData
     """Type of input data: numpy.ndarray (array) or path (tiff, czi, or custom)."""
 
-    tile_size: Optional[Union[list[int]]] = Field(
-        default=None, min_length=2, max_length=3
-    )
+    tile_size: Union[list[int]] | None = Field(default=None, min_length=2, max_length=3)
     """Tile size of prediction, only effective if `tile_overlap` is specified."""
 
-    tile_overlap: Optional[Union[list[int]]] = Field(
+    tile_overlap: Union[list[int]] | None = Field(
         default=None, min_length=2, max_length=3
     )
     """Overlap between tiles, only effective if `tile_size` is specified."""
@@ -48,8 +45,8 @@ class InferenceConfig(BaseModel):
     @field_validator("tile_overlap")
     @classmethod
     def all_elements_non_zero_even(
-        cls, tile_overlap: Optional[list[int]]
-    ) -> Optional[list[int]]:
+        cls, tile_overlap: list[int] | None
+    ) -> list[int] | None:
         """
         Validate tile overlap.
 
@@ -86,9 +83,7 @@ class InferenceConfig(BaseModel):
 
     @field_validator("tile_size")
     @classmethod
-    def tile_min_8_power_of_2(
-        cls, tile_list: Optional[list[int]]
-    ) -> Optional[list[int]]:
+    def tile_min_8_power_of_2(cls, tile_list: list[int] | None) -> list[int] | None:
         """
         Validate that each entry is greater or equal than 8 and a power of 2.
 

careamics/config/likelihood_model.py

@@ -1,6 +1,6 @@
 """Likelihood model."""
 
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 import numpy as np
 import torch
@@ -31,7 +31,7 @@ class GaussianLikelihoodConfig(BaseModel):
 
     model_config = ConfigDict(validate_assignment=True)
 
-    predict_logvar: Optional[Literal["pixelwise"]] = None
+    predict_logvar: Literal["pixelwise"] | None = None
     """If `pixelwise`, log-variance is computed for each pixel, else log-variance
     is not computed."""
 
@@ -50,11 +50,11 @@ class NMLikelihoodConfig(BaseModel):
     model_config = ConfigDict(validate_assignment=True, arbitrary_types_allowed=True)
 
     # TODO remove and use as parameters to the likelihood functions?
-    data_mean: Tensor = torch.zeros(1)
+    data_mean: Tensor | None = None
     """The mean of the data, used to unnormalize data for noise model evaluation.
     Shape is (target_ch,) (or (1, target_ch, [1], 1, 1))."""
 
     # TODO remove and use as parameters to the likelihood functions?
-    data_std: Tensor = torch.ones(1)
+    data_std: Tensor | None = None
     """The standard deviation of the data, used to unnormalize data for noise
     model evaluation. Shape is (target_ch,) (or (1, target_ch, [1], 1, 1))."""

careamics/config/loss_model.py

@@ -35,7 +35,9 @@ class LVAELossConfig(BaseModel):
         validate_assignment=True, validate_default=True, arbitrary_types_allowed=True
     )
 
-    loss_type: Literal["musplit", "denoisplit", "denoisplit_musplit"]
+    loss_type: Literal[
+        "hdn", "microsplit", "musplit", "denoisplit", "denoisplit_musplit"
+    ]
     """Type of loss to use for LVAE."""
 
     reconstruction_weight: float = 1.0
@@ -50,7 +52,9 @@ class LVAELossConfig(BaseModel):
     """Weight for the denoiSplit loss (used in the muSplit-deonoiSplit loss)."""
     kl_params: KLLossConfig = KLLossConfig()
     """KL loss configuration."""
-
+    # TODO revisit weights for the losses
     # TODO: remove?
     non_stochastic: bool = False
     """Whether to sample latents and compute KL."""
+
+    # TODO what are the correct parameters for HDN ?

careamics/config/nm_model.py

@@ -1,7 +1,7 @@
 """Noise models config."""
 
 from pathlib import Path
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Self, Union
 
 import numpy as np
 import torch
@@ -11,6 +11,7 @@ from pydantic import (
     Field,
     PlainSerializer,
     PlainValidator,
+    model_validator,
 )
 
 from careamics.utils.serializers import _array_to_json, _to_numpy
@@ -42,21 +43,19 @@ class GaussianMixtureNMConfig(BaseModel):
     # model type
     model_type: Literal["GaussianMixtureNoiseModel"]
 
-    path: Optional[Union[Path, str]] = None
+    path: Union[Path, str] | None = None
     """Path to the directory where the trained noise model (*.npz) is saved in the
     `train` method."""
 
     # TODO remove and use as parameters to the NM functions?
-    signal: Optional[Union[str, Path, np.ndarray]] = Field(default=None, exclude=True)
+    signal: Union[str, Path, np.ndarray] | None = Field(default=None, exclude=True)
     """Path to the file containing signal or respective numpy array."""
 
     # TODO remove and use as parameters to the NM functions?
-    observation: Optional[Union[str, Path, np.ndarray]] = Field(
-        default=None, exclude=True
-    )
+    observation: Union[str, Path, np.ndarray] | None = Field(default=None, exclude=True)
     """Path to the file containing observation or respective numpy array."""
 
-    weight: Optional[Array] = None
+    weight: Array | None = None
     """A [3*n_gaussian, n_coeff] sized array containing the values of the weights
     describing the GMM noise model, with each row corresponding to one
     parameter of each gaussian, namely [mean, standard deviation and weight].
@@ -88,6 +87,30 @@ class GaussianMixtureNMConfig(BaseModel):
     tol: float = Field(default=1e-10)
     """Tolerance used in the computation of the noise model likelihood."""
 
+    @model_validator(mode="after")
+    def validate_path(self: Self) -> Self:
+        """Validate that the path points to a valid .npz file if provided.
+
+        Returns
+        -------
+        Self
+            Returns itself.
+
+        Raises
+        ------
+        ValueError
+            If the path is provided but does not point to a valid .npz file.
+        """
+        if self.path is not None:
+            path = Path(self.path)
+            if not path.exists():
+                raise ValueError(f"Path {path} does not exist.")
+            if path.suffix != ".npz":
+                raise ValueError(f"Path {path} must point to a .npz file.")
+            if not path.is_file():
+                raise ValueError(f"Path {path} must point to a file.")
+        return self
+
     # @model_validator(mode="after")
     # def validate_path_to_pretrained_vs_training_data(self: Self) -> Self:
     #     """Validate paths provided in the config.

careamics/config/optimizer_models.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Literal
+from typing import Literal, Self
 
 from pydantic import (
     BaseModel,
@@ -13,7 +13,6 @@ from pydantic import (
     model_validator,
 )
 from torch import optim
-from typing_extensions import Self
 
 from careamics.utils.torch_utils import filter_parameters
 

careamics/config/support/supported_algorithms.py

@@ -26,9 +26,11 @@ class SupportedAlgorithm(str, BaseEnum):
     MUSPLIT = "musplit"
     """An image splitting approach based on ladder VAE architectures."""
 
+    MICROSPLIT = "microsplit"
+    """A micro-level image splitting approach based on ladder VAE architectures."""
+
     DENOISPLIT = "denoisplit"
     """An image splitting and denoising approach based on ladder VAE architectures."""
 
-    # PN2V = "pn2v"
-    # HDN = "hdn"
-    # SEG = "segmentation"
+    HDN = "hdn"
+    """Hierarchical Denoising Network, an unsupervised denoising algorithm"""

careamics/config/support/supported_losses.py

@@ -21,9 +21,12 @@ class SupportedLoss(str, BaseEnum):
     MAE = "mae"
     N2V = "n2v"
     # PN2V = "pn2v"
-    # HDN = "hdn"
+    HDN = "hdn"
     MUSPLIT = "musplit"
+    MICROSPLIT = "microsplit"
     DENOISPLIT = "denoisplit"
-    DENOISPLIT_MUSPLIT = "denoisplit_musplit"
+    DENOISPLIT_MUSPLIT = (
+        "denoisplit_musplit"  # TODO refac losses, leave only microsplit
+    )
     # CE = "ce"
     # DICE = "dice"

careamics/config/training_model.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Literal, Optional, Union
+from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 from .callback_model import CheckpointModel, EarlyStoppingModel
 
@@ -29,31 +29,20 @@ class TrainingConfig(BaseModel):
     model_config = ConfigDict(
         validate_assignment=True,
     )
+    lightning_trainer_config: dict | None = None
+    """Configuration for the PyTorch Lightning Trainer, following PyTorch Lightning
+    Trainer class"""
 
-    num_epochs: int = Field(default=20, ge=1)
-    """Number of epochs, greater than 0."""
-
-    precision: Literal["64", "32", "16-mixed", "bf16-mixed"] = Field(default="32")
-    """Numerical precision"""
-    max_steps: int = Field(default=-1, ge=-1)
-    """Maximum number of steps to train for. -1 means no limit."""
-    check_val_every_n_epoch: int = Field(default=1, ge=1)
-    """Validation step frequency."""
-    accumulate_grad_batches: int = Field(default=1, ge=1)
-    """Number of batches to accumulate gradients over before stepping the optimizer."""
-    gradient_clip_val: Optional[Union[int, float]] = None
-    """The value to which to clip the gradient"""
-    gradient_clip_algorithm: Literal["value", "norm"] = "norm"
-    """The algorithm to use for gradient clipping (see lightning `Trainer`)."""
-    logger: Optional[Literal["wandb", "tensorboard"]] = None
+    logger: Literal["wandb", "tensorboard"] | None = None
     """Logger to use during training. If None, no logger will be used. Available
     loggers are defined in SupportedLogger."""
 
+    # Only basic callbacks
     checkpoint_callback: CheckpointModel = CheckpointModel()
     """Checkpoint callback configuration, following PyTorch Lightning Checkpoint
     callback."""
 
-    early_stopping_callback: Optional[EarlyStoppingModel] = Field(
+    early_stopping_callback: EarlyStoppingModel | None = Field(
         default=None, validate_default=True
     )
     """Early stopping callback configuration, following PyTorch Lightning Checkpoint
@@ -78,22 +67,3 @@ class TrainingConfig(BaseModel):
             Whether the logger is defined or not.
         """
         return self.logger is not None
-
-    @field_validator("max_steps")
-    @classmethod
-    def validate_max_steps(cls, max_steps: int) -> int:
-        """Validate the max_steps parameter.
-
-        Parameters
-        ----------
-        max_steps : int
-            Maximum number of steps to train for. -1 means no limit.
-
-        Returns
-        -------
-        int
-            Validated max_steps.
-        """
-        if max_steps == 0:
-            raise ValueError("max_steps must be greater than 0. Use -1 for no limit.")
-        return max_steps

careamics/config/transformations/normalize_model.py

@@ -1,9 +1,8 @@
 """Pydantic model for the Normalize transform."""
 
-from typing import Literal, Optional
+from typing import Literal, Self
 
 from pydantic import ConfigDict, Field, model_validator
-from typing_extensions import Self
 
 from .transform_model import TransformModel
 
@@ -31,8 +30,8 @@ class NormalizeModel(TransformModel):
     name: Literal["Normalize"] = "Normalize"
     image_means: list = Field(..., min_length=0, max_length=32)
     image_stds: list = Field(..., min_length=0, max_length=32)
-    target_means: Optional[list] = Field(default=None, min_length=0, max_length=32)
-    target_stds: Optional[list] = Field(default=None, min_length=0, max_length=32)
+    target_means: list | None = Field(default=None, min_length=0, max_length=32)
+    target_stds: list | None = Field(default=None, min_length=0, max_length=32)
 
     @model_validator(mode="after")
     def validate_means_stds(self: Self) -> Self:

careamics/config/transformations/xy_flip_model.py

@@ -1,6 +1,6 @@
 """Pydantic model for the XYFlip transform."""
 
-from typing import Literal, Optional
+from typing import Literal
 
 from pydantic import ConfigDict, Field
 
@@ -40,4 +40,4 @@ class XYFlipModel(TransformModel):
         ge=0,
         le=1,
     )
-    seed: Optional[int] = None
+    seed: int | None = None

careamics/config/transformations/xy_random_rotate90_model.py

@@ -1,6 +1,6 @@
 """Pydantic model for the XYRandomRotate90 transform."""
 
-from typing import Literal, Optional
+from typing import Literal
 
 from pydantic import ConfigDict, Field
 
@@ -32,4 +32,4 @@ class XYRandomRotate90Model(TransformModel):
         ge=0,
         le=1,
     )
-    seed: Optional[int] = None
+    seed: int | None = None

careamics/config/validators/validator_utils.py

@@ -5,7 +5,6 @@ These functions are used to validate dimensions and axes of inputs.
 """
 
 from collections.abc import Sequence
-from typing import Optional
 
 _AXES = "STCZYX"
 
@@ -80,7 +79,7 @@ def value_ge_than_8_power_of_2(
 
 
 def patch_size_ge_than_8_power_of_2(
-    patch_list: Optional[Sequence[int]],
+    patch_list: Sequence[int] | None,
 ) -> None:
     """
     Validate that each entry is greater or equal than 8 and a power of 2.

careamics/dataset/dataset_utils/iterate_over_files.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Optional, Union
+from typing import Union
 
 from numpy.typing import NDArray
 from torch.utils.data import get_worker_info
@@ -21,9 +21,9 @@ logger = get_logger(__name__)
 def iterate_over_files(
     data_config: Union[DataConfig, InferenceConfig],
     data_files: list[Path],
-    target_files: Optional[list[Path]] = None,
+    target_files: list[Path] | None = None,
     read_source_func: Callable = read_tiff,
-) -> Generator[tuple[NDArray, Optional[NDArray]], None, None]:
+) -> Generator[tuple[NDArray, NDArray | None], None, None]:
     """Iterate over data source and yield whole reshaped images.
 
     Parameters

careamics/dataset/in_memory_dataset.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import copy
 from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import numpy as np
 from torch.utils.data import Dataset
@@ -49,7 +49,7 @@ class InMemoryDataset(Dataset):
         self,
         data_config: DataConfig,
         inputs: Union[np.ndarray, list[Path]],
-        input_target: Optional[Union[np.ndarray, list[Path]]] = None,
+        input_target: Union[np.ndarray, list[Path]] | None = None,
         read_source_func: Callable = read_tiff,
         **kwargs: Any,
     ) -> None:

careamics/dataset/iterable_dataset.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import copy
 from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Optional
 
 import numpy as np
 from torch.utils.data import IterableDataset
@@ -51,7 +50,7 @@ class PathIterableDataset(IterableDataset):
         self,
         data_config: DataConfig,
         src_files: list[Path],
-        target_files: Optional[list[Path]] = None,
+        target_files: list[Path] | None = None,
         read_source_func: Callable = read_tiff,
     ) -> None:
         """Constructors.

careamics/dataset/patching/random_patching.py

@@ -1,7 +1,7 @@
 """Random patching utilities."""
 
 from collections.abc import Generator
-from typing import Optional, Union
+from typing import Union
 
 import numpy as np
 import zarr
@@ -13,9 +13,9 @@ from .validate_patch_dimension import validate_patch_dimensions
 def extract_patches_random(
     arr: np.ndarray,
     patch_size: Union[list[int], tuple[int, ...]],
-    target: Optional[np.ndarray] = None,
-    seed: Optional[int] = None,
-) -> Generator[tuple[np.ndarray, Optional[np.ndarray]], None, None]:
+    target: np.ndarray | None = None,
+    seed: int | None = None,
+) -> Generator[tuple[np.ndarray, np.ndarray | None], None, None]:
     """
     Generate patches from an array in a random manner.
 
@@ -115,8 +115,8 @@ def extract_patches_random_from_chunks(
     arr: zarr.Array,
     patch_size: Union[list[int], tuple[int, ...]],
     chunk_size: Union[list[int], tuple[int, ...]],
-    chunk_limit: Optional[int] = None,
-    seed: Optional[int] = None,
+    chunk_limit: int | None = None,
+    seed: int | None = None,
 ) -> Generator[np.ndarray, None, None]:
     """
     Generate patches from an array in a random manner.

careamics/dataset/patching/sequential_patching.py

@@ -1,6 +1,6 @@
 """Sequential patching functions."""
 
-from typing import Optional, Union
+from typing import Union
 
 import numpy as np
 from skimage.util import view_as_windows
@@ -110,7 +110,7 @@ def _compute_patch_views(
     window_shape: list[int],
     step: tuple[int, ...],
     output_shape: list[int],
-    target: Optional[np.ndarray] = None,
+    target: np.ndarray | None = None,
 ) -> np.ndarray:
     """
     Compute views of an array corresponding to patches.
@@ -151,8 +151,8 @@ def _compute_patch_views(
 def extract_patches_sequential(
     arr: np.ndarray,
     patch_size: Union[list[int], tuple[int, ...]],
-    target: Optional[np.ndarray] = None,
-) -> tuple[np.ndarray, Optional[np.ndarray]]:
+    target: np.ndarray | None = None,
+) -> tuple[np.ndarray, np.ndarray | None]:
     """
     Generate patches from an array in a sequential manner.
 

careamics/dataset/tiling/lvae_tiled_patching.py

@@ -3,7 +3,7 @@
 import builtins
 import itertools
 from collections.abc import Generator
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -16,7 +16,7 @@ def extract_tiles(
     arr: NDArray,
     tile_size: NDArray[np.int_],
     overlaps: NDArray[np.int_],
-    padding_kwargs: Optional[dict[str, Any]] = None,
+    padding_kwargs: dict[str, Any] | None = None,
 ) -> Generator[tuple[NDArray, TileInformation], None, None]:
     """Generate tiles from the input array with specified overlap.