careamics 0.0.19__py3-none-any.whl

careamics/config/transformations/normalize_config.py

@@ -0,0 +1,59 @@
+"""Pydantic model for the Normalize transform."""
+
+from typing import Literal, Self
+
+from pydantic import ConfigDict, Field, model_validator
+
+from .transform_config import TransformConfig
+
+
+class NormalizeConfig(TransformConfig):
+    """
+    Pydantic model used to represent Normalize transformation.
+
+    The Normalize transform is a zero mean and unit variance transformation.
+
+    Attributes
+    ----------
+    name : Literal["Normalize"]
+        Name of the transformation.
+    mean : float
+        Mean value for normalization.
+    std : float
+        Standard deviation value for normalization.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    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: 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:
+        """Validate that the means and stds have the same length.
+
+        Returns
+        -------
+        Self
+            The instance of the model.
+        """
+        if len(self.image_means) != len(self.image_stds):
+            raise ValueError("The number of image means and stds must be the same.")
+
+        if (self.target_means is None) != (self.target_stds is None):
+            raise ValueError(
+                "Both target means and stds must be provided together, or bot None."
+            )
+
+        if self.target_means is not None and self.target_stds is not None:
+            if len(self.target_means) != len(self.target_stds):
+                raise ValueError(
+                    "The number of target means and stds must be the same."
+                )
+
+        return self

careamics/config/transformations/transform_config.py

@@ -0,0 +1,45 @@
+"""Parent model for the transforms."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class TransformConfig(BaseModel):
+    """
+    Pydantic model used to represent a transformation.
+
+    The `model_dump` method is overwritten to exclude the name field.
+
+    Attributes
+    ----------
+    name : str
+        Name of the transformation.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",  # throw errors if the parameters are not properly passed
+    )
+
+    name: str
+
+    def model_dump(self, **kwargs) -> dict[str, Any]:
+        """
+        Return the model as a dictionary.
+
+        Parameters
+        ----------
+        **kwargs
+            Pydantic BaseMode model_dump method keyword arguments.
+
+        Returns
+        -------
+        {str: Any}
+            Dictionary representation of the model.
+        """
+        model_dict = super().model_dump(**kwargs)
+
+        # remove the name field
+        model_dict.pop("name")
+
+        return model_dict

careamics/config/transformations/transform_unions.py

@@ -0,0 +1,29 @@
+"""Type used to represent all transformations users can create."""
+
+from typing import Annotated, Union
+
+from pydantic import Discriminator
+
+from .normalize_config import NormalizeConfig
+from .xy_flip_config import XYFlipConfig
+from .xy_random_rotate90_config import XYRandomRotate90Config
+
+NORM_AND_SPATIAL_UNION = Annotated[
+    Union[
+        NormalizeConfig,
+        XYFlipConfig,
+        XYRandomRotate90Config,
+    ],
+    Discriminator("name"),  # used to tell the different transform models apart
+]
+"""All transforms including normalization."""
+
+
+SPATIAL_TRANSFORMS_UNION = Annotated[
+    Union[
+        XYFlipConfig,
+        XYRandomRotate90Config,
+    ],
+    Discriminator("name"),  # used to tell the different transform models apart
+]
+"""Available spatial transforms in CAREamics."""

careamics/config/transformations/xy_flip_config.py

@@ -0,0 +1,43 @@
+"""Pydantic model for the XYFlip transform."""
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field
+
+from .transform_config import TransformConfig
+
+
+class XYFlipConfig(TransformConfig):
+    """
+    Pydantic model used to represent XYFlip transformation.
+
+    Attributes
+    ----------
+    name : Literal["XYFlip"]
+        Name of the transformation.
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator,  by default None.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["XYFlip"] = "XYFlip"
+    flip_x: bool = Field(
+        True,
+        description="Whether to flip along the X axis.",
+    )
+    flip_y: bool = Field(
+        True,
+        description="Whether to flip along the Y axis.",
+    )
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: int | None = None

careamics/config/transformations/xy_random_rotate90_config.py

@@ -0,0 +1,35 @@
+"""Pydantic model for the XYRandomRotate90 transform."""
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field
+
+from .transform_config import TransformConfig
+
+
+class XYRandomRotate90Config(TransformConfig):
+    """
+    Pydantic model used to represent the XY random 90 degree rotation transformation.
+
+    Attributes
+    ----------
+    name : Literal["XYRandomRotate90"]
+        Name of the transformation.
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator, by default None.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["XYRandomRotate90"] = "XYRandomRotate90"
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: int | None = None

careamics/config/utils/__init__.py

@@ -0,0 +1,8 @@
+"""Configuration utilities."""
+
+__all__ = [
+    "load_configuration",
+    "save_configuration",
+]
+
+from .configuration_io import load_configuration, save_configuration

careamics/config/utils/configuration_io.py

@@ -0,0 +1,85 @@
+"""I/O functions for Configuration objects."""
+
+from pathlib import Path
+from typing import Union
+
+import yaml
+
+from careamics.config import Configuration
+
+
+def load_configuration(path: Union[str, Path]) -> Configuration:
+    """
+    Load configuration from a yaml file.
+
+    Parameters
+    ----------
+    path : str or Path
+        Path to the configuration.
+
+    Returns
+    -------
+    Configuration
+        Configuration.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the configuration file does not exist.
+    """
+    # load dictionary from yaml
+    if not Path(path).exists():
+        raise FileNotFoundError(
+            f"Configuration file {path} does not exist in " f" {Path.cwd()!s}"
+        )
+
+    dictionary = yaml.load(Path(path).open("r"), Loader=yaml.SafeLoader)
+
+    return Configuration(**dictionary)
+
+
+def save_configuration(config: Configuration, path: Union[str, Path]) -> Path:
+    """
+    Save configuration to path.
+
+    Parameters
+    ----------
+    config : Configuration
+        Configuration to save.
+    path : str or Path
+        Path to a existing folder in which to save the configuration, or to a valid
+        configuration file path (uses a .yml or .yaml extension).
+
+    Returns
+    -------
+    Path
+        Path object representing the configuration.
+
+    Raises
+    ------
+    ValueError
+        If the path does not point to an existing directory or .yml file.
+    """
+    # make sure path is a Path object
+    config_path = Path(path)
+
+    # check if path is pointing to an existing directory or .yml file
+    if config_path.exists():
+        if config_path.is_dir():
+            config_path = Path(config_path, "config.yml")
+        elif config_path.suffix != ".yml" and config_path.suffix != ".yaml":
+            raise ValueError(
+                f"Path must be a directory or .yml or .yaml file (got {config_path})."
+            )
+    else:
+        if config_path.suffix != ".yml" and config_path.suffix != ".yaml":
+            raise ValueError(
+                f"Path must be a directory or .yml or .yaml file (got {config_path})."
+            )
+
+    # save configuration as dictionary to yaml
+    with open(config_path, "w") as f:
+        # dump configuration
+        yaml.dump(config.model_dump(), f, default_flow_style=False, sort_keys=False)
+
+    return config_path

careamics/config/validators/__init__.py

@@ -0,0 +1,18 @@
+"""Validator utilities."""
+
+__all__ = [
+    "check_axes_validity",
+    "check_czi_axes_validity",
+    "model_matching_in_out_channels",
+    "model_without_final_activation",
+    "model_without_n2v2",
+    "patch_size_ge_than_8_power_of_2",
+]
+
+from .axes_validators import check_axes_validity, check_czi_axes_validity
+from .model_validators import (
+    model_matching_in_out_channels,
+    model_without_final_activation,
+    model_without_n2v2,
+)
+from .patch_validators import patch_size_ge_than_8_power_of_2

careamics/config/validators/axes_validators.py

@@ -0,0 +1,90 @@
+"""Axes validation utilities."""
+
+_AXES = "STCZYX"
+
+
+def check_axes_validity(axes: str) -> None:
+    """
+    Sanity check on axes.
+
+    The constraints on the axes are the following:
+    - must be a combination of 'STCZYX'
+    - must not contain duplicates
+    - must contain at least 2 contiguous axes: X and Y
+    - must contain at most 4 axes
+
+    Axes do not need to be in the order 'STCZYX', as this depends on the user data.
+
+    Parameters
+    ----------
+    axes : str
+        Axes to validate.
+    """
+    _axes = axes.upper()
+
+    # Minimum is 2 (XY) and maximum is 4 (TZYX)
+    if len(_axes) < 2 or len(_axes) > 6:
+        raise ValueError(
+            f"Invalid axes {axes}. Must contain at least 2 and at most 6 axes."
+        )
+
+    if "YX" not in _axes and "XY" not in _axes:
+        raise ValueError(
+            f"Invalid axes {axes}. Must contain at least X and Y axes consecutively."
+        )
+
+    # all characters must be in REF_AXES = 'STCZYX'
+    if not all(s in _AXES for s in _axes):
+        raise ValueError(f"Invalid axes {axes}. Must be a combination of {_AXES}.")
+
+    # check for repeating characters
+    for i, s in enumerate(_axes):
+        if i != _axes.rfind(s):
+            raise ValueError(
+                f"Invalid axes {axes}. Cannot contain duplicate axes"
+                f" (got multiple {axes[i]})."
+            )
+
+
+def check_czi_axes_validity(axes: str) -> bool:
+    """
+    Check if the provided axes string is valid for CZI files.
+
+    CZI axes is always in the "SC(Z/T)YX" format, where Z or T are optional, and S and C
+    can be singleton dimensions, but must be provided.
+
+    Parameters
+    ----------
+    axes : str
+        The axes string to validate.
+
+    Returns
+    -------
+    bool
+        True if the axes string is valid, False otherwise.
+    """
+    valid_axes = {"S", "C", "Z", "T", "Y", "X"}
+    axes_set = set(axes)
+
+    # check for invalid characters
+    if not axes_set.issubset(valid_axes):
+        return False
+
+    # check for mandatory axes
+    if not ({"S", "C", "Y", "X"}.issubset(axes_set)):
+        return False
+
+    # check for mutually exclusive axes
+    if "Z" in axes_set and "T" in axes_set:
+        return False
+
+    # check for correct order
+    order = "SCZYX" if "Z" in axes else "SCTYX"
+    last_index = -1
+    for axis in axes:
+        current_index = order.find(axis)
+        if current_index < last_index:
+            return False
+        last_index = current_index
+
+    return True

careamics/config/validators/model_validators.py

@@ -0,0 +1,84 @@
+"""Architecture model validators."""
+
+from careamics.config.architectures import UNetConfig
+
+
+def model_without_n2v2(model: UNetConfig) -> UNetConfig:
+    """Validate that the Unet model does not have the n2v2 attribute.
+
+    Parameters
+    ----------
+    model : UNetModel
+        Model to validate.
+
+    Returns
+    -------
+    UNetModel
+        The validated model.
+
+    Raises
+    ------
+    ValueError
+        If the model has the `n2v2` attribute set to `True`.
+    """
+    if model.n2v2:
+        raise ValueError(
+            "The algorithm does not support the `n2v2` attribute in the model. "
+            "Set it to `False`."
+        )
+
+    return model
+
+
+def model_without_final_activation(model: UNetConfig) -> UNetConfig:
+    """Validate that the UNet model does not have the final_activation.
+
+    Parameters
+    ----------
+    model : UNetModel
+        Model to validate.
+
+    Returns
+    -------
+    UNetModel
+        The validated model.
+
+    Raises
+    ------
+    ValueError
+        If the model has the final_activation attribute set.
+    """
+    if model.final_activation != "None":
+        raise ValueError(
+            "The algorithm does not support a `final_activation` in the model. "
+            'Set it to `"None"`.'
+        )
+
+    return model
+
+
+def model_matching_in_out_channels(model: UNetConfig) -> UNetConfig:
+    """Validate that the UNet model has the same number of channel inputs and outputs.
+
+    Parameters
+    ----------
+    model : UNetModel
+        Model to validate.
+
+    Returns
+    -------
+    UNetModel
+        Validated model.
+
+    Raises
+    ------
+    ValueError
+        If the model has different number of input and output channels.
+    """
+    if model.num_classes != model.in_channels:
+        raise ValueError(
+            "The algorithm requires the same number of input and output channels. "
+            "Make sure that `in_channels` and `num_classes` are equal."
+        )
+
+    return model

careamics/config/validators/patch_validators.py

@@ -0,0 +1,55 @@
+"""
+Validator functions.
+
+These functions are used to validate dimensions and axes of inputs.
+"""
+
+from collections.abc import Sequence
+
+
+def _value_ge_than_8_power_of_2(
+    value: int,
+) -> None:
+    """
+    Validate that the value is greater or equal than 8 and a power of 2.
+
+    Parameters
+    ----------
+    value : int
+        Value to validate.
+
+    Raises
+    ------
+    ValueError
+        If the value is smaller than 8.
+    ValueError
+        If the value is not a power of 2.
+    """
+    if value < 8:
+        raise ValueError(f"Value must be greater than 8 (got {value}).")
+
+    if (value & (value - 1)) != 0:
+        raise ValueError(f"Value must be a power of 2 (got {value}).")
+
+
+def patch_size_ge_than_8_power_of_2(
+    patch_list: Sequence[int] | None,
+) -> None:
+    """
+    Validate that each entry is greater or equal than 8 and a power of 2.
+
+    Parameters
+    ----------
+    patch_list : Sequence of int, or None
+        Patch size.
+
+    Raises
+    ------
+    ValueError
+        If the patch size if smaller than 8.
+    ValueError
+        If the patch size is not a power of 2.
+    """
+    if patch_list is not None:
+        for dim in patch_list:
+            _value_ge_than_8_power_of_2(dim)

careamics/conftest.py

@@ -0,0 +1,39 @@
+"""File used to discover python modules and run doctest.
+
+See https://sybil.readthedocs.io/en/latest/use.html#pytest
+"""
+
+from pathlib import Path
+
+import pytest
+from pytest import TempPathFactory
+from sybil import Sybil
+from sybil.parsers.codeblock import PythonCodeBlockParser
+from sybil.parsers.doctest import DocTestParser
+
+
+@pytest.fixture(scope="module")
+def my_path(tmpdir_factory: TempPathFactory) -> Path:
+    """Fixture used in doctest to create a temporary directory.
+
+    Parameters
+    ----------
+    tmpdir_factory : TempPathFactory
+        Temporary path factory from pytest.
+
+    Returns
+    -------
+    Path
+        Temporary directory path.
+    """
+    return tmpdir_factory.mktemp("my_path")
+
+
+pytest_collect_file = Sybil(
+    parsers=[
+        DocTestParser(),
+        PythonCodeBlockParser(future_imports=["print_function"]),
+    ],
+    pattern="*.py",
+    fixtures=["my_path"],
+).pytest()

careamics/dataset/__init__.py

@@ -0,0 +1,17 @@
+"""Dataset module."""
+
+__all__ = [
+    "InMemoryDataset",
+    "InMemoryPredDataset",
+    "InMemoryTiledPredDataset",
+    "IterablePredDataset",
+    "IterableTiledPredDataset",
+    "PathIterableDataset",
+]
+
+from .in_memory_dataset import InMemoryDataset
+from .in_memory_pred_dataset import InMemoryPredDataset
+from .in_memory_tiled_pred_dataset import InMemoryTiledPredDataset
+from .iterable_dataset import PathIterableDataset
+from .iterable_pred_dataset import IterablePredDataset
+from .iterable_tiled_pred_dataset import IterableTiledPredDataset

careamics/dataset/dataset_utils/__init__.py

@@ -0,0 +1,19 @@
+"""Files and arrays utils used in the datasets."""
+
+__all__ = [
+    "WelfordStatistics",
+    "compute_normalization_stats",
+    "get_files_size",
+    "iterate_over_files",
+    "list_files",
+    "reshape_array",
+    "validate_source_target_files",
+]
+
+
+from .dataset_utils import (
+    reshape_array,
+)
+from .file_utils import get_files_size, list_files, validate_source_target_files
+from .iterate_over_files import iterate_over_files
+from .running_stats import WelfordStatistics, compute_normalization_stats