kumoai 2.12.0.dev202511071730__cp310-cp310-win_amd64.whl → 2.13.0.dev202512021731__cp310-cp310-win_amd64.whl

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

@@ -0,0 +1,32 @@
+from typing import Any, TypeAlias
+
+try:
+    import snowflake.connector
+except ImportError:
+    raise ImportError("No module named 'snowflake'. Please install Kumo SDK "
+                      "with the 'snowflake' extension via "
+                      "`pip install kumoai[snowflake]`.")
+
+Connection: TypeAlias = snowflake.connector.SnowflakeConnection
+
+
+def connect(**kwargs: Any) -> Connection:
+    r"""Opens a connection to a :class:`snowflake` database.
+
+    If available, will return a connection to the active session.
+
+    kwargs: Connection arguments, following the :class:`snowflake` protocol.
+    """
+    try:
+        from snowflake.snowpark.context import get_active_session
+        return get_active_session().connection
+    except Exception:
+        pass
+
+    return snowflake.connector.connect(**kwargs)
+
+
+__all__ = [
+    'connect',
+    'Connection',
+]

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,124 @@
+import re
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import pyarrow as pa
+from kumoapi.typing import Dtype, Stype
+from typing_extensions import Self
+
+from kumoai.experimental.rfm.backend.sqlite import Connection
+from kumoai.experimental.rfm.base import Table
+from kumoai.experimental.rfm.infer import infer_stype
+
+
+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
+        self._dtype_dict: Dict[str, Dtype] = {}
+
+        with connection.cursor() as cursor:
+            cursor.execute(f"PRAGMA table_info({name})")
+            for _, column, dtype, _, _, is_pkey in cursor.fetchall():
+                if bool(is_pkey):
+                    if primary_key is not None and primary_key != column:
+                        raise ValueError(f"Found duplicate primary key "
+                                         f"definition '{primary_key}' and "
+                                         f"'{column}' in table '{name}'")
+                    primary_key = column
+
+                # Determine colun affinity:
+                dtype = dtype.strip().upper()
+                if re.search('INT', dtype):
+                    self._dtype_dict[column] = Dtype.int
+                elif re.search('TEXT|CHAR|CLOB', dtype):
+                    self._dtype_dict[column] = Dtype.string
+                elif re.search('REAL|FLOA|DOUB', dtype):
+                    self._dtype_dict[column] = Dtype.float
+                else:  # NUMERIC affinity.
+                    self._dtype_dict[column] = Dtype.unsupported
+
+            if len(self._dtype_dict) > 0:
+                column_names = ', '.join(self._dtype_dict.keys())
+                cursor.execute(f"SELECT {column_names} FROM {name} "
+                               f"ORDER BY rowid LIMIT 1000")
+                self._sample = cursor.fetch_arrow_table()
+
+            for column_name in list(self._dtype_dict.keys()):
+                if self._dtype_dict[column_name] == Dtype.unsupported:
+                    dtype = self._sample[column_name].type
+                    if pa.types.is_integer(dtype):
+                        self._dtype_dict[column_name] = Dtype.int
+                    elif pa.types.is_floating(dtype):
+                        self._dtype_dict[column_name] = Dtype.float
+                    elif pa.types.is_decimal(dtype):
+                        self._dtype_dict[column_name] = Dtype.float
+                    elif pa.types.is_string(dtype):
+                        self._dtype_dict[column_name] = Dtype.string
+                    else:
+                        del self._dtype_dict[column_name]
+
+        if len(self._dtype_dict) == 0:
+            raise RuntimeError(f"Table '{name}' does not exist or does not "
+                               f"hold any column with a supported data type")
+
+        super().__init__(
+            name=name,
+            columns=columns or list(self._dtype_dict.keys()),
+            primary_key=primary_key,
+            time_column=time_column,
+            end_time_column=end_time_column,
+        )
+
+    def infer_metadata(self, verbose: bool = True) -> Self:
+        r"""Infers metadata, *i.e.*, primary keys and time columns, in the
+        table.
+
+        Args:
+            verbose: Whether to print verbose output.
+        """
+        return self
+
+    def _has_source_column(self, name: str) -> bool:
+        return name in self._dtype_dict
+
+    def _get_source_dtype(self, name: str) -> Dtype:
+        return self._dtype_dict[name]
+
+    def _get_source_stype(self, name: str, dtype: Dtype) -> Stype:
+        return infer_stype(self._sample[name].to_pandas(), name, dtype)
+
+    def _get_source_foreign_keys(self) -> List[Tuple[str, str, str]]:
+        edges: List[Tuple[str, str, str]] = []
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"PRAGMA foreign_key_list({self.name})")
+            for _, _, dst_table, fkey, pkey, _, _, _ in cursor.fetchall():
+                edges.append((fkey, dst_table, pkey))
+        return edges
+
+    def _infer_primary_key(self, candidates: List[str]) -> Optional[str]:
+        return None  # TODO
+
+    def _infer_time_column(self, candidates: List[str]) -> Optional[str]:
+        return None  # TODO
+
+    def _num_rows(self) -> Optional[int]:
+        return None

kumoai/experimental/rfm/base/__init__.py

@@ -0,0 +1,7 @@
+from .column import Column
+from .table import Table
+
+__all__ = [
+    'Column',
+    'Table',
+]

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/{local_table.py → base/table.py}

@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Sequence, Tuple
 
 import pandas as pd
 from kumoapi.source_table import UnavailableSourceTable
@@ -9,107 +9,17 @@ from kumoapi.typing import Dtype, Stype
 from typing_extensions import Self
 
 from kumoai import in_notebook
-from kumoai.experimental.rfm import utils
+from kumoai.experimental.rfm.base import Column
 
 
-@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})')
-
-
-class LocalTable:
-    r"""A table backed by a :class:`pandas.DataFrame`.
-
-    A :class:`LocalTable` fully specifies the relevant metadata, *i.e.*
-    selected columns, column semantic types, primary keys and time columns.
-    :class:`LocalTable` is used to create a :class:`LocalGraph`.
-
-    .. code-block:: python
-
-        import pandas as pd
-        import kumoai.experimental.rfm as rfm
-
-        # Load data from a CSV file:
-        df = pd.read_csv("data.csv")
-
-        # Create a table from a `pandas.DataFrame` and infer its metadata ...
-        table = rfm.LocalTable(df, name="my_table").infer_metadata()
-
-        # ... or create a table explicitly:
-        table = rfm.LocalTable(
-            df=df,
-            name="my_table",
-            primary_key="id",
-            time_column="time",
-            end_time_column=None,
-        )
-
-        # Verify metadata:
-        table.print_metadata()
-
-        # Change the semantic type of a column:
-        table[column].stype = "text"
+class Table(ABC):
+    r"""A :class:`Table` fully specifies the relevant metadata of a single
+    table, *i.e.* its selected columns, data types, semantic types, primary
+    keys and time columns.
 
     Args:
-        df: The data frame to create the table from.
-        name: The name of the table.
+        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
@@ -117,46 +27,40 @@ class LocalTable:
     """
     def __init__(
         self,
-        df: pd.DataFrame,
         name: str,
+        columns: Optional[Sequence[str]] = None,
         primary_key: Optional[str] = None,
         time_column: Optional[str] = None,
         end_time_column: Optional[str] = None,
     ) -> None:
 
-        if df.empty:
-            raise ValueError("Data frame must have at least one row")
-        if isinstance(df.columns, pd.MultiIndex):
-            raise ValueError("Data frame must not have a multi-index")
-        if not df.columns.is_unique:
-            raise ValueError("Data frame must have unique column names")
-        if any(col == '' for col in df.columns):
-            raise ValueError("Data frame must have non-empty column names")
-
-        df = df.copy(deep=False)
-
-        self._data = df
         self._name = name
         self._primary_key: Optional[str] = None
         self._time_column: Optional[str] = None
         self._end_time_column: Optional[str] = None
 
         self._columns: Dict[str, Column] = {}
-        for column_name in df.columns:
+        for column_name in columns or []:
             self.add_column(column_name)
 
         if primary_key is not None:
+            if primary_key not in self:
+                self.add_column(primary_key)
             self.primary_key = primary_key
 
         if time_column is not None:
+            if time_column not in self:
+                self.add_column(time_column)
             self.time_column = time_column
 
         if end_time_column is not None:
+            if end_time_column not in self:
+                self.add_column(end_time_column)
             self.end_time_column = end_time_column
 
     @property
     def name(self) -> str:
-        r"""The name of the table."""
+        r"""The name of this table."""
         return self._name
 
     # Data column #############################################################
@@ -200,24 +104,25 @@ class LocalTable:
             raise KeyError(f"Column '{name}' already exists in table "
                            f"'{self.name}'")
 
-        if name not in self._data.columns:
-            raise KeyError(f"Column '{name}' does not exist in the underyling "
-                           f"data frame")
+        if not self._has_source_column(name):
+            raise KeyError(f"Column '{name}' does not exist in the underlying "
+                           f"source table")
 
         try:
-            dtype = utils.to_dtype(self._data[name])
+            dtype = self._get_source_dtype(name)
         except Exception as e:
-            raise RuntimeError(f"Data type inference for column '{name}' in "
-                               f"table '{self.name}' failed. Consider "
-                               f"changing the data type of the column or "
-                               f"removing it from the table.") from e
+            raise RuntimeError(f"Could not obtain data type for column "
+                               f"'{name}' in table '{self.name}'. Change "
+                               f"the data type of the column in the source "
+                               f"table or remove it from the table.") from e
+
         try:
-            stype = utils.infer_stype(self._data[name], name, dtype)
+            stype = self._get_source_stype(name, dtype)
         except Exception as e:
-            raise RuntimeError(f"Semantic type inference for column '{name}' "
-                               f"in table '{self.name}' failed. Consider "
-                               f"changing the data type of the column or "
-                               f"removing it from the table.") from e
+            raise RuntimeError(f"Could not obtain semantic type for column "
+                               f"'{name}' in table '{self.name}'. Change "
+                               f"the data type of the column in the source "
+                               f"table or remove it from the table.") from e
 
         self._columns[name] = Column(
             name=name,
@@ -432,12 +337,14 @@ class LocalTable:
         })
 
     def print_metadata(self) -> None:
-        r"""Prints the :meth:`~LocalTable.metadata` of the table."""
+        r"""Prints the :meth:`~metadata` of this table."""
+        num_rows = self._num_rows()
+        num_rows_repr = ' ({num_rows:,} rows)' if num_rows is not None else ''
+
         if in_notebook():
             from IPython.display import Markdown, display
-            display(
-                Markdown(f"### 🏷️ Metadata of Table `{self.name}` "
-                         f"({len(self._data):,} rows)"))
+            md_repr = f"### 🏷️ Metadata of Table `{self.name}`{num_rows_repr}"
+            display(Markdown(md_repr))
             df = self.metadata
             try:
                 if hasattr(df.style, 'hide'):
@@ -447,8 +354,7 @@ class LocalTable:
             except ImportError:
                 print(df.to_string(index=False))  # missing jinja2
         else:
-            print(f"🏷️ Metadata of Table '{self.name}' "
-                  f"({len(self._data):,} rows):")
+            print(f"🏷️ Metadata of Table '{self.name}'{num_rows_repr}")
             print(self.metadata.to_string(index=False))
 
     def infer_metadata(self, verbose: bool = True) -> Self:
@@ -478,11 +384,7 @@ class LocalTable:
                 column.name for column in self.columns if is_candidate(column)
             ]
 
-            if primary_key := utils.detect_primary_key(
-                    table_name=self.name,
-                    df=self._data,
-                    candidates=candidates,
-            ):
+            if primary_key := self._infer_primary_key(candidates):
                 self.primary_key = primary_key
                 logs.append(f"primary key '{primary_key}'")
 
@@ -493,7 +395,7 @@ class LocalTable:
                 if column.stype == Stype.timestamp
                 and column.name != self._end_time_column
             ]
-            if time_column := utils.detect_time_column(self._data, candidates):
+            if time_column := self._infer_time_column(candidates):
                 self.time_column = time_column
                 logs.append(f"time column '{time_column}'")
 
@@ -543,3 +445,33 @@ class LocalTable:
                 f'  time_column={self._time_column},\n'
                 f'  end_time_column={self._end_time_column},\n'
                 f')')
+
+    # Abstract method #########################################################
+
+    @abstractmethod
+    def _has_source_column(self, name: str) -> bool:
+        pass
+
+    @abstractmethod
+    def _get_source_dtype(self, name: str) -> Dtype:
+        pass
+
+    @abstractmethod
+    def _get_source_stype(self, name: str, dtype: Dtype) -> Stype:
+        pass
+
+    @abstractmethod
+    def _get_source_foreign_keys(self) -> List[Tuple[str, str, str]]:
+        pass
+
+    @abstractmethod
+    def _infer_primary_key(self, candidates: List[str]) -> Optional[str]:
+        pass
+
+    @abstractmethod
+    def _infer_time_column(self, candidates: List[str]) -> Optional[str]:
+        pass
+
+    @abstractmethod
+    def _num_rows(self) -> Optional[int]:
+        pass