kumoai 2.12.1__py3-none-any.whl → 2.14.0.dev202512141732__py3-none-any.whl

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

@@ -0,0 +1,135 @@
+import re
+from typing import List, Optional, Sequence, cast
+
+import pandas as pd
+from kumoapi.typing import Dtype
+
+from kumoai.experimental.rfm.backend.snow import Connection
+from kumoai.experimental.rfm.base import (
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+    Table,
+)
+from kumoai.utils import quote_ident
+
+
+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 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:
+            names.append(quote_ident(self._database))
+        if self._schema is not None:
+            names.append(quote_ident(self._schema))
+        return '.'.join(names + [quote_ident(self._name)])
+
+    def _get_source_columns(self) -> List[SourceColumn]:
+        source_columns: List[SourceColumn] = []
+        with self._connection.cursor() as cursor:
+            try:
+                sql = f"DESCRIBE TABLE {self.fqn}"
+                cursor.execute(sql)
+            except Exception as e:
+                names: list[str] = []
+                if self._database is not None:
+                    names.append(self._database)
+                if self._schema is not None:
+                    names.append(self._schema)
+                name = '.'.join(names + [self._name])
+                raise ValueError(f"Table '{name}' does not exist") from e
+
+            for row in cursor.fetchall():
+                column, type, _, null, _, 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',
+                    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] = []
+        with self._connection.cursor() as cursor:
+            sql = f"SHOW IMPORTED KEYS IN TABLE {self.fqn}"
+            cursor.execute(sql)
+            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 = [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]:
+        return None

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

@@ -0,0 +1,32 @@
+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
+from .sampler import SQLiteSampler  # noqa: E402
+
+__all__ = [
+    'connect',
+    'Connection',
+    'SQLiteTable',
+    'SQLiteSampler',
+]

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

@@ -0,0 +1,112 @@
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import pandas as pd
+from kumoapi.pquery import ValidatedPredictiveQuery
+
+from kumoai.experimental.rfm.backend.sqlite import SQLiteTable
+from kumoai.experimental.rfm.base import Sampler, SamplerOutput
+from kumoai.utils import ProgressLogger, quote_ident
+
+if TYPE_CHECKING:
+    from kumoai.experimental.rfm import Graph
+
+
+class SQLiteSampler(Sampler):
+    def __init__(
+        self,
+        graph: 'Graph',
+        verbose: bool | ProgressLogger = True,
+    ) -> None:
+        super().__init__(graph=graph)
+
+        for table in graph.tables.values():
+            assert isinstance(table, SQLiteTable)
+            self._connection = table._connection
+
+        # TODO Check for indices being present.
+
+    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 {quote_ident(table_name)}")
+            selects.append(select)
+        sql = "\nUNION ALL\n".join(selects)
+
+        out_dict: dict[str, tuple[pd.Timestamp, pd.Timestamp]] = {}
+        with self._connection.cursor() as cursor:
+            cursor.execute(sql, table_names)
+            for table_name, _min, _max in cursor.fetchall():
+                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_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:
+        raise NotImplementedError
+
+    def _sample_entity_table(
+        self,
+        table_name: str,
+        columns: set[str],
+        num_rows: int,
+        random_seed: int | None = None,
+    ) -> pd.DataFrame:
+        # NOTE SQLite does not natively support passing a `random_seed`.
+
+        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")
+
+        # TODO Make this query more efficient - it does full table scan.
+        sql = (f"SELECT {', '.join(quote_ident(col) for col in columns)}\n"
+               f"FROM {quote_ident(table_name)}")
+        if len(filters) > 0:
+            sql += f"\nWHERE{' AND'.join(filters)}"
+        sql += f"\nORDER BY RANDOM() LIMIT {num_rows}"
+
+        with self._connection.cursor() as cursor:
+            # NOTE This may return duplicate primary keys. This is okay.
+            cursor.execute(sql)
+            table = cursor.fetch_arrow_table()
+
+        return table.to_pandas(types_mapper=pd.ArrowDtype)
+
+    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]:
+        raise NotImplementedError

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

@@ -0,0 +1,115 @@
+import re
+import warnings
+from typing import List, Optional, Sequence, cast
+
+import pandas as pd
+from kumoapi.typing import Dtype
+
+from kumoai.experimental.rfm.backend.sqlite import Connection
+from kumoai.experimental.rfm.base import (
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+    Table,
+)
+from kumoai.experimental.rfm.infer import infer_dtype
+from kumoai.utils import quote_ident
+
+
+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,
+        )
+
+    @property
+    def backend(self) -> DataBackend:
+        return cast(DataBackend, DataBackend.SQLITE)
+
+    def _get_source_columns(self) -> List[SourceColumn]:
+        source_columns: List[SourceColumn] = []
+        with self._connection.cursor() as cursor:
+            sql = f"PRAGMA table_info({quote_ident(self.name)})"
+            cursor.execute(sql)
+            rows = cursor.fetchall()
+
+            if len(rows) == 0:
+                raise ValueError(f"Table '{self.name}' does not exist")
+
+            for _, column, type, notnull, _, 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,
+                    is_nullable=not bool(is_pkey) and not bool(notnull),
+                )
+                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:
+            sql = f"PRAGMA foreign_key_list({quote_ident(self.name)})"
+            cursor.execute(sql)
+            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:
+            sql = (f"SELECT * FROM {quote_ident(self.name)} "
+                   f"ORDER BY rowid LIMIT 1000")
+            cursor.execute(sql)
+            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,23 @@
+from kumoapi.common import StrEnum
+
+
+class DataBackend(StrEnum):
+    LOCAL = 'local'
+    SQLITE = 'sqlite'
+    SNOWFLAKE = 'snowflake'
+
+
+from .source import SourceColumn, SourceForeignKey  # noqa: E402
+from .column import Column  # noqa: E402
+from .table import Table  # noqa: E402
+from .sampler import SamplerOutput, Sampler  # noqa: E402
+
+__all__ = [
+    'DataBackend',
+    'SourceColumn',
+    'SourceForeignKey',
+    'Column',
+    'Table',
+    '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})')