ngio 0.1.6__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

ngio/utils/__init__.py

@@ -2,29 +2,42 @@
 
 import os
 
-from ngio.utils._common_types import ArrayLike
+from ngio.common._common_types import ArrayLike
+from ngio.utils._datasets import download_ome_zarr_dataset, list_ome_zarr_datasets
 from ngio.utils._errors import (
     NgioFileExistsError,
     NgioFileNotFoundError,
-    NgioNGFFValidationError,
     NgioTableValidationError,
+    NgioValidationError,
+    NgioValueError,
 )
 from ngio.utils._logger import ngio_logger, set_logger_level
-from ngio.utils._pydantic_utils import BaseWithExtraFields, unique_items_validator
+from ngio.utils._zarr_utils import (
+    AccessModeLiteral,
+    StoreOrGroup,
+    ZarrGroupHandler,
+    open_group_wrapper,
+)
 
 set_logger_level(os.getenv("NGIO_LOGGER_LEVEL", "WARNING"))
 
 __all__ = [
+    # Zarr
+    "AccessModeLiteral",
     "ArrayLike",
-    # Pydantic
-    "BaseWithExtraFields",
-    "unique_items_validator",
-    # Logger
-    "ngio_logger",
-    "set_logger_level",
     # Errors
     "NgioFileExistsError",
     "NgioFileNotFoundError",
-    "NgioNGFFValidationError",
     "NgioTableValidationError",
+    "NgioValidationError",
+    "NgioValueError",
+    "StoreOrGroup",
+    "ZarrGroupHandler",
+    # Datasets
+    "download_ome_zarr_dataset",
+    "list_ome_zarr_datasets",
+    # Logger
+    "ngio_logger",
+    "open_group_wrapper",
+    "set_logger_level",
 ]

ngio/utils/_datasets.py

@@ -0,0 +1,51 @@
+"""Download testing OME-Zarr datasets."""
+
+from pathlib import Path
+
+import pooch
+
+_ome_zarr_zoo = {
+    "CardiomyocyteTiny": {
+        "url": "https://zenodo.org/records/13305156/files/20200812-CardiomyocyteDifferentiation14-Cycle1.zarr.zip",
+        "known_hash": "md5:efc21fe8d4ea3abab76226d8c166452c",
+        "fname": "20200812-CardiomyocyteDifferentiation14-Cycle1.zarr.zip",
+        "processor": pooch.Unzip(extract_dir=""),
+    },
+    "CardiomyocyteSmallMip": {
+        "url": "https://zenodo.org/records/13305316/files/20200812-CardiomyocyteDifferentiation14-Cycle1_mip.zarr.zip",
+        "known_hash": "md5:3ed3ea898e0ed42d397da2e1dbe40750",
+        "fname": "20200812-CardiomyocyteDifferentiation14-Cycle1_mip.zarr.zip",
+        "processor": pooch.Unzip(extract_dir=""),
+    },
+}
+
+
+def list_ome_zarr_datasets() -> list[str]:
+    """List available OME-Zarr datasets."""
+    return list(_ome_zarr_zoo.keys())
+
+
+def download_ome_zarr_dataset(
+    dataset_name: str,
+    download_dir: str = "data",
+) -> str:
+    """Download an OME-Zarr dataset.
+
+    To list available datasets, use `list_ome_zarr_datasets`.
+
+    Args:
+        dataset_name (str): The dataset name.
+        download_dir (str): The download directory. Defaults to "data".
+    """
+    if dataset_name not in _ome_zarr_zoo:
+        raise ValueError(f"Dataset {dataset_name} not found in the OME-Zarr zoo.")
+    ome_zarr_url = _ome_zarr_zoo[dataset_name]
+    pooch.retrieve(
+        path=download_dir,
+        **ome_zarr_url,
+    )
+    path = Path(download_dir) / ome_zarr_url["fname"]
+
+    if isinstance(ome_zarr_url["processor"], pooch.Unzip):
+        path = path.with_suffix("")
+    return path

ngio/utils/_errors.py

@@ -7,20 +7,20 @@ class NgioError(Exception):
     pass
 
 
-class NgioFileNotFoundError(NgioError):
+class NgioFileNotFoundError(NgioError, FileNotFoundError):
     """Error raised when a file is not found."""
 
     pass
 
 
-class NgioFileExistsError(NgioError):
+class NgioFileExistsError(NgioError, FileExistsError):
     """Error raised when a file already exists."""
 
     pass
 
 
-class NgioNGFFValidationError(NgioError):
-    """Error raised when a file does not pass validation."""
+class NgioValidationError(NgioError, ValueError):
+    """Generic error raised when a file does not pass validation."""
 
     pass
 
@@ -29,3 +29,9 @@ class NgioTableValidationError(NgioError):
     """Error raised when a table does not pass validation."""
 
     pass
+
+
+class NgioValueError(NgioError, ValueError):
+    """Error raised when a value does not pass a run time test."""
+
+    pass

ngio/utils/_zarr_utils.py

@@ -0,0 +1,378 @@
+"""Common utilities for working with Zarr groups in consistent ways."""
+
+# %%
+from pathlib import Path
+from typing import Literal
+
+import fsspec
+import zarr
+from filelock import BaseFileLock, FileLock
+from zarr.errors import ContainsGroupError, GroupNotFoundError
+from zarr.storage import DirectoryStore, FSStore, Store
+
+from ngio.utils import NgioFileExistsError, NgioFileNotFoundError, NgioValueError
+from ngio.utils._errors import NgioError
+
+AccessModeLiteral = Literal["r", "r+", "w", "w-", "a"]
+# StoreLike is more restrictive than it could be
+# but to make sure we can handle the store correctly
+# we need to be more restrictive
+NgioSupportedStore = str | Path | fsspec.mapping.FSMap | FSStore | DirectoryStore
+GenericStore = Store | NgioSupportedStore
+StoreOrGroup = GenericStore | zarr.Group
+
+
+def _check_store(store) -> NgioSupportedStore:
+    """Check the store and return a valid store."""
+    if isinstance(store, NgioSupportedStore):
+        return store
+
+    raise NotImplementedError(
+        f"Store type {type(store)} is not supported. "
+        f"Supported types are: {NgioSupportedStore}"
+    )
+
+
+def _check_group(group: zarr.Group, mode: AccessModeLiteral) -> zarr.Group:
+    """Check the group and return a valid group."""
+    is_read_only = getattr(group, "_read_only", False)
+    if is_read_only and mode in ["w", "w-"]:
+        raise NgioValueError(
+            "The group is read only. Cannot open in write mode ['w', 'w-']"
+        )
+
+    if mode == "r" and not is_read_only:
+        # let's make sure we don't accidentally write to the group
+        group = zarr.open_group(store=group.store, path=group.path, mode="r")
+
+    return group
+
+
+def open_group_wrapper(
+    store: StoreOrGroup, mode: AccessModeLiteral
+) -> tuple[zarr.Group, NgioSupportedStore]:
+    """Wrapper around zarr.open_group with some additional checks.
+
+    Args:
+        store (StoreOrGroup): The store or group to open.
+        mode (ReadOrEdirLiteral): The mode to open the group in.
+
+    Returns:
+        zarr.Group: The opened Zarr group.
+    """
+    if isinstance(store, zarr.Group):
+        group = _check_group(store, mode)
+        if hasattr(group, "store_path"):
+            _store = group.store_path
+        if isinstance(group.store, DirectoryStore):
+            _store = group.store.path
+        else:
+            _store = group.store
+
+        _store = _check_store(_store)
+        return group, _store
+
+    try:
+        store = _check_store(store)
+        group = zarr.open_group(store=store, mode=mode)
+
+    except ContainsGroupError as e:
+        raise NgioFileExistsError(
+            f"A Zarr group already exists at {store}, consider setting overwrite=True."
+        ) from e
+
+    except GroupNotFoundError as e:
+        raise NgioFileNotFoundError(f"No Zarr group found at {store}") from e
+
+    return group, store
+
+
+class ZarrGroupHandler:
+    """A simple wrapper around a Zarr group to handle metadata."""
+
+    def __init__(
+        self,
+        store: StoreOrGroup,
+        cache: bool = False,
+        mode: AccessModeLiteral = "a",
+        parallel_safe: bool = False,
+        parent: "ZarrGroupHandler | None" = None,
+    ):
+        """Initialize the handler.
+
+        Args:
+            store (StoreOrGroup): The Zarr store or group containing the image data.
+            meta_mode (str): The mode of the metadata handler.
+            cache (bool): Whether to cache the metadata.
+            mode (str): The mode of the store.
+            parallel_safe (bool): If True, the handler will create a lock file to make
+                that can be used to make the handler parallel safe.
+                Be aware that the lock needs to be used manually.
+            parent (ZarrGroupHandler | None): The parent handler.
+        """
+        if mode not in ["r", "r+", "w", "w-", "a"]:
+            raise NgioValueError(f"Mode {mode} is not supported.")
+
+        if parallel_safe and cache:
+            raise NgioValueError(
+                "The cache and parallel_safe options are mutually exclusive."
+                "If you want to use the lock mechanism, you should not use the cache."
+            )
+
+        _group, _store = open_group_wrapper(store, mode)
+
+        # Make sure the cache is set in the attrs
+        # in the same way as the cache in the handler
+        _group.attrs.cache = cache
+
+        if parallel_safe:
+            if not isinstance(_store, str | Path):
+                raise NgioValueError(
+                    "The store needs to be a path to use the lock mechanism."
+                )
+            self._lock_path = f"{_store}.lock"
+            self._lock = FileLock(self._lock_path)
+
+        else:
+            self._lock_path = None
+            self._lock = None
+
+        self._group = _group
+        self._mode = mode
+        self._store = _store
+        self.use_cache = cache
+        self._parallel_safe = parallel_safe
+        self._cache = {}
+        self._parent = parent
+
+    def __repr__(self) -> str:
+        """Return a string representation of the handler."""
+        return (
+            f"ZarrGroupHandler(full_path={self.full_path}, mode={self.mode}, "
+            f"cache={self.use_cache}"
+        )
+
+    @property
+    def store(self) -> NgioSupportedStore:
+        """Return the store of the group."""
+        return self._store
+
+    @property
+    def full_path(self) -> str:
+        """Return the store path."""
+        return f"{self._store}/{self._group.path}"
+
+    @property
+    def mode(self) -> AccessModeLiteral:
+        """Return the mode of the group."""
+        return self._mode  # type: ignore
+
+    @property
+    def lock(self) -> BaseFileLock | None:
+        """Return the lock."""
+        return self._lock
+
+    @property
+    def parent(self) -> "ZarrGroupHandler | None":
+        """Return the parent handler."""
+        return self._parent
+
+    def remove_lock(self) -> None:
+        """Return the lock."""
+        if self._lock is None or self._lock_path is None:
+            return None
+
+        lock_path = Path(self._lock_path)
+        if lock_path.exists() and self._lock.lock_counter == 0:
+            lock_path.unlink()
+            self._lock = None
+            self._lock_path = None
+            return None
+
+        raise NgioValueError("The lock is still in use. Cannot remove it.")
+
+    @property
+    def group(self) -> zarr.Group:
+        """Return the group."""
+        return self._group
+
+    def add_to_cache(self, key: str, value: object) -> None:
+        """Add an object to the cache."""
+        if not self.use_cache:
+            return None
+        self._cache[key] = value
+
+    def get_from_cache(self, key: str) -> object | None:
+        """Get an object from the cache."""
+        if not self.use_cache:
+            return None
+        return self._cache.get(key, None)
+
+    def clean_cache(self) -> None:
+        """Clear the cached metadata."""
+        self._cache = {}
+
+    def load_attrs(self) -> dict:
+        """Load the attributes of the group."""
+        attrs = self.get_from_cache("attrs")
+        if attrs is not None and isinstance(attrs, dict):
+            return attrs
+
+        attrs = dict(self.group.attrs)
+
+        self.add_to_cache("attrs", attrs)
+        return attrs
+
+    def _write_attrs(self, attrs: dict, overwrite: bool = False) -> None:
+        """Write the metadata to the store."""
+        is_read_only = getattr(self._group, "_read_only", False)
+        if is_read_only:
+            raise NgioValueError("The group is read only. Cannot write metadata.")
+
+        # we need to invalidate the current attrs cache
+        self.add_to_cache("attrs", None)
+        if overwrite:
+            self.group.attrs.clear()
+
+        self.group.attrs.update(attrs)
+
+    def write_attrs(self, attrs: dict, overwrite: bool = False) -> None:
+        """Write the metadata to the store."""
+        # Maybe we should use the lock here
+        self._write_attrs(attrs, overwrite)
+
+    def _obj_get(self, path: str):
+        """Get a group from the group."""
+        group_or_array = self.get_from_cache(path)
+        if group_or_array is not None:
+            return group_or_array
+
+        group_or_array = self.group.get(path, None)
+        self.add_to_cache(path, group_or_array)
+        return group_or_array
+
+    def create_group(self, path: str, overwrite: bool = False) -> zarr.Group:
+        """Create a group in the group."""
+        if self.mode == "r":
+            raise NgioValueError("Cannot create a group in read only mode.")
+
+        try:
+            group = self.group.create_group(path, overwrite=overwrite)
+        except ContainsGroupError as e:
+            raise NgioFileExistsError(
+                f"A Zarr group already exists at {path}, "
+                "consider setting overwrite=True."
+            ) from e
+        self.add_to_cache(path, group)
+        return group
+
+    def get_group(
+        self,
+        path: str,
+        create_mode: bool = False,
+    ) -> zarr.Group:
+        """Get a group from the group.
+
+        Args:
+            path (str): The path to the group.
+            create_mode (bool): If True, create the group if it does not exist.
+
+        Returns:
+            zarr.Group: The Zarr group.
+
+        """
+        group = self._obj_get(path)
+        if isinstance(group, zarr.Group):
+            return group
+
+        if group is not None:
+            raise NgioValueError(
+                f"The object at {path} is not a group, but a {type(group)}"
+            )
+
+        if not create_mode:
+            raise NgioFileNotFoundError(f"No group found at {path}")
+        group = self.create_group(path)
+        return group
+
+    def safe_get_group(
+        self, path: str, create_mode: bool = False
+    ) -> tuple[bool, zarr.Group | NgioError]:
+        """Get a group from the group.
+
+        Args:
+            path (str): The path to the group.
+            create_mode (bool): If True, create the group if it does not exist.
+
+        Returns:
+            zarr.Group | None: The Zarr group or None if it does not exist
+                or an error occurs.
+
+        """
+        try:
+            return True, self.get_group(path, create_mode)
+        except NgioError as e:
+            return False, e
+
+    def get_array(self, path: str) -> zarr.Array:
+        """Get an array from the group."""
+        array = self._obj_get(path)
+        if array is None:
+            raise NgioFileNotFoundError(f"No array found at {path}")
+        if not isinstance(array, zarr.Array):
+            raise NgioValueError(
+                f"The object at {path} is not an array, but a {type(array)}"
+            )
+        return array
+
+    def create_array(
+        self,
+        path: str,
+        shape: tuple[int, ...],
+        dtype: str,
+        chunks: tuple[int, ...] | None = None,
+        overwrite: bool = False,
+    ) -> zarr.Array:
+        if self.mode == "r":
+            raise NgioValueError("Cannot create an array in read only mode.")
+
+        try:
+            return self.group.zeros(
+                name=path,
+                shape=shape,
+                dtype=dtype,
+                chunks=chunks,
+                dimension_separator="/",
+                overwrite=overwrite,
+            )
+        except ContainsGroupError as e:
+            raise NgioFileExistsError(
+                f"A Zarr array already exists at {path}, "
+                "consider setting overwrite=True."
+            ) from e
+        except Exception as e:
+            raise NgioValueError(f"Error creating array at {path}") from e
+
+    def derive_handler(
+        self,
+        path: str,
+    ) -> "ZarrGroupHandler":
+        """Derive a new handler from the current handler."""
+        group = self.get_group(path, create_mode=True)
+        return ZarrGroupHandler(
+            store=group,
+            cache=self.use_cache,
+            mode=self.mode,
+            parallel_safe=self._parallel_safe,
+            parent=self,
+        )
+
+    def safe_derive_handler(
+        self,
+        path: str,
+    ) -> tuple[bool, "ZarrGroupHandler | NgioError"]:
+        """Derive a new handler from the current handler."""
+        try:
+            return True, self.derive_handler(path)
+        except NgioError as e:
+            return False, e

{ngio-0.1.6.dist-info → ngio-0.2.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngio
-Version: 0.1.6
+Version: 0.2.0a1
 Summary: Next Generation file format IO
 Project-URL: homepage, https://github.com/lorenzocerrone/ngio
 Project-URL: repository, https://github.com/lorenzocerrone/ngio
@@ -10,54 +10,34 @@ License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.11
 Requires-Dist: aiohttp
 Requires-Dist: anndata>=0.8.0
 Requires-Dist: dask[array]
+Requires-Dist: dask[distributed]
+Requires-Dist: filelock
 Requires-Dist: numpy
+Requires-Dist: ome-zarr-models
 Requires-Dist: pandas>=1.2.0
+Requires-Dist: pooch
 Requires-Dist: pydantic
 Requires-Dist: requests
-Provides-Extra: core
-Requires-Dist: dask-image; extra == 'core'
-Requires-Dist: dask[distributed]; extra == 'core'
-Requires-Dist: zarr<3; extra == 'core'
-Provides-Extra: dev2
-Requires-Dist: dask-image; extra == 'dev2'
-Requires-Dist: dask[distributed]; extra == 'dev2'
-Requires-Dist: ipython; extra == 'dev2'
-Requires-Dist: matplotlib; extra == 'dev2'
-Requires-Dist: mypy; extra == 'dev2'
-Requires-Dist: napari; extra == 'dev2'
-Requires-Dist: notebook; extra == 'dev2'
-Requires-Dist: pdbpp; extra == 'dev2'
-Requires-Dist: plotly; extra == 'dev2'
-Requires-Dist: pre-commit; extra == 'dev2'
-Requires-Dist: pyqt5; extra == 'dev2'
-Requires-Dist: pytest; extra == 'dev2'
-Requires-Dist: pytest-cov; extra == 'dev2'
-Requires-Dist: rich; extra == 'dev2'
-Requires-Dist: ruff; extra == 'dev2'
-Requires-Dist: scikit-image; extra == 'dev2'
-Requires-Dist: zarr<3; extra == 'dev2'
-Provides-Extra: dev3
-Requires-Dist: dask-image; extra == 'dev3'
-Requires-Dist: dask[distributed]; extra == 'dev3'
-Requires-Dist: ipython; extra == 'dev3'
-Requires-Dist: mypy; extra == 'dev3'
-Requires-Dist: notebook; extra == 'dev3'
-Requires-Dist: pdbpp; extra == 'dev3'
-Requires-Dist: pre-commit; extra == 'dev3'
-Requires-Dist: pytest; extra == 'dev3'
-Requires-Dist: pytest-cov; extra == 'dev3'
-Requires-Dist: rich; extra == 'dev3'
-Requires-Dist: ruff; extra == 'dev3'
-Requires-Dist: zarr==v3.0.0-alpha.4; extra == 'dev3'
+Requires-Dist: xarray
+Requires-Dist: zarr<3
+Provides-Extra: dev
+Requires-Dist: matplotlib; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: napari; extra == 'dev'
+Requires-Dist: notebook; extra == 'dev'
+Requires-Dist: pdbpp; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pyqt5; extra == 'dev'
+Requires-Dist: rich; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == 'docs'
 Requires-Dist: mkdocs-autorefs; extra == 'docs'
@@ -70,7 +50,6 @@ Requires-Dist: scikit-image; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
-Requires-Dist: zarr<3; extra == 'test'
 Description-Content-Type: text/markdown
 
 # NGIO - Next Generation file format IO

ngio-0.2.0a1.dist-info/RECORD

@@ -0,0 +1,53 @@
+ngio/__init__.py,sha256=8FKJLwwoat9eykBHWa-U93PkzIlkQcde-sRZvtOdDYg,991
+ngio/common/__init__.py,sha256=1vyK1i1ueu2BKKI-gaUhEyERVtHOtfKjQuPJOKDbrLA,1140
+ngio/common/_array_pipe.py,sha256=DyYjGTy2L74zBtD6S2jGPsFG4zj7KaY39TwPGWsSf8g,4877
+ngio/common/_axes_transforms.py,sha256=Dmrta3ZT1IgZAWomdUeTZVje8TBF_oU3RMKBv1r4EvM,1989
+ngio/common/_common_types.py,sha256=OkAYNSNjZkixL1MI-HPBVuXamheFBr862uJ4PvTxmhk,129
+ngio/common/_dimensions.py,sha256=t3X2wzqCl3-UeocqIpQgKRdcWYagijtKsaHTQz5bfT4,3680
+ngio/common/_pyramid.py,sha256=rFFIrOtgcDLsUvUX5WMQkQx9ce2MBqyk-hcXHXxxTqY,7203
+ngio/common/_roi.py,sha256=q7HZg2lPbnJ6flKRgK9e4nfOIgkGpDjDcdz-tE8F0Ys,2869
+ngio/common/_slicer.py,sha256=Qk7XXmd4W9T3w55LvFTjAyloyIcS9tt9NTXiDZNwOx8,3076
+ngio/common/_zoom.py,sha256=z2UjgotoDw7pvpeZVrxiGx4PXx65nk1vwQH3osTFACI,5422
+ngio/hcs/__init__.py,sha256=ugnRl22hM9dic5XRsqQr-HCyyyY1qXTqYOAOzyOZm4M,1624
+ngio/images/__init__.py,sha256=aijqG14eyqVgHtnlcKVNx37FRfT6QvKt8V6bwBpX_r8,526
+ngio/images/abstract_image.py,sha256=n4akBHWQul7vmo4OlYtKWZwpsYl8IYg82AThJrvDrxc,7113
+ngio/images/create.py,sha256=DMyiNVmj3uaJmJQqsL9ftzZNvXxeqgZ0-Pjo63WqWoM,8991
+ngio/images/image.py,sha256=23rrwR2rUN9WA_YFoPrlcsSdETQlW6dwNsOeGxu1qRo,12363
+ngio/images/label.py,sha256=fhxMC_pL_BbyE5IyS_86mMuzRWzKckSwUX8_oXHQ3Qk,2871
+ngio/images/omezarr_container.py,sha256=QEcPPX4-dgAY4oEWJAq3KhtMN5yo4R78_ulc9Zvjeis,18439
+ngio/ome_zarr_meta/__init__.py,sha256=9kYdyuCc3ouQCLDyUCB_lCVXUJ69Ls0fYwtodk3GtYI,798
+ngio/ome_zarr_meta/_generic_handlers.py,sha256=4zRm3P1CRKgUQgD5Z2C9j8VVv659DZIifrmzkQ7o31I,10987
+ngio/ome_zarr_meta/_meta_handlers.py,sha256=b6r1zX3SBBTKoQdKfEqvJaSnTOen5t1EPO3rh0I9VH4,4925
+ngio/ome_zarr_meta/ngio_specs/__init__.py,sha256=S2bNEhqrUhp2muDCCiVik3E6HrbaG91Q9mfT9EXnWNs,1370
+ngio/ome_zarr_meta/ngio_specs/_axes.py,sha256=zgAE0-2DHzJfqGqBhyjY7y_6qAgDLdV9iuWz-YsHe9Y,16682
+ngio/ome_zarr_meta/ngio_specs/_channels.py,sha256=KLQAo7eerBXa5NN3-QWSFxeAfM_bvXXaxFjFNM6OMoA,13762
+ngio/ome_zarr_meta/ngio_specs/_dataset.py,sha256=xT4GY2mdIsm6nAP8bXRj5E9-P6rS-iwzcXT_o3pZajo,4696
+ngio/ome_zarr_meta/ngio_specs/_ngio_hcs.py,sha256=Gk29MJ4Vn4TLFK4M7X_33BumCLiZWRuXtSeLX6H56s4,115
+ngio/ome_zarr_meta/ngio_specs/_ngio_image.py,sha256=FnVSupNHHsUxlQOfDXQP2fBZqL8BOX7bB_c1gHP0iWk,14703
+ngio/ome_zarr_meta/ngio_specs/_pixel_size.py,sha256=Ny4F0Wa7uVCKdDQhvFJPCQFUEtKP_DpwId8vdVxkVyQ,2777
+ngio/ome_zarr_meta/v04/__init__.py,sha256=0sb_CaJNgC1AOYeR6LDB91oUmSk6edJyQTTo3Lnh5Y4,226
+ngio/ome_zarr_meta/v04/_meta_handlers.py,sha256=aRvuq9ofzQQCB-CJehD3e2T1eKBtZwKg6r2OkpTG1Oo,1768
+ngio/ome_zarr_meta/v04/_v04_spec_utils.py,sha256=_vszk3ORSLObwW_0xbR61ptekvwgFiXsBLZ-5wgWli8,13775
+ngio/tables/__init__.py,sha256=7Mz0kzssaM4k39az__6F9L8s46RaN0Vbw1JkfkysCPU,565
+ngio/tables/_validators.py,sha256=Cg2sFb__G60RwSbNv4n9g_941R4Dzbp_LnaQBdVyaWw,6457
+ngio/tables/tables_container.py,sha256=d7PVerDkAtrhWRmv8BVVE0tbrdugPSxZEa8w9tR5KrA,9508
+ngio/tables/backends/__init__.py,sha256=NlOXmZXDA1kOCVONUyo_aqSjdMHmfqk-3xuKBLXpaUM,217
+ngio/tables/backends/_abstract_backend.py,sha256=JlaHqLjDm2uVnXFWxsHMojNeKo3leg6uauzoFMSF5O4,2256
+ngio/tables/backends/_anndata_utils.py,sha256=xqkm52XMMWC-jJ126oK7x1w7s4Y2jDjtgP8dmHSB3uU,6792
+ngio/tables/backends/_anndata_v1.py,sha256=rzr471-Ae76KFJ0vjgzbGyW2m2Gb0El7JcmnT6mwGJY,2573
+ngio/tables/backends/_json_v1.py,sha256=mT7qJY2U4vhwromZnT9foz_vVtNh_fwmsASGnLZbIac,1897
+ngio/tables/backends/_table_backends.py,sha256=XXtnZqVDbMqFkbUkHbf9IBNz4teCouLpa5fWgEgVtfg,3269
+ngio/tables/v1/__init__.py,sha256=C35WD3vSqB-AcATi7MRhGbCw5Z5VK7gGb8E8cMgL_L0,359
+ngio/tables/v1/_feature_table.py,sha256=WOkFOb0UDxwM-MPZGdv-nLIiqfiGL8etVkMett9iQic,5099
+ngio/tables/v1/_generic_table.py,sha256=KOVzbeUs8AwVvI83Os5gBZky948ucEKjxXl2CGzSQqQ,3483
+ngio/tables/v1/_masking_roi_table.py,sha256=vPlUWGQalxDJ7G4NcSmzsOFqSEIJFXbuCLD_ucBj7ew,5492
+ngio/tables/v1/_roi_table.py,sha256=UMwJEMkOAgDf-80z0qPfIiB6fsQInjzjDlR4OkBYH4o,7147
+ngio/utils/__init__.py,sha256=fhT4CUTk3obQHzjfTcZYOwjZrSuuI1uXQ8qJmyH17iY,1021
+ngio/utils/_datasets.py,sha256=o6-CGwK7tEUtlwrTOayrg08Yc_nYBuKxWCu1K3dAgm4,1668
+ngio/utils/_errors.py,sha256=pKQ12LUjQLYE1nUawemA5h7HsgznjaSvV1n2PQU33N0,759
+ngio/utils/_logger.py,sha256=zvFG-Ta3ZIJxTyY93zYoPGp2A6TTUf7mSO0zr_uFy4A,837
+ngio/utils/_zarr_utils.py,sha256=5Mo8Nfb7oww7rGVqEWUH29VvOkhD3-Despb3c1SlENM,12172
+ngio-0.2.0a1.dist-info/METADATA,sha256=7IwTK3iOC_hzeIa2Q7n7TXvROIboYJjjUMGkW9oFf5c,4804
+ngio-0.2.0a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngio-0.2.0a1.dist-info/licenses/LICENSE,sha256=UgN_a1QCeNh9rZWfz-wORQFxE3elQzLWPQaoK6N6fxQ,1502
+ngio-0.2.0a1.dist-info/RECORD,,

ngio/core/__init__.py

@@ -1,7 +0,0 @@
-"""Core classes for the ngio library."""
-
-from ngio.core.image_handler import Image
-from ngio.core.label_handler import Label
-from ngio.core.ngff_image import NgffImage
-
-__all__ = ["NgffImage", "Image", "Label"]