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

ngio/tables/v1/__init__.py

@@ -1,7 +1,14 @@
 """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._generic_table import GenericTable
 from ngio.tables.v1._roi_table import MaskingRoiTableV1, RoiTableV1
 
-__all__ = ["FeatureTableV1", "GenericTable", "MaskingRoiTableV1", "RoiTableV1"]
+__all__ = [
+    "ConditionTableV1",
+    "FeatureTableV1",
+    "GenericTable",
+    "MaskingRoiTableV1",
+    "RoiTableV1",
+]

ngio/tables/v1/_condition_table.py

@@ -0,0 +1,67 @@
+"""Implementation of a generic table class."""
+
+from ngio.tables.abstract_table import AbstractBaseTable
+from ngio.tables.backends import BackendMeta, TableBackendProtocol, TabularData
+from ngio.utils import ZarrGroupHandler
+
+
+class ConditionTableMeta(BackendMeta):
+    """Metadata for the condition table."""
+
+    fractal_table_version: str | None = "1"
+    type: str | None = "condition_table"
+
+
+class ConditionTableV1(AbstractBaseTable):
+    """Condition table class.
+
+    This class is used to load a condition table.
+    The condition table is a generic table that does not
+    have a specific definition.
+
+    It is used to store informations about the particular conditions
+    used to generate the data.
+    - How much drug was used in the experiment
+    - What treatment was used
+    - etc.
+    """
+
+    def __init__(
+        self,
+        table_data: TabularData | None = None,
+        *,
+        meta: ConditionTableMeta | None = None,
+    ) -> None:
+        """Initialize the ConditionTable."""
+        if meta is None:
+            meta = ConditionTableMeta()
+
+        super().__init__(
+            table_data=table_data,
+            meta=meta,
+        )
+
+    @staticmethod
+    def table_type() -> str:
+        """Return the type of the table."""
+        return "condition_table"
+
+    @staticmethod
+    def version() -> str:
+        """The generic table does not have a version.
+
+        Since does not follow a specific schema.
+        """
+        return "1"
+
+    @classmethod
+    def from_handler(
+        cls,
+        handler: ZarrGroupHandler,
+        backend: str | TableBackendProtocol | None = None,
+    ) -> "ConditionTableV1":
+        return cls._from_handler(
+            handler=handler,
+            backend=backend,
+            meta_model=ConditionTableMeta,
+        )

ngio/tables/v1/_feature_table.py

@@ -6,12 +6,19 @@ https://fractal-analytics-platform.github.io/fractal-tasks-core/tables/
 
 from typing import Literal
 
-import pandas as pd
 from pydantic import BaseModel
 
-from ngio.tables.backends import BackendMeta, ImplementedTableBackends
-from ngio.tables.backends._utils import normalize_pandas_df
-from ngio.utils import NgioValueError, ZarrGroupHandler
+from ngio.tables.abstract_table import AbstractBaseTable
+from ngio.tables.backends import BackendMeta, TableBackendProtocol, TabularData
+from ngio.utils import NgioValueError
+from ngio.utils._zarr_utils import ZarrGroupHandler
+
+
+class GenericTableMeta(BackendMeta):
+    """Metadata for the ROI table."""
+
+    fractal_table_version: str | None = None
+    type: str | None = None
 
 
 class RegionMeta(BaseModel):
@@ -27,38 +34,43 @@ class FeatureTableMeta(BackendMeta):
     type: Literal["feature_table"] = "feature_table"
     region: RegionMeta | None = None
     instance_key: str = "label"
+    index_key: str | None = "label"
+    index_type: Literal["int", "str"] | None = "int"
 
 
-class FeatureTableV1:
-    """Class to represent a feature table.
-
-    This can be used to load any table that does not have
-    a specific definition.
-    """
-
+class FeatureTableV1(AbstractBaseTable):
     def __init__(
         self,
-        dataframe: pd.DataFrame | None = None,
+        table_data: TabularData | None = None,
+        *,
         reference_label: str | None = None,
+        meta: FeatureTableMeta | None = None,
     ) -> None:
         """Initialize the GenericTable."""
-        if reference_label is None:
-            self._meta = FeatureTableMeta()
-        else:
+        if meta is None:
+            meta = FeatureTableMeta()
+
+        if reference_label is not None:
             path = f"../labels/{reference_label}"
-            self._meta = FeatureTableMeta(region=RegionMeta(path=path))
-
-        self._instance_key = "label"
-        if dataframe is None:
-            self._dataframe = None
-        else:
-            self._dataframe = normalize_pandas_df(
-                dataframe,
-                index_key=self._instance_key,
-                index_type="int",
-                reset_index=False,
+            meta = FeatureTableMeta(region=RegionMeta(path=path))
+
+        if table_data is not None and not isinstance(table_data, TabularData):
+            raise NgioValueError(
+                f"The table is not of type SupportedTables. Got {type(table_data)}"
             )
-        self._table_backend = None
+
+        if meta.index_key is None:
+            meta.index_key = "label"
+
+        if meta.index_type is None:
+            meta.index_type = "int"
+
+        meta.instance_key = meta.index_key
+
+        super().__init__(
+            table_data=table_data,
+            meta=meta,
+        )
 
     def __repr__(self) -> str:
         """Return a string representation of the table."""
@@ -69,8 +81,29 @@ class FeatureTableV1:
             properties += f", reference_label={self.reference_label}"
         return f"FeatureTableV1({properties})"
 
+    @classmethod
+    def from_handler(
+        cls,
+        handler: ZarrGroupHandler,
+        backend: str | TableBackendProtocol | None = None,
+    ) -> "FeatureTableV1":
+        return cls._from_handler(
+            handler=handler,
+            backend=backend,
+            meta_model=FeatureTableMeta,
+        )
+
+    @property
+    def meta(self) -> FeatureTableMeta:
+        """Return the metadata of the table."""
+        if not isinstance(self._meta, FeatureTableMeta):
+            raise NgioValueError(
+                "The metadata of the table is not of type FeatureTableMeta."
+            )
+        return self._meta
+
     @staticmethod
-    def type() -> str:
+    def table_type() -> str:
         """Return the type of the table."""
         return "feature_table"
 
@@ -82,110 +115,13 @@ class FeatureTableV1:
         """
         return "1"
 
-    @property
-    def backend_name(self) -> str | None:
-        """Return the name of the backend."""
-        if self._table_backend is None:
-            return None
-        return self._table_backend.backend_name()
-
     @property
     def reference_label(self) -> str | None:
         """Return the reference label."""
-        path = self._meta.region
+        path = self.meta.region
         if path is None:
             return None
 
         path = path.path
         path = path.split("/")[-1]
         return path
-
-    @property
-    def dataframe(self) -> pd.DataFrame:
-        """Return the table as a DataFrame."""
-        if self._dataframe is None and self._table_backend is None:
-            raise NgioValueError(
-                "The table does not have a DataFrame in memory nor a backend."
-            )
-
-        if self._dataframe is None and self._table_backend is not None:
-            self._dataframe = self._table_backend.load_as_pandas_df()
-
-        if self._dataframe is None:
-            raise NgioValueError(
-                "The table does not have a DataFrame in memory nor a backend."
-            )
-        return self._dataframe
-
-    @dataframe.setter
-    def dataframe(self, dataframe: pd.DataFrame) -> None:
-        """Set the table as a DataFrame."""
-        self._dataframe = normalize_pandas_df(
-            dataframe,
-            index_key=self._instance_key,
-            index_type="int",
-            reset_index=False,
-        )
-
-    @classmethod
-    def _from_handler(
-        cls, handler: ZarrGroupHandler, backend_name: str | None = None
-    ) -> "FeatureTableV1":
-        """Create a new ROI table from a Zarr group handler."""
-        meta = FeatureTableMeta(**handler.load_attrs())
-        instance_key = "label" if meta.instance_key is None else meta.instance_key
-        if backend_name is None:
-            backend = ImplementedTableBackends().get_backend(
-                backend_name=meta.backend,
-                group_handler=handler,
-                index_key=instance_key,
-                index_type="int",
-            )
-        else:
-            backend = ImplementedTableBackends().get_backend(
-                backend_name=backend_name,
-                group_handler=handler,
-                index_key=instance_key,
-                index_type="int",
-            )
-            meta.backend = backend_name
-
-        if not backend.implements_pandas:
-            raise NgioValueError(
-                "The backend does not implement the dataframe protocol."
-            )
-
-        table = cls()
-        table._meta = meta
-        table._table_backend = backend
-        return table
-
-    def _set_backend(
-        self,
-        handler: ZarrGroupHandler,
-        backend_name: str | None = None,
-    ) -> None:
-        """Set the backend of the table."""
-        instance_key = "label" if self._instance_key is None else self._instance_key
-        backend = ImplementedTableBackends().get_backend(
-            backend_name=backend_name,
-            group_handler=handler,
-            index_key=instance_key,
-            index_type="int",
-        )
-        self._meta.backend = backend_name
-        self._table_backend = backend
-
-    def consolidate(self) -> None:
-        """Write the current state of the table to the Zarr file."""
-        if self._table_backend is None:
-            raise NgioValueError(
-                "No backend set for the table. "
-                "Please add the table to a OME-Zarr Image before calling consolidate."
-            )
-
-        self._table_backend.write(
-            self.dataframe,
-            metadata=self._meta.model_dump(exclude_none=True),
-            mode="pandas",
-        )

ngio/tables/v1/_generic_table.py

@@ -1,69 +1,21 @@
 """Implementation of a generic table class."""
 
-import pandas as pd
-from anndata import AnnData
+from ngio.tables.abstract_table import AbstractBaseTable
+from ngio.tables.backends import BackendMeta, TableBackendProtocol
+from ngio.utils import ZarrGroupHandler
 
-from ngio.tables.backends import (
-    BackendMeta,
-    ImplementedTableBackends,
-    convert_anndata_to_pandas,
-    convert_pandas_to_anndata,
-)
-from ngio.utils import NgioValueError, ZarrGroupHandler
 
-
-class GenericTableMeta(BackendMeta):
-    """Metadata for the ROI table."""
-
-    fractal_table_version: str | None = None
-    type: str | None = None
-
-
-class GenericTable:
+class GenericTable(AbstractBaseTable):
     """Class to a non-specific table.
 
     This can be used to load any table that does not have
     a specific definition.
     """
 
-    def __init__(
-        self,
-        dataframe: pd.DataFrame | None = None,
-        anndata: AnnData | None = None,
-    ) -> None:
-        """Initialize the GenericTable."""
-        self._meta = GenericTableMeta()
-        if dataframe is None and anndata is None:
-            raise NgioValueError(
-                "Either a DataFrame or an AnnData object must be provided."
-            )
-
-        if dataframe is not None and anndata is not None:
-            raise NgioValueError(
-                "Only one of DataFrame or AnnData object can be provided."
-            )
-
-        self._dataframe = dataframe
-        self._anndata = anndata
-
-        self.anndata_native = True if anndata is not None else False
-
-        self._table_backend = None
-
-    def __repr__(self) -> str:
-        """Return a string representation of the table."""
-        if self._dataframe is not None:
-            num_rows = len(self.dataframe)
-            num_columns = len(self.dataframe.columns)
-            prop = f"num_rows={num_rows}, num_columns={num_columns}, mode=dataframe"
-        else:
-            prop = "mode=anndata"
-        return f"GenericTable({prop})"
-
     @staticmethod
-    def type() -> str:
+    def table_type() -> str:
         """Return the type of the table."""
-        return "generic"
+        return "generic_table"
 
     @staticmethod
     def version() -> str:
@@ -73,115 +25,14 @@ class GenericTable:
         """
         return "1"
 
-    @property
-    def backend_name(self) -> str | None:
-        """Return the name of the backend."""
-        if self._table_backend is None:
-            return None
-        return self._table_backend.backend_name()
-
-    @property
-    def dataframe(self) -> pd.DataFrame:
-        """Return the table as a DataFrame."""
-        if self._dataframe is not None:
-            return self._dataframe
-
-        if self._anndata is not None:
-            return convert_anndata_to_pandas(self._anndata)
-
-        raise NgioValueError("No table loaded.")
-
-    @dataframe.setter
-    def dataframe(self, dataframe: pd.DataFrame) -> None:
-        """Set the table as a DataFrame."""
-        self._dataframe = dataframe
-        self.anndata_native = False
-
-    @property
-    def anndata(self) -> AnnData:
-        """Return the table as an AnnData object."""
-        if self._anndata is not None:
-            return self._anndata
-
-        if self._dataframe is not None:
-            return convert_pandas_to_anndata(
-                self._dataframe,
-            )
-        raise NgioValueError("No table loaded.")
-
-    @anndata.setter
-    def anndata(self, anndata: AnnData) -> None:
-        """Set the table as an AnnData object."""
-        self._anndata = anndata
-        self.anndata_native = True
-
     @classmethod
-    def _from_handler(
-        cls, handler: ZarrGroupHandler, backend_name: str | None = None
-    ) -> "GenericTable":
-        """Create a new ROI table from a Zarr group handler."""
-        meta = GenericTableMeta(**handler.load_attrs())
-        if backend_name is None:
-            backend = ImplementedTableBackends().get_backend(
-                backend_name=meta.backend,
-                group_handler=handler,
-                index_key=None,
-            )
-        else:
-            backend = ImplementedTableBackends().get_backend(
-                backend_name=backend_name,
-                group_handler=handler,
-                index_key=None,
-            )
-            meta.backend = backend_name
-
-        if backend.implements_anndata():
-            anndata = backend.load_as_anndata()
-            table = cls(anndata=anndata)
-
-        elif backend.implements_pandas():
-            dataframe = backend.load_as_pandas_df()
-            table = cls(dataframe=dataframe)
-        else:
-            raise NgioValueError(
-                "The backend does not implement the dataframe protocol."
-            )
-
-        table._meta = meta
-        table._table_backend = backend
-        return table
-
-    def _set_backend(
-        self,
+    def from_handler(
+        cls,
         handler: ZarrGroupHandler,
-        backend_name: str | None = None,
-    ) -> None:
-        """Set the backend of the table."""
-        backend = ImplementedTableBackends().get_backend(
-            backend_name=backend_name,
-            group_handler=handler,
-            index_key=None,
+        backend: str | TableBackendProtocol | None = None,
+    ) -> "GenericTable":
+        return cls._from_handler(
+            handler=handler,
+            backend=backend,
+            meta_model=BackendMeta,
         )
-        self._meta.backend = backend_name
-        self._table_backend = backend
-
-    def consolidate(self) -> None:
-        """Write the current state of the table to the Zarr file."""
-        if self._table_backend is None:
-            raise NgioValueError(
-                "No backend set for the table. "
-                "Please add the table to a OME-Zarr Image before calling consolidate."
-            )
-
-        if self.anndata_native:
-            self._table_backend.write(
-                self.anndata,
-                metadata=self._meta.model_dump(exclude_none=True),
-                mode="anndata",
-            )
-        else:
-            self._table_backend.write(
-                self.dataframe,
-                metadata=self._meta.model_dump(exclude_none=True),
-                mode="pandas",
-            )