ngio 0.2.0a3__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_ngio_image.py

@@ -14,8 +14,6 @@ import numpy as np
 from pydantic import BaseModel
 
 from ngio.ome_zarr_meta.ngio_specs._axes import (
-    SpaceUnits,
-    TimeUnits,
     canonical_axes,
 )
 from ngio.ome_zarr_meta.ngio_specs._channels import Channel, ChannelsMeta
@@ -56,15 +54,59 @@ class AbstractNgioImageMeta:
             raise NgioValidationError("At least one dataset must be provided.")
 
         self._datasets = datasets
+        self._axes_mapper = datasets[0].axes_mapper
 
     def __repr__(self):
         class_name = type(self).__name__
         paths = [dataset.path for dataset in self.datasets]
-        on_disk_axes = self.datasets[0].axes_mapper.on_disk_axes_names
-        return (
-            f"{class_name}(name={self.name}, "
-            f"datasets={paths}, "
-            f"on_disk_axes={on_disk_axes})"
+        on_disk_axes = self.axes_mapper.on_disk_axes_names
+        return f"{class_name}(name={self.name}, datasets={paths}, axes={on_disk_axes})"
+
+    @classmethod
+    def default_init(
+        cls,
+        levels: int | Collection[str],
+        axes_names: Collection[str],
+        pixel_size: PixelSize,
+        scaling_factors: Collection[float] | None = None,
+        name: str | None = None,
+        version: str = "0.4",
+    ):
+        """Initialize the ImageMeta object."""
+        axes = canonical_axes(
+            axes_names,
+            space_units=pixel_size.space_unit,
+            time_units=pixel_size.time_unit,
+        )
+
+        px_size_dict = pixel_size.as_dict()
+        scale = [px_size_dict.get(ax.on_disk_name, 1.0) for ax in axes]
+        translation = [0.0] * len(scale)
+
+        if scaling_factors is None:
+            _default = {"x": 2.0, "y": 2.0}
+            scaling_factors = [_default.get(ax.on_disk_name, 1.0) for ax in axes]
+
+        if isinstance(levels, int):
+            levels = [str(i) for i in range(levels)]
+
+        datasets = []
+        for level in levels:
+            dataset = Dataset(
+                path=level,
+                on_disk_axes=axes,
+                on_disk_scale=scale,
+                on_disk_translation=translation,
+                allow_non_canonical_axes=False,
+                strict_canonical_order=True,
+            )
+            datasets.append(dataset)
+            scale = [s * f for s, f in zip(scale, scaling_factors, strict=True)]
+
+        return cls(
+            version=version,
+            name=name,
+            datasets=datasets,
         )
 
     @property
@@ -82,6 +124,11 @@ class AbstractNgioImageMeta:
         """List of datasets in the multiscale."""
         return self._datasets
 
+    @property
+    def axes_mapper(self):
+        """Return the axes mapper."""
+        return self._axes_mapper
+
     @property
     def levels(self) -> int:
         """Number of levels in the multiscale."""
@@ -105,33 +152,86 @@ class AbstractNgioImageMeta:
             raise NgioValueError(f"Index {idx} out of range.")
         return self.datasets[idx]
 
-    def _get_dataset_by_pixel_size(
-        self, pixel_size: PixelSize, strict: bool = False, tol: float = 1e-6
-    ) -> Dataset:
-        """Get a dataset with the closest pixel size.
+    def _find_closest_dataset(
+        self, pixel_size: PixelSize, mode: str = "any"
+    ) -> Dataset | None:
+        """Find the closest dataset to the given pixel size.
 
         Args:
             pixel_size(PixelSize): The pixel size to search for.
-            strict(bool): If True, the pixel size must smaller than tol.
-            tol(float): Any pixel size with a distance less than tol will be considered.
+            mode(str): The mode to find the closest dataset.
+                "any": Will find the closest dataset.
+                "lr": Will find closest "lower" resolution dataset.
+                "hr": Will find closest "higher" resolution
         """
         min_dist = np.inf
-
         closest_dataset = None
-        for dataset in self.datasets:
-            dist = dataset.pixel_size.distance(pixel_size)
+
+        if mode == "any":
+            datasets = self.datasets
+        elif mode == "lr":
+            # Lower resolution means that the pixel size is larger.
+            datasets = [d for d in self.datasets if d.pixel_size > pixel_size]
+        elif mode == "hr":
+            # Higher resolution means that the pixel size is smaller.
+            datasets = [d for d in self.datasets if d.pixel_size < pixel_size]
+        else:
+            raise NgioValueError(f"Mode {mode} not recognized.")
+
+        for d in datasets:
+            dist = d.pixel_size.distance(pixel_size)
             if dist < min_dist:
                 min_dist = dist
-                closest_dataset = dataset
+                closest_dataset = d
+
+        return closest_dataset
+
+    def _get_closest_dataset(
+        self, pixel_size: PixelSize, strict: bool = False
+    ) -> Dataset:
+        """Get a dataset with the closest pixel size.
+
+        Args:
+            pixel_size(PixelSize): The pixel size to search for.
+            strict(bool): If True, the pixel size must be exactly the same.
+        """
+        closest_dataset = self._find_closest_dataset(pixel_size, mode="any")
 
         if closest_dataset is None:
             raise NgioValueError("No dataset found.")
 
-        if strict and min_dist > tol:
-            raise NgioValueError("No dataset with a pixel size close enough.")
-
+        if strict and closest_dataset.pixel_size != pixel_size:
+            raise NgioValueError(
+                "No dataset with a pixel size close enough. "
+                "Best match is "
+                f"{closest_dataset.path}:{closest_dataset.pixel_size}"
+            )
         return closest_dataset
 
+    def get_lowest_resolution_dataset(self) -> Dataset:
+        """Get the dataset with the lowest resolution."""
+        dataset = self.datasets[-1]
+        while True:
+            lower_res_dataset = self._find_closest_dataset(
+                dataset.pixel_size, mode="lr"
+            )
+            if lower_res_dataset is None:
+                break
+            dataset = lower_res_dataset
+        return dataset
+
+    def get_highest_resolution_dataset(self) -> Dataset:
+        """Get the dataset with the highest resolution."""
+        dataset = self.datasets[0]
+        while True:
+            higher_res_dataset = self._find_closest_dataset(
+                dataset.pixel_size, mode="hr"
+            )
+            if higher_res_dataset is None:
+                break
+            dataset = higher_res_dataset
+        return dataset
+
     def get_dataset(
         self,
         *,
@@ -169,115 +269,65 @@ class AbstractNgioImageMeta:
         elif idx is not None:
             return self._get_dataset_by_index(idx)
         elif pixel_size is not None:
-            return self._get_dataset_by_pixel_size(pixel_size, strict=strict)
+            return self._get_closest_dataset(pixel_size, strict=strict)
         else:
             return self.get_highest_resolution_dataset()
 
-    @classmethod
-    def default_init(
-        cls,
-        levels: int | Collection[str],
-        axes_names: Collection[str],
-        pixel_size: PixelSize,
-        scaling_factors: Collection[float] | None = None,
-        name: str | None = None,
-        version: str = "0.4",
-    ):
-        """Initialize the ImageMeta object."""
-        axes = canonical_axes(
-            axes_names,
-            space_units=pixel_size.space_unit,
-            time_units=pixel_size.time_unit,
-        )
-
-        px_size_dict = pixel_size.as_dict()
-        scale = [px_size_dict.get(ax.on_disk_name, 1.0) for ax in axes]
-        translation = [0.0] * len(scale)
-
-        if scaling_factors is None:
-            _default = {"x": 2.0, "y": 2.0}
-            scaling_factors = [_default.get(ax.on_disk_name, 1.0) for ax in axes]
-
-        if isinstance(levels, int):
-            levels = [str(i) for i in range(levels)]
-
-        datasets = []
-        for level in levels:
-            dataset = Dataset(
-                path=level,
-                on_disk_axes=axes,
-                on_disk_scale=scale,
-                on_disk_translation=translation,
-                allow_non_canonical_axes=False,
-                strict_canonical_order=True,
+    def _get_closest_datasets(self, path: str | None = None) -> tuple[Dataset, Dataset]:
+        """Get the closest datasets to a dataset."""
+        dataset = self.get_dataset(path=path)
+        lr_dataset = self._find_closest_dataset(dataset.pixel_size, mode="lr")
+        if lr_dataset is None:
+            raise NgioValueError(
+                "No lower resolution dataset found. "
+                "This is the lowest resolution dataset."
             )
-            datasets.append(dataset)
-            scale = [s * f for s, f in zip(scale, scaling_factors, strict=True)]
+        return dataset, lr_dataset
 
-        return cls(
-            version=version,
-            name=name,
-            datasets=datasets,
-        )
+    def scaling_factor(self, path: str | None = None) -> list[float]:
+        """Get the scaling factors from a dataset to its lower resolution."""
+        if self.levels == 1:
+            return [1.0] * len(self.axes_mapper.on_disk_axes_names)
+        dataset, lr_dataset = self._get_closest_datasets(path=path)
 
-    def get_highest_resolution_dataset(self) -> Dataset:
-        """Get the dataset with the highest resolution."""
-        return self._get_dataset_by_pixel_size(
-            pixel_size=PixelSize(
-                x=0.0,
-                y=0.0,
-                z=0.0,
-                t=0.0,
-                space_unit=SpaceUnits.micrometer,
-                time_unit=TimeUnits.s,
-            ),
-            strict=False,
-        )
+        scaling_factors = []
+        for ax_name in self.axes_mapper.on_disk_axes_names:
+            s_d = dataset.get_scale(ax_name)
+            s_lr_d = lr_dataset.get_scale(ax_name)
+            scaling_factors.append(s_lr_d / s_d)
+        return scaling_factors
+
+    def yx_scaling(self, path: str | None = None) -> tuple[float, float]:
+        """Get the scaling factor from a dataset to its lower resolution."""
+        if self.levels == 1:
+            return 1.0, 1.0
+        dataset, lr_dataset = self._get_closest_datasets(path=path)
+
+        if lr_dataset is None:
+            raise NgioValueError(
+                "No lower resolution dataset found. "
+                "This is the lowest resolution dataset."
+            )
 
-    def get_lowest_resolution_dataset(self) -> Dataset:
-        """Get the dataset with the lowest resolution."""
-        return self._get_dataset_by_pixel_size(
-            pixel_size=PixelSize(
-                x=1000.0,
-                y=1000.0,
-                z=1000.0,
-                t=1000.0,
-                space_unit=SpaceUnits.micrometer,
-                time_unit=TimeUnits.s,
-            ),
-            strict=False,
-        )
+        s_d = dataset.get_scale("y")
+        s_lr_d = lr_dataset.get_scale("y")
+        scale_y = s_lr_d / s_d
 
-    def get_scaling_factor(self, axis_name: str) -> float:
-        """Get the scaling factors of the dataset."""
-        scaling_factors = []
-        for d1, d2 in zip(self.datasets[1:], self.datasets[:-1], strict=True):
-            scale_d1 = d1.get_scale(axis_name)
-            scale_d2 = d2.get_scale(axis_name)
-            scaling_factors.append(scale_d1 / scale_d2)
+        s_d = dataset.get_scale("x")
+        s_lr_d = lr_dataset.get_scale("x")
+        scale_x = s_lr_d / s_d
 
-        if not np.allclose(scaling_factors, scaling_factors[0]):
-            raise NgioValidationError(
-                f"Inconsistent scaling factors are not supported. {scaling_factors}"
-            )
-        return scaling_factors[0]
+        return scale_y, scale_x
 
-    @property
-    def xy_scaling_factor(self) -> float:
-        """Get the xy scaling factor of the dataset."""
-        x_scaling_factors = self.get_scaling_factor("x")
-        y_scaling_factors = self.get_scaling_factor("y")
-        if not np.isclose(x_scaling_factors, y_scaling_factors):
-            raise NgioValidationError(
-                "Inconsistent scaling factors are not supported. "
-                f"{x_scaling_factors}, {y_scaling_factors}"
-            )
-        return x_scaling_factors
+    def z_scaling(self, path: str | None = None) -> float:
+        """Get the scaling factor from a dataset to its lower resolution."""
+        if self.levels == 1:
+            return 1.0
+        dataset, lr_dataset = self._get_closest_datasets(path=path)
 
-    @property
-    def z_scaling_factor(self) -> float:
-        """Get the z scaling factor of the dataset."""
-        return self.get_scaling_factor("z")
+        s_d = dataset.get_scale("z")
+        s_lr_d = lr_dataset.get_scale("z")
+        return s_lr_d / s_d
 
 
 class NgioLabelMeta(AbstractNgioImageMeta):
@@ -294,7 +344,7 @@ class NgioLabelMeta(AbstractNgioImageMeta):
         super().__init__(version, name, datasets)
 
         # Make sure that there are no channel axes
-        channel_axis = self.datasets[0].axes_mapper.get_axis("c")
+        channel_axis = self.axes_mapper.get_axis("c")
         if channel_axis is not None:
             raise NgioValidationError("Label metadata must not have channel axes.")
 

ngio/ome_zarr_meta/ngio_specs/_pixel_size.py

@@ -1,5 +1,8 @@
 """Fractal internal module for dataset metadata handling."""
 
+import math
+from functools import total_ordering
+
 import numpy as np
 
 from ngio.ome_zarr_meta.ngio_specs import SpaceUnits, TimeUnits
@@ -20,6 +23,7 @@ def _validate_type(value: float, name: str) -> float:
     return float(value)
 
 
+@total_ordering
 class PixelSize:
     """PixelSize class to store the pixel size in 3D space."""
 
@@ -28,7 +32,7 @@ class PixelSize:
         x: float,
         y: float,
         z: float,
-        t: float = 0,
+        t: float = 1,
         space_unit: SpaceUnits = SpaceUnits.micrometer,
         time_unit: TimeUnits | None = TimeUnits.s,
     ):
@@ -50,10 +54,38 @@ class PixelSize:
         """Return a string representation of the pixel size."""
         return f"PixelSize(x={self.x}, y={self.y}, z={self.z}, t={self.t})"
 
+    def __eq__(self, other) -> bool:
+        """Check if two pixel sizes are equal."""
+        if not isinstance(other, PixelSize):
+            raise TypeError("Can only compare PixelSize with PixelSize.")
+
+        if (
+            self.time_unit is not None
+            and other.time_unit is None
+            and self.time_unit != other.time_unit
+        ):
+            return False
+
+        if self.space_unit != other.space_unit:
+            return False
+        return math.isclose(self.distance(other), 0)
+
+    def __lt__(self, other: "PixelSize") -> bool:
+        """Check if one pixel size is less than the other."""
+        if not isinstance(other, PixelSize):
+            raise TypeError("Can only compare PixelSize with PixelSize.")
+        ref = PixelSize(0, 0, 0, 0, self.space_unit, self.time_unit)
+        return self.distance(ref) < other.distance(ref)
+
     def as_dict(self) -> dict:
         """Return the pixel size as a dictionary."""
         return {"t": self.t, "z": self.z, "y": self.y, "x": self.x}
 
+    @property
+    def tzyx(self) -> tuple[float, float, float, float]:
+        """Return the voxel size in t, z, y, x order."""
+        return self.t, self.z, self.y, self.x
+
     @property
     def zyx(self) -> tuple[float, float, float]:
         """Return the voxel size in z, y, x order."""
@@ -80,5 +112,5 @@ class PixelSize:
         return self.t
 
     def distance(self, other: "PixelSize") -> float:
-        """Return the distance between two pixel sizes in 3D space."""
-        return float(np.linalg.norm(np.array(self.zyx) - np.array(other.zyx)))
+        """Return the distance between two pixel sizes."""
+        return float(np.linalg.norm(np.array(self.tzyx) - np.array(other.tzyx)))

ngio/ome_zarr_meta/v04/__init__.py

@@ -1,11 +1,23 @@
 """Utility to read/write OME-Zarr metadata v0.4."""
 
-from ngio.ome_zarr_meta.v04._meta_handlers import (
-    V04ImageMetaHandler,
-    V04LabelMetaHandler,
+from ngio.ome_zarr_meta.v04._v04_spec_utils import (
+    ngio_to_v04_image_meta,
+    ngio_to_v04_label_meta,
+    ngio_to_v04_plate_meta,
+    ngio_to_v04_well_meta,
+    v04_to_ngio_image_meta,
+    v04_to_ngio_label_meta,
+    v04_to_ngio_plate_meta,
+    v04_to_ngio_well_meta,
 )
 
 __all__ = [
-    "V04ImageMetaHandler",
-    "V04LabelMetaHandler",
+    "ngio_to_v04_image_meta",
+    "ngio_to_v04_label_meta",
+    "ngio_to_v04_plate_meta",
+    "ngio_to_v04_well_meta",
+    "v04_to_ngio_image_meta",
+    "v04_to_ngio_label_meta",
+    "v04_to_ngio_plate_meta",
+    "v04_to_ngio_well_meta",
 ]

ngio/ome_zarr_meta/v04/_v04_spec_utils.py

@@ -15,6 +15,7 @@ from ome_zarr_models.v04.coordinate_transformations import VectorScale as Vector
 from ome_zarr_models.v04.coordinate_transformations import (
     VectorTranslation as VectorTranslationV04,
 )
+from ome_zarr_models.v04.hcs import HCSAttrs as HCSAttrsV04
 from ome_zarr_models.v04.image import ImageAttrs as ImageAttrsV04
 from ome_zarr_models.v04.image_label import ImageLabelAttrs as LabelAttrsV04
 from ome_zarr_models.v04.multiscales import Dataset as DatasetV04
@@ -22,6 +23,7 @@ from ome_zarr_models.v04.multiscales import Multiscale as MultiscaleV04
 from ome_zarr_models.v04.omero import Channel as ChannelV04
 from ome_zarr_models.v04.omero import Omero as OmeroV04
 from ome_zarr_models.v04.omero import Window as WindowV04
+from ome_zarr_models.v04.well import WellAttrs as WellAttrsV04
 from pydantic import ValidationError
 
 from ngio.ome_zarr_meta.ngio_specs import (
@@ -35,6 +37,8 @@ from ngio.ome_zarr_meta.ngio_specs import (
     ImageLabelSource,
     NgioImageMeta,
     NgioLabelMeta,
+    NgioPlateMeta,
+    NgioWellMeta,
     default_channel_name,
 )
 from ngio.ome_zarr_meta.ngio_specs._ngio_image import NgffVersion
@@ -301,10 +305,11 @@ def v04_to_ngio_label_meta(
     )
 
 
-def _ngio_to_v04_multiscale(datasets: list[Dataset]) -> MultiscaleV04:
+def _ngio_to_v04_multiscale(name: str | None, datasets: list[Dataset]) -> MultiscaleV04:
     """Convert a ngio multiscale to a v04 multiscale.
 
     Args:
+        name (str | None): The name of the multiscale.
         datasets (list[Dataset]): The ngio datasets.
 
     Returns:
@@ -340,9 +345,7 @@ def _ngio_to_v04_multiscale(datasets: list[Dataset]) -> MultiscaleV04:
             DatasetV04(path=dataset.path, coordinateTransformations=transform)
         )
     return MultiscaleV04(
-        axes=v04_axes,
-        datasets=tuple(v04_datasets),
-        version="0.4",
+        axes=v04_axes, datasets=tuple(v04_datasets), version="0.4", name=name
     )
 
 
@@ -387,11 +390,13 @@ def ngio_to_v04_image_meta(metadata: NgioImageMeta) -> dict:
     Returns:
         dict: The v04 image metadata.
     """
-    v04_muliscale = _ngio_to_v04_multiscale(metadata.datasets)
+    v04_muliscale = _ngio_to_v04_multiscale(
+        name=metadata.name, datasets=metadata.datasets
+    )
     v04_omero = _ngio_to_v04_omero(metadata._channels_meta)
 
     v04_image = ImageAttrsV04(multiscales=[v04_muliscale], omero=v04_omero)
-    return v04_image.model_dump(exclude_none=True)
+    return v04_image.model_dump(exclude_none=True, by_alias=True)
 
 
 def ngio_to_v04_label_meta(metadata: NgioLabelMeta) -> dict:
@@ -403,10 +408,78 @@ def ngio_to_v04_label_meta(metadata: NgioLabelMeta) -> dict:
     Returns:
         dict: The v04 image metadata.
     """
-    v04_muliscale = _ngio_to_v04_multiscale(metadata.datasets)
-    v04_label = LabelAttrsV04(
-        multiscales=[v04_muliscale],
-        # image_label is aliased as 'imae-label'
-        image_label=metadata.image_label.model_dump(),  # type: ignore
+    v04_muliscale = _ngio_to_v04_multiscale(
+        name=metadata.name, datasets=metadata.datasets
     )
-    return v04_label.model_dump(exclude_none=True)
+    labels_meta = {
+        "multiscales": [v04_muliscale],
+        "image-label": metadata.image_label.model_dump(),
+    }
+    v04_label = LabelAttrsV04(**labels_meta)
+    return v04_label.model_dump(exclude_none=True, by_alias=True)
+
+
+def v04_to_ngio_well_meta(
+    metadata: dict,
+) -> tuple[bool, NgioWellMeta | ValidationError]:
+    """Convert a v04 well metadata to a ngio well metadata.
+
+    Args:
+        metadata (dict): The v04 well metadata.
+
+    Returns:
+        result (bool): True if the conversion was successful, False otherwise.
+        ngio_well_meta (NgioWellMeta): The ngio well metadata.
+    """
+    try:
+        v04_well = WellAttrsV04(**metadata)
+    except ValidationError as e:
+        return False, e
+
+    return True, NgioWellMeta(**v04_well.model_dump())
+
+
+def v04_to_ngio_plate_meta(
+    metadata: dict,
+) -> tuple[bool, NgioPlateMeta | ValidationError]:
+    """Convert a v04 plate metadata to a ngio plate metadata.
+
+    Args:
+        metadata (dict): The v04 plate metadata.
+
+    Returns:
+        result (bool): True if the conversion was successful, False otherwise.
+        ngio_plate_meta (NgioPlateMeta): The ngio plate metadata.
+    """
+    try:
+        v04_plate = HCSAttrsV04(**metadata)
+    except ValidationError as e:
+        return False, e
+
+    return True, NgioPlateMeta(**v04_plate.model_dump())
+
+
+def ngio_to_v04_well_meta(metadata: NgioWellMeta) -> dict:
+    """Convert a ngio well metadata to a v04 well metadata.
+
+    Args:
+        metadata (NgioWellMeta): The ngio well metadata.
+
+    Returns:
+        dict: The v04 well metadata.
+    """
+    v04_well = WellAttrsV04(**metadata.model_dump())
+    return v04_well.model_dump(exclude_none=True, by_alias=True)
+
+
+def ngio_to_v04_plate_meta(metadata: NgioPlateMeta) -> dict:
+    """Convert a ngio plate metadata to a v04 plate metadata.
+
+    Args:
+        metadata (NgioPlateMeta): The ngio plate metadata.
+
+    Returns:
+        dict: The v04 plate metadata.
+    """
+    v04_plate = HCSAttrsV04(**metadata.model_dump())
+    return v04_plate.model_dump(exclude_none=True, by_alias=True)

ngio/tables/__init__.py

@@ -3,6 +3,7 @@
 from ngio.tables.backends import ImplementedTableBackends
 from ngio.tables.tables_container import (
     FeatureTable,
+    GenericRoiTable,
     MaskingROITable,
     RoiTable,
     Table,
@@ -15,6 +16,7 @@ from ngio.tables.v1._generic_table import GenericTable
 
 __all__ = [
     "FeatureTable",
+    "GenericRoiTable",
     "GenericTable",
     "ImplementedTableBackends",
     "MaskingROITable",

ngio/tables/_validators.py

@@ -4,9 +4,7 @@ from typing import Protocol
 import pandas as pd
 import pandas.api.types as ptypes
 
-from ngio.utils import (
-    NgioTableValidationError,
-)
+from ngio.utils import NgioTableValidationError, NgioValueError
 
 
 class TableValidator(Protocol):
@@ -134,7 +132,7 @@ def validate_index_dtype(dataframe: pd.DataFrame, index_type: str) -> pd.DataFra
                     f"Table index must be of integer type, got {dataframe.index.dtype}"
                 )
         case _:
-            raise ValueError(f"index_type {index_type} not recognized")
+            raise NgioValueError(f"index_type {index_type} not recognized")
 
     return dataframe
 

ngio/tables/backends/_anndata_utils.py

@@ -17,6 +17,7 @@ from anndata.experimental import read_dispatched
 from ngio.tables._validators import validate_index_dtype, validate_index_key
 from ngio.utils import (
     NgioTableValidationError,
+    NgioValueError,
     StoreOrGroup,
     open_group_wrapper,
 )
@@ -90,7 +91,7 @@ def custom_read_zarr(
         _clean_uns(adata)
 
     if not isinstance(adata, AnnData):
-        raise ValueError(f"Expected an AnnData object, but got {type(adata)}")
+        raise NgioValueError(f"Expected an AnnData object, but got {type(adata)}")
     return adata
 
 

ngio/tables/backends/_anndata_v1.py

@@ -10,6 +10,7 @@ from ngio.tables.backends._anndata_utils import (
     custom_read_zarr,
     dataframe_to_anndata,
 )
+from ngio.utils import NgioValueError
 
 
 class AnnDataBackend(AbstractTableBackend):
@@ -65,7 +66,7 @@ class AnnDataBackend(AbstractTableBackend):
         """Consolidate the metadata in the store."""
         store = self._group_handler.store
         if not isinstance(store, str | Path):
-            raise ValueError(
+            raise NgioValueError(
                 "To write an AnnData object the store must be a local path/str."
             )