kumoai 2.8.0.dev202508221830__cp312-cp312-win_amd64.whl → 2.13.0.dev202512041141__cp312-cp312-win_amd64.whl

kumoai/experimental/rfm/__init__.py

@@ -1,43 +1,123 @@
-try:
-    import kumoai.kumolib  # noqa: F401
-except Exception as e:
-    import platform
-
-    _msg = f"""RFM is not supported in your environment.
-
-💻 Your Environment:
-Python version: {platform.python_version()}
-Operating system: {platform.system()}
-CPU architecture: {platform.machine()}
-glibc version: {platform.libc_ver()[1]}
-
-✅ Supported Environments:
-* Python versions: 3.9, 3.10, 3.11, 3.12, 3.13
-* Operating systems and CPU architectures:
-  * Linux (x86_64)
-  * macOS (arm64)
-  * Windows (x86_64)
-* glibc versions: >=2.28
-
-❌ Unsupported Environments:
-* Python versions: 3.8, 3.14
-* Operating systems and CPU architectures:
-  * Linux (arm64)
-  * macOS (x86_64)
-  * Windows (arm64)
-* glibc versions: <2.28
-
-Please create a feature request at 'https://github.com/kumo-ai/kumo-rfm'."""
-
-    raise RuntimeError(_msg) from e
-
-from typing import Optional, Dict
+import ipaddress
+import logging
 import os
+import re
+import socket
+import threading
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, Optional, Tuple
+from urllib.parse import urlparse
+
 import kumoai
-from .local_table import LocalTable
-from .local_graph import LocalGraph
-from .rfm import KumoRFM
+from kumoai.client.client import KumoClient
+
 from .authenticate import authenticate
+from .sagemaker import (
+    KumoClient_SageMakerAdapter,
+    KumoClient_SageMakerProxy_Local,
+)
+from .base import Table
+from .backend.local import LocalTable
+from .graph import Graph
+from .rfm import ExplainConfig, Explanation, KumoRFM
+
+logger = logging.getLogger('kumoai_rfm')
+
+
+def _is_local_address(host: str | None) -> bool:
+    """Return True if the hostname/IP refers to the local machine."""
+    if not host:
+        return False
+    try:
+        infos = socket.getaddrinfo(host, None)
+        for _, _, _, _, sockaddr in infos:
+            ip = sockaddr[0]
+            ip_obj = ipaddress.ip_address(ip)
+            if ip_obj.is_loopback or ip_obj.is_unspecified:
+                return True
+        return False
+    except Exception:
+        return False
+
+
+class InferenceBackend(str, Enum):
+    REST = "REST"
+    LOCAL_SAGEMAKER = "LOCAL_SAGEMAKER"
+    AWS_SAGEMAKER = "AWS_SAGEMAKER"
+    UNKNOWN = "UNKNOWN"
+
+
+def _detect_backend(
+        url: str) -> Tuple[InferenceBackend, Optional[str], Optional[str]]:
+    parsed = urlparse(url)
+
+    # Remote SageMaker
+    if ("runtime.sagemaker" in parsed.netloc
+            and parsed.path.endswith("/invocations")):
+        # Example: https://runtime.sagemaker.us-west-2.amazonaws.com/
+        # endpoints/Name/invocations
+        match = re.search(r"runtime\.sagemaker\.([a-z0-9-]+)\.amazonaws\.com",
+                          parsed.netloc)
+        region = match.group(1) if match else None
+        m = re.search(r"/endpoints/([^/]+)/invocations", parsed.path)
+        endpoint_name = m.group(1) if m else None
+        return InferenceBackend.AWS_SAGEMAKER, region, endpoint_name
+
+    # Local SageMaker
+    if parsed.port == 8080 and parsed.path.endswith(
+            "/invocations") and _is_local_address(parsed.hostname):
+        return InferenceBackend.LOCAL_SAGEMAKER, None, None
+
+    # Default: regular REST
+    return InferenceBackend.REST, None, None
+
+
+@dataclass
+class RfmGlobalState:
+    _url: str = '__url_not_provided__'
+    _backend: InferenceBackend = InferenceBackend.UNKNOWN
+    _region: Optional[str] = None
+    _endpoint_name: Optional[str] = None
+    _thread_local = threading.local()
+
+    # Thread-safe init-once.
+    _initialized: bool = False
+    _lock: threading.Lock = threading.Lock()
+
+    @property
+    def client(self) -> KumoClient:
+        if self._backend == InferenceBackend.REST:
+            return kumoai.global_state.client
+
+        if hasattr(self._thread_local, '_sagemaker'):
+            # Set the spcs token in the client to ensure it has the latest.
+            return self._thread_local._sagemaker
+
+        sagemaker_client: KumoClient
+        if self._backend == InferenceBackend.LOCAL_SAGEMAKER:
+            sagemaker_client = KumoClient_SageMakerProxy_Local(self._url)
+        else:
+            assert self._backend == InferenceBackend.AWS_SAGEMAKER
+            assert self._region
+            assert self._endpoint_name
+            sagemaker_client = KumoClient_SageMakerAdapter(
+                self._region, self._endpoint_name)
+
+        self._thread_local._sagemaker = sagemaker_client
+        return sagemaker_client
+
+    def reset(self) -> None:  # For testing only.
+        with self._lock:
+            self._initialized = False
+            self._url = '__url_not_provided__'
+            self._backend = InferenceBackend.UNKNOWN
+            self._region = None
+            self._endpoint_name = None
+            self._thread_local = threading.local()
+
+
+global_state = RfmGlobalState()
 
 
 def init(
@@ -47,19 +127,57 @@ def init(
     snowflake_application: Optional[str] = None,
     log_level: str = "INFO",
 ) -> None:
-    if url is None:
-        url = os.getenv("KUMO_API_URL", "https://kumorfm.ai/api")
+    with global_state._lock:
+        if global_state._initialized:
+            if url != global_state._url:
+                raise ValueError(
+                    "Kumo RFM has already been initialized with a different "
+                    "URL. Re-initialization with a different URL is not "
+                    "supported.")
+            return
 
-    kumoai.init(url=url, api_key=api_key,
-                snowflake_credentials=snowflake_credentials,
-                snowflake_application=snowflake_application,
-                log_level=log_level)
+        if url is None:
+            url = os.getenv("RFM_API_URL", "https://kumorfm.ai/api")
 
+        backend, region, endpoint_name = _detect_backend(url)
+        if backend == InferenceBackend.REST:
+            # Initialize kumoai.global_state
+            if (kumoai.global_state.initialized
+                    and kumoai.global_state._url != url):
+                raise ValueError(
+                    "Kumo AI SDK has already been initialized with different "
+                    "API URL. Please restart Python interpreter and "
+                    "initialize via kumoai.rfm.init()")
+            kumoai.init(url=url, api_key=api_key,
+                        snowflake_credentials=snowflake_credentials,
+                        snowflake_application=snowflake_application,
+                        log_level=log_level)
+        elif backend == InferenceBackend.AWS_SAGEMAKER:
+            assert region
+            assert endpoint_name
+            KumoClient_SageMakerAdapter(region, endpoint_name).authenticate()
+        else:
+            assert backend == InferenceBackend.LOCAL_SAGEMAKER
+            KumoClient_SageMakerProxy_Local(url).authenticate()
+
+        global_state._url = url
+        global_state._backend = backend
+        global_state._region = region
+        global_state._endpoint_name = endpoint_name
+        global_state._initialized = True
+        logger.info("Kumo RFM initialized with backend: %s, url: %s", backend,
+                    url)
+
+
+LocalGraph = Graph  # NOTE Backward compatibility - do not use anymore.
 
 __all__ = [
-    'LocalTable',
-    'LocalGraph',
-    'KumoRFM',
     'authenticate',
     'init',
+    'Table',
+    'LocalTable',
+    'Graph',
+    'KumoRFM',
+    'ExplainConfig',
+    'Explanation',
 ]

kumoai/experimental/rfm/authenticate.py

@@ -264,14 +264,17 @@ def _authenticate_local(api_url: str, redirect_port: int = 8765) -> None:
                  f"?callback_url={urllib.parse.quote(callback_url)}" +
                  f"&token_name={urllib.parse.quote(token_name)}")
 
-    print("Opening browser page to automatically generate an API key...")
+    print(
+        "Opening browser page to automatically generate an API key...\n" +
+        "If the page does not open, manually create a new API key at " +
+        f"{api_url}/api-keys and set it using os.environ[\"KUMO_API_KEY\"] " +
+        "= \"YOUR_API_KEY\"")
+
     webbrowser.open(login_url)
 
     def get_user_input() -> None:
-        print("If the page does not open, manually create a new API key at " +
-              f"{api_url}/api-keys and paste it below:")
-
-        token_entered = getpass("API Key (type then press enter): ").strip()
+        token_entered = getpass(
+            "or paste the API key here and press enter: ").strip()
 
         while (len(token_entered) == 0):
             token_entered = getpass(

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

@@ -0,0 +1,38 @@
+try:
+    import kumoai.kumolib  # noqa: F401
+except Exception as e:
+    import platform
+
+    _msg = f"""RFM is not supported in your environment.
+
+💻 Your Environment:
+Python version: {platform.python_version()}
+Operating system: {platform.system()}
+CPU architecture: {platform.machine()}
+glibc version: {platform.libc_ver()[1]}
+
+✅ Supported Environments:
+* Python versions: 3.10, 3.11, 3.12, 3.13
+* Operating systems and CPU architectures:
+  * Linux (x86_64)
+  * macOS (arm64)
+  * Windows (x86_64)
+* glibc versions: >=2.28
+
+❌ Unsupported Environments:
+* Python versions: 3.8, 3.9, 3.14
+* Operating systems and CPU architectures:
+  * Linux (arm64)
+  * macOS (x86_64)
+  * Windows (arm64)
+* glibc versions: <2.28
+
+Please create a feature request at 'https://github.com/kumo-ai/kumo-rfm'."""
+
+    raise RuntimeError(_msg) from e
+
+from .table import LocalTable
+
+__all__ = [
+    'LocalTable',
+]

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

@@ -0,0 +1,109 @@
+import warnings
+from typing import List, Optional
+
+import pandas as pd
+
+from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+from kumoai.experimental.rfm.infer import infer_dtype
+
+
+class LocalTable(Table):
+    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:`Graph`.
+
+    .. 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"
+
+    Args:
+        df: The data frame to create this table from.
+        name: The name 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,
+        df: pd.DataFrame,
+        name: str,
+        primary_key: Optional[str] = None,
+        time_column: Optional[str] = None,
+        end_time_column: Optional[str] = None,
+    ) -> None:
+
+        if df.empty:
+            raise ValueError("Data frame is empty")
+        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")
+
+        self._data = df.copy(deep=False)
+
+        super().__init__(
+            name=name,
+            columns=list(df.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] = []
+        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.")
+                continue
+
+            source_column = SourceColumn(
+                name=column,
+                dtype=dtype,
+                is_primary_key=False,
+                is_unique_key=False,
+            )
+            source_columns.append(source_column)
+
+        return source_columns
+
+    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+        return []
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        return self._data
+
+    def _get_num_rows(self) -> Optional[int]:
+        return len(self._data)

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

@@ -0,0 +1,35 @@
+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)
+
+
+from .table import SnowTable  # noqa: E402
+
+__all__ = [
+    'connect',
+    'Connection',
+    'SnowTable',
+]

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