kumoai 2.13.0.dev202512081731__cp313-cp313-macosx_11_0_arm64.whl → 2.14.0.dev202512211732__cp313-cp313-macosx_11_0_arm64.whl

kumoai/experimental/rfm/base/sql_sampler.py

@@ -0,0 +1,84 @@
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import pandas as pd
+
+from kumoai.experimental.rfm.base import Sampler, SamplerOutput, SQLTable
+from kumoai.utils import ProgressLogger
+
+if TYPE_CHECKING:
+    from kumoai.experimental.rfm import Graph
+
+
+class SQLSampler(Sampler):
+    def __init__(
+        self,
+        graph: 'Graph',
+        verbose: bool | ProgressLogger = True,
+    ) -> None:
+        super().__init__(graph=graph, verbose=verbose)
+
+        self._fqn_dict: dict[str, str] = {}
+        for table in graph.tables.values():
+            assert isinstance(table, SQLTable)
+            self._connection = table._connection
+            self._fqn_dict[table.name] = table.fqn
+
+    @property
+    def fqn_dict(self) -> dict[str, str]:
+        r"""The fully-qualified quoted source name for all table names in the
+        graph.
+        """
+        return self._fqn_dict
+
+    def _sample_subgraph(
+        self,
+        entity_table_name: str,
+        entity_pkey: pd.Series,
+        anchor_time: pd.Series | Literal['entity'],
+        columns_dict: dict[str, set[str]],
+        num_neighbors: list[int],
+    ) -> SamplerOutput:
+
+        df, batch = self._by_pkey(
+            table_name=entity_table_name,
+            pkey=entity_pkey,
+            columns=columns_dict[entity_table_name],
+        )
+        if len(batch) != len(entity_pkey):
+            mask = np.ones(len(entity_pkey), dtype=bool)
+            mask[batch] = False
+            raise KeyError(f"The primary keys "
+                           f"{entity_pkey.iloc[mask].tolist()} do not exist "
+                           f"in the '{entity_table_name}' table")
+
+        perm = batch.argsort()
+        batch = batch[perm]
+        df = df.iloc[perm].reset_index(drop=True)
+
+        if not isinstance(anchor_time, pd.Series):
+            time_column = self.time_column_dict[entity_table_name]
+            anchor_time = df[time_column]
+
+        return SamplerOutput(
+            anchor_time=anchor_time.astype(int).to_numpy(),
+            df_dict={entity_table_name: df},
+            inverse_dict={},
+            batch_dict={entity_table_name: batch},
+            num_sampled_nodes_dict={entity_table_name: [len(batch)]},
+            row_dict={},
+            col_dict={},
+            num_sampled_edges_dict={},
+        )
+
+    # Abstract Methods ########################################################
+
+    @abstractmethod
+    def _by_pkey(
+        self,
+        table_name: str,
+        pkey: pd.Series,
+        columns: set[str],
+    ) -> tuple[pd.DataFrame, np.ndarray]:
+        pass

kumoai/experimental/rfm/base/sql_table.py

@@ -0,0 +1,229 @@
+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