ngio 0.3.0a1__py3-none-any.whl → 0.3.2__py3-none-any.whl

ngio/common/_array_pipe.py

@@ -1,10 +1,11 @@
 from collections.abc import Collection, Iterable
 from typing import Literal
 
-import dask
-import dask.delayed
+import dask.array as da
 import numpy as np
 import zarr
+from dask.array import Array as DaskArray
+from dask.delayed import Delayed, delayed
 
 from ngio.common._axes_transforms import transform_dask_array, transform_numpy_array
 from ngio.common._common_types import ArrayLike
@@ -55,26 +56,26 @@ def _numpy_get_pipe(
     slices: SliceTransform,
     transformations: tuple[AxesTransformation, ...],
 ) -> np.ndarray:
-    array = numpy_get_slice(array, slices)
-    return transform_numpy_array(array, transformations)
+    _array = numpy_get_slice(array, slices)
+    return transform_numpy_array(_array, transformations)
 
 
 def _delayed_numpy_get_pipe(
     array: zarr.Array,
     slices: SliceTransform,
     transformations: tuple[AxesTransformation, ...],
-) -> dask.delayed:
-    array = dask.delayed(numpy_get_slice)(array, slices)
-    return dask.delayed(transform_numpy_array)(array, transformations)
+) -> Delayed:
+    _array = delayed(numpy_get_slice)(array, slices)
+    return delayed(transform_numpy_array)(_array, transformations)
 
 
 def _dask_get_pipe(
     array: zarr.Array,
     slices: SliceTransform,
     transformations: tuple[AxesTransformation, ...],
-) -> dask.array:
-    array = dask_get_slice(array, slices)
-    return transform_dask_array(array, transformations)
+) -> DaskArray:
+    _array = dask_get_slice(array, slices)
+    return transform_dask_array(_array, transformations)
 
 
 def _numpy_set_pipe(
@@ -89,22 +90,22 @@ def _numpy_set_pipe(
 
 def _dask_set_pipe(
     array: zarr.Array,
-    patch: np.ndarray,
+    patch: DaskArray,
     slices: SliceTransform,
     transformations: tuple[AxesTransformation, ...],
 ) -> None:
-    patch = transform_dask_array(patch, transformations)
-    dask_set_slice(array, patch, slices)
+    _patch = transform_dask_array(patch, transformations)
+    dask_set_slice(array, _patch, slices)
 
 
 def _delayed_numpy_set_pipe(
     array: zarr.Array,
-    patch: np.ndarray,
+    patch: np.ndarray | Delayed,
     slices: SliceTransform,
     transformations: tuple[AxesTransformation, ...],
-) -> dask.delayed:
-    patch = dask.delayed(transform_numpy_array)(patch, transformations)
-    return dask.delayed(numpy_set_slice)(array, patch, slices)
+) -> Delayed:
+    _patch = delayed(transform_numpy_array)(patch, transformations)
+    return delayed(numpy_set_slice)(array, _patch, slices)
 
 
 def get_pipe(
@@ -144,7 +145,7 @@ def set_pipe(
     slices, transformations = _compute_to_disk_transforms(
         dimensions=dimensions, axes_order=axes_order, **slice_kwargs
     )
-    if isinstance(patch, dask.array.Array):
+    if isinstance(patch, DaskArray):
         _dask_set_pipe(
             array=array, patch=patch, slices=slices, transformations=transformations
         )
@@ -152,7 +153,7 @@ def set_pipe(
         _numpy_set_pipe(
             array=array, patch=patch, slices=slices, transformations=transformations
         )
-    elif isinstance(patch, dask.delayed.Delayed):
+    elif isinstance(patch, Delayed):
         _delayed_numpy_set_pipe(
             array=array, patch=patch, slices=slices, transformations=transformations
         )
@@ -193,12 +194,15 @@ def _mask_pipe_common(
         **slice_kwargs,
     )
 
-    if isinstance(array_patch, np.ndarray):
+    if isinstance(array_patch, np.ndarray) and isinstance(label_patch, np.ndarray):
         label_patch = np.broadcast_to(label_patch, array_patch.shape)
-    elif isinstance(array_patch, dask.array.Array):
-        label_patch = dask.array.broadcast_to(label_patch, array_patch.shape)
+    elif isinstance(array_patch, DaskArray) and isinstance(label_patch, DaskArray):
+        label_patch = da.broadcast_to(label_patch, array_patch.shape)
     else:
-        raise NgioValueError(f"Mode {mode} not yet supported for masked array.")
+        raise NgioValueError(
+            "Incompatible types for array and label: "
+            f"{type(array_patch)} and {type(label_patch)}"
+        )
 
     mask = label_patch == label
     return array_patch, mask
@@ -225,7 +229,14 @@ def get_masked_pipe(
         mode=mode,
         **slice_kwargs,
     )
-    array_patch[~mask] = 0
+    if isinstance(array_patch, np.ndarray):
+        array_patch[~mask] = 0
+    elif isinstance(array_patch, DaskArray):
+        array_patch = da.where(mask, array_patch, 0)
+    else:
+        raise NgioValueError(
+            "Mode not yet supported for masked array. Expected a numpy or dask array."
+        )
     return array_patch
 
 
@@ -240,7 +251,7 @@ def set_masked_pipe(
     axes_order: Collection[str] | None = None,
     **slice_kwargs: slice | int | Iterable[int],
 ):
-    if isinstance(patch, dask.array.Array):
+    if isinstance(patch, DaskArray):
         mode = "dask"
     elif isinstance(patch, np.ndarray):
         mode = "numpy"
@@ -259,7 +270,19 @@ def set_masked_pipe(
         mode=mode,
         **slice_kwargs,
     )
-    patch = np.where(mask, patch, array_patch)
+    if isinstance(patch, np.ndarray):
+        assert isinstance(array_patch, np.ndarray)
+        _patch = np.where(mask, patch, array_patch)
+    elif isinstance(patch, DaskArray):
+        _patch = da.where(mask, patch, array_patch)
+    else:
+        raise NgioValueError(
+            "Mode not yet supported for masked array. Expected a numpy or dask array."
+        )
     set_pipe(
-        array, patch, dimensions=dimensions_array, axes_order=axes_order, **slice_kwargs
+        array,
+        _patch,
+        dimensions=dimensions_array,
+        axes_order=axes_order,
+        **slice_kwargs,
     )

ngio/common/_roi.py

@@ -57,6 +57,7 @@ class Roi(BaseModel):
             x_length=_to_raster(self.x_length, pixel_size.x, dim_x),
             y_length=_to_raster(self.y_length, pixel_size.y, dim_y),
             z_length=_to_raster(self.z_length, pixel_size.z, dim_z),
+            **self.model_extra,
         )
 
     def zoom(self, zoom_factor: float = 1) -> "Roi":
@@ -94,6 +95,7 @@ class RoiPixels(BaseModel):
             y_length=_to_world(self.y_length, pixel_size.y),
             z_length=_to_world(self.z_length, pixel_size.z),
             unit=pixel_size.space_unit,
+            **self.model_extra,
         )
 
     def to_slices(self) -> dict[str, slice]:

ngio/common/_table_ops.py

@@ -9,7 +9,7 @@ from typing import Literal
 import pandas as pd
 import polars as pl
 
-from ngio.images.ome_zarr_container import OmeZarrContainer
+from ngio.images._ome_zarr_container import OmeZarrContainer
 from ngio.tables import Table, TableType
 
 

ngio/hcs/__init__.py

@@ -1,6 +1,6 @@
 """OME-Zarr HCS objects models."""
 
-from ngio.hcs.plate import (
+from ngio.hcs._plate import (
     OmeZarrPlate,
     OmeZarrWell,
     create_empty_plate,

ngio/hcs/{plate.py → _plate.py}

@@ -27,6 +27,7 @@ from ngio.ome_zarr_meta import (
 )
 from ngio.tables import (
     ConditionTable,
+    DefaultTableBackend,
     FeatureTable,
     GenericRoiTable,
     MaskingRoiTable,
@@ -39,7 +40,6 @@ from ngio.tables import (
 )
 from ngio.utils import (
     AccessModeLiteral,
-    NgioValidationError,
     NgioValueError,
     StoreOrGroup,
     ZarrGroupHandler,
@@ -805,22 +805,38 @@ class OmeZarrPlate:
             parallel_safe=parallel_safe,
         )
 
-    @property
-    def tables_container(self) -> TablesContainer:
+    def _get_tables_container(self) -> TablesContainer | None:
         """Return the tables container."""
         if self._tables_container is None:
-            self._tables_container = _default_table_container(self._group_handler)
-            if self._tables_container is None:
-                raise NgioValidationError("No tables found in the image.")
+            _tables_container = _default_table_container(self._group_handler)
+            if _tables_container is None:
+                return None
+            self._tables_container = _tables_container
         return self._tables_container
 
-    def list_tables(self, filter_types: str | None = None) -> list[str]:
+    @property
+    def tables_container(self) -> TablesContainer:
+        """Return the tables container."""
+        _table_container = self._get_tables_container()
+        if _table_container is None:
+            raise NgioValueError(
+                "No tables container found. Please add a tables container to the plate."
+            )
+        return _table_container
+
+    def list_tables(self, filter_types: TypedTable | str | None = None) -> list[str]:
         """List all tables in the image."""
         return self.tables_container.list(filter_types=filter_types)
 
     def list_roi_tables(self) -> list[str]:
         """List all ROI tables in the image."""
-        return self.tables_container.list_roi_tables()
+        masking_roi = self.tables_container.list(
+            filter_types="masking_roi_table",
+        )
+        roi = self.tables_container.list(
+            filter_types="roi_table",
+        )
+        return masking_roi + roi
 
     def get_roi_table(self, name: str) -> RoiTable:
         """Get a ROI table from the image.
@@ -929,7 +945,7 @@ class OmeZarrPlate:
         self,
         name: str,
         table: Table,
-        backend: TableBackend = "anndata",
+        backend: TableBackend = DefaultTableBackend,
         overwrite: bool = False,
     ) -> None:
         """Add a table to the image."""

ngio/images/__init__.py

@@ -1,8 +1,8 @@
 """OME-Zarr object models."""
 
-from ngio.images.image import Image, ImagesContainer
-from ngio.images.label import Label, LabelsContainer
-from ngio.images.ome_zarr_container import (
+from ngio.images._image import Image, ImagesContainer
+from ngio.images._label import Label, LabelsContainer
+from ngio.images._ome_zarr_container import (
     OmeZarrContainer,
     create_empty_ome_zarr,
     create_ome_zarr_from_array,

ngio/images/{image.py → _image.py}

@@ -3,11 +3,11 @@
 from collections.abc import Collection
 from typing import Literal
 
-from dask import array as da
+import dask.array as da
 
 from ngio.common import Dimensions
-from ngio.images.abstract_image import AbstractImage, consolidate_image
-from ngio.images.create import create_empty_image_container
+from ngio.images._abstract_image import AbstractImage, consolidate_image
+from ngio.images._create import create_empty_image_container
 from ngio.ome_zarr_meta import (
     ImageMetaHandler,
     NgioImageMeta,
@@ -152,31 +152,33 @@ class ImagesContainer:
 
     def set_channel_meta(
         self,
-        labels: Collection[str] | int | None = None,
-        wavelength_id: Collection[str] | None = None,
-        start: Collection[float] | None = None,
-        end: Collection[float] | None = None,
+        labels: Collection[str | None] | int | None = None,
+        wavelength_id: Collection[str | None] | None = None,
+        start: Collection[float | None] | None = None,
+        end: Collection[float | None] | None = None,
         percentiles: tuple[float, float] | None = None,
-        colors: Collection[str] | None = None,
-        active: Collection[bool] | None = None,
+        colors: Collection[str | None] | None = None,
+        active: Collection[bool | None] | None = None,
         **omero_kwargs: dict,
     ) -> None:
         """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.
+            labels(Collection[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(Collection[str | None]): The wavelength ID of the channel.
                 If None, the wavelength ID will be the same as the channel name.
-            start(Collection[float] | None): The start value for each channel.
+            start(Collection[float | None]): The start value for each channel.
                 If None, the start value will be computed from the image.
-            end(Collection[float] | None): The end value for each channel.
+            end(Collection[float | None]): The end value for each channel.
                 If None, the end value will be computed from the image.
-            percentiles(tuple[float, float] | None): The start and end percentiles
-                for each channel. If None, the percentiles will not be computed.
-            colors(Collection[str, NgioColors] | None): The list of colors for the
+            percentiles(tuple[float, float] | None): The start and end
+                percentiles for each channel. If None, the percentiles will
+                not be computed.
+            colors(Collection[str | None]): The list of colors for the
                 channels. If None, the colors will be random.
-            active (Collection[bool] | None):active(bool): Whether the channel should
+            active (Collection[bool | None]): Whether the channel should
                 be shown by default.
             omero_kwargs(dict): Extra fields to store in the omero attributes.
         """
@@ -376,9 +378,12 @@ def compute_image_percentile(
     starts, ends = [], []
     for c in range(image.num_channels):
         if image.num_channels == 1:
-            data = image.get_array(mode="dask").ravel()
+            data = image.get_array(mode="dask")
         else:
-            data = image.get_array(c=c, mode="dask").ravel()
+            data = image.get_array(c=c, mode="dask")
+
+        assert isinstance(data, da.Array), "Data must be a Dask array."
+        data = da.ravel(data)
         # remove all the zeros
         mask = data > 1e-16
         data = data[mask]
@@ -391,7 +396,7 @@ def compute_image_percentile(
         # compute the percentiles
         _s_perc, _e_perc = da.percentile(
             data, [start_percentile, end_percentile], method="nearest"
-        ).compute()
+        ).compute()  # type: ignore
 
         starts.append(float(_s_perc))
         ends.append(float(_e_perc))

ngio/images/{label.py → _label.py}

@@ -3,10 +3,12 @@
 from collections.abc import Collection
 from typing import Literal
 
+import dask.array as da
+
 from ngio.common import compute_masking_roi
-from ngio.images.abstract_image import AbstractImage, consolidate_image
-from ngio.images.create import create_empty_label_container
-from ngio.images.image import Image
+from ngio.images._abstract_image import AbstractImage, consolidate_image
+from ngio.images._create import create_empty_label_container
+from ngio.images._image import Image
 from ngio.ome_zarr_meta import (
     LabelMetaHandler,
     NgioLabelMeta,
@@ -309,6 +311,6 @@ def build_masking_roi_table(label: Label) -> MaskingRoiTable:
         raise NgioValueError("Time series labels are not supported.")
 
     array = label.get_array(axes_order=["z", "y", "x"], mode="dask")
-
+    assert isinstance(array, da.Array), "Array must be a Dask array."
     rois = compute_masking_roi(array, label.pixel_size)
     return MaskingRoiTable(rois, reference_label=label.meta.name)

ngio/images/{masked_image.py → _masked_image.py}

@@ -4,8 +4,8 @@ from collections.abc import Collection, Iterable
 from typing import Literal
 
 from ngio.common import ArrayLike, get_masked_pipe, roi_to_slice_kwargs, set_masked_pipe
-from ngio.images.image import Image
-from ngio.images.label import Label
+from ngio.images._image import Image
+from ngio.images._label import Label
 from ngio.ome_zarr_meta import ImageMetaHandler, LabelMetaHandler
 from ngio.tables import MaskingRoiTable
 from ngio.utils import (

ngio/images/{ome_zarr_container.py → _ome_zarr_container.py}

@@ -5,10 +5,10 @@ from collections.abc import Collection
 
 import numpy as np
 
-from ngio.images.create import create_empty_image_container
-from ngio.images.image import Image, ImagesContainer
-from ngio.images.label import Label, LabelsContainer
-from ngio.images.masked_image import MaskedImage, MaskedLabel
+from ngio.images._create import create_empty_image_container
+from ngio.images._image import Image, ImagesContainer
+from ngio.images._label import Label, LabelsContainer
+from ngio.images._masked_image import MaskedImage, MaskedLabel
 from ngio.ome_zarr_meta import (
     NgioImageMeta,
     PixelSize,
@@ -23,6 +23,7 @@ from ngio.ome_zarr_meta.ngio_specs import (
 )
 from ngio.tables import (
     ConditionTable,
+    DefaultTableBackend,
     FeatureTable,
     GenericRoiTable,
     MaskingRoiTable,
@@ -68,7 +69,7 @@ class OmeZarrContainer:
         group_handler: ZarrGroupHandler,
         table_container: TablesContainer | None = None,
         label_container: LabelsContainer | None = None,
-        validate_arrays: bool = True,
+        validate_paths: bool = False,
     ) -> None:
         """Initialize the OmeZarrContainer."""
         self._group_handler = group_handler
@@ -77,6 +78,10 @@ class OmeZarrContainer:
         self._labels_container = label_container
         self._tables_container = table_container
 
+        if validate_paths:
+            for level_path in self._images_container.levels_paths:
+                self.get_image(path=level_path)
+
     def __repr__(self) -> str:
         """Return a string representation of the image."""
         num_labels = len(self.list_labels())
@@ -99,24 +104,40 @@ class OmeZarrContainer:
         """Return the image container."""
         return self._images_container
 
-    @property
-    def labels_container(self) -> LabelsContainer:
+    def _get_labels_container(self) -> LabelsContainer | None:
         """Return the labels container."""
         if self._labels_container is None:
-            self._labels_container = _default_label_container(self._group_handler)
-            if self._labels_container is None:
-                raise NgioValidationError("No labels found in the image.")
+            _labels_container = _default_label_container(self._group_handler)
+            if _labels_container is None:
+                return None
+            self._labels_container = _labels_container
         return self._labels_container
 
     @property
-    def tables_container(self) -> TablesContainer:
+    def labels_container(self) -> LabelsContainer:
+        """Return the labels container."""
+        _labels_container = self._get_labels_container()
+        if _labels_container is None:
+            raise NgioValidationError("No labels found in the image.")
+        return _labels_container
+
+    def _get_tables_container(self) -> TablesContainer | None:
         """Return the tables container."""
         if self._tables_container is None:
-            self._tables_container = _default_table_container(self._group_handler)
-            if self._tables_container is None:
-                raise NgioValidationError("No tables found in the image.")
+            _tables_container = _default_table_container(self._group_handler)
+            if _tables_container is None:
+                return None
+            self._tables_container = _tables_container
         return self._tables_container
 
+    @property
+    def tables_container(self) -> TablesContainer:
+        """Return the tables container."""
+        _tables_container = self._get_tables_container()
+        if _tables_container is None:
+            raise NgioValidationError("No tables found in the image.")
+        return _tables_container
+
     @property
     def image_meta(self) -> NgioImageMeta:
         """Return the image metadata."""
@@ -332,7 +353,7 @@ class OmeZarrContainer:
 
         new_ome_zarr = OmeZarrContainer(
             group_handler=handler,
-            validate_arrays=False,
+            validate_paths=False,
         )
 
         if copy_labels:
@@ -346,13 +367,25 @@ class OmeZarrContainer:
             )
         return new_ome_zarr
 
-    def list_tables(self, filter_types: str | None = None) -> list[str]:
+    def list_tables(self, filter_types: TypedTable | str | None = None) -> list[str]:
         """List all tables in the image."""
-        return self.tables_container.list(filter_types=filter_types)
+        table_container = self._get_tables_container()
+        if table_container is None:
+            return []
+
+        return table_container.list(
+            filter_types=filter_types,
+        )
 
     def list_roi_tables(self) -> list[str]:
         """List all ROI tables in the image."""
-        return self.tables_container.list_roi_tables()
+        masking_roi = self.tables_container.list(
+            filter_types="masking_roi_table",
+        )
+        roi = self.tables_container.list(
+            filter_types="roi_table",
+        )
+        return masking_roi + roi
 
     def get_roi_table(self, name: str) -> RoiTable:
         """Get a ROI table from the image.
@@ -469,7 +502,7 @@ class OmeZarrContainer:
         self,
         name: str,
         table: Table,
-        backend: TableBackend = "anndata",
+        backend: TableBackend = DefaultTableBackend,
         overwrite: bool = False,
     ) -> None:
         """Add a table to the image."""
@@ -479,7 +512,10 @@ class OmeZarrContainer:
 
     def list_labels(self) -> list[str]:
         """List all labels in the image."""
-        return self.labels_container.list()
+        label_container = self._get_labels_container()
+        if label_container is None:
+            return []
+        return label_container.list()
 
     def get_label(
         self,
@@ -597,7 +633,7 @@ def open_ome_zarr_container(
     handler = ZarrGroupHandler(store=store, cache=cache, mode=mode)
     return OmeZarrContainer(
         group_handler=handler,
-        validate_arrays=validate_arrays,
+        validate_paths=validate_arrays,
     )
 
 
@@ -796,7 +832,7 @@ def create_ome_zarr_from_array(
         axes_names=axes_names,
         name=name,
         chunks=chunks,
-        dtype=array.dtype,
+        dtype=str(array.dtype),
         overwrite=overwrite,
         version=version,
     )

ngio/ome_zarr_meta/ngio_specs/_axes.py

@@ -2,15 +2,12 @@
 
 from collections.abc import Collection
 from enum import Enum
-from logging import Logger
 from typing import Literal, TypeVar
 
 import numpy as np
 from pydantic import BaseModel, ConfigDict, Field
 
-from ngio.utils import NgioValidationError, NgioValueError
-
-logger = Logger(__name__)
+from ngio.utils import NgioValidationError, NgioValueError, ngio_logger
 
 T = TypeVar("T")
 
@@ -102,20 +99,20 @@ class Axis(BaseModel):
     def implicit_type_cast(self, cast_type: AxisType) -> "Axis":
         unit = self.unit
         if self.axis_type != cast_type:
-            logger.warning(
+            ngio_logger.warning(
                 f"Axis {self.on_disk_name} has type {self.axis_type}. "
                 f"Casting to {cast_type}."
             )
 
         if cast_type == AxisType.time and unit is None:
-            logger.warning(
+            ngio_logger.warning(
                 f"Time axis {self.on_disk_name} has unit {self.unit}. "
                 f"Casting to {DefaultSpaceUnit}."
             )
             unit = DefaultTimeUnit
 
         if cast_type == AxisType.space and unit is None:
-            logger.warning(
+            ngio_logger.warning(
                 f"Space axis {self.on_disk_name} has unit {unit}. "
                 f"Casting to {DefaultSpaceUnit}."
             )