ngio 0.3.0a0__py3-none-any.whl → 0.3.1__py3-none-any.whl

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}."
             )

ngio/ome_zarr_meta/ngio_specs/_channels.py

@@ -329,33 +329,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: Collection[str | None] | int,
+        wavelength_id: Collection[str | None] | None = None,
+        colors: Collection[str | NgioColors | None] | None = None,
+        start: Collection[int | float | None] | int | float | None = None,
+        end: Collection[int | float | None] | int | float | None = None,
+        active: Collection[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(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] | 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] | None): The list of
+                colors for the channels. If None, the colors will be random.
+            start(Collection[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(Collection[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 (Collection[bool | None] | None): Whether the channel should
                 be shown by default.
             omero_kwargs(dict): Extra fields to store in the omero attributes.
         """
@@ -366,25 +368,35 @@ class ChannelsMeta(BaseModel):
         labels = _check_unique(labels)
 
         _wavelength_id: Collection[str | None] = [None] * len(labels)
-        if isinstance(wavelength_id, Collection):
+        if wavelength_id is None:
+            _wavelength_id: Collection[str | None] = [None] * len(labels)
+        else:
             _wavelength_id = _check_elements(wavelength_id, str)
             _wavelength_id = _check_unique(wavelength_id)
 
-        _colors: Collection[str | NgioColors | None] = [None] * 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),

ngio/tables/__init__.py

@@ -1,7 +1,6 @@
 """Ngio Tables implementations."""
 
-from ngio.tables.backends import ImplementedTableBackends, TableBackendProtocol
-from ngio.tables.tables_container import (
+from ngio.tables._tables_container import (
     ConditionTable,
     FeatureTable,
     GenericRoiTable,
@@ -15,6 +14,11 @@ from ngio.tables.tables_container import (
     open_table_as,
     open_tables_container,
 )
+from ngio.tables.backends import (
+    ImplementedTableBackends,
+    TableBackend,
+    TableBackendProtocol,
+)
 from ngio.tables.v1._generic_table import GenericTable
 
 __all__ = [
@@ -26,6 +30,7 @@ __all__ = [
     "MaskingRoiTable",
     "RoiTable",
     "Table",
+    "TableBackend",
     "TableBackendProtocol",
     "TableType",
     "TablesContainer",

ngio/tables/{abstract_table.py → _abstract_table.py}

@@ -11,6 +11,7 @@ from anndata import AnnData
 from ngio.tables.backends import (
     BackendMeta,
     ImplementedTableBackends,
+    TableBackend,
     TableBackendProtocol,
     TabularData,
     convert_to_anndata,
@@ -146,7 +147,7 @@ class AbstractBaseTable(ABC):
     def _load_backend(
         meta: BackendMeta,
         handler: ZarrGroupHandler,
-        backend: str | TableBackendProtocol,
+        backend: TableBackend,
     ) -> TableBackendProtocol:
         """Create a new ROI table from a Zarr group handler."""
         if isinstance(backend, str):
@@ -202,7 +203,7 @@ class AbstractBaseTable(ABC):
     def set_backend(
         self,
         handler: ZarrGroupHandler | None = None,
-        backend: str | TableBackendProtocol = "anndata_v1",
+        backend: TableBackend = "anndata",
     ) -> None:
         """Set the backend of the table."""
         if handler is None:
@@ -226,7 +227,7 @@ class AbstractBaseTable(ABC):
         cls,
         handler: ZarrGroupHandler,
         meta_model: builtins.type[BackendMeta],
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
     ) -> Self:
         """Create a new ROI table from a Zarr group handler."""
         meta = meta_model(**handler.load_attrs())
@@ -241,7 +242,7 @@ class AbstractBaseTable(ABC):
     def from_handler(
         cls,
         handler: ZarrGroupHandler,
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
     ) -> Self:
         """Create a new ROI table from a Zarr group handler."""
         pass

ngio/tables/{tables_container.py → _tables_container.py}

@@ -8,7 +8,7 @@ import polars as pl
 
 from ngio.tables.backends import (
     BackendMeta,
-    TableBackendProtocol,
+    TableBackend,
     TabularData,
 )
 from ngio.tables.v1 import (
@@ -90,7 +90,7 @@ class Table(Protocol):
     def set_backend(
         self,
         handler: ZarrGroupHandler | None = None,
-        backend: str | TableBackendProtocol = "anndata_v1",
+        backend: TableBackend = "anndata",
     ) -> None:
         """Set the backend store and path for the table.
 
@@ -105,7 +105,7 @@ class Table(Protocol):
     def from_handler(
         cls,
         handler: ZarrGroupHandler,
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
     ) -> "Table":
         """Create a new table from a Zarr group handler."""
         ...
@@ -126,25 +126,30 @@ class Table(Protocol):
 
 
 TypedTable = Literal[
+    "generic_table",
     "roi_table",
     "masking_roi_table",
     "feature_table",
-    "generic_roi_table",
     "condition_table",
 ]
 
+TypedRoiTable = Literal[
+    "roi_table",
+    "masking_roi_table",
+]
+
 TableType = TypeVar("TableType", bound=Table)
 
 
 class TableMeta(BackendMeta):
     """Base class for table metadata."""
 
-    fractal_table_version: str = "1"
+    table_version: str = "1"
     type: str = "generic_table"
 
     def unique_name(self) -> str:
         """Return the unique name for the table."""
-        return f"{self.type}_v{self.fractal_table_version}"
+        return f"{self.type}_v{self.table_version}"
 
 
 def _get_meta(handler: ZarrGroupHandler) -> TableMeta:
@@ -175,7 +180,7 @@ class ImplementedTables:
         self,
         meta: TableMeta,
         handler: ZarrGroupHandler,
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
         strict: bool = True,
     ) -> Table:
         """Try to get a handler for the given store based on the metadata version."""
@@ -192,19 +197,34 @@ class ImplementedTables:
         table = table_cls.from_handler(handler=handler, backend=backend)
         return table
 
-    def add_implementation(self, handler: type[Table], overwrite: bool = False):
+    def _add_implementation(
+        self, handler: type[Table], name: str, overwrite: bool = False
+    ) -> None:
+        """Register a new table handler."""
+        if name in self._implemented_tables and not overwrite:
+            raise NgioValueError(
+                f"Table handler for {name} already implemented. "
+                "Use overwrite=True to replace it."
+            )
+        self._implemented_tables[name] = handler
+
+    def add_implementation(
+        self,
+        handler: type[Table],
+        overwrite: bool = False,
+        aliases: list[str] | None = None,
+    ) -> None:
         """Register a new table handler."""
         meta = TableMeta(
             type=handler.table_type(),
-            fractal_table_version=handler.version(),
+            table_version=handler.version(),
         )
 
-        if meta.unique_name() in self._implemented_tables and not overwrite:
-            raise NgioValueError(
-                f"Table handler for {meta.unique_name()} already implemented. "
-                "Use overwrite=True to replace it."
-            )
-        self._implemented_tables[meta.unique_name()] = handler
+        self._add_implementation(handler, meta.unique_name(), overwrite)
+
+        if aliases is not None:
+            for alias in aliases:
+                self._add_implementation(handler, alias, overwrite)
 
 
 class TablesContainer:
@@ -240,14 +260,7 @@ class TablesContainer:
         handler = self._group_handler.derive_handler(path=name)
         return handler
 
-    def list_roi_tables(self) -> list[str]:
-        """List all ROI tables in the group."""
-        _tables = []
-        for _type in ["roi_table", "masking_roi_table"]:
-            _tables.extend(self.list(_type))
-        return _tables
-
-    def list(self, filter_types: str | None = None) -> list[str]:
+    def list(self, filter_types: TypedTable | str | None = None) -> list[str]:
         """List all labels in the group."""
         tables = self._get_tables_list()
         if filter_types is None:
@@ -264,7 +277,7 @@ class TablesContainer:
     def get(
         self,
         name: str,
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
         strict: bool = True,
     ) -> Table:
         """Get a label from the group."""
@@ -285,7 +298,7 @@ class TablesContainer:
         self,
         name: str,
         table_cls: type[TableType],
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
     ) -> TableType:
         """Get a table from the group as a specific type."""
         if name not in self.list():
@@ -301,7 +314,7 @@ class TablesContainer:
         self,
         name: str,
         table: Table,
-        backend: str | TableBackendProtocol = "anndata_v1",
+        backend: TableBackend = "anndata",
         overwrite: bool = False,
     ) -> None:
         """Add a table to the group."""
@@ -357,7 +370,7 @@ def open_tables_container(
 
 def open_table(
     store: StoreOrGroup,
-    backend: str | TableBackendProtocol | None = None,
+    backend: TableBackend | None = None,
     cache: bool = False,
     mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,
@@ -375,7 +388,7 @@ def open_table(
 def open_table_as(
     store: StoreOrGroup,
     table_cls: type[TableType],
-    backend: str | TableBackendProtocol = "anndata_v1",
+    backend: TableBackend | None = None,
     cache: bool = False,
     mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,
@@ -393,7 +406,7 @@ def open_table_as(
 def write_table(
     store: StoreOrGroup,
     table: Table,
-    backend: str | TableBackendProtocol = "anndata_v1",
+    backend: TableBackend = "anndata",
     cache: bool = False,
     mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,

ngio/tables/backends/__init__.py

@@ -1,12 +1,13 @@
 """Ngio Tables backend implementations."""
 
 from ngio.tables.backends._abstract_backend import AbstractTableBackend, BackendMeta
-from ngio.tables.backends._anndata_v1 import AnnDataBackend
-from ngio.tables.backends._csv_v1 import CsvTableBackend
-from ngio.tables.backends._json_v1 import JsonTableBackend
-from ngio.tables.backends._parquet_v1 import ParquetTableBackend
+from ngio.tables.backends._anndata import AnnDataBackend
+from ngio.tables.backends._csv import CsvTableBackend
+from ngio.tables.backends._json import JsonTableBackend
+from ngio.tables.backends._parquet import ParquetTableBackend
 from ngio.tables.backends._table_backends import (
     ImplementedTableBackends,
+    TableBackend,
     TableBackendProtocol,
 )
 from ngio.tables.backends._utils import (
@@ -34,6 +35,7 @@ __all__ = [
     "ImplementedTableBackends",
     "JsonTableBackend",
     "ParquetTableBackend",
+    "TableBackend",
     "TableBackendProtocol",
     "TabularData",
     "convert_anndata_to_pandas",

ngio/tables/backends/_abstract_backend.py

@@ -19,7 +19,7 @@ from ngio.utils import NgioValueError, ZarrGroupHandler
 class BackendMeta(BaseModel):
     """Metadata for the backend."""
 
-    backend: str = "anndata_v1"
+    backend: str = "anndata"
     index_key: str | None = None
     index_type: Literal["int", "str"] | None = None
 

ngio/tables/backends/{_anndata_v1.py → _anndata.py}

@@ -21,7 +21,7 @@ class AnnDataBackend(AbstractTableBackend):
     @staticmethod
     def backend_name() -> str:
         """Return the name of the backend."""
-        return "anndata_v1"
+        return "anndata"
 
     @staticmethod
     def implements_anndata() -> bool:

ngio/tables/backends/{_csv_v1.py → _csv.py}

@@ -1,7 +1,7 @@
 import pandas as pd
 import polars as pl
 
-from ngio.tables.backends._non_zarr_backends_v1 import NonZarrBaseBackend
+from ngio.tables.backends._non_zarr_backends import NonZarrBaseBackend
 
 
 def write_lf_to_csv(path: str, table: pl.DataFrame) -> None:
@@ -32,4 +32,4 @@ class CsvTableBackend(NonZarrBaseBackend):
     @staticmethod
     def backend_name() -> str:
         """Return the name of the backend."""
-        return "experimental_csv_v1"
+        return "csv"

ngio/tables/backends/{_json_v1.py → _json.py}

@@ -17,7 +17,7 @@ class JsonTableBackend(AbstractTableBackend):
     @staticmethod
     def backend_name() -> str:
         """Return the name of the backend."""
-        return "experimental_json_v1"
+        return "json"
 
     @staticmethod
     def implements_anndata() -> bool:

ngio/tables/backends/{_parquet_v1.py → _parquet.py}

@@ -1,7 +1,7 @@
 import pandas as pd
 import polars as pl
 
-from ngio.tables.backends._non_zarr_backends_v1 import NonZarrBaseBackend
+from ngio.tables.backends._non_zarr_backends import NonZarrBaseBackend
 
 
 def write_lf_to_parquet(path: str, table: pl.DataFrame) -> None:
@@ -44,4 +44,4 @@ class ParquetTableBackend(NonZarrBaseBackend):
     @staticmethod
     def backend_name() -> str:
         """Return the name of the backend."""
-        return "experimental_parquet_v1"
+        return "parquet"

ngio/tables/backends/_table_backends.py

@@ -7,10 +7,10 @@ from pandas import DataFrame
 from polars import DataFrame as PolarsDataFrame
 from polars import LazyFrame
 
-from ngio.tables.backends._anndata_v1 import AnnDataBackend
-from ngio.tables.backends._csv_v1 import CsvTableBackend
-from ngio.tables.backends._json_v1 import JsonTableBackend
-from ngio.tables.backends._parquet_v1 import ParquetTableBackend
+from ngio.tables.backends._anndata import AnnDataBackend
+from ngio.tables.backends._csv import CsvTableBackend
+from ngio.tables.backends._json import JsonTableBackend
+from ngio.tables.backends._parquet import ParquetTableBackend
 from ngio.tables.backends._utils import TabularData
 from ngio.utils import NgioValueError, ZarrGroupHandler
 
@@ -167,7 +167,7 @@ class ImplementedTableBackends:
         self,
         *,
         group_handler: ZarrGroupHandler,
-        backend_name: str = "anndata_v1",
+        backend_name: str = "anndata",
         index_key: str | None = None,
         index_type: Literal["int", "str"] | None = None,
     ) -> TableBackendProtocol:
@@ -180,22 +180,46 @@ class ImplementedTableBackends:
         )
         return backend
 
-    def add_backend(
+    def _add_backend(
         self,
-        table_beckend: type[TableBackendProtocol],
+        table_backend: type[TableBackendProtocol],
+        name: str,
         overwrite: bool = False,
-    ):
+    ) -> None:
         """Register a new handler."""
-        backend_name = table_beckend.backend_name()
-        if backend_name in self._implemented_backends and not overwrite:
+        if name in self._implemented_backends and not overwrite:
             raise NgioValueError(
-                f"Table backend {backend_name} already implemented. "
+                f"Table backend {name} already implemented. "
                 "Use the `overwrite=True` parameter to overwrite it."
             )
-        self._implemented_backends[backend_name] = table_beckend
-
+        self._implemented_backends[name] = table_backend
 
-ImplementedTableBackends().add_backend(AnnDataBackend)
-ImplementedTableBackends().add_backend(JsonTableBackend)
-ImplementedTableBackends().add_backend(CsvTableBackend)
-ImplementedTableBackends().add_backend(ParquetTableBackend)
+    def add_backend(
+        self,
+        table_backend: type[TableBackendProtocol],
+        overwrite: bool = False,
+        aliases: list[str] | None = None,
+    ) -> None:
+        """Register a new handler."""
+        self._add_backend(
+            table_backend=table_backend,
+            name=table_backend.backend_name(),
+            overwrite=overwrite,
+        )
+        if aliases is not None:
+            for alias in aliases:
+                self._add_backend(
+                    table_backend=table_backend, name=alias, overwrite=overwrite
+                )
+
+
+ImplementedTableBackends().add_backend(AnnDataBackend, aliases=["anndata_v1"])
+ImplementedTableBackends().add_backend(
+    JsonTableBackend, aliases=["experimental_json_v1"]
+)
+ImplementedTableBackends().add_backend(CsvTableBackend, aliases=["experimental_csv_v1"])
+ImplementedTableBackends().add_backend(
+    ParquetTableBackend, aliases=["experimental_parquet_v1"]
+)
+
+TableBackend = Literal["anndata", "json", "csv", "parquet"] | str | TableBackendProtocol

ngio/tables/v1/__init__.py

@@ -1,14 +1,23 @@
 """Tables implementations for fractal_tables v1."""
 
-from ngio.tables.v1._condition_table import ConditionTableV1
-from ngio.tables.v1._feature_table import FeatureTableV1
+from ngio.tables.v1._condition_table import ConditionTableMeta, ConditionTableV1
+from ngio.tables.v1._feature_table import FeatureTableMeta, FeatureTableV1
 from ngio.tables.v1._generic_table import GenericTable
-from ngio.tables.v1._roi_table import MaskingRoiTableV1, RoiTableV1
+from ngio.tables.v1._roi_table import (
+    MaskingRoiTableV1,
+    MaskingRoiTableV1Meta,
+    RoiTableV1,
+    RoiTableV1Meta,
+)
 
 __all__ = [
+    "ConditionTableMeta",
     "ConditionTableV1",
+    "FeatureTableMeta",
     "FeatureTableV1",
     "GenericTable",
     "MaskingRoiTableV1",
+    "MaskingRoiTableV1Meta",
     "RoiTableV1",
+    "RoiTableV1Meta",
 ]

ngio/tables/v1/_condition_table.py

@@ -1,14 +1,18 @@
 """Implementation of a generic table class."""
 
-from ngio.tables.abstract_table import AbstractBaseTable
-from ngio.tables.backends import BackendMeta, TableBackendProtocol, TabularData
+from ngio.tables._abstract_table import AbstractBaseTable
+from ngio.tables.backends import (
+    BackendMeta,
+    TableBackend,
+    TabularData,
+)
 from ngio.utils import ZarrGroupHandler
 
 
 class ConditionTableMeta(BackendMeta):
     """Metadata for the condition table."""
 
-    fractal_table_version: str | None = "1"
+    table_version: str | None = "1"
     type: str | None = "condition_table"
 
 
@@ -58,7 +62,7 @@ class ConditionTableV1(AbstractBaseTable):
     def from_handler(
         cls,
         handler: ZarrGroupHandler,
-        backend: str | TableBackendProtocol | None = None,
+        backend: TableBackend | None = None,
     ) -> "ConditionTableV1":
         return cls._from_handler(
             handler=handler,