kumoai 2.13.0.dev202511181731__cp311-cp311-macosx_11_0_arm64.whl → 2.14.0.dev202512191731__cp311-cp311-macosx_11_0_arm64.whl

kumoai/experimental/rfm/{local_table.py → base/table.py}

@@ -1,115 +1,32 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from functools import cached_property
 
 import pandas as pd
+from kumoapi.model_plan import MissingType
 from kumoapi.source_table import UnavailableSourceTable
 from kumoapi.table import Column as ColumnDefinition
 from kumoapi.table import TableDefinition
-from kumoapi.typing import Dtype, Stype
+from kumoapi.typing import Stype
 from typing_extensions import Self
 
-from kumoai import in_notebook
-from kumoai.experimental.rfm import utils
+from kumoai import in_notebook, in_snowflake_notebook
+from kumoai.experimental.rfm.base import Column, DataBackend, SourceColumn
+from kumoai.experimental.rfm.infer import (
+    infer_primary_key,
+    infer_stype,
+    infer_time_column,
+)
 
 
-@dataclass(init=False, repr=False, eq=False)
-class Column:
-    stype: Stype
-
-    def __init__(
-        self,
-        name: str,
-        dtype: Dtype,
-        stype: Stype,
-        is_primary_key: bool = False,
-        is_time_column: bool = False,
-        is_end_time_column: bool = False,
-    ) -> None:
-        self._name = name
-        self._dtype = Dtype(dtype)
-        self._is_primary_key = is_primary_key
-        self._is_time_column = is_time_column
-        self._is_end_time_column = is_end_time_column
-        self.stype = Stype(stype)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def dtype(self) -> Dtype:
-        return self._dtype
-
-    def __setattr__(self, key: str, val: Any) -> None:
-        if key == 'stype':
-            if isinstance(val, str):
-                val = Stype(val)
-            assert isinstance(val, Stype)
-            if not val.supports_dtype(self.dtype):
-                raise ValueError(f"Column '{self.name}' received an "
-                                 f"incompatible semantic type (got "
-                                 f"dtype='{self.dtype}' and stype='{val}')")
-            if self._is_primary_key and val != Stype.ID:
-                raise ValueError(f"Primary key '{self.name}' must have 'ID' "
-                                 f"semantic type (got '{val}')")
-            if self._is_time_column and val != Stype.timestamp:
-                raise ValueError(f"Time column '{self.name}' must have "
-                                 f"'timestamp' semantic type (got '{val}')")
-            if self._is_end_time_column and val != Stype.timestamp:
-                raise ValueError(f"End time column '{self.name}' must have "
-                                 f"'timestamp' semantic type (got '{val}')")
-
-        super().__setattr__(key, val)
-
-    def __hash__(self) -> int:
-        return hash((self.name, self.stype, self.dtype))
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Column):
-            return False
-        return hash(self) == hash(other)
-
-    def __repr__(self) -> str:
-        return (f'{self.__class__.__name__}(name={self.name}, '
-                f'stype={self.stype}, dtype={self.dtype})')
-
-
-class LocalTable:
-    r"""A table backed by a :class:`pandas.DataFrame`.
-
-    A :class:`LocalTable` fully specifies the relevant metadata, *i.e.*
-    selected columns, column semantic types, primary keys and time columns.
-    :class:`LocalTable` is used to create a :class:`LocalGraph`.
-
-    .. code-block:: python
-
-        import pandas as pd
-        import kumoai.experimental.rfm as rfm
-
-        # Load data from a CSV file:
-        df = pd.read_csv("data.csv")
-
-        # Create a table from a `pandas.DataFrame` and infer its metadata ...
-        table = rfm.LocalTable(df, name="my_table").infer_metadata()
-
-        # ... or create a table explicitly:
-        table = rfm.LocalTable(
-            df=df,
-            name="my_table",
-            primary_key="id",
-            time_column="time",
-            end_time_column=None,
-        )
-
-        # Verify metadata:
-        table.print_metadata()
-
-        # Change the semantic type of a column:
-        table[column].stype = "text"
+class Table(ABC):
+    r"""A :class:`Table` fully specifies the relevant metadata of a single
+    table, *i.e.* its selected columns, data types, semantic types, primary
+    keys and time columns.
 
     Args:
-        df: The data frame to create the table from.
-        name: The name of the table.
+        name: The name of this table.
+        columns: The selected columns of this table.
         primary_key: The name of the primary key of this table, if it exists.
         time_column: The name of the time column of this table, if it exists.
         end_time_column: The name of the end time column of this table, if it
@@ -117,49 +34,53 @@ class LocalTable:
     """
     def __init__(
         self,
-        df: pd.DataFrame,
         name: str,
-        primary_key: Optional[str] = None,
-        time_column: Optional[str] = None,
-        end_time_column: Optional[str] = None,
+        columns: Sequence[str] | None = None,
+        primary_key: MissingType | str | None = MissingType.VALUE,
+        time_column: str | None = None,
+        end_time_column: str | None = None,
     ) -> None:
 
-        if df.empty:
-            raise ValueError("Data frame must have at least one row")
-        if isinstance(df.columns, pd.MultiIndex):
-            raise ValueError("Data frame must not have a multi-index")
-        if not df.columns.is_unique:
-            raise ValueError("Data frame must have unique column names")
-        if any(col == '' for col in df.columns):
-            raise ValueError("Data frame must have non-empty column names")
-
-        df = df.copy(deep=False)
-
-        self._data = df
         self._name = name
-        self._primary_key: Optional[str] = None
-        self._time_column: Optional[str] = None
-        self._end_time_column: Optional[str] = None
+        self._primary_key: str | None = None
+        self._time_column: str | None = None
+        self._end_time_column: str | None = None
+
+        if columns is None:
+            columns = list(self._source_column_dict.keys())
 
-        self._columns: Dict[str, Column] = {}
-        for column_name in df.columns:
+        self._columns: dict[str, Column] = {}
+        for column_name in columns:
             self.add_column(column_name)
 
-        if primary_key is not None:
+        if isinstance(primary_key, MissingType):
+            # Inference from source column metadata:
+            if '_source_column_dict' in self.__dict__:
+                primary_key = self._source_primary_key
+                if (primary_key is not None and primary_key in self
+                        and self[primary_key].is_physical):
+                    self.primary_key = primary_key
+        elif primary_key is not None:
+            if primary_key not in self:
+                self.add_column(primary_key)
             self.primary_key = primary_key
 
         if time_column is not None:
+            if time_column not in self:
+                self.add_column(time_column)
             self.time_column = time_column
 
         if end_time_column is not None:
+            if end_time_column not in self:
+                self.add_column(end_time_column)
             self.end_time_column = end_time_column
 
     @property
     def name(self) -> str:
-        r"""The name of the table."""
+        r"""The name of this table."""
         return self._name
 
-    # Data column #############################################################
+    # Column ##################################################################
 
     def has_column(self, name: str) -> bool:
         r"""Returns ``True`` if this table holds a column with name ``name``;
@@ -181,7 +102,7 @@ class LocalTable:
         return self._columns[name]
 
     @property
-    def columns(self) -> List[Column]:
+    def columns(self) -> list[Column]:
         r"""Returns a list of :class:`Column` objects that represent the
         columns in this table.
         """
@@ -200,29 +121,26 @@ class LocalTable:
             raise KeyError(f"Column '{name}' already exists in table "
                            f"'{self.name}'")
 
-        if name not in self._data.columns:
-            raise KeyError(f"Column '{name}' does not exist in the underyling "
-                           f"data frame")
+        if name not in self._source_column_dict:
+            raise KeyError(f"Column '{name}' does not exist in the underlying "
+                           f"source table")
 
+        dtype = self._source_column_dict[name].dtype
+
+        ser = self._source_sample_df[name]
         try:
-            dtype = utils.to_dtype(self._data[name])
-        except Exception as e:
-            raise RuntimeError(f"Data type inference for column '{name}' in "
-                               f"table '{self.name}' failed. Consider "
-                               f"changing the data type of the column or "
-                               f"removing it from the table.") from e
-        try:
-            stype = utils.infer_stype(self._data[name], name, dtype)
+            stype = infer_stype(ser, name, dtype)
         except Exception as e:
-            raise RuntimeError(f"Semantic type inference for column '{name}' "
-                               f"in table '{self.name}' failed. Consider "
-                               f"changing the data type of the column or "
-                               f"removing it from the table.") from e
+            raise RuntimeError(f"Could not obtain semantic type for column "
+                               f"'{name}' with data type '{dtype}' in table "
+                               f"'{self.name}'. Change the data type of the "
+                               f"column in the source table or remove it from "
+                               f"this table.") from e
 
         self._columns[name] = Column(
             name=name,
-            dtype=dtype,
             stype=stype,
+            dtype=dtype,
         )
 
         return self._columns[name]
@@ -258,7 +176,7 @@ class LocalTable:
         return self._primary_key is not None
 
     @property
-    def primary_key(self) -> Optional[Column]:
+    def primary_key(self) -> Column | None:
         r"""The primary key column of this table.
 
         The getter returns the primary key column of this table, or ``None`` if
@@ -273,7 +191,7 @@ class LocalTable:
         return self[self._primary_key]
 
     @primary_key.setter
-    def primary_key(self, name: Optional[str]) -> None:
+    def primary_key(self, name: str | None) -> None:
         if name is not None and name == self._time_column:
             raise ValueError(f"Cannot specify column '{name}' as a primary "
                              f"key since it is already defined to be a time "
@@ -303,7 +221,7 @@ class LocalTable:
         return self._time_column is not None
 
     @property
-    def time_column(self) -> Optional[Column]:
+    def time_column(self) -> Column | None:
         r"""The time column of this table.
 
         The getter returns the time column of this table, or ``None`` if no
@@ -318,7 +236,7 @@ class LocalTable:
         return self[self._time_column]
 
     @time_column.setter
-    def time_column(self, name: Optional[str]) -> None:
+    def time_column(self, name: str | None) -> None:
         if name is not None and name == self._primary_key:
             raise ValueError(f"Cannot specify column '{name}' as a time "
                              f"column since it is already defined to be a "
@@ -348,7 +266,7 @@ class LocalTable:
         return self._end_time_column is not None
 
     @property
-    def end_time_column(self) -> Optional[Column]:
+    def end_time_column(self) -> Column | None:
         r"""The end time column of this table.
 
         The getter returns the end time column of this table, or ``None`` if no
@@ -364,7 +282,7 @@ class LocalTable:
         return self[self._end_time_column]
 
     @end_time_column.setter
-    def end_time_column(self, name: Optional[str]) -> None:
+    def end_time_column(self, name: str | None) -> None:
         if name is not None and name == self._primary_key:
             raise ValueError(f"Cannot specify column '{name}' as an end time "
                              f"column since it is already defined to be a "
@@ -432,12 +350,20 @@ class LocalTable:
         })
 
     def print_metadata(self) -> None:
-        r"""Prints the :meth:`~LocalTable.metadata` of the table."""
-        if in_notebook():
+        r"""Prints the :meth:`~metadata` of this table."""
+        num_rows_repr = ''
+        if self._num_rows is not None:
+            num_rows_repr = ' ({self._num_rows:,} rows)'
+
+        if in_snowflake_notebook():
+            import streamlit as st
+            md_repr = f"### 🏷️ Metadata of Table `{self.name}`{num_rows_repr}"
+            st.markdown(md_repr)
+            st.dataframe(self.metadata, hide_index=True)
+        elif in_notebook():
             from IPython.display import Markdown, display
-            display(
-                Markdown(f"### 🏷️ Metadata of Table `{self.name}` "
-                         f"({len(self._data):,} rows)"))
+            md_repr = f"### 🏷️ Metadata of Table `{self.name}`{num_rows_repr}"
+            display(Markdown(md_repr))
             df = self.metadata
             try:
                 if hasattr(df.style, 'hide'):
@@ -447,12 +373,94 @@ class LocalTable:
             except ImportError:
                 print(df.to_string(index=False))  # missing jinja2
         else:
-            print(f"🏷️ Metadata of Table '{self.name}' "
-                  f"({len(self._data):,} rows):")
+            print(f"🏷️ Metadata of Table '{self.name}'{num_rows_repr}")
             print(self.metadata.to_string(index=False))
 
+    def infer_primary_key(self, verbose: bool = True) -> Self:
+        r"""Infers the primary key in this table.
+
+        Args:
+            verbose: Whether to print verbose output.
+        """
+        if self.has_primary_key():
+            return self
+
+        def _set_primary_key(primary_key: str) -> None:
+            self.primary_key = primary_key
+            if verbose:
+                print(f"Detected primary key '{primary_key}' in table "
+                      f"'{self.name}'")
+
+        # Inference from source column metadata:
+        if '_source_column_dict' in self.__dict__:
+            primary_key = self._source_primary_key
+            if (primary_key is not None and primary_key in self
+                    and self[primary_key].is_physical):
+                _set_primary_key(primary_key)
+                return self
+
+            unique_keys = [
+                column.name for column in self._source_column_dict.values()
+                if column.is_unique_key
+            ]
+            if (len(unique_keys) == 1  # NOTE No composite keys yet.
+                    and unique_keys[0] in self
+                    and self[unique_keys[0]].is_physical):
+                _set_primary_key(unique_keys[0])
+                return self
+
+        # Heuristic-based inference:
+        candidates = [
+            column.name for column in self.columns if column.stype == Stype.ID
+        ]
+        if len(candidates) == 0:
+            for column in self.columns:
+                if self.name.lower() == column.name.lower():
+                    candidates.append(column.name)
+                elif (self.name.lower().endswith('s')
+                      and self.name.lower()[:-1] == column.name.lower()):
+                    candidates.append(column.name)
+
+        if primary_key := infer_primary_key(
+                table_name=self.name,
+                df=self._sample_current_df(columns=candidates),
+                candidates=candidates,
+        ):
+            _set_primary_key(primary_key)
+            return self
+
+        return self
+
+    def infer_time_column(self, verbose: bool = True) -> Self:
+        r"""Infers the time column in this table.
+
+        Args:
+            verbose: Whether to print verbose output.
+        """
+        if self.has_time_column():
+            return self
+
+        # Heuristic-based inference:
+        candidates = [
+            column.name for column in self.columns
+            if column.stype == Stype.timestamp
+            and column.name != self._end_time_column
+        ]
+
+        if time_column := infer_time_column(
+                df=self._sample_current_df(columns=candidates),
+                candidates=candidates,
+        ):
+            self.time_column = time_column
+
+            if verbose:
+                print(f"Detected time column '{time_column}' in table "
+                      f"'{self.name}'")
+
+        return self
+
     def infer_metadata(self, verbose: bool = True) -> Self:
-        r"""Infers metadata, *i.e.*, primary keys and time columns, in the
+        r"""Infers metadata, *i.e.*, primary keys and time columns, in this
         table.
 
         Args:
@@ -460,42 +468,15 @@ class LocalTable:
         """
         logs = []
 
-        # Try to detect primary key if not set:
         if not self.has_primary_key():
+            self.infer_primary_key(verbose=False)
+            if self.has_primary_key():
+                logs.append(f"primary key '{self._primary_key}'")
 
-            def is_candidate(column: Column) -> bool:
-                if column.stype == Stype.ID:
-                    return True
-                if all(column.stype != Stype.ID for column in self.columns):
-                    if self.name == column.name:
-                        return True
-                    if (self.name.endswith('s')
-                            and self.name[:-1] == column.name):
-                        return True
-                return False
-
-            candidates = [
-                column.name for column in self.columns if is_candidate(column)
-            ]
-
-            if primary_key := utils.detect_primary_key(
-                    table_name=self.name,
-                    df=self._data,
-                    candidates=candidates,
-            ):
-                self.primary_key = primary_key
-                logs.append(f"primary key '{primary_key}'")
-
-        # Try to detect time column if not set:
         if not self.has_time_column():
-            candidates = [
-                column.name for column in self.columns
-                if column.stype == Stype.timestamp
-                and column.name != self._end_time_column
-            ]
-            if time_column := utils.detect_time_column(self._data, candidates):
-                self.time_column = time_column
-                logs.append(f"time column '{time_column}'")
+            self.infer_time_column(verbose=False)
+            if self.has_time_column():
+                logs.append(f"time column '{self._time_column}'")
 
         if verbose and len(logs) > 0:
             print(f"Detected {' and '.join(logs)} in table '{self.name}'")
@@ -516,6 +497,36 @@ class LocalTable:
             end_time_col=self._end_time_column,
         )
 
+    @cached_property
+    def _source_column_dict(self) -> dict[str, SourceColumn]:
+        source_columns = self._get_source_columns()
+        if len(source_columns) == 0:
+            raise ValueError(f"Table '{self.name}' does not hold any column "
+                             f"with a supported data type")
+        return {column.name: column for column in source_columns}
+
+    @cached_property
+    def _source_sample_df(self) -> pd.DataFrame:
+        return self._get_source_sample_df()
+
+    @property
+    def _source_primary_key(self) -> str | None:
+        primary_keys = [
+            column.name for column in self._source_column_dict.values()
+            if column.is_primary_key
+        ]
+        if len(primary_keys) == 1:  # NOTE No composite keys yet.
+            return primary_keys[0]
+
+        return None
+
+    @cached_property
+    def _num_rows(self) -> int | None:
+        return self._get_num_rows()
+
+    def _sample_current_df(self, columns: Sequence[str]) -> pd.DataFrame:
+        return self._source_sample_df[columns]
+
     # Python builtins #########################################################
 
     def __hash__(self) -> int:
@@ -543,3 +554,22 @@ class LocalTable:
                 f'  time_column={self._time_column},\n'
                 f'  end_time_column={self._end_time_column},\n'
                 f')')
+
+    # Abstract Methods ########################################################
+
+    @property
+    @abstractmethod
+    def backend(self) -> DataBackend:
+        r"""The data backend of this table."""
+
+    @abstractmethod
+    def _get_source_columns(self) -> list[SourceColumn]:
+        pass
+
+    @abstractmethod
+    def _get_source_sample_df(self) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def _get_num_rows(self) -> int | None:
+        pass