careamics 0.1.0rc1__py3-none-any.whl → 0.1.0rc3__py3-none-any.whl

careamics/config/config.py

@@ -1,296 +0,0 @@
-"""Pydantic CAREamics configuration."""
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Dict, List, Union
-
-import yaml
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    field_validator,
-    model_validator,
-)
-
-from .algorithm import Algorithm
-from .config_filter import paths_to_str
-from .data import Data
-from .training import Training
-
-
-class Configuration(BaseModel):
-    """
-    CAREamics configuration.
-
-    To change the configuration from 2D to 3D, we recommend using the following method:
-    >>> set_3D(is_3D, axes)
-
-    Attributes
-    ----------
-    experiment_name : str
-        Name of the experiment.
-    working_directory : Union[str, Path]
-        Path to the working directory.
-    algorithm : Algorithm
-        Algorithm configuration.
-    training : Training
-        Training configuration.
-    """
-
-    model_config = ConfigDict(validate_assignment=True)
-
-    # required parameters
-    experiment_name: str
-    working_directory: Path
-
-    # Sub-configurations
-    algorithm: Algorithm
-    data: Data
-    training: Training
-
-    def set_3D(self, is_3D: bool, axes: str) -> None:
-        """
-        Set 3D flag and axes.
-
-        Parameters
-        ----------
-        is_3D : bool
-            Whether the algorithm is 3D or not.
-        axes : str
-            Axes of the data.
-        """
-        # set the flag and axes (this will not trigger validation at the config level)
-        self.algorithm.is_3D = is_3D
-        self.data.axes = axes
-
-        # cheap hack: trigger validation
-        self.algorithm = self.algorithm
-
-    @field_validator("experiment_name")
-    def no_symbol(cls, name: str) -> str:
-        """
-        Validate experiment name.
-
-        A valid experiment name is a non-empty string with only contains letters,
-        numbers, underscores, dashes and spaces.
-
-        Parameters
-        ----------
-        name : str
-            Name to validate.
-
-        Returns
-        -------
-        str
-            Validated name.
-
-        Raises
-        ------
-        ValueError
-            If the name is empty or contains invalid characters.
-        """
-        if len(name) == 0 or name.isspace():
-            raise ValueError("Experiment name is empty.")
-
-        # Validate using a regex that it contains only letters, numbers, underscores,
-        # dashes and spaces
-        if not re.match(r"^[a-zA-Z0-9_\- ]*$", name):
-            raise ValueError(
-                f"Experiment name contains invalid characters (got {name}). "
-                f"Only letters, numbers, underscores, dashes and spaces are allowed."
-            )
-
-        return name
-
-    @field_validator("working_directory")
-    def parent_directory_exists(cls, workdir: Union[str, Path]) -> Path:
-        """
-        Validate working directory.
-
-        A valid working directory is a directory whose parent directory exists. If the
-        working directory does not exist itself, it is then created.
-
-        Parameters
-        ----------
-        workdir : Union[str, Path]
-            Working directory to validate.
-
-        Returns
-        -------
-        Path
-            Validated working directory.
-
-        Raises
-        ------
-        ValueError
-            If the working directory is not a directory, or if the parent directory does
-            not exist.
-        """
-        path = Path(workdir)
-
-        # check if it is a directory
-        if path.exists() and not path.is_dir():
-            raise ValueError(f"Working directory is not a directory (got {workdir}).")
-
-        # check if parent directory exists
-        if not path.parent.exists():
-            raise ValueError(
-                f"Parent directory of working directory does not exist (got {workdir})."
-            )
-
-        # create directory if it does not exist already
-        path.mkdir(exist_ok=True)
-
-        return path
-
-    @model_validator(mode="after")
-    def validate_3D(cls, config: Configuration) -> Configuration:
-        """
-        Check 3D flag validity.
-
-        Check that the algorithm is_3D flag is compatible with the axes in the
-        data configuration.
-
-        Parameters
-        ----------
-        config : Configuration
-            Configuration to validate.
-
-        Returns
-        -------
-        Configuration
-            Validated configuration.
-
-        Raises
-        ------
-        ValueError
-            If the algorithm is 3D but the data axes are not, or if the algorithm is
-            not 3D but the data axes are.
-        """
-        # check that is_3D and axes are compatible
-        if config.algorithm.is_3D and "Z" not in config.data.axes:
-            raise ValueError(
-                f"Algorithm is 3D but data axes are not (got axes {config.data.axes})."
-            )
-        elif not config.algorithm.is_3D and "Z" in config.data.axes:
-            raise ValueError(
-                f"Algorithm is not 3D but data axes are (got axes {config.data.axes})."
-            )
-
-        return config
-
-    def model_dump(
-        self, exclude_optionals: bool = True, *args: List, **kwargs: Dict
-    ) -> Dict:
-        """
-        Override model_dump method.
-
-        The purpose is to ensure export smooth import to yaml. It includes:
-            - remove entries with None value.
-            - remove optional values if they have the default value.
-
-        Parameters
-        ----------
-        exclude_optionals : bool, optional
-            Whether to exclude optional fields with default values or not, by default
-            True.
-        *args : List
-            Positional arguments, unused.
-        **kwargs : Dict
-            Keyword arguments, unused.
-
-        Returns
-        -------
-        dict
-            Dictionary containing the model parameters.
-        """
-        dictionary = super().model_dump(exclude_none=True)
-
-        # remove paths
-        dictionary = paths_to_str(dictionary)
-
-        dictionary["algorithm"] = self.algorithm.model_dump(
-            exclude_optionals=exclude_optionals
-        )
-        dictionary["data"] = self.data.model_dump()
-
-        dictionary["training"] = self.training.model_dump(
-            exclude_optionals=exclude_optionals
-        )
-
-        return dictionary
-
-
-def load_configuration(path: Union[str, Path]) -> Configuration:
-    """
-    Load configuration from a yaml file.
-
-    Parameters
-    ----------
-    path : Union[str, 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 : Union[str, Path]
-        Path to a existing folder in which to save the configuration or to an existing
-        configuration file.
-
-    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":
-            raise ValueError(
-                f"Path must be a directory or .yml file (got {config_path})."
-            )
-    else:
-        if config_path.suffix != ".yml":
-            raise ValueError(f"Path must be a .yml file (got {config_path}).")
-
-    # save configuration as dictionary to yaml
-    with open(config_path, "w") as f:
-        yaml.dump(config.model_dump(), f, default_flow_style=False)
-
-    return config_path

careamics/config/config_filter.py

@@ -1,44 +0,0 @@
-"""Convenience functions to filter dictionaries resulting from a Pydantic export."""
-from pathlib import Path
-from typing import Dict
-
-
-def paths_to_str(dictionary: dict) -> dict:
-    """
-    Replace Path objects in a dictionary by str.
-
-    Parameters
-    ----------
-    dictionary : dict
-        Dictionary to modify.
-
-    Returns
-    -------
-    dict
-        Modified dictionary.
-    """
-    for k in dictionary.keys():
-        if isinstance(dictionary[k], Path):
-            dictionary[k] = str(dictionary[k])
-
-    return dictionary
-
-
-def remove_default_optionals(dictionary: Dict, default: Dict) -> None:
-    """
-    Remove default arguments from a dictionary.
-
-    The method removes arguments if they are equal to the provided default ones.
-
-    Parameters
-    ----------
-    dictionary : dict
-        Dictionary to modify.
-    default : dict
-        Dictionary containing the default values.
-    """
-    dict_copy = dictionary.copy()
-    for k in dict_copy.keys():
-        if k in default.keys():
-            if dict_copy[k] == default[k]:
-                del dictionary[k]

careamics/config/data.py

@@ -1,194 +0,0 @@
-"""Data configuration."""
-from __future__ import annotations
-
-from enum import Enum
-from typing import Dict, List, Optional
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    field_validator,
-    model_validator,
-)
-
-from ..utils import check_axes_validity
-
-
-class SupportedExtension(str, Enum):
-    """
-    Supported extensions for input data.
-
-    Currently supported:
-        - tif/tiff: .tiff files.
-    """
-
-    TIFF = "tiff"
-    TIF = "tif"
-
-    @classmethod
-    def _missing_(cls, value: object) -> str:
-        """
-        Override default behaviour for missing values.
-
-        This method is called when `value` is not found in the enum values. It converts
-        `value` to lowercase, removes "." if it is the first character and tries to
-        match it with enum values.
-
-        Parameters
-        ----------
-        value : object
-            Value to be matched with enum values.
-
-        Returns
-        -------
-        str
-            Matched enum value.
-        """
-        if isinstance(value, str):
-            lower_value = value.lower()
-
-            if lower_value.startswith("."):
-                lower_value = lower_value[1:]
-
-            # attempt to match lowercase value with enum values
-            for member in cls:
-                if member.value == lower_value:
-                    return member
-
-        # still missing
-        return super()._missing_(value)
-
-
-class Data(BaseModel):
-    """
-    Data configuration.
-
-    If std is specified, mean must be specified as well. Note that setting the std first
-    and then the mean (if they were both `None` before) will raise a validation error.
-    Prefer instead the following:
-    >>> set_mean_and_std(mean, std)
-
-    Attributes
-    ----------
-    in_memory : bool
-        Whether to load the data in memory or not.
-    data_format : SupportedExtension
-        Extension of the data, without period.
-    axes : str
-        Axes of the data.
-    mean: Optional[float]
-        Expected data mean.
-    std: Optional[float]
-        Expected data standard deviation.
-    """
-
-    # Pydantic class configuration
-    model_config = ConfigDict(
-        use_enum_values=True,
-        validate_assignment=True,
-    )
-
-    # Mandatory fields
-    in_memory: bool
-    data_format: SupportedExtension
-    axes: str
-
-    # Optional fields
-    mean: Optional[float] = Field(default=None, ge=0)
-    std: Optional[float] = Field(default=None, gt=0)
-
-    def set_mean_and_std(self, mean: float, std: float) -> None:
-        """
-        Set mean and standard deviation of the data.
-
-        This method is preferred to setting the fields directly, as it ensures that the
-        mean is set first, then the std; thus avoiding a validation error to be thrown.
-
-        Parameters
-        ----------
-        mean : float
-            Mean of the data.
-        std : float
-            Standard deviation of the data.
-        """
-        self.mean = mean
-        self.std = std
-
-    @field_validator("axes")
-    def valid_axes(cls, axes: str) -> str:
-        """
-        Validate axes.
-
-        Axes must be a subset of STZYX, must contain YX, be in the right order
-        and not contain both S and T.
-
-        Parameters
-        ----------
-        axes : str
-            Axes of the training data.
-
-        Returns
-        -------
-        str
-            Validated axes of the training data.
-
-        Raises
-        ------
-        ValueError
-            If axes are not valid.
-        """
-        # validate axes
-        check_axes_validity(axes)
-
-        return axes
-
-    @model_validator(mode="after")
-    def std_only_with_mean(cls, data_model: Data) -> Data:
-        """
-        Check that mean and std are either both None, or both specified.
-
-        If we enforce both None or both specified, we cannot set the values one by one
-        due to the ConfDict enforcing the validation on assignment. Therefore, we check
-        only when the std is not None and the mean is None.
-
-        Parameters
-        ----------
-        data_model : Data
-            Data model.
-
-        Returns
-        -------
-        Data
-            Validated data model.
-
-        Raises
-        ------
-        ValueError
-            If std is not None and mean is None.
-        """
-        if data_model.std is not None and data_model.mean is None:
-            raise ValueError("Cannot have std non None if mean is None.")
-
-        return data_model
-
-    def model_dump(self, *args: List, **kwargs: Dict) -> dict:
-        """
-        Override model_dump method.
-
-        The purpose is to ensure export smooth import to yaml. It includes:
-            - remove entries with None value.
-
-        Parameters
-        ----------
-        *args : List
-            Positional arguments, unused.
-        **kwargs : Dict
-            Keyword arguments, unused.
-
-        Returns
-        -------
-        dict
-            Dictionary containing the model parameters.
-        """
-        return super().model_dump(exclude_none=True)

careamics/config/torch_optim.py

@@ -1,118 +0,0 @@
-"""Convenience functions to instantiate torch.optim optimizers and schedulers."""
-import inspect
-from enum import Enum
-from typing import Dict
-
-from torch import optim
-
-
-class TorchOptimizer(str, Enum):
-    """
-    Supported optimizers.
-
-    Currently only supports Adam and SGD.
-    """
-
-    # ASGD = "ASGD"
-    # Adadelta = "Adadelta"
-    # Adagrad = "Adagrad"
-    Adam = "Adam"
-    # AdamW = "AdamW"
-    # Adamax = "Adamax"
-    # LBFGS = "LBFGS"
-    # NAdam = "NAdam"
-    # RAdam = "RAdam"
-    # RMSprop = "RMSprop"
-    # Rprop = "Rprop"
-    SGD = "SGD"
-    # SparseAdam = "SparseAdam"
-
-
-# TODO: Test which schedulers are compatible and if not, how to make them compatible
-# (if we want to support them)
-class TorchLRScheduler(str, Enum):
-    """
-    Supported learning rate schedulers.
-
-    Currently only supports ReduceLROnPlateau and StepLR.
-    """
-
-    # ChainedScheduler = "ChainedScheduler"
-    # ConstantLR = "ConstantLR"
-    # CosineAnnealingLR = "CosineAnnealingLR"
-    # CosineAnnealingWarmRestarts = "CosineAnnealingWarmRestarts"
-    # CyclicLR = "CyclicLR"
-    # ExponentialLR = "ExponentialLR"
-    # LambdaLR = "LambdaLR"
-    # LinearLR = "LinearLR"
-    # MultiStepLR = "MultiStepLR"
-    # MultiplicativeLR = "MultiplicativeLR"
-    # OneCycleLR = "OneCycleLR"
-    # PolynomialLR = "PolynomialLR"
-    ReduceLROnPlateau = "ReduceLROnPlateau"
-    # SequentialLR = "SequentialLR"
-    StepLR = "StepLR"
-
-
-def get_parameters(
-    func: type,
-    user_params: dict,
-) -> dict:
-    """
-    Filter parameters according to the function signature.
-
-    Parameters
-    ----------
-    func : type
-        Class object.
-    user_params : Dict
-        User provided parameters.
-
-    Returns
-    -------
-    Dict
-        Parameters matching `func`'s signature.
-    """
-    # Get the list of all default parameters
-    default_params = list(inspect.signature(func).parameters.keys())
-
-    # Filter matching parameters
-    params_to_be_used = set(user_params.keys()) & set(default_params)
-
-    return {key: user_params[key] for key in params_to_be_used}
-
-
-def get_optimizers() -> Dict[str, str]:
-    """
-    Return the list of all optimizers available in torch.optim.
-
-    Returns
-    -------
-    Dict
-        Optimizers available in torch.optim.
-    """
-    optims = {}
-    for name, obj in inspect.getmembers(optim):
-        if inspect.isclass(obj) and issubclass(obj, optim.Optimizer):
-            if name != "Optimizer":
-                optims[name] = name
-    return optims
-
-
-def get_schedulers() -> Dict[str, str]:
-    """
-    Return the list of all schedulers available in torch.optim.lr_scheduler.
-
-    Returns
-    -------
-    Dict
-        Schedulers available in torch.optim.lr_scheduler.
-    """
-    schedulers = {}
-    for name, obj in inspect.getmembers(optim.lr_scheduler):
-        if inspect.isclass(obj) and issubclass(obj, optim.lr_scheduler.LRScheduler):
-            if "LRScheduler" not in name:
-                schedulers[name] = name
-        elif name == "ReduceLROnPlateau":  # somewhat not a subclass of LRScheduler
-            schedulers[name] = name
-    return schedulers