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/backend/local/table.py

@@ -1,9 +1,10 @@
 import warnings
-from typing import List, Optional
+from typing import cast
 
 import pandas as pd
+from kumoapi.model_plan import MissingType
 
-from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+from kumoai.experimental.rfm.base import DataBackend, SourceColumn, Table
 from kumoai.experimental.rfm.infer import infer_dtype
 
 
@@ -52,9 +53,9 @@ class LocalTable(Table):
         self,
         df: pd.DataFrame,
         name: str,
-        primary_key: Optional[str] = None,
-        time_column: Optional[str] = None,
-        end_time_column: Optional[str] = None,
+        primary_key: MissingType | str | None = MissingType.VALUE,
+        time_column: str | None = None,
+        end_time_column: str | None = None,
     ) -> None:
 
         if df.empty:
@@ -76,17 +77,23 @@ class LocalTable(Table):
             end_time_column=end_time_column,
         )
 
-    def _get_source_columns(self) -> List[SourceColumn]:
-        source_columns: List[SourceColumn] = []
+    @property
+    def backend(self) -> DataBackend:
+        return cast(DataBackend, DataBackend.LOCAL)
+
+    def _get_source_columns(self) -> list[SourceColumn]:
+        source_columns: list[SourceColumn] = []
         for column in self._data.columns:
             ser = self._data[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.")
+                warnings.warn(f"Encountered unsupported data type "
+                              f"'{ser.dtype}' for column '{column}' in table "
+                              f"'{self.name}'. Please change the data type of "
+                              f"the column in the `pandas.DataFrame` to use "
+                              f"it within this table, or remove it to "
+                              f"suppress this warning.")
                 continue
 
             source_column = SourceColumn(
@@ -94,16 +101,14 @@ class LocalTable(Table):
                 dtype=dtype,
                 is_primary_key=False,
                 is_unique_key=False,
+                is_nullable=True,
             )
             source_columns.append(source_column)
 
         return source_columns
 
-    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
-        return []
-
-    def _get_sample_df(self) -> pd.DataFrame:
+    def _get_source_sample_df(self) -> pd.DataFrame:
         return self._data
 
-    def _get_num_rows(self) -> Optional[int]:
+    def _get_num_rows(self) -> int | None:
         return len(self._data)

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

@@ -27,9 +27,11 @@ def connect(**kwargs: Any) -> Connection:
 
 
 from .table import SnowTable  # noqa: E402
+from .sampler import SnowSampler  # noqa: E402
 
 __all__ = [
     'connect',
     'Connection',
     'SnowTable',
+    'SnowSampler',
 ]

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

@@ -0,0 +1,252 @@
+import json
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from kumoapi.pquery import ValidatedPredictiveQuery
+
+from kumoai.experimental.rfm.backend.snow import Connection
+from kumoai.experimental.rfm.base import SQLSampler
+from kumoai.experimental.rfm.pquery import PQueryPandasExecutor
+from kumoai.utils import quote_ident
+
+
+@contextmanager
+def paramstyle(connection: Connection, style: str = 'qmark') -> Iterator[None]:
+    _style = connection._paramstyle
+    connection._paramstyle = style
+    yield
+    connection._paramstyle = _style
+
+
+class SnowSampler(SQLSampler):
+    def _get_min_max_time_dict(
+        self,
+        table_names: list[str],
+    ) -> dict[str, tuple[pd.Timestamp, pd.Timestamp]]:
+        selects: list[str] = []
+        for table_name in table_names:
+            time_column = self.time_column_dict[table_name]
+            select = (f"SELECT\n"
+                      f"  ? as table_name,\n"
+                      f"  MIN({quote_ident(time_column)}) as min_date,\n"
+                      f"  MAX({quote_ident(time_column)}) as max_date\n"
+                      f"FROM {self.fqn_dict[table_name]}")
+            selects.append(select)
+        sql = "\nUNION ALL\n".join(selects)
+
+        out_dict: dict[str, tuple[pd.Timestamp, pd.Timestamp]] = {}
+        with paramstyle(self._connection), self._connection.cursor() as cursor:
+            cursor.execute(sql, table_names)
+            rows = cursor.fetchall()
+        for table_name, _min, _max in rows:
+            out_dict[table_name] = (
+                pd.Timestamp.max if _min is None else pd.Timestamp(_min),
+                pd.Timestamp.min if _max is None else pd.Timestamp(_max),
+            )
+
+        return out_dict
+
+    def _sample_entity_table(
+        self,
+        table_name: str,
+        columns: set[str],
+        num_rows: int,
+        random_seed: int | None = None,
+    ) -> pd.DataFrame:
+        # NOTE Snowflake does support `SEED` only as part of `SYSTEM` sampling.
+        num_rows = min(num_rows, 1_000_000)  # Snowflake's upper limit.
+
+        filters: list[str] = []
+        primary_key = self.primary_key_dict[table_name]
+        if self.source_table_dict[table_name][primary_key].is_nullable:
+            filters.append(f" {quote_ident(primary_key)} IS NOT NULL")
+        time_column = self.time_column_dict.get(table_name)
+        if (time_column is not None and
+                self.source_table_dict[table_name][time_column].is_nullable):
+            filters.append(f" {quote_ident(time_column)} IS NOT NULL")
+
+        sql = (f"SELECT {', '.join(quote_ident(col) for col in columns)}\n"
+               f"FROM {self.fqn_dict[table_name]}\n"
+               f"SAMPLE ROW ({num_rows} ROWS)")
+        if len(filters) > 0:
+            sql += f"\nWHERE{' AND'.join(filters)}"
+
+        with self._connection.cursor() as cursor:
+            # NOTE This may return duplicate primary keys. This is okay.
+            cursor.execute(sql)
+            table = cursor.fetch_arrow_all()
+
+        return self._sanitize(table_name, table)
+
+    def _sample_target(
+        self,
+        query: ValidatedPredictiveQuery,
+        entity_df: pd.DataFrame,
+        train_index: np.ndarray,
+        train_time: pd.Series,
+        num_train_examples: int,
+        test_index: np.ndarray,
+        test_time: pd.Series,
+        num_test_examples: int,
+        columns_dict: dict[str, set[str]],
+        time_offset_dict: dict[
+            tuple[str, str, str],
+            tuple[pd.DateOffset | None, pd.DateOffset],
+        ],
+    ) -> tuple[pd.Series, np.ndarray, pd.Series, np.ndarray]:
+
+        # NOTE For Snowflake, we execute everything at once to pay minimal
+        # query initialization costs.
+        index = np.concatenate([train_index, test_index])
+        time = pd.concat([train_time, test_time], axis=0, ignore_index=True)
+
+        entity_df = entity_df.iloc[index].reset_index(drop=True)
+
+        feat_dict: dict[str, pd.DataFrame] = {query.entity_table: entity_df}
+        time_dict: dict[str, pd.Series] = {}
+        time_column = self.time_column_dict.get(query.entity_table)
+        if time_column in columns_dict[query.entity_table]:
+            time_dict[query.entity_table] = entity_df[time_column]
+        batch_dict: dict[str, np.ndarray] = {
+            query.entity_table: np.arange(len(entity_df)),
+        }
+        for edge_type, (min_offset, max_offset) in time_offset_dict.items():
+            table_name, fkey, _ = edge_type
+            feat_dict[table_name], batch_dict[table_name] = self._by_time(
+                table_name=table_name,
+                fkey=fkey,
+                pkey=entity_df[self.primary_key_dict[query.entity_table]],
+                anchor_time=time,
+                min_offset=min_offset,
+                max_offset=max_offset,
+                columns=columns_dict[table_name],
+            )
+            time_column = self.time_column_dict.get(table_name)
+            if time_column in columns_dict[table_name]:
+                time_dict[table_name] = feat_dict[table_name][time_column]
+
+        y, mask = PQueryPandasExecutor().execute(
+            query=query,
+            feat_dict=feat_dict,
+            time_dict=time_dict,
+            batch_dict=batch_dict,
+            anchor_time=time,
+            num_forecasts=query.num_forecasts,
+        )
+
+        train_mask = mask[:len(train_index)]
+        test_mask = mask[len(train_index):]
+
+        boundary = int(train_mask.sum())
+        train_y = y.iloc[:boundary]
+        test_y = y.iloc[boundary:].reset_index(drop=True)
+
+        return train_y, train_mask, test_y, test_mask
+
+    def _by_pkey(
+        self,
+        table_name: str,
+        pkey: pd.Series,
+        columns: set[str],
+    ) -> tuple[pd.DataFrame, np.ndarray]:
+
+        pkey_name = self.primary_key_dict[table_name]
+        source_table = self.source_table_dict[table_name]
+
+        payload = json.dumps(list(pkey))
+
+        sql = ("WITH TMP as (\n"
+               "  SELECT\n"
+               "    f.index as BATCH,\n")
+        if source_table[pkey_name].dtype.is_int():
+            sql += "    f.value::NUMBER as ID\n"
+        elif source_table[pkey_name].dtype.is_float():
+            sql += "    f.value::FLOAT as ID\n"
+        else:
+            sql += "    f.value::VARCHAR as ID\n"
+        sql += (f"  FROM TABLE(FLATTEN(INPUT => PARSE_JSON(?))) f\n"
+                f")\n"
+                f"SELECT TMP.BATCH as __BATCH__, "
+                f"{', '.join('ENT.' + quote_ident(col) for col in columns)}\n"
+                f"FROM TMP\n"
+                f"JOIN {self.fqn_dict[table_name]} ENT\n"
+                f"  ON ENT.{quote_ident(pkey_name)} = TMP.ID")
+
+        with paramstyle(self._connection), self._connection.cursor() as cursor:
+            cursor.execute(sql, (payload, ))
+            table = cursor.fetch_arrow_all()
+
+        # Remove any duplicated primary keys in post-processing:
+        tmp = table.append_column('__TMP__', pa.array(range(len(table))))
+        gb = tmp.group_by('__BATCH__').aggregate([('__TMP__', 'min')])
+        table = table.take(gb['__TMP___min'])
+
+        batch = table['__BATCH__'].cast(pa.int64()).to_numpy()
+        table = table.remove_column(table.schema.get_field_index('__BATCH__'))
+
+        return table.to_pandas(), batch  # TODO Use `self._sanitize`.
+
+    # Helper Methods ##########################################################
+
+    def _by_time(
+        self,
+        table_name: str,
+        fkey: str,
+        pkey: pd.Series,
+        anchor_time: pd.Series,
+        min_offset: pd.DateOffset | None,
+        max_offset: pd.DateOffset,
+        columns: set[str],
+    ) -> tuple[pd.DataFrame, np.ndarray]:
+
+        end_time = anchor_time + max_offset
+        end_time = end_time.dt.strftime("%Y-%m-%d %H:%M:%S")
+        if min_offset is not None:
+            start_time = anchor_time + min_offset
+            start_time = start_time.dt.strftime("%Y-%m-%d %H:%M:%S")
+            payload = json.dumps(list(zip(pkey, end_time, start_time)))
+        else:
+            payload = json.dumps(list(zip(pkey, end_time)))
+
+        # Based on benchmarking, JSON payload is the fastest way to query by
+        # custom indices (compared to large `IN` clauses or temporary tables):
+        source_table = self.source_table_dict[table_name]
+        time_column = self.time_column_dict[table_name]
+        sql = ("WITH TMP as (\n"
+               "  SELECT\n"
+               "    f.index as BATCH,\n")
+        if source_table[fkey].dtype.is_int():
+            sql += "    f.value[0]::NUMBER as ID,\n"
+        elif source_table[fkey].dtype.is_float():
+            sql += "    f.value[0]::FLOAT as ID,\n"
+        else:
+            sql += "    f.value[0]::VARCHAR as ID,\n"
+        sql += "    f.value[1]::TIMESTAMP_NTZ as END_TIME"
+        if min_offset is not None:
+            sql += ",\n    f.value[2]::TIMESTAMP_NTZ as START_TIME"
+        sql += (f"\n"
+                f"  FROM TABLE(FLATTEN(INPUT => PARSE_JSON(?))) f\n"
+                f")\n"
+                f"SELECT TMP.BATCH as __BATCH__, "
+                f"{', '.join('FACT.' + quote_ident(col) for col in columns)}\n"
+                f"FROM TMP\n"
+                f"JOIN {self.fqn_dict[table_name]} FACT\n"
+                f"  ON FACT.{quote_ident(fkey)} = TMP.ID\n"
+                f" AND FACT.{quote_ident(time_column)} <= TMP.END_TIME")
+        if min_offset is not None:
+            sql += f"\n AND FACT.{quote_ident(time_column)} > TMP.START_TIME"
+
+        with paramstyle(self._connection), self._connection.cursor() as cursor:
+            cursor.execute(sql, (payload, ))
+            table = cursor.fetch_arrow_all()
+
+        batch = table['__BATCH__'].cast(pa.int64()).to_numpy()
+        table = table.remove_column(table.schema.get_field_index('__BATCH__'))
+
+        return self._sanitize(table_name, table), batch
+
+    def _sanitize(self, table_name: str, table: pa.table) -> pd.DataFrame:
+        return table.to_pandas(types_mapper=pd.ArrowDtype)

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

@@ -1,22 +1,35 @@
 import re
-from typing import List, Optional, Sequence
+from collections.abc import Sequence
+from typing import cast
 
 import pandas as pd
+from kumoapi.model_plan import MissingType
 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):
+from kumoai.experimental.rfm.base import (
+    ColumnExpressionSpec,
+    ColumnExpressionType,
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+    SQLTable,
+)
+from kumoai.utils import quote_ident
+
+
+class SnowTable(SQLTable):
     r"""A table backed by a :class:`sqlite` database.
 
     Args:
         connection: The connection to a :class:`snowflake` database.
-        name: The name of this table.
+        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.
         database: The database.
         schema: The schema.
-        columns: The selected columns of this table.
+        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
@@ -26,17 +39,20 @@ class SnowTable(Table):
         self,
         connection: Connection,
         name: str,
+        source_name: str | None = None,
         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,
+        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:
 
         if database is not None and schema is None:
-            raise ValueError(f"Missing 'schema' for table '{name}' in "
-                             f"database '{database}'")
+            raise ValueError(f"Unspecified 'schema' for table "
+                             f"'{source_name or name}' in database "
+                             f"'{database}'")
 
         self._connection = connection
         self._database = database
@@ -44,47 +60,67 @@ class SnowTable(Table):
 
         super().__init__(
             name=name,
+            source_name=source_name,
             columns=columns,
+            column_expressions=column_expressions,
             primary_key=primary_key,
             time_column=time_column,
             end_time_column=end_time_column,
         )
 
+    @staticmethod
+    def to_dtype(snowflake_dtype: str | None) -> Dtype | None:
+        if snowflake_dtype is None:
+            return None
+        snowflake_dtype = snowflake_dtype.strip().upper()
+        # TODO 'NUMBER(...)' is not always an integer!
+        if snowflake_dtype.startswith('NUMBER'):
+            return Dtype.int
+        elif snowflake_dtype.startswith('VARCHAR'):
+            return Dtype.string
+        elif snowflake_dtype == 'FLOAT':
+            return Dtype.float
+        elif snowflake_dtype == 'BOOLEAN':
+            return Dtype.bool
+        elif re.search('DATE|TIMESTAMP', snowflake_dtype):
+            return Dtype.date
+        return None
+
     @property
-    def fqn_name(self) -> str:
-        names: List[str] = []
+    def backend(self) -> DataBackend:
+        return cast(DataBackend, DataBackend.SNOWFLAKE)
+
+    @property
+    def fqn(self) -> str:
+        r"""The fully-qualified quoted table name."""
+        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] = []
+            names.append(quote_ident(self._database))
+        if self._schema is not None:
+            names.append(quote_ident(self._schema))
+        return '.'.join(names + [quote_ident(self._source_name)])
+
+    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}")
+                sql = f"DESCRIBE TABLE {self.fqn}"
+                cursor.execute(sql)
             except Exception as e:
-                raise ValueError(
-                    f"Table '{self.fqn_name}' does not exist") from e
+                names: list[str] = []
+                if self._database is not None:
+                    names.append(self._database)
+                if self._schema is not None:
+                    names.append(self._schema)
+                source_name = '.'.join(names + [self._source_name])
+                raise ValueError(f"Table '{source_name}' does not exist in "
+                                 f"the remote data backend") 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:
+                column, type, _, null, _, is_pkey, is_unique, *_ = row
+
+                dtype = self.to_dtype(type)
+                if dtype is None:
                     continue
 
                 source_column = SourceColumn(
@@ -92,26 +128,42 @@ class SnowTable(Table):
                     dtype=dtype,
                     is_primary_key=is_pkey.strip().upper() == 'Y',
                     is_unique_key=is_unique.strip().upper() == 'Y',
+                    is_nullable=null.strip().upper() == 'Y',
                 )
                 source_columns.append(source_column)
 
         return source_columns
 
-    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
-        source_fkeys: List[SourceForeignKey] = []
+    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}")
+            sql = f"SHOW IMPORTED KEYS IN TABLE {self.fqn}"
+            cursor.execute(sql)
             for row in cursor.fetchall():
-                _, _, _, dst_table, pkey, _, _, _, fkey = row[:9]
+                _, _, _, dst_table, pkey, _, _, _, fkey, *_ = row
                 source_fkeys.append(SourceForeignKey(fkey, dst_table, pkey))
         return source_fkeys
 
-    def _get_sample_df(self) -> pd.DataFrame:
+    def _get_source_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")
+            columns = [quote_ident(col) for col in self._source_column_dict]
+            sql = f"SELECT {', '.join(columns)} FROM {self.fqn} LIMIT 1000"
+            cursor.execute(sql)
             table = cursor.fetch_arrow_all()
             return table.to_pandas(types_mapper=pd.ArrowDtype)
 
-    def _get_num_rows(self) -> Optional[int]:
+    def _get_num_rows(self) -> int | None:
         return None
+
+    def _get_expression_sample_df(
+        self,
+        specs: Sequence[ColumnExpressionSpec],
+    ) -> pd.DataFrame:
+        with self._connection.cursor() as cursor:
+            columns = [
+                f"{spec.expr} AS {quote_ident(spec.name)}" for spec in specs
+            ]
+            sql = f"SELECT {', '.join(columns)} FROM {self.fqn} LIMIT 1000"
+            cursor.execute(sql)
+            table = cursor.fetch_arrow_all()
+            return table.to_pandas(types_mapper=pd.ArrowDtype)

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

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, TypeAlias, Union
+from typing import Any, TypeAlias
 
 try:
     import adbc_driver_sqlite.dbapi as adbc
@@ -11,7 +11,7 @@ except ImportError:
 Connection: TypeAlias = adbc.AdbcSqliteConnection
 
 
-def connect(uri: Union[str, Path, None] = None, **kwargs: Any) -> Connection:
+def connect(uri: 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.
@@ -22,9 +22,11 @@ def connect(uri: Union[str, Path, None] = None, **kwargs: Any) -> Connection:
 
 
 from .table import SQLiteTable  # noqa: E402
+from .sampler import SQLiteSampler  # noqa: E402
 
 __all__ = [
     'connect',
     'Connection',
     'SQLiteTable',
+    'SQLiteSampler',
 ]