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

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

@@ -1,22 +1,35 @@
 import re
 import warnings
-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.sqlite import Connection
-from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+from kumoai.experimental.rfm.base import (
+    ColumnExpressionSpec,
+    ColumnExpressionType,
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+    SQLTable,
+)
 from kumoai.experimental.rfm.infer import infer_dtype
+from kumoai.utils import quote_ident
 
 
-class SQLiteTable(Table):
+class SQLiteTable(SQLTable):
     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.
+        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.
+        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,32 +39,53 @@ class SQLiteTable(Table):
         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,
+        source_name: str | None = 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:
 
         self._connection = connection
 
         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,
         )
 
-    def _get_source_columns(self) -> List[SourceColumn]:
-        source_columns: List[SourceColumn] = []
+    @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:
-            cursor.execute(f"PRAGMA table_info({self.name})")
-            rows = cursor.fetchall()
+            sql = f"PRAGMA table_info({self.fqn})"
+            cursor.execute(sql)
+            columns = cursor.fetchall()
+
+            if len(columns) == 0:
+                raise ValueError(f"Table '{self._source_name}' does not exist "
+                                 f"in the SQLite database")
 
-            if len(rows) == 0:
-                raise ValueError(f"Table '{self.name}' does not exist")
+            unique_keys: set[str] = set()
+            sql = f"PRAGMA index_list({self.fqn})"
+            cursor.execute(sql)
+            for _, index_name, is_unique, *_ in cursor.fetchall():
+                if bool(is_unique):
+                    sql = f"PRAGMA index_info({quote_ident(index_name)})"
+                    cursor.execute(sql)
+                    index = cursor.fetchall()
+                    if len(index) == 1:
+                        unique_keys.add(index[0][2])
 
-            for _, column, type, _, _, is_pkey in rows:
+            for _, column, type, notnull, _, is_pkey in columns:
                 # Determine column affinity:
                 type = type.strip().upper()
                 if re.search('INT', type):
@@ -61,41 +95,60 @@ class SQLiteTable(Table):
                 elif re.search('REAL|FLOA|DOUB', type):
                     dtype = Dtype.float
                 else:  # NUMERIC affinity.
-                    ser = self._sample_df[column]
+                    ser = self._source_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.")
+                        warnings.warn(f"Encountered unsupported data type "
+                                      f"'{ser.dtype}' with source data type "
+                                      f"'{type}' for column '{column}' in "
+                                      f"table '{self.name}'. If possible, "
+                                      f"change the data type of the column in "
+                                      f"your SQLite database 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_unique_key=column in unique_keys,
+                    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] = []
+    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():
+            sql = f"PRAGMA foreign_key_list({self.fqn})"
+            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:
+    def _get_source_sample_df(self) -> pd.DataFrame:
         with self._connection.cursor() as cursor:
-            cursor.execute(f"SELECT * FROM {self.name} "
-                           f"ORDER BY rowid LIMIT 1000")
+            sql = (f"SELECT * FROM {self.fqn} "
+                   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]:
+    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} "
+                   f"ORDER BY rowid LIMIT 1000")
+            cursor.execute(sql)
+            table = cursor.fetch_arrow_table()
+            return table.to_pandas(types_mapper=pd.ArrowDtype)

kumoai/experimental/rfm/base/__init__.py

@@ -1,10 +1,33 @@
-from .source import SourceColumn, SourceForeignKey
-from .column import Column
-from .table import Table
+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 .column_expression import ColumnExpressionSpec  # noqa: E402
+from .column_expression import ColumnExpressionType  # noqa: E402
+from .column_expression import ColumnExpression  # noqa: E402
+from .table import Table  # noqa: E402
+from .sql_table import SQLTable  # noqa: E402
+from .sampler import SamplerOutput, Sampler  # noqa: E402
+from .sql_sampler import SQLSampler  # noqa: E402
 
 __all__ = [
+    'DataBackend',
     'SourceColumn',
     'SourceForeignKey',
     'Column',
+    'ColumnExpressionSpec',
+    'ColumnExpressionType',
+    'ColumnExpression',
     'Table',
+    'SQLTable',
+    'SamplerOutput',
+    'Sampler',
+    'SQLSampler',
 ]

kumoai/experimental/rfm/base/column.py

@@ -8,20 +8,14 @@ from kumoapi.typing import Dtype, Stype
 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:
+    def __init__(self, name: str, stype: Stype, dtype: Dtype) -> 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._is_primary_key = False
+        self._is_time_column = False
+        self._is_end_time_column = False
+
         self.stype = Stype(stype)
 
     @property
@@ -32,6 +26,14 @@ class Column:
     def dtype(self) -> Dtype:
         return self._dtype
 
+    @property
+    def is_physical(self) -> bool:
+        return True
+
+    @property
+    def is_logical(self) -> bool:
+        return not self.is_physical
+
     def __setattr__(self, key: str, val: Any) -> None:
         if key == 'stype':
             if isinstance(val, str):

kumoai/experimental/rfm/base/column_expression.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from typing import Any, TypeAlias
+
+from kumoapi.typing import Dtype, Stype
+
+from kumoai.experimental.rfm.base import Column
+from kumoai.mixin import CastMixin
+
+
+@dataclass(frozen=True)
+class ColumnExpressionSpec(CastMixin):
+    name: str
+    expr: str
+    dtype: Dtype | None = None
+
+
+ColumnExpressionType: TypeAlias = ColumnExpressionSpec | dict[str, Any]
+
+
+@dataclass(init=False, repr=False, eq=False)
+class ColumnExpression(Column):
+    def __init__(
+        self,
+        name: str,
+        expr: str,
+        stype: Stype,
+        dtype: Dtype,
+    ) -> None:
+        super().__init__(name=name, stype=stype, dtype=dtype)
+        self._expr = expr
+
+    @property
+    def expr(self) -> str:
+        return self._expr
+
+    @property
+    def is_physical(self) -> bool:
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.expr, self.stype, self.dtype))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, ColumnExpression):
+            return False
+        return hash(self) == hash(other)
+
+    def __repr__(self) -> str:
+        return (f'{self.__class__.__name__}(name={self.name}, '
+                f'expr={self.expr}, stype={self.stype}, dtype={self.dtype})')