ngio 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_axes.py

@@ -3,7 +3,7 @@
 from collections.abc import Collection
 from enum import Enum
 from logging import Logger
-from typing import TypeVar
+from typing import Literal, TypeVar
 
 import numpy as np
 from pydantic import BaseModel, ConfigDict, Field
@@ -32,98 +32,108 @@ class AxisType(str, Enum):
     space = "space"
 
 
-class SpaceUnits(str, Enum):
-    """Allowed space units."""
-
-    nanometer = "nanometer"
-    nm = "nm"
-    micrometer = "micrometer"
-    um = "um"
-    millimeter = "millimeter"
-    mm = "mm"
-    centimeter = "centimeter"
-    cm = "cm"
-
-    @classmethod
-    def default(cls) -> "SpaceUnits":
-        return SpaceUnits.um
-
-
-class TimeUnits(str, Enum):
-    """Allowed time units."""
-
-    seconds = "seconds"
-    s = "s"
-
-    @classmethod
-    def default(cls) -> "TimeUnits":
-        return TimeUnits.s
+SpaceUnits = Literal[
+    "micrometer",
+    "nanometer",
+    "angstrom",
+    "picometer",
+    "millimeter",
+    "centimeter",
+    "decimeter",
+    "meter",
+    "inch",
+    "foot",
+    "yard",
+    "mile",
+    "kilometer",
+    "hectometer",
+    "megameter",
+    "gigameter",
+    "terameter",
+    "petameter",
+    "exameter",
+    "parsec",
+    "femtometer",
+    "attometer",
+    "zeptometer",
+    "yoctometer",
+    "zettameter",
+    "yottameter",
+]
+DefaultSpaceUnit = "micrometer"
+
+TimeUnits = Literal[
+    "attosecond",
+    "centisecond",
+    "day",
+    "decisecond",
+    "exasecond",
+    "femtosecond",
+    "gigasecond",
+    "hectosecond",
+    "hour",
+    "kilosecond",
+    "megasecond",
+    "microsecond",
+    "millisecond",
+    "minute",
+    "nanosecond",
+    "petasecond",
+    "picosecond",
+    "second",
+    "terasecond",
+    "yoctosecond",
+    "yottasecond",
+    "zeptosecond",
+    "zettasecond",
+]
+DefaultTimeUnit = "second"
 
 
 class Axis(BaseModel):
     """Axis infos model."""
 
     on_disk_name: str
-    unit: SpaceUnits | TimeUnits | None = None
+    unit: str | None = None
     axis_type: AxisType | None = None
 
     model_config = ConfigDict(extra="forbid", frozen=True)
 
     def implicit_type_cast(self, cast_type: AxisType) -> "Axis":
+        unit = self.unit
         if self.axis_type != cast_type:
             logger.warning(
                 f"Axis {self.on_disk_name} has type {self.axis_type}. "
                 f"Casting to {cast_type}."
             )
-        new_axis = Axis(
-            on_disk_name=self.on_disk_name, axis_type=cast_type, unit=self.unit
-        )
-        if cast_type == AxisType.time and not isinstance(self.unit, TimeUnits):
+
+        if cast_type == AxisType.time and unit is None:
             logger.warning(
                 f"Time axis {self.on_disk_name} has unit {self.unit}. "
-                f"Casting to {TimeUnits.default()}."
-            )
-            new_axis = Axis(
-                on_disk_name=self.on_disk_name,
-                axis_type=AxisType.time,
-                unit=TimeUnits.default(),
-            )
-        elif cast_type == AxisType.space and not isinstance(self.unit, SpaceUnits):
-            logger.warning(
-                f"Space axis {self.on_disk_name} has unit {self.unit}. "
-                f"Casting to {SpaceUnits.default()}."
+                f"Casting to {DefaultSpaceUnit}."
             )
-            new_axis = Axis(
-                on_disk_name=self.on_disk_name,
-                axis_type=AxisType.space,
-                unit=SpaceUnits.default(),
-            )
-        elif cast_type == AxisType.channel and self.unit is not None:
+            unit = DefaultTimeUnit
+
+        if cast_type == AxisType.space and unit is None:
             logger.warning(
-                f"Channel axis {self.on_disk_name} has unit {self.unit}. Removing unit."
-            )
-            new_axis = Axis(
-                on_disk_name=self.on_disk_name,
-                axis_type=AxisType.channel,
-                unit=None,
+                f"Space axis {self.on_disk_name} has unit {unit}. "
+                f"Casting to {DefaultSpaceUnit}."
             )
-        return new_axis
+            unit = DefaultSpaceUnit
+
+        return Axis(on_disk_name=self.on_disk_name, axis_type=cast_type, unit=unit)
 
     def canonical_axis_cast(self, canonical_name: str) -> "Axis":
         """Cast the implicit axis to the correct type."""
         match canonical_name:
             case "t":
-                if self.axis_type != AxisType.time or not isinstance(
-                    self.unit, TimeUnits
-                ):
+                if self.axis_type != AxisType.time or self.unit is None:
                     return self.implicit_type_cast(AxisType.time)
             case "c":
-                if self.axis_type != AxisType.channel or self.unit is not None:
+                if self.axis_type != AxisType.channel:
                     return self.implicit_type_cast(AxisType.channel)
             case "z" | "y" | "x":
-                if self.axis_type != AxisType.space or not isinstance(
-                    self.unit, SpaceUnits
-                ):
+                if self.axis_type != AxisType.space or self.unit is None:
                     return self.implicit_type_cast(AxisType.space)
         return self
 
@@ -345,6 +355,11 @@ class AxesMapper:
                 _index_mapping[canonical_key] = None
         return _index_mapping
 
+    @property
+    def axes_setup(self) -> AxesSetup:
+        """Return the axes setup."""
+        return self._axes_setup
+
     @property
     def on_disk_axes(self) -> list[Axis]:
         return list(self._on_disk_axes)
@@ -353,6 +368,16 @@ class AxesMapper:
     def on_disk_axes_names(self) -> list[str]:
         return [ax.on_disk_name for ax in self._on_disk_axes]
 
+    @property
+    def allow_non_canonical_axes(self) -> bool:
+        """Return if non canonical axes are allowed."""
+        return self._allow_non_canonical_axes
+
+    @property
+    def strict_canonical_order(self) -> bool:
+        """Return if strict canonical order is enforced."""
+        return self._strict_canonical_order
+
     def get_index(self, name: str) -> int | None:
         """Get the index of the axis by name."""
         if name not in self._index_mapping.keys():
@@ -443,8 +468,8 @@ class AxesMapper:
 
 def canonical_axes(
     axes_names: Collection[str],
-    space_units: SpaceUnits | None = None,
-    time_units: TimeUnits | None = None,
+    space_units: SpaceUnits | None = DefaultSpaceUnit,
+    time_units: TimeUnits | None = DefaultTimeUnit,
 ) -> list[Axis]:
     """Create a new canonical axes mapper.
 

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,
+        )