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

ngio/tables/v1/_feature_table.py

@@ -6,12 +6,12 @@ https://fractal-analytics-platform.github.io/fractal-tasks-core/tables/
 
 from typing import Literal
 
-import pandas as pd
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-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, TableBackend, TabularData
+from ngio.utils import NgioValueError
+from ngio.utils._zarr_utils import ZarrGroupHandler
 
 
 class RegionMeta(BaseModel):
@@ -23,42 +23,52 @@ class RegionMeta(BaseModel):
 class FeatureTableMeta(BackendMeta):
     """Metadata for the ROI table."""
 
-    fractal_table_version: Literal["1"] = "1"
+    table_version: Literal["1"] = "1"
     type: Literal["feature_table"] = "feature_table"
     region: RegionMeta | None = None
-    instance_key: str = "label"
+    instance_key: str = "label" # Legacy field, kept for compatibility
+    # Backend metadata
+    index_key: str | None = "label"
+    index_type: Literal["int", "str"] | None = "int"
+    # Columns optional types
+    categorical_columns: list[str] = Field(default_factory=list)
+    measurement_columns: list[str] = Field(default_factory=list)
+    metadata_columns: list[str] = Field(default_factory=list)
 
 
-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 +79,29 @@ class FeatureTableV1:
             properties += f", reference_label={self.reference_label}"
         return f"FeatureTableV1({properties})"
 
+    @classmethod
+    def from_handler(
+        cls,
+        handler: ZarrGroupHandler,
+        backend: TableBackend | 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 +113,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,32 @@
 """Implementation of a generic table class."""
 
-import pandas as pd
-from anndata import AnnData
-
-from ngio.tables.backends import (
-    BackendMeta,
-    ImplementedTableBackends,
-    convert_anndata_to_pandas,
-    convert_pandas_to_anndata,
-)
-from ngio.utils import NgioValueError, ZarrGroupHandler
+from ngio.tables.abstract_table import AbstractBaseTable
+from ngio.tables.backends import BackendMeta, TableBackend
+from ngio.utils import ZarrGroupHandler
 
 
 class GenericTableMeta(BackendMeta):
-    """Metadata for the ROI table."""
+    """Metadata for the generic table.
+
+    This is used to store metadata for a generic table.
+    It does not have a specific definition.
+    """
 
-    fractal_table_version: str | None = None
-    type: str | None = None
+    table_version: str | None = "1"
+    type: str | None = "generic_table"
 
 
-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 +36,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: TableBackend | 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",
-            )