ngio 0.2.0b3__py3-none-any.whl → 0.2.2__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_dataset.py

@@ -6,6 +6,9 @@ from ngio.ome_zarr_meta.ngio_specs._axes import (
     AxesMapper,
     AxesSetup,
     Axis,
+    AxisType,
+    DefaultSpaceUnit,
+    DefaultTimeUnit,
     SpaceUnits,
     TimeUnits,
 )
@@ -86,7 +89,7 @@ class Dataset:
         return self._path
 
     @property
-    def space_unit(self) -> SpaceUnits:
+    def space_unit(self) -> str | None:
         """Return the space unit for a given axis."""
         x_axis = self._axes_mapper.get_axis("x")
         y_axis = self._axes_mapper.get_axis("y")
@@ -97,8 +100,6 @@ class Dataset:
             )
 
         if x_axis.unit == y_axis.unit:
-            if not isinstance(x_axis.unit, SpaceUnits):
-                raise NgioValidationError("The space unit must be of type SpaceUnits.")
             return x_axis.unit
         else:
             raise NgioValidationError(
@@ -107,13 +108,11 @@ class Dataset:
             )
 
     @property
-    def time_unit(self) -> TimeUnits | None:
+    def time_unit(self) -> str | None:
         """Return the time unit for a given axis."""
         t_axis = self._axes_mapper.get_axis("t")
         if t_axis is None:
             return None
-        if not isinstance(t_axis.unit, TimeUnits):
-            raise NgioValidationError("The time unit must be of type TimeUnits.")
         return t_axis.unit
 
     @property
@@ -124,11 +123,50 @@ class Dataset:
             y=self.get_scale("y"),
             z=self.get_scale("z"),
             t=self.get_scale("t"),
-            space_unit=self.space_unit,
-            time_unit=self.time_unit,
+            space_unit=self.space_unit,  # type: ignore
+            time_unit=self.time_unit,  # type: ignore
         )
 
     @property
     def axes_mapper(self) -> AxesMapper:
         """Return the axes mapper object."""
         return self._axes_mapper
+
+    def to_units(
+        self,
+        *,
+        space_unit: SpaceUnits = DefaultSpaceUnit,
+        time_unit: TimeUnits = DefaultTimeUnit,
+    ) -> "Dataset":
+        """Convert the pixel size to the given units.
+
+        Args:
+            space_unit(str): The space unit to convert to.
+            time_unit(str): The time unit to convert to.
+        """
+        new_axes = []
+        for ax in self.axes_mapper.on_disk_axes:
+            if ax.axis_type == AxisType.space:
+                new_ax = Axis(
+                    on_disk_name=ax.on_disk_name,
+                    axis_type=ax.axis_type,
+                    unit=space_unit,
+                )
+                new_axes.append(new_ax)
+            elif ax.axis_type == AxisType.time:
+                new_ax = Axis(
+                    on_disk_name=ax.on_disk_name, axis_type=ax.axis_type, unit=time_unit
+                )
+                new_axes.append(new_ax)
+            else:
+                new_axes.append(ax)
+
+        return Dataset(
+            path=self.path,
+            on_disk_axes=new_axes,
+            on_disk_scale=self._on_disk_scale,
+            on_disk_translation=self._on_disk_translation,
+            axes_setup=self.axes_mapper.axes_setup,
+            allow_non_canonical_axes=self.axes_mapper.allow_non_canonical_axes,
+            strict_canonical_order=self.axes_mapper.strict_canonical_order,
+        )

ngio/ome_zarr_meta/ngio_specs/_ngio_hcs.py

@@ -1,6 +1,6 @@
 """HCS (High Content Screening) specific metadata classes for NGIO."""
 
-from typing import Literal
+from typing import Annotated
 
 from ome_zarr_models.v04.hcs import HCSAttrs
 from ome_zarr_models.v04.plate import (
@@ -10,11 +10,34 @@ from ome_zarr_models.v04.plate import (
     Row,
     WellInPlate,
 )
-from ome_zarr_models.v04.well import WellAttrs
-from ome_zarr_models.v04.well_types import WellImage, WellMeta
-from pydantic import BaseModel
-
-from ngio.utils import NgioValueError
+from ome_zarr_models.v04.well import WellAttrs as WellAttrs04
+from ome_zarr_models.v04.well_types import WellImage as WellImage04
+from ome_zarr_models.v04.well_types import WellMeta as WellMeta04
+from pydantic import BaseModel, SkipValidation, field_serializer
+
+from ngio.ome_zarr_meta.ngio_specs._ngio_image import DefaultNgffVersion, NgffVersions
+from ngio.utils import NgioValueError, ngio_logger
+
+
+def path_in_well_validation(path: str) -> str:
+    """Validate the path in the well."""
+    if path.find("_") != -1:
+        # Remove underscores from the path
+        # This is a custom serialization step
+        old_value = path
+        path = path.replace("_", "")
+        ngio_logger.warning(
+            f"Underscores in well-paths are not allowed. "
+            f"Path '{old_value}' was changed to '{path}'"
+            f" to comply with the specification."
+        )
+    # Check if the value contains only alphanumeric characters
+    if not path.isalnum():
+        raise NgioValueError(
+            f"Path '{path}' contains non-alphanumeric characters. "
+            f"Only alphanumeric characters are allowed."
+        )
+    return path
 
 
 class ImageInWellPath(BaseModel):
@@ -27,23 +50,55 @@ class ImageInWellPath(BaseModel):
     acquisition_name: str | None = None
 
 
-class NgioWellMeta(WellAttrs):
+class CustomWellImage(WellImage04):
+    path: Annotated[str, SkipValidation]
+
+    @field_serializer("path")
+    def serialize_path(self, value: str) -> str:
+        """Custom serialization for the path."""
+        return path_in_well_validation(value)
+
+
+class CustomWellMeta(WellMeta04):
+    images: list[CustomWellImage]  # type: ignore[valid-type]
+
+
+class CustomWellAttrs(WellAttrs04):
+    well: CustomWellMeta  # type: ignore[valid-type]
+
+
+class NgioWellMeta(CustomWellAttrs):
     """HCS well metadata."""
 
     @classmethod
     def default_init(
         cls,
-        images: list[ImageInWellPath] | None = None,
-        version: Literal["0.4"] | None = None,
+        version: NgffVersions | None = None,
     ) -> "NgioWellMeta":
-        well = cls(well=WellMeta(images=[], version=version))
-        if images is None:
-            return well
-
-        for image in images:
-            well = well.add_image(path=image.path, acquisition=image.acquisition_id)
+        if version is None:
+            version = DefaultNgffVersion
+        well = cls(well=CustomWellMeta(images=[], version=version))
         return well
 
+    @property
+    def acquisition_ids(self) -> list[int]:
+        """Return the acquisition ids in the well."""
+        acquisitions = []
+        for images in self.well.images:
+            if (
+                images.acquisition is not None
+                and images.acquisition not in acquisitions
+            ):
+                acquisitions.append(images.acquisition)
+        return acquisitions
+
+    def get_image_acquisition_id(self, image_path: str) -> int | None:
+        """Return the acquisition id for the given image path."""
+        for images in self.well.images:
+            if images.path == image_path:
+                return images.acquisition
+        raise NgioValueError(f"Image at path {image_path} not found in the well.")
+
     def paths(self, acquisition: int | None = None) -> list[str]:
         """Return the images paths in the well.
 
@@ -61,12 +116,16 @@ class NgioWellMeta(WellAttrs):
             if images.acquisition == acquisition
         ]
 
-    def add_image(self, path: str, acquisition: int | None = None) -> "NgioWellMeta":
+    def add_image(
+        self, path: str, acquisition: int | None = None, strict: bool = True
+    ) -> "NgioWellMeta":
         """Add an image to the well.
 
         Args:
             path (str): The path of the image.
             acquisition (int | None): The acquisition id of the image.
+            strict (bool): If True, check if the image already exists in the well.
+                If False, do not check if the image already exists in the well.
         """
         list_of_images = self.well.images
         for image in list_of_images:
@@ -75,10 +134,20 @@ class NgioWellMeta(WellAttrs):
                     f"Image at path {path} already exists in the well."
                 )
 
-        new_image = WellImage(path=path, acquisition=acquisition)
+        if (
+            strict
+            and (acquisition is not None)
+            and (acquisition not in self.acquisition_ids)
+        ):
+            raise NgioValueError(
+                f"Acquisition ID {acquisition} not found in well. "
+                "Please add it to the plate metadata first."
+            )
+
+        new_image = CustomWellImage(path=path, acquisition=acquisition)
         list_of_images.append(new_image)
         return NgioWellMeta(
-            well=WellMeta(images=list_of_images, version=self.well.version)
+            well=CustomWellMeta(images=list_of_images, version=self.well.version)
         )
 
     def remove_image(self, path: str) -> "NgioWellMeta":
@@ -92,7 +161,9 @@ class NgioWellMeta(WellAttrs):
             if image.path == path:
                 list_of_images.remove(image)
                 return NgioWellMeta(
-                    well=WellMeta(images=list_of_images, version=self.well.version)
+                    well=CustomWellMeta(
+                        images=list_of_images, version=self.well.version
+                    )
                 )
         raise NgioValueError(f"Image at path {path} not found in the well.")
 
@@ -164,7 +235,7 @@ class NgioPlateMeta(HCSAttrs):
         cls,
         images: list[ImageInWellPath] | None = None,
         name: str | None = None,
-        version: str | None = None,
+        version: NgffVersions | None = None,
     ) -> "NgioPlateMeta":
         plate = cls(
             plate=Plate(
@@ -185,9 +256,12 @@ class NgioPlateMeta(HCSAttrs):
             plate = plate.add_well(
                 row=image.row,
                 column=image.column,
-                acquisition_id=image.acquisition_id,
-                acquisition_name=image.acquisition_name,
             )
+            if image.acquisition_id is not None:
+                plate = plate.add_acquisition(
+                    acquisition_id=image.acquisition_id,
+                    acquisition_name=image.acquisition_name,
+                )
         return plate
 
     @property
@@ -208,7 +282,7 @@ class NgioPlateMeta(HCSAttrs):
         return [acquisitions.name for acquisitions in self.plate.acquisitions]
 
     @property
-    def acquisitions_ids(self) -> list[int]:
+    def acquisition_ids(self) -> list[int]:
         """Return the acquisitions ids in the plate."""
         if self.plate.acquisitions is None:
             return []
@@ -255,50 +329,94 @@ class NgioPlateMeta(HCSAttrs):
             f"Well at row {row} and column {column} not found in the plate."
         )
 
-    def add_well(
-        self,
-        row: str,
-        column: str | int,
-        acquisition_id: int | None = None,
-        acquisition_name: str | None = None,
-        **acquisition_kwargs,
-    ) -> "NgioPlateMeta":
-        """Add an image to the well.
+    def add_row(self, row: str) -> "tuple[NgioPlateMeta, int]":
+        """Add a row to the plate.
 
         Args:
-            row (str): The row of the well.
-            column (str | int): The column of the well.
-            acquisition_id (int | None): The acquisition id of the well.
-            acquisition_name (str | None): The acquisition name of the well.
-            **acquisition_kwargs: Additional acquisition metadata.
+            row (str): The row to add.
         """
         relabel_wells = False
 
         row_names = self.rows
         row_idx = _find_row_index(row_names, row)
-        if row_idx is None:
-            row_names.append(row)
-            row_names.sort()
-            row_idx = row_names.index(row)
-            relabel_wells = True
+        if row_idx is not None:
+            # Nothing to do
+            return self, row_idx
+
+        row_names.append(row)
+        row_names.sort()
+        row_idx = row_names.index(row)
+        relabel_wells = True
 
         rows = [Row(name=row) for row in row_names]
 
+        if relabel_wells:
+            wells = _relabel_wells(self.plate.wells, rows, self.plate.columns)
+        else:
+            wells = self.plate.wells
+
+        new_plate = Plate(
+            rows=rows,
+            columns=self.plate.columns,
+            acquisitions=self.plate.acquisitions,
+            wells=wells,
+            field_count=self.plate.field_count,
+            version=self.plate.version,
+        )
+        return NgioPlateMeta(plate=new_plate), row_idx
+
+    def add_column(self, column: str | int) -> "tuple[NgioPlateMeta, int]":
+        """Add a column to the plate.
+
+        Args:
+            column (str | int): The column to add.
+        """
+        relabel_wells = False
+
         columns_names = self.columns
         column_idx = _find_column_index(columns_names, column)
-        if column_idx is None:
-            columns_names.append(_stringify_column(column))
-            # sort as numbers
-            columns_names.sort(key=lambda x: int(x))
-            column_idx = columns_names.index(_stringify_column(column))
-            relabel_wells = True
+        if column_idx is not None:
+            # Nothing to do
+            return self, column_idx
+
+        columns_names.append(_stringify_column(column))
+        # sort as numbers
+        columns_names.sort(key=lambda x: int(x))
+        column_idx = columns_names.index(_stringify_column(column))
+        relabel_wells = True
 
         columns = [Column(name=column) for column in columns_names]
 
-        wells = self.plate.wells
         if relabel_wells:
-            wells = _relabel_wells(wells, rows, columns)
+            wells = _relabel_wells(self.plate.wells, self.plate.rows, columns)
+        else:
+            wells = self.plate.wells
 
+        new_plate = Plate(
+            rows=self.plate.rows,
+            columns=columns,
+            acquisitions=self.plate.acquisitions,
+            wells=wells,
+            field_count=self.plate.field_count,
+            version=self.plate.version,
+        )
+        return NgioPlateMeta(plate=new_plate), column_idx
+
+    def add_well(
+        self,
+        row: str,
+        column: str | int,
+    ) -> "NgioPlateMeta":
+        """Add an image to the well.
+
+        Args:
+            row (str): The row of the well.
+            column (str | int): The column of the well.
+        """
+        plate, row_idx = self.add_row(row=row)
+        plate, column_idx = plate.add_column(column=column)
+
+        wells = plate.plate.wells
         for well_obj in wells:
             if well_obj.rowIndex == row_idx and well_obj.columnIndex == column_idx:
                 break
@@ -311,28 +429,49 @@ class NgioPlateMeta(HCSAttrs):
                 )
             )
 
+        new_plate = Plate(
+            rows=plate.plate.rows,
+            columns=plate.plate.columns,
+            acquisitions=plate.plate.acquisitions,
+            wells=wells,
+            field_count=plate.plate.field_count,
+            version=plate.plate.version,
+        )
+        return NgioPlateMeta(plate=new_plate)
+
+    def add_acquisition(
+        self,
+        acquisition_id: int,
+        acquisition_name: str | None = None,
+        **acquisition_kwargs,
+    ) -> "NgioPlateMeta":
+        """Add an acquisition to the plate.
+
+        Args:
+            acquisition_id (int): The acquisition id of the well.
+            acquisition_name (str | None): The acquisition name of the well.
+            **acquisition_kwargs: Additional acquisition metadata.
+        """
         acquisitions = self.plate.acquisitions
-        if acquisition_id is not None:
-            if acquisitions is None and len(wells) > 0:
-                acquisitions = [Acquisition(id=0, name=acquisition_name)]
-            elif acquisitions is None:
-                acquisitions = []
-
-            for acquisition_obj in acquisitions:
-                if acquisition_obj.id == acquisition_id:
-                    break
-            else:
-                acquisitions.append(
-                    Acquisition(
-                        id=acquisition_id, name=acquisition_name, **acquisition_kwargs
-                    )
-                )
+        if acquisitions is None:
+            acquisitions = []
+
+        for acquisition_obj in acquisitions:
+            if acquisition_obj.id == acquisition_id:
+                # If the acquisition already exists
+                # Nothing to do
+                # Maybe we should update the acquisition name and kwargs
+                return self
+
+        acquisitions.append(
+            Acquisition(id=acquisition_id, name=acquisition_name, **acquisition_kwargs)
+        )
 
         new_plate = Plate(
-            rows=rows,
-            columns=columns,
+            rows=self.plate.rows,
+            columns=self.plate.columns,
             acquisitions=acquisitions,
-            wells=wells,
+            wells=self.plate.wells,
             field_count=self.plate.field_count,
             version=self.plate.version,
         )
@@ -373,5 +512,39 @@ class NgioPlateMeta(HCSAttrs):
         )
         return NgioPlateMeta(plate=new_plate)
 
+    def derive(
+        self,
+        name: str | None = None,
+        version: NgffVersions | None = None,
+        keep_acquisitions: bool = False,
+    ) -> "NgioPlateMeta":
+        """Derive the plate metadata.
+
+        Args:
+            name (str): The name of the derived plate.
+            version (NgffVersion | None): The version of the derived plate.
+                If None, use the version of the original plate.
+            keep_acquisitions (bool): If True, keep the acquisitions in the plate.
+        """
+        columns = self.plate.columns
+        rows = self.plate.rows
+
+        if keep_acquisitions:
+            acquisitions = self.plate.acquisitions
+        else:
+            acquisitions = None
 
-# %%
+        if version is None:
+            version = self.plate.version  # type: ignore[assignment]
+
+        return NgioPlateMeta(
+            plate=Plate(
+                rows=rows,
+                columns=columns,
+                acquisitions=acquisitions,
+                wells=[],
+                field_count=self.plate.field_count,
+                version=version,
+                name=name,
+            )
+        )

ngio/ome_zarr_meta/ngio_specs/_ngio_image.py

@@ -7,13 +7,16 @@ can be converted to the OME standard.
 """
 
 from collections.abc import Collection
-from enum import Enum
-from typing import Any, TypeVar
+from typing import Any, Literal, TypeVar
 
 import numpy as np
 from pydantic import BaseModel
 
 from ngio.ome_zarr_meta.ngio_specs._axes import (
+    DefaultSpaceUnit,
+    DefaultTimeUnit,
+    SpaceUnits,
+    TimeUnits,
     canonical_axes,
 )
 from ngio.ome_zarr_meta.ngio_specs._channels import Channel, ChannelsMeta
@@ -22,22 +25,18 @@ from ngio.ome_zarr_meta.ngio_specs._pixel_size import PixelSize
 from ngio.utils import NgioValidationError, NgioValueError
 
 T = TypeVar("T")
-
-
-class NgffVersion(str, Enum):
-    """Allowed NGFF versions."""
-
-    v04 = "0.4"
+NgffVersions = Literal["0.4"]
+DefaultNgffVersion: Literal["0.4"] = "0.4"
 
 
 class ImageLabelSource(BaseModel):
     """Image label source model."""
 
-    version: NgffVersion
+    version: NgffVersions
     source: dict[str, str | None]
 
     @classmethod
-    def default_init(cls, version: NgffVersion) -> "ImageLabelSource":
+    def default_init(cls, version: NgffVersions) -> "ImageLabelSource":
         """Initialize the ImageLabelSource object."""
         return cls(version=version, source={"image": "../../"})
 
@@ -45,9 +44,11 @@ class ImageLabelSource(BaseModel):
 class AbstractNgioImageMeta:
     """Base class for ImageMeta and LabelMeta."""
 
-    def __init__(self, version: str, name: str | None, datasets: list[Dataset]) -> None:
+    def __init__(
+        self, version: NgffVersions, name: str | None, datasets: list[Dataset]
+    ) -> None:
         """Initialize the ImageMeta object."""
-        self._version = NgffVersion(version)
+        self._version = version
         self._name = name
 
         if len(datasets) == 0:
@@ -70,13 +71,13 @@ class AbstractNgioImageMeta:
         pixel_size: PixelSize,
         scaling_factors: Collection[float] | None = None,
         name: str | None = None,
-        version: str = "0.4",
+        version: NgffVersions = DefaultNgffVersion,
     ):
         """Initialize the ImageMeta object."""
         axes = canonical_axes(
             axes_names,
-            space_units=pixel_size.space_unit,
-            time_units=pixel_size.time_unit,
+            space_units=pixel_size.space_unit,  # type: ignore[arg-type]
+            time_units=pixel_size.time_unit,  # type: ignore[arg-type]
         )
 
         px_size_dict = pixel_size.as_dict()
@@ -109,10 +110,33 @@ class AbstractNgioImageMeta:
             datasets=datasets,
         )
 
+    def to_units(
+        self,
+        *,
+        space_unit: SpaceUnits = DefaultSpaceUnit,
+        time_unit: TimeUnits = DefaultTimeUnit,
+    ):
+        """Convert the pixel size to the given units.
+
+        Args:
+            space_unit(str): The space unit to convert to.
+            time_unit(str): The time unit to convert to.
+        """
+        new_datasets = []
+        for dataset in self.datasets:
+            new_dataset = dataset.to_units(space_unit=space_unit, time_unit=time_unit)
+            new_datasets.append(new_dataset)
+
+        return type(self)(
+            version=self.version,
+            name=self.name,
+            datasets=new_datasets,
+        )
+
     @property
-    def version(self) -> NgffVersion:
+    def version(self) -> NgffVersions:
         """Version of the OME-NFF metadata used to build the object."""
-        return self._version
+        return self._version  # type: ignore[return-value]
 
     @property
     def name(self) -> str | None:
@@ -139,6 +163,16 @@ class AbstractNgioImageMeta:
         """List of paths of the datasets."""
         return [dataset.path for dataset in self.datasets]
 
+    @property
+    def space_unit(self) -> str | None:
+        """Get the space unit of the pixel size."""
+        return self.datasets[0].pixel_size.space_unit
+
+    @property
+    def time_unit(self) -> str | None:
+        """Get the time unit of the pixel size."""
+        return self.datasets[0].pixel_size.time_unit
+
     def _get_dataset_by_path(self, path: str) -> Dataset:
         """Get a dataset by its path."""
         for dataset in self.datasets:
@@ -335,7 +369,7 @@ class NgioLabelMeta(AbstractNgioImageMeta):
 
     def __init__(
         self,
-        version: str,
+        version: NgffVersions,
         name: str | None,
         datasets: list[Dataset],
         image_label: ImageLabelSource | None = None,
@@ -374,7 +408,7 @@ class NgioImageMeta(AbstractNgioImageMeta):
 
     def __init__(
         self,
-        version: str,
+        version: NgffVersions,
         name: str | None,
         datasets: list[Dataset],
         channels: ChannelsMeta | None = None,