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

kumoai/__init__.py

@@ -184,15 +184,12 @@ def init(
         snowflake_credentials
     ) if not api_key and snowflake_credentials else None
     client = KumoClient(url=url, api_key=api_key, spcs_token=spcs_token)
-    if client.authenticate():
-        global_state._url = client._url
-        global_state._api_key = client._api_key
-        global_state._snowflake_credentials = snowflake_credentials
-        global_state._spcs_token = client._spcs_token
-        global_state._snowpark_session = snowpark_session
-    else:
-        raise ValueError("Client authentication failed. Please check if you "
-                         "have a valid API key.")
+    client.authenticate()
+    global_state._url = client._url
+    global_state._api_key = client._api_key
+    global_state._snowflake_credentials = snowflake_credentials
+    global_state._spcs_token = client._spcs_token
+    global_state._snowpark_session = snowpark_session
 
     if not api_key and snowflake_credentials:
         # Refresh token every 10 minutes (expires in 1 hour):

kumoai/_version.py

@@ -1 +1 @@
-__version__ = '2.12.0.dev202511071730'
+__version__ = '2.13.0.dev202512021731'

kumoai/client/client.py

@@ -20,7 +20,6 @@ if TYPE_CHECKING:
     )
     from kumoai.client.online import OnlineServingEndpointAPI
     from kumoai.client.pquery import PQueryAPI
-    from kumoai.client.rfm import RFMAPI
     from kumoai.client.source_table import SourceTableAPI
     from kumoai.client.table import TableAPI
 
@@ -73,12 +72,15 @@ class KumoClient:
             self._session.headers.update(
                 {'Authorization': f'Snowflake Token={self._spcs_token}'})
 
-    def authenticate(self) -> bool:
-        r"""Raises an exception if authentication fails. Succeeds if the
-        client is properly formed.
-        """
-        return self._session.get(f"{self._url}/v1/connectors",
-                                 verify=self._verify_ssl).ok
+    def authenticate(self) -> None:
+        """Raises an exception if authentication fails."""
+        try:
+            self._session.get(self._url + '/v1/connectors',
+                              verify=self._verify_ssl).raise_for_status()
+        except Exception:
+            raise ValueError(
+                "Client authentication failed. Please check if you "
+                "have a valid API key/credentials.")
 
     def set_spcs_token(self, spcs_token: str) -> None:
         r"""Sets the SPCS token for the client and updates the session
@@ -163,12 +165,6 @@ class KumoClient:
         from kumoai.client.online import OnlineServingEndpointAPI
         return OnlineServingEndpointAPI(self)
 
-    @property
-    def rfm_api(self) -> 'RFMAPI':
-        r"""Returns the typed RFM API."""
-        from kumoai.client.rfm import RFMAPI
-        return RFMAPI(self)
-
     def _request(self, endpoint: Endpoint, **kwargs: Any) -> requests.Response:
         r"""Send a HTTP request to the specified endpoint."""
         endpoint_str = endpoint.get_path()

kumoai/client/rfm.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from kumoapi.json_serde import to_json_dict
 from kumoapi.rfm import (
     RFMEvaluateResponse,
@@ -28,25 +30,32 @@ class RFMAPI:
         Returns:
             RFMPredictResponse containing the predictions
         """
-        # Send binary data to the predict endpoint
         response = self._client._request(
-            RFMEndpoints.predict, data=request,
-            headers={'Content-Type': 'application/x-protobuf'})
+            RFMEndpoints.predict,
+            data=request,
+            headers={'Content-Type': 'application/x-protobuf'},
+        )
         raise_on_error(response)
         return parse_response(RFMPredictResponse, response)
 
-    def explain(self, request: bytes) -> RFMExplanationResponse:
+    def explain(
+        self,
+        request: bytes,
+        skip_summary: bool = False,
+    ) -> RFMExplanationResponse:
         """Explain the RFM model on the given context.
 
         Args:
             request: The predict request as serialized protobuf.
+            skip_summary: Whether to skip generating a human-readable summary
+                of the explanation.
 
         Returns:
             RFMPredictResponse containing the explanations
         """
-        # Send binary data to the explain endpoint
+        params: dict[str, Any] = {'generate_summary': not skip_summary}
         response = self._client._request(
-            RFMEndpoints.explain, data=request,
+            RFMEndpoints.explain, data=request, params=params,
             headers={'Content-Type': 'application/x-protobuf'})
         raise_on_error(response)
         return parse_response(RFMExplanationResponse, response)
@@ -60,7 +69,6 @@ class RFMAPI:
         Returns:
             RFMEvaluateResponse containing the computed metrics
         """
-        # Send binary data to the evaluate endpoint
         response = self._client._request(
             RFMEndpoints.evaluate, data=request,
             headers={'Content-Type': 'application/x-protobuf'})

kumoai/connector/utils.py

@@ -381,8 +381,29 @@ def _handle_duplicate_names(names: List[str]) -> List[str]:
 
 
 def _sanitize_columns(names: List[str]) -> Tuple[List[str], bool]:
-    _SAN_RE = re.compile(r"[^0-9A-Za-z]+")
+    """Normalize column names in a CSV or Parquet file.
+
+    Rules:
+      - Replace any non-alphanumeric character with "_"
+      - Strip leading/trailing underscores
+      - Ensure uniqueness by appending suffixes: _1, _2, ...
+      - Auto-name empty columns as auto_named_<n>
+
+    Returns:
+        (new_column_names, changed)
+    """
+    _SAN_RE = re.compile(r"[^0-9A-Za-z,\t]")
+    # 1) Replace non-alphanumeric sequences with underscore
     new = [_SAN_RE.sub("_", n).strip("_") for n in names]
+
+    # 2) Auto-name any empty column names to match UI behavior
+    unnamed_counter = 0
+    for i, n in enumerate(new):
+        if not n:
+            new[i] = f"auto_named_{unnamed_counter}"
+            unnamed_counter += 1
+
+    # 3) Ensure uniqueness (append suffixes where needed)
     new = _handle_duplicate_names(new)
     return new, new != names
 
@@ -1168,7 +1189,7 @@ def _detect_and_validate_csv(head_bytes: bytes) -> str:
     - Re-serializes those rows and validates with pandas (small nrows) to catch
       malformed inputs.
     - Raises ValueError on empty input or if parsing fails with the chosen
-    delimiter.
+      delimiter.
     """
     if not head_bytes:
         raise ValueError("Could not auto-detect a delimiter: file is empty.")

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.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 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/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,244 @@
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from kumoapi.typing import Dtype, Stype
+from typing_extensions import Self
+
+from kumoai.experimental.rfm import utils
+from kumoai.experimental.rfm.base import Column, Table
+from kumoai.experimental.rfm.infer import infer_stype
+
+
+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 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")
+
+        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 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.
+        """
+        logs = []
+
+        # Try to detect primary key if not set:
+        if not self.has_primary_key():
+
+            def is_candidate(column: Column) -> bool:
+                if column.stype == Stype.ID:
+                    return True
+                if all(column.stype != Stype.ID for column in self.columns):
+                    if self.name == column.name:
+                        return True
+                    if (self.name.endswith('s')
+                            and self.name[:-1] == column.name):
+                        return True
+                return False
+
+            candidates = [
+                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,
+            ):
+                self.primary_key = primary_key
+                logs.append(f"primary key '{primary_key}'")
+
+        # Try to detect time column if not set:
+        if not self.has_time_column():
+            candidates = [
+                column.name for column in self.columns
+                if column.stype == Stype.timestamp
+                and column.name != self._end_time_column
+            ]
+            if time_column := utils.detect_time_column(self._data, candidates):
+                self.time_column = time_column
+                logs.append(f"time column '{time_column}'")
+
+        if verbose and len(logs) > 0:
+            print(f"Detected {' and '.join(logs)} in table '{self.name}'")
+
+        return self
+
+    def _has_source_column(self, name: str) -> bool:
+        return name in self._data.columns
+
+    def _get_source_dtype(self, name: str) -> Dtype:
+        return to_dtype(self._data[name])
+
+    def _get_source_stype(self, name: str, dtype: Dtype) -> Stype:
+        return infer_stype(self._data[name], name, dtype)
+
+    def _get_source_foreign_keys(self) -> List[Tuple[str, str, str]]:
+        return []
+
+    def _infer_primary_key(self, candidates: List[str]) -> Optional[str]:
+        return utils.detect_primary_key(
+            table_name=self.name,
+            df=self._data,
+            candidates=candidates,
+        )
+
+    def _infer_time_column(self, candidates: List[str]) -> Optional[str]:
+        return utils.detect_time_column(df=self._data, candidates=candidates)
+
+    def _num_rows(self) -> Optional[int]:
+        return len(self._data)
+
+
+# Data Type ###################################################################
+
+PANDAS_TO_DTYPE: Dict[Any, Dtype] = {
+    np.dtype('bool'): Dtype.bool,
+    pd.BooleanDtype(): Dtype.bool,
+    pa.bool_(): Dtype.bool,
+    np.dtype('byte'): Dtype.int,
+    pd.UInt8Dtype(): Dtype.int,
+    np.dtype('int16'): Dtype.int,
+    pd.Int16Dtype(): Dtype.int,
+    np.dtype('int32'): Dtype.int,
+    pd.Int32Dtype(): Dtype.int,
+    np.dtype('int64'): Dtype.int,
+    pd.Int64Dtype(): Dtype.int,
+    np.dtype('float32'): Dtype.float,
+    pd.Float32Dtype(): Dtype.float,
+    np.dtype('float64'): Dtype.float,
+    pd.Float64Dtype(): Dtype.float,
+    np.dtype('object'): Dtype.string,
+    pd.StringDtype(storage='python'): Dtype.string,
+    pd.StringDtype(storage='pyarrow'): Dtype.string,
+    pa.string(): Dtype.string,
+    pa.binary(): Dtype.binary,
+    np.dtype('datetime64[ns]'): Dtype.date,
+    np.dtype('timedelta64[ns]'): Dtype.timedelta,
+    pa.list_(pa.float32()): Dtype.floatlist,
+    pa.list_(pa.int64()): Dtype.intlist,
+    pa.list_(pa.string()): Dtype.stringlist,
+}
+
+
+def to_dtype(ser: pd.Series) -> Dtype:
+    """Extracts the :class:`Dtype` from a :class:`pandas.Series`.
+
+    Args:
+        ser: A :class:`pandas.Series` to analyze.
+
+    Returns:
+        The data type.
+    """
+    if pd.api.types.is_datetime64_any_dtype(ser.dtype):
+        return Dtype.date
+
+    if isinstance(ser.dtype, pd.CategoricalDtype):
+        return Dtype.string
+
+    if pd.api.types.is_object_dtype(ser.dtype):
+        index = ser.iloc[:1000].first_valid_index()
+        if index is not None and pd.api.types.is_list_like(ser[index]):
+            pos = ser.index.get_loc(index)
+            assert isinstance(pos, int)
+            ser = ser.iloc[pos:pos + 1000].dropna()
+
+            if not ser.map(pd.api.types.is_list_like).all():
+                raise ValueError("Data contains a mix of list-like and "
+                                 "non-list-like values")
+
+            # Remove all empty Python lists without known data type:
+            ser = ser[ser.map(lambda x: not isinstance(x, list) or len(x) > 0)]
+
+            # Infer unique data types in this series:
+            dtypes = ser.apply(lambda x: PANDAS_TO_DTYPE.get(
+                np.array(x).dtype, Dtype.string)).unique().tolist()
+
+            invalid_dtypes = set(dtypes) - {
+                Dtype.string,
+                Dtype.int,
+                Dtype.float,
+            }
+            if len(invalid_dtypes) > 0:
+                raise ValueError(f"Data contains unsupported list data types: "
+                                 f"{list(invalid_dtypes)}")
+
+            if Dtype.string in dtypes:
+                return Dtype.stringlist
+
+            if dtypes == [Dtype.int]:
+                return Dtype.intlist
+
+            return Dtype.floatlist
+
+    if ser.dtype not in PANDAS_TO_DTYPE:
+        raise ValueError(f"Unsupported data type '{ser.dtype}'")
+
+    return PANDAS_TO_DTYPE[ser.dtype]