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

careamics/careamist.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Literal, Optional, Union, overload
+from typing import Any, Literal, Union, overload
 
 import numpy as np
 from numpy.typing import NDArray
@@ -79,8 +79,8 @@ class CAREamist:
     def __init__(  # numpydoc ignore=GL08
         self,
         source: Union[Path, str],
-        work_dir: Optional[Union[Path, str]] = None,
-        callbacks: Optional[list[Callback]] = None,
+        work_dir: Union[Path, str] | None = None,
+        callbacks: list[Callback] | None = None,
         enable_progress_bar: bool = True,
     ) -> None: ...
 
@@ -88,16 +88,16 @@ class CAREamist:
     def __init__(  # numpydoc ignore=GL08
         self,
         source: Configuration,
-        work_dir: Optional[Union[Path, str]] = None,
-        callbacks: Optional[list[Callback]] = None,
+        work_dir: Union[Path, str] | None = None,
+        callbacks: list[Callback] | None = None,
         enable_progress_bar: bool = True,
     ) -> None: ...
 
     def __init__(
         self,
         source: Union[Path, str, Configuration],
-        work_dir: Optional[Union[Path, str]] = None,
-        callbacks: Optional[list[Callback]] = None,
+        work_dir: Union[Path, str] | None = None,
+        callbacks: list[Callback] | None = None,
         enable_progress_bar: bool = True,
     ) -> None:
         """
@@ -222,11 +222,11 @@ class CAREamist:
         )
 
         # place holder for the datamodules
-        self.train_datamodule: Optional[TrainDataModule] = None
-        self.pred_datamodule: Optional[PredictDataModule] = None
+        self.train_datamodule: TrainDataModule | None = None
+        self.pred_datamodule: PredictDataModule | None = None
 
     def _define_callbacks(
-        self, callbacks: Optional[list[Callback]], enable_progress_bar: bool
+        self, callbacks: list[Callback] | None, enable_progress_bar: bool
     ) -> None:
         """Define the callbacks for the training loop.
 
@@ -288,11 +288,11 @@ class CAREamist:
     def train(
         self,
         *,
-        datamodule: Optional[TrainDataModule] = None,
-        train_source: Optional[Union[Path, str, NDArray]] = None,
-        val_source: Optional[Union[Path, str, NDArray]] = None,
-        train_target: Optional[Union[Path, str, NDArray]] = None,
-        val_target: Optional[Union[Path, str, NDArray]] = None,
+        datamodule: TrainDataModule | None = None,
+        train_source: Union[Path, str, NDArray] | None = None,
+        val_source: Union[Path, str, NDArray] | None = None,
+        train_target: Union[Path, str, NDArray] | None = None,
+        val_target: Union[Path, str, NDArray] | None = None,
         use_in_memory: bool = True,
         val_percentage: float = 0.1,
         val_minimum_split: int = 1,
@@ -443,9 +443,9 @@ class CAREamist:
     def _train_on_array(
         self,
         train_data: NDArray,
-        val_data: Optional[NDArray] = None,
-        train_target: Optional[NDArray] = None,
-        val_target: Optional[NDArray] = None,
+        val_data: NDArray | None = None,
+        train_target: NDArray | None = None,
+        val_target: NDArray | None = None,
         val_percentage: float = 0.1,
         val_minimum_split: int = 5,
     ) -> None:
@@ -484,9 +484,9 @@ class CAREamist:
     def _train_on_path(
         self,
         path_to_train_data: Union[Path, str],
-        path_to_val_data: Optional[Union[Path, str]] = None,
-        path_to_train_target: Optional[Union[Path, str]] = None,
-        path_to_val_target: Optional[Union[Path, str]] = None,
+        path_to_val_data: Union[Path, str] | None = None,
+        path_to_train_target: Union[Path, str] | None = None,
+        path_to_val_target: Union[Path, str] | None = None,
         use_in_memory: bool = True,
         val_percentage: float = 0.1,
         val_minimum_split: int = 1,
@@ -549,13 +549,13 @@ class CAREamist:
         source: Union[Path, str],
         *,
         batch_size: int = 1,
-        tile_size: Optional[tuple[int, ...]] = None,
-        tile_overlap: Optional[tuple[int, ...]] = (48, 48),
-        axes: Optional[str] = None,
-        data_type: Optional[Literal["tiff", "custom"]] = None,
+        tile_size: tuple[int, ...] | None = None,
+        tile_overlap: tuple[int, ...] | None = (48, 48),
+        axes: str | None = None,
+        data_type: Literal["tiff", "custom"] | None = None,
         tta_transforms: bool = False,
-        dataloader_params: Optional[dict] = None,
-        read_source_func: Optional[Callable] = None,
+        dataloader_params: dict | None = None,
+        read_source_func: Callable | None = None,
         extension_filter: str = "",
     ) -> Union[list[NDArray], NDArray]: ...
 
@@ -565,12 +565,12 @@ class CAREamist:
         source: NDArray,
         *,
         batch_size: int = 1,
-        tile_size: Optional[tuple[int, ...]] = None,
-        tile_overlap: Optional[tuple[int, ...]] = (48, 48),
-        axes: Optional[str] = None,
-        data_type: Optional[Literal["array"]] = None,
+        tile_size: tuple[int, ...] | None = None,
+        tile_overlap: tuple[int, ...] | None = (48, 48),
+        axes: str | None = None,
+        data_type: Literal["array"] | None = None,
         tta_transforms: bool = False,
-        dataloader_params: Optional[dict] = None,
+        dataloader_params: dict | None = None,
     ) -> Union[list[NDArray], NDArray]: ...
 
     def predict(
@@ -578,13 +578,13 @@ class CAREamist:
         source: Union[PredictDataModule, Path, str, NDArray],
         *,
         batch_size: int = 1,
-        tile_size: Optional[tuple[int, ...]] = None,
-        tile_overlap: Optional[tuple[int, ...]] = (48, 48),
-        axes: Optional[str] = None,
-        data_type: Optional[Literal["array", "tiff", "custom"]] = None,
+        tile_size: tuple[int, ...] | None = None,
+        tile_overlap: tuple[int, ...] | None = (48, 48),
+        axes: str | None = None,
+        data_type: Literal["array", "tiff", "custom"] | None = None,
         tta_transforms: bool = False,
-        dataloader_params: Optional[dict] = None,
-        read_source_func: Optional[Callable] = None,
+        dataloader_params: dict | None = None,
+        read_source_func: Callable | None = None,
         extension_filter: str = "",
         **kwargs: Any,
     ) -> Union[list[NDArray], NDArray]:
@@ -704,18 +704,18 @@ class CAREamist:
         source: Union[PredictDataModule, Path, str],
         *,
         batch_size: int = 1,
-        tile_size: Optional[tuple[int, ...]] = None,
-        tile_overlap: Optional[tuple[int, ...]] = (48, 48),
-        axes: Optional[str] = None,
-        data_type: Optional[Literal["tiff", "custom"]] = None,
+        tile_size: tuple[int, ...] | None = None,
+        tile_overlap: tuple[int, ...] | None = (48, 48),
+        axes: str | None = None,
+        data_type: Literal["tiff", "custom"] | None = None,
         tta_transforms: bool = False,
-        dataloader_params: Optional[dict] = None,
-        read_source_func: Optional[Callable] = None,
+        dataloader_params: dict | None = None,
+        read_source_func: Callable | None = None,
         extension_filter: str = "",
         write_type: Literal["tiff", "custom"] = "tiff",
-        write_extension: Optional[str] = None,
-        write_func: Optional[WriteFunc] = None,
-        write_func_kwargs: Optional[dict[str, Any]] = None,
+        write_extension: str | None = None,
+        write_func: WriteFunc | None = None,
+        write_func_kwargs: dict[str, Any] | None = None,
         prediction_dir: Union[Path, str] = "predictions",
         **kwargs,
     ) -> None:
@@ -885,8 +885,8 @@ class CAREamist:
         authors: list[dict],
         general_description: str,
         data_description: str,
-        covers: Optional[list[Union[Path, str]]] = None,
-        channel_names: Optional[list[str]] = None,
+        covers: list[Union[Path, str]] | None = None,
+        channel_names: list[str] | None = None,
         model_version: str = "0.1.0",
     ) -> None:
         """Export the model to the BioImage Model Zoo format.

careamics/cli/conf.py

@@ -3,7 +3,7 @@
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated
 
 import click
 import typer
@@ -135,10 +135,10 @@ def care(  # numpydoc ignore=PR01
         ),
     ] = "mae",
     n_channels_in: Annotated[
-        Optional[int], typer.Option(help="Number of channels in")
+        int | None, typer.Option(help="Number of channels in")
     ] = None,
     n_channels_out: Annotated[
-        Optional[int], typer.Option(help="Number of channels out")
+        int | None, typer.Option(help="Number of channels out")
     ] = None,
     logger: Annotated[
         click.Choice,
@@ -222,10 +222,10 @@ def n2n(  # numpydoc ignore=PR01
         ),
     ] = "mae",
     n_channels_in: Annotated[
-        Optional[int], typer.Option(help="Number of channels in")
+        int | None, typer.Option(help="Number of channels in")
     ] = None,
     n_channels_out: Annotated[
-        Optional[int], typer.Option(help="Number of channels out")
+        int | None, typer.Option(help="Number of channels out")
     ] = None,
     logger: Annotated[
         click.Choice,
@@ -300,7 +300,7 @@ def n2v(  # numpydoc ignore=PR01
     ] = True,
     use_n2v2: Annotated[bool, typer.Option(help="Whether to use N2V2")] = False,
     n_channels: Annotated[
-        Optional[int], typer.Option(help="Number of channels (in and out)")
+        int | None, typer.Option(help="Number of channels (in and out)")
     ] = None,
     roi_size: Annotated[int, typer.Option(help="N2V pixel manipulation area.")] = 11,
     masked_pixel_percentage: Annotated[

careamics/cli/main.py

@@ -7,7 +7,7 @@ its implementation is contained in the conf.py file.
 """
 
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated
 
 import click
 import typer
@@ -47,7 +47,7 @@ def train(  # numpydoc ignore=PR01
         ),
     ],
     train_target: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             "--train-target",
             "-tt",
@@ -58,7 +58,7 @@ def train(  # numpydoc ignore=PR01
         ),
     ] = None,
     val_source: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             "--val-source",
             "-vs",
@@ -69,7 +69,7 @@ def train(  # numpydoc ignore=PR01
         ),
     ] = None,
     val_target: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             "--val-target",
             "-vt",
@@ -96,7 +96,7 @@ def train(  # numpydoc ignore=PR01
         typer.Option(help="Minimum number of files to use for validation,"),
     ] = 1,
     work_dir: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             "--work-dir",
             "-wd",
@@ -142,7 +142,7 @@ def predict(  # numpydoc ignore=PR01
     ],
     batch_size: Annotated[int, typer.Option(help="Batch size.")] = 1,
     tile_size: Annotated[
-        Optional[click.Tuple],
+        click.Tuple | None,
         typer.Option(
             help=(
                 "Size of the tiles to use for prediction, (if the data "
@@ -164,7 +164,7 @@ def predict(  # numpydoc ignore=PR01
         ),
     ] = (48, 48, -1),
     axes: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             help="Axes of the input data. If unused the data is assumed to have the "
             "same axes as the original training data."
@@ -190,7 +190,7 @@ def predict(  # numpydoc ignore=PR01
     ] = "tiff",
     # TODO: could make dataloader_params as json, necessary?
     work_dir: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             "--work-dir",
             "-wd",

careamics/cli/utils.py

@@ -1,11 +1,9 @@
 """Utility functions for the CAREamics CLI."""
 
-from typing import Optional
-
 
 def handle_2D_3D_callback(
-    value: Optional[tuple[int, int, int]],
-) -> Optional[tuple[int, ...]]:
+    value: tuple[int, int, int] | None,
+) -> tuple[int, ...] | None:
     """
     Callback for options that require 2D or 3D inputs.
 

careamics/config/algorithms/vae_algorithm_model.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Literal, Optional
+from typing import Literal
 
 from pydantic import BaseModel, ConfigDict, model_validator
 from typing_extensions import Self
@@ -45,9 +45,9 @@ class VAEBasedAlgorithm(BaseModel):
     # NOTE: these are all configs (pydantic models)
     loss: LVAELossConfig
     model: LVAEModel
-    noise_model: Optional[MultiChannelNMConfig] = None
-    noise_model_likelihood: Optional[NMLikelihoodConfig] = None
-    gaussian_likelihood: Optional[GaussianLikelihoodConfig] = None
+    noise_model: MultiChannelNMConfig | None = None
+    noise_model_likelihood: NMLikelihoodConfig | None = None
+    gaussian_likelihood: GaussianLikelihoodConfig | None = None
 
     # Optional fields
     optimizer: OptimizerModel = OptimizerModel()

careamics/config/callback_model.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from typing import Literal, Optional
+from typing import Literal
 
 from pydantic import (
     BaseModel,
@@ -33,7 +33,7 @@ class CheckpointModel(BaseModel):
     save_weights_only: bool = Field(default=False)
     """When `True`, only the model's weights will be saved (model.save_weights)."""
 
-    save_last: Optional[Literal[True, False, "link"]] = Field(default=True)
+    save_last: Literal[True, False, "link"] | None = Field(default=True)
     """When `True`, saves a last.ckpt copy whenever a checkpoint file gets saved."""
 
     save_top_k: int = Field(default=3, ge=-1, le=100)
@@ -51,13 +51,13 @@ class CheckpointModel(BaseModel):
     auto_insert_metric_name: bool = Field(default=False)
     """When `True`, the checkpoints filenames will contain the metric name."""
 
-    every_n_train_steps: Optional[int] = Field(default=None, ge=1, le=1000)
+    every_n_train_steps: int | None = Field(default=None, ge=1, le=1000)
     """Number of training steps between checkpoints."""
 
-    train_time_interval: Optional[timedelta] = Field(default=None)
+    train_time_interval: timedelta | None = Field(default=None)
     """Checkpoints are monitored at the specified time interval."""
 
-    every_n_epochs: Optional[int] = Field(default=None, ge=1, le=100)
+    every_n_epochs: int | None = Field(default=None, ge=1, le=100)
     """Number of epochs between checkpoints."""
 
 
@@ -96,14 +96,14 @@ class EarlyStoppingModel(BaseModel):
     """When `True`, stops training when the monitored quantity becomes `NaN` or
     `inf`."""
 
-    stopping_threshold: Optional[float] = Field(default=None)
+    stopping_threshold: float | None = Field(default=None)
     """Stop training immediately once the monitored quantity reaches this threshold."""
 
-    divergence_threshold: Optional[float] = Field(default=None)
+    divergence_threshold: float | None = Field(default=None)
     """Stop training as soon as the monitored quantity becomes worse than this
     threshold."""
 
-    check_on_train_epoch_end: Optional[bool] = Field(default=False)
+    check_on_train_epoch_end: bool | None = Field(default=False)
     """Whether to run early stopping at the end of the training epoch. If this is
     `False`, then the check runs at the end of the validation."""
 

careamics/config/configuration_factories.py

@@ -1,7 +1,7 @@
 """Convenience functions to create configurations for training and inference."""
 
 from collections.abc import Sequence
-from typing import Annotated, Any, Literal, Optional, Union
+from typing import Annotated, Any, Literal, Union
 
 from pydantic import Field, TypeAdapter
 
@@ -50,7 +50,7 @@ def algorithm_factory(
 
 
 def _list_spatial_augmentations(
-    augmentations: Optional[list[SPATIAL_TRANSFORMS_UNION]] = None,
+    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
 ) -> list[SPATIAL_TRANSFORMS_UNION]:
     """
     List the augmentations to apply.
@@ -105,7 +105,7 @@ def _create_unet_configuration(
     n_channels_out: int,
     independent_channels: bool,
     use_n2v2: bool,
-    model_params: Optional[dict[str, Any]] = None,
+    model_params: dict[str, Any] | None = None,
 ) -> UNetModel:
     """
     Create a dictionary with the parameters of the UNet model.
@@ -153,11 +153,11 @@ def _create_algorithm_configuration(
     n_channels_in: int,
     n_channels_out: int,
     use_n2v2: bool = False,
-    model_params: Optional[dict] = None,
+    model_params: dict | None = None,
     optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
-    optimizer_params: Optional[dict[str, Any]] = None,
+    optimizer_params: dict[str, Any] | None = None,
     lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
-    lr_scheduler_params: Optional[dict[str, Any]] = None,
+    lr_scheduler_params: dict[str, Any] | None = None,
 ) -> dict:
     """
     Create a dictionary with the parameters of the algorithm model.
@@ -227,8 +227,8 @@ def _create_data_configuration(
     patch_size: list[int],
     batch_size: int,
     augmentations: Union[list[SPATIAL_TRANSFORMS_UNION]],
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
 ) -> DataConfig:
     """
     Create a dictionary with the parameters of the data model.
@@ -283,11 +283,11 @@ def _create_ng_data_configuration(
     patch_size: Sequence[int],
     batch_size: int,
     augmentations: list[SPATIAL_TRANSFORMS_UNION],
-    patch_overlaps: Optional[Sequence[int]] = None,
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
-    test_dataloader_params: Optional[dict[str, Any]] = None,
-    seed: Optional[int] = None,
+    patch_overlaps: Sequence[int] | None = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
+    test_dataloader_params: dict[str, Any] | None = None,
+    seed: int | None = None,
 ) -> NGDataConfig:
     """
     Create a dictionary with the parameters of the data model.
@@ -359,7 +359,7 @@ def _create_ng_data_configuration(
 def _create_training_configuration(
     num_epochs: int,
     logger: Literal["wandb", "tensorboard", "none"],
-    checkpoint_params: Optional[dict[str, Any]] = None,
+    checkpoint_params: dict[str, Any] | None = None,
 ) -> TrainingConfig:
     """
     Create a dictionary with the parameters of the training model.
@@ -395,20 +395,20 @@ def _create_supervised_config_dict(
     patch_size: list[int],
     batch_size: int,
     num_epochs: int,
-    augmentations: Optional[list[SPATIAL_TRANSFORMS_UNION]] = None,
+    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
     independent_channels: bool = True,
     loss: Literal["mae", "mse"] = "mae",
-    n_channels_in: Optional[int] = None,
-    n_channels_out: Optional[int] = None,
+    n_channels_in: int | None = None,
+    n_channels_out: int | None = None,
     logger: Literal["wandb", "tensorboard", "none"] = "none",
-    model_params: Optional[dict] = None,
+    model_params: dict | None = None,
     optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
-    optimizer_params: Optional[dict[str, Any]] = None,
+    optimizer_params: dict[str, Any] | None = None,
     lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
-    lr_scheduler_params: Optional[dict[str, Any]] = None,
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
-    checkpoint_params: Optional[dict[str, Any]] = None,
+    lr_scheduler_params: dict[str, Any] | None = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
+    checkpoint_params: dict[str, Any] | None = None,
 ) -> dict:
     """
     Create a configuration for training CARE or Noise2Noise.
@@ -540,20 +540,20 @@ def create_care_configuration(
     patch_size: list[int],
     batch_size: int,
     num_epochs: int,
-    augmentations: Optional[list[Union[XYFlipModel, XYRandomRotate90Model]]] = None,
+    augmentations: list[Union[XYFlipModel, XYRandomRotate90Model]] | None = None,
     independent_channels: bool = True,
     loss: Literal["mae", "mse"] = "mae",
-    n_channels_in: Optional[int] = None,
-    n_channels_out: Optional[int] = None,
+    n_channels_in: int | None = None,
+    n_channels_out: int | None = None,
     logger: Literal["wandb", "tensorboard", "none"] = "none",
-    model_params: Optional[dict] = None,
+    model_params: dict | None = None,
     optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
-    optimizer_params: Optional[dict[str, Any]] = None,
+    optimizer_params: dict[str, Any] | None = None,
     lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
-    lr_scheduler_params: Optional[dict[str, Any]] = None,
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
-    checkpoint_params: Optional[dict[str, Any]] = None,
+    lr_scheduler_params: dict[str, Any] | None = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
+    checkpoint_params: dict[str, Any] | None = None,
 ) -> Configuration:
     """
     Create a configuration for training CARE.
@@ -756,20 +756,20 @@ def create_n2n_configuration(
     patch_size: list[int],
     batch_size: int,
     num_epochs: int,
-    augmentations: Optional[list[Union[XYFlipModel, XYRandomRotate90Model]]] = None,
+    augmentations: list[Union[XYFlipModel, XYRandomRotate90Model]] | None = None,
     independent_channels: bool = True,
     loss: Literal["mae", "mse"] = "mae",
-    n_channels_in: Optional[int] = None,
-    n_channels_out: Optional[int] = None,
+    n_channels_in: int | None = None,
+    n_channels_out: int | None = None,
     logger: Literal["wandb", "tensorboard", "none"] = "none",
-    model_params: Optional[dict] = None,
+    model_params: dict | None = None,
     optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
-    optimizer_params: Optional[dict[str, Any]] = None,
+    optimizer_params: dict[str, Any] | None = None,
     lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
-    lr_scheduler_params: Optional[dict[str, Any]] = None,
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
-    checkpoint_params: Optional[dict[str, Any]] = None,
+    lr_scheduler_params: dict[str, Any] | None = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
+    checkpoint_params: dict[str, Any] | None = None,
 ) -> Configuration:
     """
     Create a configuration for training Noise2Noise.
@@ -972,23 +972,23 @@ def create_n2v_configuration(
     patch_size: list[int],
     batch_size: int,
     num_epochs: int,
-    augmentations: Optional[list[Union[XYFlipModel, XYRandomRotate90Model]]] = None,
+    augmentations: list[Union[XYFlipModel, XYRandomRotate90Model]] | None = None,
     independent_channels: bool = True,
     use_n2v2: bool = False,
-    n_channels: Optional[int] = None,
+    n_channels: int | None = None,
     roi_size: int = 11,
     masked_pixel_percentage: float = 0.2,
     struct_n2v_axis: Literal["horizontal", "vertical", "none"] = "none",
     struct_n2v_span: int = 5,
     logger: Literal["wandb", "tensorboard", "none"] = "none",
-    model_params: Optional[dict] = None,
+    model_params: dict | None = None,
     optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
-    optimizer_params: Optional[dict[str, Any]] = None,
+    optimizer_params: dict[str, Any] | None = None,
     lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
-    lr_scheduler_params: Optional[dict[str, Any]] = None,
-    train_dataloader_params: Optional[dict[str, Any]] = None,
-    val_dataloader_params: Optional[dict[str, Any]] = None,
-    checkpoint_params: Optional[dict[str, Any]] = None,
+    lr_scheduler_params: dict[str, Any] | None = None,
+    train_dataloader_params: dict[str, Any] | None = None,
+    val_dataloader_params: dict[str, Any] | None = None,
+    checkpoint_params: dict[str, Any] | None = None,
 ) -> Configuration:
     """
     Create a configuration for training Noise2Void.

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, Union
 from warnings import warn
 
 import numpy as np
@@ -109,22 +109,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 +382,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.