ngio 0.2.0a2__py3-none-any.whl → 0.5.0b4__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._validators import validate_index_key
-from ngio.tables.backends import ImplementedTableBackends
-from ngio.utils import 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):
@@ -20,47 +20,88 @@ class RegionMeta(BaseModel):
     path: str
 
 
-class FeatureTableMeta(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"
-    backend: str | None = None
     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._reference_label = reference_label
-        self._instance_key = "label"
-        if dataframe is None:
-            self._dataframe = None
-        else:
-            self._dataframe = validate_index_key(
-                dataframe, self._instance_key, overwrite=True
+            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)}"
+            )
+
+        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."""
+        num_rows = len(self.dataframe) if self.dataframe is not None else 0
+        num_columns = len(self.dataframe.columns) if self.dataframe is not None else 0
+        properties = f"num_rows={num_rows}, num_columns={num_columns}"
+        if self.reference_label is not None:
+            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."
             )
-        self._table_backend = None
+        return self._meta
 
     @staticmethod
-    def type() -> str:
+    def table_type() -> str:
         """Return the type of the table."""
         return "feature_table"
 
@@ -73,89 +114,12 @@ class FeatureTableV1:
         return "1"
 
     @property
-    def backend_name(self) -> str | None:
-        """Return the name of the backend."""
-        if self._table_backend is None:
+    def reference_label(self) -> str | None:
+        """Return the reference label."""
+        path = self.meta.region
+        if path 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 None and self._table_backend is None:
-            raise ValueError(
-                "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_dataframe()
-
-        if self._dataframe is None:
-            raise ValueError(
-                "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 = dataframe
-
-    @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_dataframe:
-            raise ValueError("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 ValueError(
-                "No backend set for the table. "
-                "Please add the table to a OME-Zarr Image before calling consolidate."
-            )
-
-        self._table_backend.write_from_dataframe(
-            self.dataframe, metadata=self._meta.model_dump(exclude_none=True)
-        )
+        path = path.path
+        path = path.split("/")[-1]
+        return path

ngio/tables/v1/_generic_table.py

@@ -1,40 +1,32 @@
 """Implementation of a generic table class."""
 
-import pandas as pd
-from pydantic import BaseModel
-
-from ngio.tables.backends import ImplementedTableBackends
+from ngio.tables._abstract_table import AbstractBaseTable
+from ngio.tables.backends import BackendMeta, TableBackend
 from ngio.utils import ZarrGroupHandler
 
 
-class GenericTableMeta(BaseModel):
-    """Metadata for the ROI table."""
+class GenericTableMeta(BackendMeta):
+    """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
-    backend: 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:
-        """Initialize the GenericTable."""
-        self._meta = GenericTableMeta()
-        self._dataframe = dataframe
-        self._table_backend = None
-
     @staticmethod
-    def type() -> str:
+    def table_type() -> str:
         """Return the type of the table."""
-        return "generic"
+        return "generic_table"
 
     @staticmethod
     def version() -> str:
@@ -44,75 +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."""
-        return self._dataframe
-
-    @dataframe.setter
-    def dataframe(self, dataframe: pd.DataFrame) -> None:
-        """Set the table as a DataFrame."""
-        self._dataframe = dataframe
-
     @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 not backend.implements_dataframe:
-            raise ValueError("The backend does not implement the dataframe protocol.")
-
-        dataframe = backend.load_as_dataframe()
-
-        table = cls(dataframe)
-        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,
-        )
-        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 ValueError(
-                "No backend set for the table. "
-                "Please add the table to a OME-Zarr Image before calling consolidate."
-            )
-
-        self._table_backend.write_from_dataframe(
-            self._dataframe, metadata=self._meta.model_dump(exclude_none=True)
+        backend: TableBackend | None = None,
+    ) -> "GenericTable":
+        return cls._from_handler(
+            handler=handler,
+            backend=backend,
+            meta_model=BackendMeta,
         )