kumoai 2.13.0.dev202512040649__cp313-cp313-win_amd64.whl → 2.14.0.dev202601081732__cp313-cp313-win_amd64.whl

kumoai/experimental/rfm/base/source.py

@@ -6,9 +6,10 @@ 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
 
 
 @dataclass

kumoai/experimental/rfm/base/sql_sampler.py

@@ -0,0 +1,247 @@
+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 (
+    LocalExpression,
+    Sampler,
+    SamplerOutput,
+    SourceColumn,
+)
+from kumoai.utils import ProgressLogger, quote_ident
+
+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._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():
+            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 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._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,
+        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:
+
+        # 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,
+            index=entity_pkey,
+            columns=sample_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")
+
+        # 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=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 ########################################################
+
+    @abstractmethod
+    def _by_pkey(
+        self,
+        table_name: str,
+        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