ngio 0.2.0a2__py3-none-any.whl → 0.5.0b4__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_channels.py

@@ -3,13 +3,13 @@
 Stores the same information as the Omero section of the ngff 0.4 metadata.
 """
 
-from collections.abc import Collection
+from collections.abc import Sequence
 from difflib import SequenceMatcher
 from enum import Enum
 from typing import Any, TypeVar
 
 import numpy as np
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from ngio.utils import NgioValidationError, NgioValueError
 
@@ -77,7 +77,8 @@ class NgioColors(str, Enum):
             # try to match the color to the channel name
             similarity[color] = SequenceMatcher(None, channel_name, color).ratio()
         # Get the color with the highest similarity
-        color_str = max(similarity, key=similarity.get)  # type: ignore
+        color_str = max(similarity, key=similarity.get)  # type: ignore (max type overload fails to infer type)
+        assert isinstance(color_str, str), "Color name must be a string."
         return NgioColors.__members__[color_str]
 
 
@@ -101,6 +102,20 @@ def valid_hex_color(v: str) -> bool:
     return True
 
 
+def into_valid_hex_color(v: str) -> str:
+    """Convert a string into a valid hexadecimal color.
+
+    If the string is already a valid hexadecimal color, return it.
+    Otherwise, return a hexadecimal color based on the hash of the string.
+    """
+    # strip leading '#' if present
+    v = v.lstrip("#")
+    if valid_hex_color(v):
+        return v
+
+    return NgioColors.semi_random_pick(v.lower()).value
+
+
 class ChannelVisualisation(BaseModel):
     """Channel visualisation model.
 
@@ -124,7 +139,6 @@ class ChannelVisualisation(BaseModel):
     model_config = ConfigDict(extra="allow", frozen=True)
 
     @field_validator("color", mode="after")
-    @classmethod
     def validate_color(cls, value: str | NgioColors) -> str:
         """Color validator.
 
@@ -135,16 +149,27 @@ class ChannelVisualisation(BaseModel):
         """
         if value is None:
             return NgioColors.semi_random_pick().value
-        if isinstance(value, str) and valid_hex_color(value):
-            return value
+        if isinstance(value, str):
+            return into_valid_hex_color(value)
         elif isinstance(value, NgioColors):
             return value.value
-        elif isinstance(value, str):
-            value_lower = value.lower()
-            return NgioColors.semi_random_pick(value_lower).value
         else:
             raise NgioValueError(f"Invalid color {value}.")
 
+    @model_validator(mode="before")
+    def check_start_end(cls, data):
+        """Check that the start and end values are valid.
+
+        If the start and end values are equal, set the end value to start + 1
+        """
+        start = data.get("start", None)
+        end = data.get("end", None)
+        if start is None or end is None:
+            return data
+        if abs(end - start) < 1e-6:
+            data["end"] = start + 1
+        return data
+
     @classmethod
     def default_init(
         cls,
@@ -261,7 +286,7 @@ class Channel(BaseModel):
 T = TypeVar("T")
 
 
-def _check_elements(elements: Collection[T], expected_type: Any) -> Collection[T]:
+def _check_elements(elements: Sequence[T], expected_type: Any) -> Sequence[T]:
     """Check that the elements are of the same type."""
     if len(elements) == 0:
         raise NgioValidationError("At least one element must be provided.")
@@ -275,7 +300,7 @@ def _check_elements(elements: Collection[T], expected_type: Any) -> Collection[T
     return elements
 
 
-def _check_unique(elements: Collection[T]) -> Collection[T]:
+def _check_unique(elements: Sequence[T]) -> Sequence[T]:
     """Check that the elements are unique."""
     if len(set(elements)) != len(elements):
         raise NgioValidationError("All elements must be unique.")
@@ -303,33 +328,35 @@ class ChannelsMeta(BaseModel):
     @classmethod
     def default_init(
         cls,
-        labels: Collection[str] | int,
-        wavelength_id: Collection[str] | None = None,
-        colors: Collection[str | NgioColors] | None = None,
-        start: Collection[int | float] | int | float | None = None,
-        end: Collection[int | float] | int | float | None = None,
-        active: Collection[bool] | None = None,
+        labels: Sequence[str | None] | int,
+        wavelength_id: Sequence[str | None] | None = None,
+        colors: Sequence[str | NgioColors | None] | None = None,
+        start: Sequence[int | float | None] | int | float | None = None,
+        end: Sequence[int | float | None] | int | float | None = None,
+        active: Sequence[bool | None] | None = None,
         data_type: Any = np.uint16,
         **omero_kwargs: dict,
     ) -> "ChannelsMeta":
         """Create a ChannelsMeta object with the default unit.
 
         Args:
-            labels(Collection[str] | int): The list of channels names in the image.
-                If an integer is provided, the channels will be named "channel_i".
-            wavelength_id(Collection[str] | None): The wavelength ID of the channel.
-                If None, the wavelength ID will be the same as the channel name.
-            colors(Collection[str, NgioColors] | None): The list of colors for the
-                channels. If None, the colors will be random.
-            start(Collection[int | float] | int | float | None): The start value of the
-                channel. If None, the start value will be the minimum value of the
-                data type.
-            end(Collection[int | float] | int | float | None): The end value of the
-                channel. If None, the end value will be the maximum value of the
-                data type.
+            labels(Sequence[str | None] | int): The list of channels names
+                in the image. If an integer is provided, the channels will be
+                named "channel_i".
+            wavelength_id(Sequence[str | None] | None): The wavelength ID of the
+                channel. If None, the wavelength ID will be the same as the
+                channel name.
+            colors(Sequence[str | NgioColors | None] | None): The list of
+                colors for the channels. If None, the colors will be random.
+            start(Sequence[int | float | None] | int | float | None): The start
+                value of the channel. If None, the start value will be the
+                minimum value of the data type.
+            end(Sequence[int | float | None] | int | float | None): The end
+                value of the channel. If None, the end value will be the
+                maximum value of the data type.
             data_type(Any): The data type of the channel. Will be used to set the
                 min and max values of the channel.
-            active (Collection[bool] | None):active(bool): Whether the channel should
+            active (Sequence[bool | None] | None): Whether the channel should
                 be shown by default.
             omero_kwargs(dict): Extra fields to store in the omero attributes.
         """
@@ -339,26 +366,47 @@ class ChannelsMeta(BaseModel):
         labels = _check_elements(labels, str)
         labels = _check_unique(labels)
 
-        _wavelength_id: Collection[str | None] = [None] * len(labels)
-        if isinstance(wavelength_id, Collection):
+        _wavelength_id: Sequence[str | None] = [None] * len(labels)
+        if wavelength_id is None:
+            _wavelength_id: Sequence[str | None] = [None] * len(labels)
+        else:
             _wavelength_id = _check_elements(wavelength_id, str)
             _wavelength_id = _check_unique(wavelength_id)
 
-        _colors: Collection[str | NgioColors] = ["random"] * len(labels)
-        if isinstance(colors, Collection):
+        if colors is None:
+            _colors = [NgioColors.semi_random_pick(label) for label in labels]
+        else:
             _colors = _check_elements(colors, str | NgioColors)
 
-        _start: Collection[int | float | None] = [None] * len(labels)
-        if isinstance(start, Collection):
+        if start is None:
+            _start = [None] * len(labels)
+        elif isinstance(start, int | float):
+            _start = [start] * len(labels)
+        else:
             _start = _check_elements(start, (int, float))
 
-        _end: Collection[int | float | None] = [None] * len(labels)
-        if isinstance(end, Collection):
+        if end is None:
+            _end = [None] * len(labels)
+        elif isinstance(end, int | float):
+            _end = [end] * len(labels)
+        else:
             _end = _check_elements(end, (int, float))
 
-        _active: Collection[bool] = [True] * len(labels)
-        if isinstance(active, Collection):
-            _active = _check_elements(active, bool)
+        if active is None:
+            _active = [True] * len(labels)
+        else:
+            _active = _check_elements(active, (bool,))
+
+        all_lengths = [
+            len(labels),
+            len(_wavelength_id),
+            len(_colors),
+            len(_start),
+            len(_end),
+            len(_active),
+        ]
+        if len(set(all_lengths)) != 1:
+            raise NgioValueError("Channels information must all have the same length.")
 
         channels = []
         for ch_name, w_id, color, s, e, a in zip(
@@ -376,3 +424,39 @@ class ChannelsMeta(BaseModel):
                 )
             )
         return cls(channels=channels, **omero_kwargs)
+
+    @property
+    def channel_labels(self) -> list[str]:
+        """Get the labels of the channels in the image."""
+        return [channel.label for channel in self.channels]
+
+    @property
+    def channel_wavelength_ids(self) -> list[str | None]:
+        """Get the wavelength IDs of the channels in the image."""
+        return [channel.wavelength_id for channel in self.channels]
+
+    def get_channel_idx(
+        self, channel_label: str | None = None, wavelength_id: str | None = None
+    ) -> int:
+        """Get the index of a channel by its label or wavelength ID."""
+        # Only one of the arguments must be provided
+        if channel_label is not None and wavelength_id is not None:
+            raise NgioValueError(
+                "get_channel_idx must receive either label or wavelength_id, not both."
+            )
+
+        if channel_label is not None:
+            if channel_label not in self.channel_labels:
+                raise NgioValueError(f"Channel with label {channel_label} not found.")
+            return self.channel_labels.index(channel_label)
+
+        if wavelength_id is not None:
+            if wavelength_id not in self.channel_wavelength_ids:
+                raise NgioValueError(
+                    f"Channel with wavelength ID {wavelength_id} not found."
+                )
+            return self.channel_wavelength_ids.index(wavelength_id)
+
+        raise NgioValueError(
+            "get_channel_idx must receive either label or wavelength_id"
+        )

ngio/ome_zarr_meta/ngio_specs/_dataset.py

@@ -1,84 +1,51 @@
 """Fractal internal module for dataset metadata handling."""
 
-from collections.abc import Collection
+from collections.abc import Sequence
 
 from ngio.ome_zarr_meta.ngio_specs._axes import (
-    AxesMapper,
-    AxesSetup,
-    Axis,
-    SpaceUnits,
-    TimeUnits,
+    AxesHandler,
 )
 from ngio.ome_zarr_meta.ngio_specs._pixel_size import PixelSize
 from ngio.utils import NgioValidationError
 
 
 class Dataset:
-    """Model for a dataset in the multiscale.
-
-    To initialize the Dataset object, the path, the axes, scale, and translation list
-    can be provided with on_disk order.
-    """
+    """Model for a dataset in the multiscale."""
 
     def __init__(
         self,
         *,
         # args coming from ngff specs
         path: str,
-        on_disk_axes: Collection[Axis],
-        on_disk_scale: Collection[float],
-        on_disk_translation: Collection[float] | None = None,
-        # user defined args
-        axes_setup: AxesSetup | None = None,
-        allow_non_canonical_axes: bool = False,
-        strict_canonical_order: bool = False,
+        axes_handler: AxesHandler,
+        scale: Sequence[float],
+        translation: Sequence[float] | None = None,
     ):
         """Initialize the Dataset object.
 
         Args:
             path (str): The path of the dataset.
-            on_disk_axes (list[Axis]): The list of axes in the multiscale.
-            on_disk_scale (list[float]): The list of scale transformation.
+            axes_handler (AxesHandler): The axes handler object.
+            scale (list[float]): The list of scale transformation.
                 The scale transformation must have the same length as the axes.
-            on_disk_translation (list[float] | None): The list of translation.
-            axes_setup (AxesSetup): The axes setup object
-            allow_non_canonical_axes (bool): Allow non-canonical axes.
-            strict_canonical_order (bool): Strict canonical order.
+            translation (list[float] | None): The list of translation.
+                The translation must have the same length as the axes.
         """
         self._path = path
-        self._axes_mapper = AxesMapper(
-            on_disk_axes=on_disk_axes,
-            axes_setup=axes_setup,
-            allow_non_canonical_axes=allow_non_canonical_axes,
-            strict_canonical_order=strict_canonical_order,
-        )
+        self._axes_handler = axes_handler
 
-        if len(on_disk_scale) != len(on_disk_axes):
+        if len(scale) != len(axes_handler.axes):
             raise NgioValidationError(
                 "The length of the scale transformation must be the same as the axes."
             )
-        self._on_disk_scale = list(on_disk_scale)
+        self._scale = list(scale)
 
-        on_disk_translation = on_disk_translation or [0.0] * len(on_disk_axes)
-        if len(on_disk_translation) != len(on_disk_axes):
+        translation = translation or [0.0] * len(axes_handler.axes)
+        if len(translation) != len(axes_handler.axes):
             raise NgioValidationError(
                 "The length of the translation must be the same as the axes."
             )
-        self._on_disk_translation = list(on_disk_translation)
-
-    def get_scale(self, axis_name: str) -> float:
-        """Return the scale for a given axis."""
-        idx = self._axes_mapper.get_index(axis_name)
-        if idx is None:
-            return 1.0
-        return self._on_disk_scale[idx]
-
-    def get_translation(self, axis_name: str) -> float:
-        """Return the translation for a given axis."""
-        idx = self._axes_mapper.get_index(axis_name)
-        if idx is None:
-            return 0.0
-        return self._on_disk_translation[idx]
+        self._translation = list(translation)
 
     @property
     def path(self) -> str:
@@ -86,49 +53,37 @@ class Dataset:
         return self._path
 
     @property
-    def space_unit(self) -> SpaceUnits:
-        """Return the space unit for a given axis."""
-        x_axis = self._axes_mapper.get_axis("x")
-        y_axis = self._axes_mapper.get_axis("y")
-
-        if x_axis is None or y_axis is None:
-            raise NgioValidationError(
-                "The dataset must have x and y axes to determine the space unit."
-            )
-
-        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(
-                "Inconsistent space units. "
-                f"x={x_axis.unit} and y={y_axis.unit} should have the same unit."
-            )
-
-    @property
-    def time_unit(self) -> TimeUnits | 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
+    def axes_handler(self) -> AxesHandler:
+        """Return the axes handler object."""
+        return self._axes_handler
 
     @property
     def pixel_size(self) -> PixelSize:
         """Return the pixel size for the dataset."""
+        scale = self._scale
+        pix_size_dict = {}
+        # Mandatory axes: x, y
+        for ax in ["x", "y"]:
+            index = self.axes_handler.get_index(ax)
+            assert index is not None
+            pix_size_dict[ax] = scale[index]
+
+        for ax in ["z", "t"]:
+            index = self.axes_handler.get_index(ax)
+            pix_size_dict[ax] = scale[index] if index is not None else 1.0
+
         return PixelSize(
-            x=self.get_scale("x"),
-            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,
+            **pix_size_dict,
+            space_unit=self.axes_handler.space_unit,
+            time_unit=self.axes_handler.time_unit,
         )
 
     @property
-    def axes_mapper(self) -> AxesMapper:
-        """Return the axes mapper object."""
-        return self._axes_mapper
+    def scale(self) -> tuple[float, ...]:
+        """Return the scale transformation as a tuple."""
+        return tuple(self._scale)
+
+    @property
+    def translation(self) -> tuple[float, ...]:
+        """Return the translation as a tuple."""
+        return tuple(self._translation)