kumoai 2.14.0.dev202512211732__cp313-cp313-win_amd64.whl → 2.14.0.dev202601081732__cp313-cp313-win_amd64.whl

kumoai/experimental/rfm/base/column.py

@@ -1,15 +1,89 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Mapping, TypeAlias
 
 from kumoapi.typing import Dtype, Stype
+from typing_extensions import Self
+
+from kumoai.experimental.rfm.base import Expression
+from kumoai.mixin import CastMixin
+
+
+@dataclass(init=False)
+class ColumnSpec(CastMixin):
+    r"""A column specification for adding a column to a table.
+
+    A column specification can either refer to a physical column present in
+    the data source, or be defined logically via an expression.
+
+    Args:
+        name: The name of the column.
+        expr: A column expression to define logical columns.
+        dtype: The data type of the column.
+    """
+    def __init__(
+        self,
+        name: str,
+        expr: Expression | Mapping[str, str] | str | None = None,
+        dtype: Dtype | str | None = None,
+        stype: Stype | str | None = None,
+    ) -> None:
+
+        self.name = name
+        self.expr = Expression.coerce(expr)
+        self.dtype = Dtype(dtype) if dtype is not None else None
+        self.stype = Stype(dtype) if stype is not None else None
+
+    @classmethod
+    def coerce(cls, spec: ColumnSpec | Mapping[str, Any] | str) -> Self:
+        r"""Coerces a column specification into a :class:`ColumnSpec`."""
+        if isinstance(spec, cls):
+            return spec
+        if isinstance(spec, str):
+            return cls(name=spec)
+        if isinstance(spec, Mapping):
+            try:
+                return cls(**spec)
+            except TypeError:
+                pass
+        raise TypeError(f"Unable to coerce 'ColumnSpec' from '{spec}'")
+
+    @property
+    def is_source(self) -> bool:
+        r"""Whether the column specification refers to a phyiscal column
+        present in the data source.
+        """
+        return self.expr is None
+
+
+ColumnSpecType: TypeAlias = ColumnSpec | Mapping[str, Any] | str
 
 
 @dataclass(init=False, repr=False, eq=False)
 class Column:
+    r"""Column-level metadata information.
+
+    A column can either refer to a physical column present in the data source,
+    or be defined logically via an expression.
+
+    Args:
+        name: The name of the column.
+        expr: A column expression to define logical columns.
+        dtype: The data type of the column.
+        stype: The semantic type of the column.
+    """
     stype: Stype
 
-    def __init__(self, name: str, stype: Stype, dtype: Dtype) -> None:
+    def __init__(
+        self,
+        name: str,
+        expr: Expression | None,
+        dtype: Dtype,
+        stype: Stype,
+    ) -> None:
         self._name = name
+        self._expr = expr
         self._dtype = Dtype(dtype)
 
         self._is_primary_key = False
@@ -20,19 +94,25 @@ class Column:
 
     @property
     def name(self) -> str:
+        r"""The name of the column."""
         return self._name
 
     @property
-    def dtype(self) -> Dtype:
-        return self._dtype
+    def expr(self) -> Expression | None:
+        r"""The expression of column (if logically)."""
+        return self._expr
 
     @property
-    def is_physical(self) -> bool:
-        return True
+    def dtype(self) -> Dtype:
+        r"""The data type of the column."""
+        return self._dtype
 
     @property
-    def is_logical(self) -> bool:
-        return not self.is_physical
+    def is_source(self) -> bool:
+        r"""Whether the column refers to a phyiscal column present in the data
+        source.
+        """
+        return self.expr is None
 
     def __setattr__(self, key: str, val: Any) -> None:
         if key == 'stype':
@@ -56,7 +136,7 @@ class Column:
         super().__setattr__(key, val)
 
     def __hash__(self) -> int:
-        return hash((self.name, self.stype, self.dtype))
+        return hash((self.name, self.expr, self.dtype, self.stype))
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Column):
@@ -64,5 +144,9 @@ class Column:
         return hash(self) == hash(other)
 
     def __repr__(self) -> str:
-        return (f'{self.__class__.__name__}(name={self.name}, '
-                f'stype={self.stype}, dtype={self.dtype})')
+        parts = [f'name={self.name}']
+        if self.expr is not None:
+            parts.append(f'expr={self.expr}')
+        parts.append(f'dtype={self.dtype}')
+        parts.append(f'stype={self.stype}')
+        return f"{self.__class__.__name__}({', '.join(parts)})"

kumoai/experimental/rfm/base/expression.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Mapping
+
+
+class Expression(ABC):
+    """A base expression to define logical columns."""
+    @classmethod
+    def coerce(
+        cls,
+        spec: Expression | Mapping[str, str] | str | None,
+    ) -> Expression | None:
+        r"""Coerces an expression specification into an :class:`Expression`, if
+        possible.
+        """
+        if spec is None:
+            return None
+        if isinstance(spec, Expression):
+            return spec
+        if isinstance(spec, str):
+            return LocalExpression(spec)
+        if isinstance(spec, Mapping):
+            for sub_cls in (LocalExpression, ):
+                try:
+                    return sub_cls(**spec)
+                except TypeError:
+                    pass
+        raise TypeError(f"Unable to coerce 'Expression' from '{spec}'")
+
+
+@dataclass(frozen=True, repr=False)
+class LocalExpression(Expression):
+    r"""A local expression to define a row-level logical attribute based on
+    physical columns of the data source in the same row.
+
+    Args:
+        value: The value of the expression.
+    """
+    value: str
+
+    def __repr__(self) -> str:
+        return self.value

kumoai/experimental/rfm/base/sampler.py

@@ -13,7 +13,6 @@ from kumoapi.pquery.AST import Aggregation, ASTNode
 from kumoapi.rfm.context import EdgeLayout, Link, Subgraph, Table
 from kumoapi.typing import Stype
 
-from kumoai.experimental.rfm.base import SourceColumn
 from kumoai.utils import ProgressLogger
 
 if TYPE_CHECKING:
@@ -53,12 +52,24 @@ class Sampler(ABC):
         graph: 'Graph',
         verbose: bool | ProgressLogger = True,
     ) -> None:
+
         self._edge_types: list[tuple[str, str, str]] = []
         for edge in graph.edges:
             edge_type = (edge.src_table, edge.fkey, edge.dst_table)
             self._edge_types.append(edge_type)
             self._edge_types.append(Subgraph.rev_edge_type(edge_type))
 
+        # Source Table -> [(Foreign Key, Destination Table)]
+        self._foreign_key_dict: dict[str, list[tuple[str, str]]] = {}
+        # Destination Table -> [(Source Table, Foreign Key)]
+        self._rev_foreign_key_dict: dict[str, list[tuple[str, str]]] = {}
+        for table in graph.tables.values():
+            self._foreign_key_dict[table.name] = []
+            self._rev_foreign_key_dict[table.name] = []
+        for src_table, fkey, dst_table in graph.edges:
+            self._foreign_key_dict[src_table].append((fkey, dst_table))
+            self._rev_foreign_key_dict[dst_table].append((src_table, fkey))
+
         self._primary_key_dict: dict[str, str] = {
             table.name: table._primary_key
             for table in graph.tables.values()
@@ -88,10 +99,6 @@ class Sampler(ABC):
                     continue
                 self._table_stype_dict[table.name][column.name] = column.stype
 
-        self._source_table_dict: dict[str, dict[str, SourceColumn]] = {}
-        for table in graph.tables.values():
-            self._source_table_dict[table.name] = table._source_column_dict
-
         self._min_time_dict: dict[str, pd.Timestamp] = {}
         self._max_time_dict: dict[str, pd.Timestamp] = {}
 
@@ -102,6 +109,16 @@ class Sampler(ABC):
         r"""All available edge types in the graph."""
         return self._edge_types
 
+    @property
+    def foreign_key_dict(self) -> dict[str, list[tuple[str, str]]]:
+        r"""The foreign keys for all tables in the graph."""
+        return self._foreign_key_dict
+
+    @property
+    def rev_foreign_key_dict(self) -> dict[str, list[tuple[str, str]]]:
+        r"""The foreign key back references for all tables in the graph."""
+        return self._rev_foreign_key_dict
+
     @property
     def primary_key_dict(self) -> dict[str, str]:
         r"""All available primary keys in the graph."""
@@ -119,16 +136,11 @@ class Sampler(ABC):
 
     @property
     def table_stype_dict(self) -> dict[str, dict[str, Stype]]:
-        r"""The registered semantic types for all columns in all tables in
-        the graph.
+        r"""The registered semantic types for all feature columns in all tables
+        in the graph.
         """
         return self._table_stype_dict
 
-    @property
-    def source_table_dict(self) -> dict[str, dict[str, SourceColumn]]:
-        r"""Source column information for all tables in the graph."""
-        return self._source_table_dict
-
     def get_min_time(
         self,
         table_names: list[str] | None = None,
@@ -189,7 +201,7 @@ class Sampler(ABC):
             exclude_cols_dict: The columns to exclude from the subgraph.
         """
         # Exclude all columns that leak target information:
-        table_stype_dict: dict[str, dict[str, Stype]] = self._table_stype_dict
+        table_stype_dict: dict[str, dict[str, Stype]] = self.table_stype_dict
         if exclude_cols_dict is not None:
             table_stype_dict = copy.deepcopy(table_stype_dict)
             for table_name, exclude_cols in exclude_cols_dict.items():
@@ -237,11 +249,8 @@ class Sampler(ABC):
                 # Set end time to NaT for all values greater than anchor time:
                 assert table_name not in out.inverse_dict
                 ser = df[end_time_column]
-                if ser.dtype != 'datetime64[ns]':
-                    ser = ser.astype('datetime64[ns]')
                 mask = ser.astype(int).to_numpy() > out.anchor_time[batch]
-                ser.iloc[mask] = pd.NaT
-                df[end_time_column] = ser
+                df.loc[mask, end_time_column] = pd.NaT
 
             stype_dict = table_stype_dict[table_name]
             for column_name, stype in stype_dict.items():

kumoai/experimental/rfm/base/source.py

@@ -6,7 +6,7 @@ from kumoapi.typing import Dtype
 @dataclass
 class SourceColumn:
     name: str
-    dtype: Dtype
+    dtype: Dtype | None
     is_primary_key: bool
     is_unique_key: bool
     is_nullable: bool

kumoai/experimental/rfm/base/sql_sampler.py

@@ -1,11 +1,18 @@
 from abc import abstractmethod
+from collections import defaultdict
 from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 import pandas as pd
+from kumoapi.typing import Dtype
 
-from kumoai.experimental.rfm.base import Sampler, SamplerOutput, SQLTable
-from kumoai.utils import ProgressLogger
+from kumoai.experimental.rfm.base import (
+    LocalExpression,
+    Sampler,
+    SamplerOutput,
+    SourceColumn,
+)
+from kumoai.utils import ProgressLogger, quote_ident
 
 if TYPE_CHECKING:
     from kumoai.experimental.rfm import Graph
@@ -19,18 +26,71 @@ class SQLSampler(Sampler):
     ) -> None:
         super().__init__(graph=graph, verbose=verbose)
 
-        self._fqn_dict: dict[str, str] = {}
+        self._source_name_dict: dict[str, str] = {
+            table.name: table._quoted_source_name
+            for table in graph.tables.values()
+        }
+
+        self._source_table_dict: dict[str, dict[str, SourceColumn]] = {}
+        for table in graph.tables.values():
+            self._source_table_dict[table.name] = {}
+            for column in table.columns:
+                if not column.is_source:
+                    continue
+                src_column = table._source_column_dict[column.name]
+                self._source_table_dict[table.name][column.name] = src_column
+
+        self._table_dtype_dict: dict[str, dict[str, Dtype]] = {}
+        for table in graph.tables.values():
+            self._table_dtype_dict[table.name] = {}
+            for column in table.columns:
+                self._table_dtype_dict[table.name][column.name] = column.dtype
+
+        self._table_column_ref_dict: dict[str, dict[str, str]] = {}
+        self._table_column_proj_dict: dict[str, dict[str, str]] = {}
         for table in graph.tables.values():
-            assert isinstance(table, SQLTable)
-            self._connection = table._connection
-            self._fqn_dict[table.name] = table.fqn
+            column_ref_dict: dict[str, str] = {}
+            column_proj_dict: dict[str, str] = {}
+            for column in table.columns:
+                if column.expr is not None:
+                    assert isinstance(column.expr, LocalExpression)
+                    column_ref_dict[column.name] = column.expr.value
+                    column_proj_dict[column.name] = (
+                        f'{column.expr} AS {quote_ident(column.name)}')
+                else:
+                    column_ref_dict[column.name] = quote_ident(column.name)
+                    column_proj_dict[column.name] = quote_ident(column.name)
+            self._table_column_ref_dict[table.name] = column_ref_dict
+            self._table_column_proj_dict[table.name] = column_proj_dict
+
+    @property
+    def source_name_dict(self) -> dict[str, str]:
+        r"""The source table names for all tables in the graph."""
+        return self._source_name_dict
+
+    @property
+    def source_table_dict(self) -> dict[str, dict[str, SourceColumn]]:
+        r"""The source column information for all tables in the graph."""
+        return self._source_table_dict
 
     @property
-    def fqn_dict(self) -> dict[str, str]:
-        r"""The fully-qualified quoted source name for all table names in the
+    def table_dtype_dict(self) -> dict[str, dict[str, Dtype]]:
+        r"""The data types for all columns in all tables in the graph."""
+        return self._table_dtype_dict
+
+    @property
+    def table_column_ref_dict(self) -> dict[str, dict[str, str]]:
+        r"""The SQL reference expression for all columns in all tables in the
         graph.
         """
-        return self._fqn_dict
+        return self._table_column_ref_dict
+
+    @property
+    def table_column_proj_dict(self) -> dict[str, dict[str, str]]:
+        r"""The SQL projection expressions for all columns in all tables in the
+        graph.
+        """
+        return self._table_column_proj_dict
 
     def _sample_subgraph(
         self,
@@ -41,10 +101,25 @@ class SQLSampler(Sampler):
         num_neighbors: list[int],
     ) -> SamplerOutput:
 
+        # Make sure to include primary key, foreign key and time columns:
+        sample_columns_dict: dict[str, set[str]] = {}
+        for table, columns in columns_dict.items():
+            sample_columns = columns | {
+                foreign_key
+                for foreign_key, _ in self.foreign_key_dict[table]
+            }
+            if primary_key := self.primary_key_dict.get(table):
+                sample_columns |= {primary_key}
+            if time_column := self.time_column_dict.get(table):
+                sample_columns |= {time_column}
+            sample_columns_dict[table] = sample_columns
+
+        # Sample Entity Table #################################################
+
         df, batch = self._by_pkey(
             table_name=entity_table_name,
-            pkey=entity_pkey,
-            columns=columns_dict[entity_table_name],
+            index=entity_pkey,
+            columns=sample_columns_dict[entity_table_name],
         )
         if len(batch) != len(entity_pkey):
             mask = np.ones(len(entity_pkey), dtype=bool)
@@ -53,23 +128,99 @@ class SQLSampler(Sampler):
                            f"{entity_pkey.iloc[mask].tolist()} do not exist "
                            f"in the '{entity_table_name}' table")
 
+        # Make sure that entities are returned in expected order:
         perm = batch.argsort()
         batch = batch[perm]
         df = df.iloc[perm].reset_index(drop=True)
 
+        # Fill 'entity' anchor times with actual values:
         if not isinstance(anchor_time, pd.Series):
             time_column = self.time_column_dict[entity_table_name]
             anchor_time = df[time_column]
+        assert isinstance(anchor_time, pd.Series)
+
+        df_hop_dict: dict[tuple[str, int], pd.DataFrame] = {
+            (entity_table_name, 0): df,
+        }
+        batch_hop_dict: dict[tuple[str, int], np.ndarray] = {
+            (entity_table_name, 0): batch,
+        }
+
+        # Recursive Neighbor Sampling #########################################
+
+        for hop, neighbors in enumerate(num_neighbors):
+            if neighbors == 0:
+                break  # Abort early.
+
+            dfs: dict[str, list[pd.DataFrame]] = defaultdict(list)
+            batches: dict[str, list[np.ndarray]] = defaultdict(list)
+
+            tables = [table for table, i in batch_hop_dict if i == hop]
+            for table in tables:
+                df = df_hop_dict[(table, hop)]
+                batch = batch_hop_dict[(table, hop)]
+
+                # Iterate over foreign keys in the current table:
+                for fkey, dst_table in self.foreign_key_dict[table]:
+                    raise NotImplementedError
+
+                # Iterate over foreign keys that reference the current table:
+                for src_table, fkey in self.rev_foreign_key_dict[table]:
+                    _df, _batch = self._by_fkey(
+                        table_name=src_table,
+                        foreign_key=fkey,
+                        index=df[self.primary_key_dict[table]],
+                        num_neighbors=neighbors,
+                        anchor_time=anchor_time.iloc[batch],
+                        columns=sample_columns_dict[src_table],
+                    )
+                    _batch = batch[_batch]
+
+                    # TODO Filter out duplicates if `src_table` has a pkey.
+                    dfs[src_table].append(_df)
+                    batches[src_table].append(_batch)
+
+                    # TODO Add edges to all sampled nodes.
+
+        # Post-Processing #####################################################
+
+        dfs_dict: dict[str, list[pd.DataFrame]] = defaultdict(list)
+        batches_dict: dict[str, list[np.ndarray]] = defaultdict(list)
+        num_hops = max(hop for _, hop in df_hop_dict.keys())  # TODO
+        num_sampled_nodes_dict: dict[str, list[int]] = {
+            table: [0] * (num_hops + 1)
+            for table in [table for table, _ in df_hop_dict.keys()]
+        }
+        for (table, hop), df in df_hop_dict.items():
+            dfs_dict[table].append(df)
+            batches_dict[table].append(batch_hop_dict[(table, hop)])
+            num_sampled_nodes_dict[table][hop] = len(df)
+
+        df_dict = {  # Concatenate data frames across hops:
+            table:
+            pd.concat(dfs, axis=0, ignore_index=True)
+            if len(dfs) > 1 else dfs[0]
+            for table, dfs in dfs_dict.items()
+        }
+        df_dict = {  # Post-filter column set:
+            table: df[list(columns_dict[table])]
+            for table_name, df in df_dict.items()
+        }
+        batch_dict = {  # Concatenate batch vector across hops:
+            table:
+            np.concatenate(batches, axis=0) if len(batches) > 1 else batches[0]
+            for table, batches in batches_dict.items()
+        }
 
         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={},
+            df_dict=df_dict,
+            inverse_dict={},  # TODO
+            batch_dict=batch_dict,
+            num_sampled_nodes_dict=num_sampled_nodes_dict,
+            row_dict={},  # TODO
+            col_dict={},  # TODO
+            num_sampled_edges_dict={},  # TODO
         )
 
     # Abstract Methods ########################################################
@@ -78,7 +229,19 @@ class SQLSampler(Sampler):
     def _by_pkey(
         self,
         table_name: str,
-        pkey: pd.Series,
+        index: pd.Series,
+        columns: set[str],
+    ) -> tuple[pd.DataFrame, np.ndarray]:
+        pass
+
+    @abstractmethod
+    def _by_fkey(
+        self,
+        table_name: str,
+        foreign_key: str,
+        index: pd.Series,
+        num_neighbors: int,
+        anchor_time: pd.Series | None,
         columns: set[str],
     ) -> tuple[pd.DataFrame, np.ndarray]:
         pass