kumoai 2.13.0.dev202511261731__cp313-cp313-macosx_11_0_arm64.whl → 2.13.0.dev202512061731__cp313-cp313-macosx_11_0_arm64.whl

kumoai/experimental/rfm/backend/snow/table.py

@@ -0,0 +1,117 @@
+import re
+from typing import List, Optional, Sequence
+
+import pandas as pd
+from kumoapi.typing import Dtype
+
+from kumoai.experimental.rfm.backend.snow import Connection
+from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+
+
+class SnowTable(Table):
+    r"""A table backed by a :class:`sqlite` database.
+
+    Args:
+        connection: The connection to a :class:`snowflake` database.
+        name: The name of this table.
+        database: The database.
+        schema: The schema.
+        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
+            exists.
+    """
+    def __init__(
+        self,
+        connection: Connection,
+        name: str,
+        database: str | None = None,
+        schema: str | None = None,
+        columns: Optional[Sequence[str]] = None,
+        primary_key: Optional[str] = None,
+        time_column: Optional[str] = None,
+        end_time_column: Optional[str] = None,
+    ) -> None:
+
+        if database is not None and schema is None:
+            raise ValueError(f"Missing 'schema' for table '{name}' in "
+                             f"database '{database}'")
+
+        self._connection = connection
+        self._database = database
+        self._schema = schema
+
+        super().__init__(
+            name=name,
+            columns=columns,
+            primary_key=primary_key,
+            time_column=time_column,
+            end_time_column=end_time_column,
+        )
+
+    @property
+    def fqn_name(self) -> str:
+        names: List[str] = []
+        if self._database is not None:
+            assert self._schema is not None
+            names.extend([self._database, self._schema])
+        elif self._schema is not None:
+            names.append(self._schema)
+        names.append(self._name)
+        return '.'.join(names)
+
+    def _get_source_columns(self) -> List[SourceColumn]:
+        source_columns: List[SourceColumn] = []
+        with self._connection.cursor() as cursor:
+            try:
+                cursor.execute(f"DESCRIBE TABLE {self.fqn_name}")
+            except Exception as e:
+                raise ValueError(
+                    f"Table '{self.fqn_name}' does not exist") from e
+
+            for row in cursor.fetchall():
+                column, type, _, _, _, is_pkey, is_unique = row[:7]
+
+                type = type.strip().upper()
+                if type.startswith('NUMBER'):
+                    dtype = Dtype.int
+                elif type.startswith('VARCHAR'):
+                    dtype = Dtype.string
+                elif type == 'FLOAT':
+                    dtype = Dtype.float
+                elif type == 'BOOLEAN':
+                    dtype = Dtype.bool
+                elif re.search('DATE|TIMESTAMP', type):
+                    dtype = Dtype.date
+                else:
+                    continue
+
+                source_column = SourceColumn(
+                    name=column,
+                    dtype=dtype,
+                    is_primary_key=is_pkey.strip().upper() == 'Y',
+                    is_unique_key=is_unique.strip().upper() == 'Y',
+                )
+                source_columns.append(source_column)
+
+        return source_columns
+
+    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+        source_fkeys: List[SourceForeignKey] = []
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"SHOW IMPORTED KEYS IN TABLE {self.fqn_name}")
+            for row in cursor.fetchall():
+                _, _, _, dst_table, pkey, _, _, _, fkey = row[:9]
+                source_fkeys.append(SourceForeignKey(fkey, dst_table, pkey))
+        return source_fkeys
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        with self._connection.cursor() as cursor:
+            columns = ', '.join(self._source_column_dict.keys())
+            cursor.execute(f"SELECT {columns} FROM {self.fqn_name} LIMIT 1000")
+            table = cursor.fetch_arrow_all()
+            return table.to_pandas(types_mapper=pd.ArrowDtype)
+
+    def _get_num_rows(self) -> Optional[int]:
+        return None

kumoai/experimental/rfm/backend/sqlite/__init__.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import Any, TypeAlias, Union
+
+try:
+    import adbc_driver_sqlite.dbapi as adbc
+except ImportError:
+    raise ImportError("No module named 'adbc_driver_sqlite'. Please install "
+                      "Kumo SDK with the 'sqlite' extension via "
+                      "`pip install kumoai[sqlite]`.")
+
+Connection: TypeAlias = adbc.AdbcSqliteConnection
+
+
+def connect(uri: Union[str, Path, None] = None, **kwargs: Any) -> Connection:
+    r"""Opens a connection to a :class:`sqlite` database.
+
+    uri: The path to the database file to be opened.
+    kwargs: Additional connection arguments, following the
+        :class:`adbc_driver_sqlite` protocol.
+    """
+    return adbc.connect(uri, **kwargs)
+
+
+from .table import SQLiteTable  # noqa: E402
+
+__all__ = [
+    'connect',
+    'Connection',
+    'SQLiteTable',
+]

kumoai/experimental/rfm/backend/sqlite/table.py

@@ -0,0 +1,101 @@
+import re
+import warnings
+from typing import List, Optional, Sequence
+
+import pandas as pd
+from kumoapi.typing import Dtype
+
+from kumoai.experimental.rfm.backend.sqlite import Connection
+from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+from kumoai.experimental.rfm.infer import infer_dtype
+
+
+class SQLiteTable(Table):
+    r"""A table backed by a :class:`sqlite` database.
+
+    Args:
+        connection: The connection to a :class:`sqlite` database.
+        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
+            exists.
+    """
+    def __init__(
+        self,
+        connection: Connection,
+        name: str,
+        columns: Optional[Sequence[str]] = None,
+        primary_key: Optional[str] = None,
+        time_column: Optional[str] = None,
+        end_time_column: Optional[str] = None,
+    ) -> None:
+
+        self._connection = connection
+
+        super().__init__(
+            name=name,
+            columns=columns,
+            primary_key=primary_key,
+            time_column=time_column,
+            end_time_column=end_time_column,
+        )
+
+    def _get_source_columns(self) -> List[SourceColumn]:
+        source_columns: List[SourceColumn] = []
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"PRAGMA table_info({self.name})")
+            rows = cursor.fetchall()
+
+            if len(rows) == 0:
+                raise ValueError(f"Table '{self.name}' does not exist")
+
+            for _, column, type, _, _, is_pkey in rows:
+                # Determine column affinity:
+                type = type.strip().upper()
+                if re.search('INT', type):
+                    dtype = Dtype.int
+                elif re.search('TEXT|CHAR|CLOB', type):
+                    dtype = Dtype.string
+                elif re.search('REAL|FLOA|DOUB', type):
+                    dtype = Dtype.float
+                else:  # NUMERIC affinity.
+                    ser = self._sample_df[column]
+                    try:
+                        dtype = infer_dtype(ser)
+                    except Exception:
+                        warnings.warn(
+                            f"Data type inference for column '{column}' in "
+                            f"table '{self.name}' failed. Consider changing "
+                            f"the data type of the column to use it within "
+                            f"this table.")
+                        continue
+
+                source_column = SourceColumn(
+                    name=column,
+                    dtype=dtype,
+                    is_primary_key=bool(is_pkey),
+                    is_unique_key=False,
+                )
+                source_columns.append(source_column)
+
+        return source_columns
+
+    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+        source_fkeys: List[SourceForeignKey] = []
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"PRAGMA foreign_key_list({self.name})")
+            for _, _, dst_table, fkey, pkey, _, _, _ in cursor.fetchall():
+                source_fkeys.append(SourceForeignKey(fkey, dst_table, pkey))
+        return source_fkeys
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"SELECT * FROM {self.name} "
+                           f"ORDER BY rowid LIMIT 1000")
+            table = cursor.fetch_arrow_table()
+            return table.to_pandas(types_mapper=pd.ArrowDtype)
+
+    def _get_num_rows(self) -> Optional[int]:
+        return None

kumoai/experimental/rfm/base/__init__.py

@@ -0,0 +1,14 @@
+from .source import SourceColumn, SourceForeignKey
+from .column import Column
+from .table import Table
+from .sampler import EdgeSpec, SamplerOutput, Sampler
+
+__all__ = [
+    'SourceColumn',
+    'SourceForeignKey',
+    'Column',
+    'Table',
+    'EdgeSpec',
+    'SamplerOutput',
+    'Sampler',
+]

kumoai/experimental/rfm/base/column.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+from typing import Any
+
+from kumoapi.typing import Dtype, Stype
+
+
+@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})')

kumoai/experimental/rfm/base/sampler.py

@@ -0,0 +1,287 @@
+import copy
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from kumoapi.rfm.context import EdgeLayout, Link, Subgraph, Table
+from kumoapi.typing import Stype
+
+if TYPE_CHECKING:
+    from kumoai.experimental.rfm import Graph
+
+
+@dataclass
+class EdgeSpec:
+    num_neighbors: int | None = None
+    time_offsets: tuple[
+        pd.DateOffset | None,
+        pd.DateOffset,
+    ] | None = None
+
+    def __post_init__(self) -> None:
+        if (self.num_neighbors is None) == (self.time_offsets is None):
+            raise ValueError("Only one of 'num_neighbors' and 'time_offsets' "
+                             "must be provided")
+
+
+@dataclass
+class SamplerOutput:
+    df_dict: dict[str, pd.DataFrame]
+    inverse_dict: dict[str, np.ndarray]
+    batch_dict: dict[str, np.ndarray]
+    num_sampled_nodes_dict: dict[str, list[int]]
+    row_dict: dict[tuple[str, str, str], np.ndarray] | None = None
+    col_dict: dict[tuple[str, str, str], np.ndarray] | None = None
+    num_sampled_edges_dict: dict[tuple[str, str, str], list[int]] | None = None
+
+
+class Sampler(ABC):
+    def __init__(self, graph: 'Graph') -> 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))
+
+        self._primary_key_dict: dict[str, str] = {
+            table.name: table._primary_key
+            for table in graph.tables.values()
+            if table._primary_key is not None
+        }
+
+        self._time_column_dict: dict[str, str] = {
+            table.name: table._time_column
+            for table in graph.tables.values()
+            if table._time_column is not None
+        }
+
+        self._end_time_column_dict: dict[str, str] = {
+            table.name: table._end_time_column
+            for table in graph.tables.values()
+            if table._end_time_column is not None
+        }
+
+        foreign_keys = {(edge.src_table, edge.fkey) for edge in graph.edges}
+        self._table_stype_dict: dict[str, dict[str, Stype]] = {}
+        for table in graph.tables.values():
+            self._table_stype_dict[table.name] = {}
+            for column in table.columns:
+                if column == table.primary_key:
+                    continue
+                if (table.name, column.name) in foreign_keys:
+                    continue
+                self._table_stype_dict[table.name][column.name] = column.stype
+
+    @property
+    def edge_types(self) -> list[tuple[str, str, str]]:
+        return self._edge_types
+
+    @property
+    def primary_key_dict(self) -> dict[str, str]:
+        return self._primary_key_dict
+
+    @property
+    def time_column_dict(self) -> dict[str, str]:
+        return self._time_column_dict
+
+    @property
+    def end_time_column_dict(self) -> dict[str, str]:
+        return self._end_time_column_dict
+
+    @property
+    def table_stype_dict(self) -> dict[str, dict[str, Stype]]:
+        return self._table_stype_dict
+
+    def sample_subgraph(
+        self,
+        entity_table_names: tuple[str, ...],
+        entity_pkey: pd.Series,
+        anchor_time: pd.Series,
+        num_neighbors: list[int],
+        exclude_cols_dict: dict[str, list[str]] | None = None,
+    ) -> Subgraph:
+
+        edge_spec_dict: dict[tuple[str, str, str], list[EdgeSpec]] = {
+            edge_type: [EdgeSpec(value) for value in num_neighbors]
+            for edge_type in self.edge_types
+        }
+
+        # Exclude all columns that leak target information:
+        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():
+                for column_name in exclude_cols:
+                    del table_stype_dict[table_name][column_name]
+
+        # Collect all columns being used as features:
+        column_spec_dict: dict[str, list[str]] = {
+            table_name: list(stype_dict.keys())
+            for table_name, stype_dict in table_stype_dict.items()
+        }
+        # Make sure to store primary key information for entity tables:
+        for table_name in entity_table_names:
+            column_spec_dict[table_name] = (
+                [self.primary_key_dict[table_name]] +
+                column_spec_dict[table_name])
+
+        if anchor_time.dtype != 'datetime64[ns]':
+            anchor_time = anchor_time.astype('datetime64[ns]')
+        out = self.sample(
+            entity_table_name=entity_table_names[0],
+            entity_pkey=entity_pkey,
+            anchor_time=anchor_time,
+            column_spec_dict=column_spec_dict,
+            edge_spec_dict=edge_spec_dict,
+            drop_duplicates=True,
+            return_edges=True,
+        )
+
+        subgraph = Subgraph(
+            anchor_time=anchor_time.astype(int).to_numpy(),
+            table_dict={},
+            link_dict={},
+        )
+
+        for table_name, batch in out.batch_dict.items():
+            if len(batch) == 0:
+                continue
+
+            primary_key = None
+            if table_name in entity_table_names:
+                primary_key = self.primary_key_dict.get(table_name, None)
+
+            df = out.df_dict[table_name].reset_index(drop=True)
+            if table_name in self.end_time_column_dict:
+                # Set end time to NaT for all values greater than anchor time:
+                end_time_column = self.end_time_column_dict[table_name]
+                ser = df[end_time_column]
+                if ser.dtype != 'datetime64[ns]':
+                    ser = ser.astype('datetime64[ns]')
+                mask = ser > anchor_time.iloc[batch]
+                ser.iloc[mask] = pd.NaT
+                df[end_time_column] = ser
+
+            stype_dict = table_stype_dict[table_name]
+            for column_name, stype in stype_dict.items():
+                if stype == Stype.text:
+                    df[column_name] = _normalize_text(df[column_name])
+
+            subgraph.table_dict[table_name] = Table(
+                df=df,
+                row=out.inverse_dict.get(table_name),
+                batch=batch,
+                num_sampled_nodes=out.num_sampled_nodes_dict[table_name],
+                stype_dict=stype_dict,
+                primary_key=primary_key,
+            )
+
+        assert out.row_dict is not None
+        assert out.col_dict is not None
+        assert out.num_sampled_edges_dict is not None
+        for edge_type in out.row_dict.keys():
+            row: np.ndarray | None = out.row_dict[edge_type]
+            col: np.ndarray | None = out.col_dict[edge_type]
+
+            if row is None or col is None or len(row) == 0:
+                continue
+
+            # Do not store reverse edge type if it is an exact replica:
+            rev_edge_type = Subgraph.rev_edge_type(edge_type)
+            if (rev_edge_type in subgraph.link_dict
+                    and np.array_equal(row, out.col_dict[rev_edge_type])
+                    and np.array_equal(col, out.row_dict[rev_edge_type])):
+                subgraph.link_dict[edge_type] = Link(
+                    layout=EdgeLayout.REV,
+                    row=None,
+                    col=None,
+                    num_sampled_edges=out.num_sampled_edges_dict[edge_type],
+                )
+                continue
+
+            # Do not store non-informative edges:
+            layout = EdgeLayout.COO
+            if np.array_equal(row, np.arange(len(row))):
+                row = None
+            if np.array_equal(col, np.arange(len(col))):
+                col = None
+
+            # Store in compressed representation if more efficient:
+            num_cols = subgraph.table_dict[edge_type[2]].num_rows
+            if col is not None and len(col) > num_cols + 1:
+                layout = EdgeLayout.CSC
+                colcount = np.bincount(col, minlength=num_cols)
+                col = np.empty(num_cols + 1, dtype=col.dtype)
+                col[0] = 0
+                np.cumsum(colcount, out=col[1:])
+
+            subgraph.link_dict[edge_type] = Link(
+                layout=layout,
+                row=row,
+                col=col,
+                num_sampled_edges=out.num_sampled_edges_dict[edge_type],
+            )
+
+        return subgraph
+
+    # Abstract Methods ########################################################
+
+    @abstractmethod
+    def sample(
+        self,
+        entity_table_name: str,
+        entity_pkey: pd.Series,
+        anchor_time: pd.Series,
+        column_spec_dict: dict[str, list[str]],
+        edge_spec_dict: dict[tuple[str, str, str], list[EdgeSpec]],
+        drop_duplicates: bool = False,
+        return_edges: bool = False,
+    ) -> SamplerOutput:
+        pass
+
+
+# Helper Functions ############################################################
+
+PUNCTUATION = re.compile(r"[\'\"\.,\(\)\!\?\;\:]")
+MULTISPACE = re.compile(r"\s+")
+
+
+def _normalize_text(
+    ser: pd.Series,
+    max_words: int | None = 50,
+) -> pd.Series:
+    r"""Normalizes text into a list of lower-case words.
+
+    Args:
+        ser: The :class:`pandas.Series` to normalize.
+        max_words: The maximum number of words to return.
+            This will auto-shrink any large text column to avoid blowing up
+            context size.
+    """
+    if len(ser) == 0 or pd.api.types.is_list_like(ser.iloc[0]):
+        return ser
+
+    def normalize_fn(line: str) -> list[str]:
+        line = PUNCTUATION.sub(" ", line)
+        line = re.sub(r"<br\s*/?>", " ", line)  # Handle <br /> or <br>
+        line = MULTISPACE.sub(" ", line)
+        words = line.split()
+        if max_words is not None:
+            words = words[:max_words]
+        return words
+
+    ser = ser.fillna('').astype(str)
+
+    if max_words is not None:
+        # We estimate the number of words as 5 characters + 1 space in an
+        # English text on average. We need this pre-filter here, as word
+        # splitting on a giant text can be very expensive:
+        ser = ser.str[:6 * max_words]
+
+    ser = ser.str.lower()
+    ser = ser.map(normalize_fn)
+
+    return ser

kumoai/experimental/rfm/base/source.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+from kumoapi.typing import Dtype
+
+
+@dataclass
+class SourceColumn:
+    name: str
+    dtype: Dtype
+    is_primary_key: bool
+    is_unique_key: bool
+
+
+@dataclass
+class SourceForeignKey:
+    name: str
+    dst_table: str
+    primary_key: str