kumoai 2.14.0.dev202512211732__cp313-cp313-macosx_11_0_arm64.whl → 2.15.0.dev202601181732__cp313-cp313-macosx_11_0_arm64.whl

kumoai/experimental/rfm/base/sql_table.py

@@ -1,229 +0,0 @@
-import warnings
-from abc import abstractmethod
-from collections import defaultdict
-from collections.abc import Sequence
-from functools import cached_property
-from typing import Any
-
-import pandas as pd
-from kumoapi.model_plan import MissingType
-
-from kumoai.experimental.rfm.base import (
-    ColumnExpression,
-    ColumnExpressionSpec,
-    ColumnExpressionType,
-    SourceForeignKey,
-    Table,
-)
-from kumoai.experimental.rfm.infer import infer_dtype, infer_stype
-from kumoai.utils import quote_ident
-
-
-class SQLTable(Table):
-    r"""A :class:`SQLTable` specifies a :class:`Table` backed by a SQL
-    database.
-
-    Args:
-        name: The logical name of this table.
-        source_name: The physical name of this table in the database. If set to
-            ``None``, ``name`` is being used.
-        columns: The selected physical columns of this table.
-        column_expressions: The logical 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
-            exists.
-    """
-    def __init__(
-        self,
-        name: str,
-        source_name: str | None = None,
-        columns: Sequence[str] | None = None,
-        column_expressions: Sequence[ColumnExpressionType] | None = None,
-        primary_key: MissingType | str | None = MissingType.VALUE,
-        time_column: str | None = None,
-        end_time_column: str | None = None,
-    ) -> None:
-
-        self._connection: Any
-        self._source_name = source_name or name
-        self._expression_sample_df = pd.DataFrame()
-
-        super().__init__(
-            name=name,
-            columns=[],
-            primary_key=None,
-            time_column=None,
-            end_time_column=None,
-        )
-
-        # Add column expressions with highest priority:
-        self.add_column_expressions(column_expressions or [])
-
-        if columns is None:
-            for column_name in self._source_column_dict.keys():
-                if column_name not in self:
-                    self.add_column(column_name)
-        else:
-            for column_name in columns:
-                self.add_column(column_name)
-
-        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 fqn(self) -> str:
-        r"""The fully-qualified quoted source table name."""
-        return quote_ident(self._source_name)
-
-    @cached_property
-    def _source_foreign_key_dict(self) -> dict[str, SourceForeignKey]:
-        fkeys = self._get_source_foreign_keys()
-        # NOTE Drop all keys that link to multiple keys in the same table since
-        # we don't support composite keys yet:
-        table_pkeys: dict[str, set[str]] = defaultdict(set)
-        for fkey in fkeys:
-            table_pkeys[fkey.dst_table].add(fkey.primary_key)
-        return {
-            fkey.name: fkey
-            for fkey in fkeys if len(table_pkeys[fkey.dst_table]) == 1
-        }
-
-    def _sample_current_df(self, columns: Sequence[str]) -> pd.DataFrame:
-        expr_columns: list[str] = []
-        source_columns: list[str] = []
-        for column_name in columns:
-            column = self[column_name]
-            if isinstance(column, ColumnExpression):
-                expr_columns.append(column_name)
-            else:
-                source_columns.append(column_name)
-
-        dfs: list[pd.DataFrame] = []
-        if len(expr_columns) > 0:
-            dfs.append(self._expression_sample_df[expr_columns])
-        if len(source_columns) > 0:
-            dfs.append(self._source_sample_df[source_columns])
-
-        if len(dfs) == 0:
-            return pd.DataFrame(index=range(1000))
-        if len(dfs) == 1:
-            return dfs[0]
-        return pd.concat(dfs, axis=1, ignore_index=True)
-
-    # Column ##################################################################
-
-    def add_column_expressions(
-        self,
-        columns: Sequence[ColumnExpressionType],
-    ) -> None:
-        r"""Adds a set of column expressions to this table.
-
-        Args:
-            columns: The set of column expressions.
-
-        Raises:
-            KeyError: If a column with the same name already exists in the
-                table.
-        """
-        if len(columns) == 0:
-            return
-
-        column_expression_specs = [
-            spec for column in columns
-            if (spec := ColumnExpressionSpec._cast(column))
-        ]
-        df = self._get_expression_sample_df(column_expression_specs)
-
-        for spec in column_expression_specs:
-            if spec.name in self:
-                raise KeyError(f"Column '{spec.name}' already exists in table "
-                               f"'{self.name}'")
-
-            dtype = spec.dtype
-            if dtype is None:
-                ser = df[spec.name]
-                try:
-                    dtype = infer_dtype(ser)
-                except Exception:
-                    warnings.warn(f"Encountered unsupported data type "
-                                  f"'{ser.dtype}' for column expression "
-                                  f"'{spec.name}' in table '{self.name}'."
-                                  f"Please manually specify the data type for "
-                                  f"this column expression to use it within "
-                                  f"this table, or remove it to suppress "
-                                  f"this warning.")
-                    continue
-
-            ser = df[spec.name]
-            try:
-                stype = infer_stype(ser, spec.name, dtype)
-            except Exception as e:
-                raise RuntimeError(f"Could not obtain semantic type for "
-                                   f"column expression '{spec.name}' with "
-                                   f"data type '{dtype}' in table "
-                                   f"'{self.name}'. Change the data type of "
-                                   f"the column expression or remove it from "
-                                   f"this table.") from e
-
-            self._columns[spec.name] = ColumnExpression(
-                name=spec.name,
-                expr=spec.expr,
-                stype=stype,
-                dtype=dtype,
-            )
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', pd.errors.PerformanceWarning)
-                self._expression_sample_df[spec.name] = ser
-
-    def add_column_expression(
-        self,
-        column: ColumnExpressionType,
-    ) -> ColumnExpression:
-        r"""Adds a column expression to this table.
-
-        Args:
-            column: The column expression.
-
-        Raises:
-            KeyError: If a column with the same name already exists in the
-                table.
-        """
-        spec = ColumnExpressionSpec._cast(column)
-        assert spec is not None
-        self.add_column_expressions([spec])
-        column_expression = self.column(spec.name)
-        assert isinstance(column_expression, ColumnExpression)
-        return column_expression
-
-    # Abstract Methods ########################################################
-
-    @abstractmethod
-    def _get_source_foreign_keys(self) -> list[SourceForeignKey]:
-        pass
-
-    @abstractmethod
-    def _get_expression_sample_df(
-        self,
-        specs: Sequence[ColumnExpressionSpec],
-    ) -> pd.DataFrame:
-        pass