kumoai 2.10.0.dev202510061830__cp313-cp313-macosx_11_0_arm64.whl → 2.13.0.dev202511261731__cp313-cp313-macosx_11_0_arm64.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):
@@ -200,9 +197,11 @@ def init(
 
     logger = logging.getLogger('kumoai')
     log_level = logging.getLevelName(logger.getEffectiveLevel())
+
     logger.info(
-        "Successfully initialized the Kumo SDK against deployment %s, with "
-        "log level %s.", url, log_level)
+        f"Successfully initialized the Kumo SDK (version {__version__}) "
+        f"against deployment {url}, with "
+        f"log level {log_level}.")
 
 
 def set_log_level(level: str) -> None:

kumoai/_version.py

@@ -1 +1 @@
-__version__ = '2.10.0.dev202510061830'
+__version__ = '2.13.0.dev202511261731'

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/endpoints.py

@@ -147,3 +147,4 @@ class RFMEndpoints:
     explain = Endpoint(f"{BASE}/explain", HTTPMethod.POST)
     evaluate = Endpoint(f"{BASE}/evaluate", HTTPMethod.POST)
     validate_query = Endpoint(f"{BASE}/validate_query", HTTPMethod.POST)
+    parse_query = Endpoint(f"{BASE}/parse_query", HTTPMethod.POST)

kumoai/client/rfm.py

@@ -1,7 +1,11 @@
+from typing import Any
+
 from kumoapi.json_serde import to_json_dict
 from kumoapi.rfm import (
     RFMEvaluateResponse,
     RFMExplanationResponse,
+    RFMParseQueryRequest,
+    RFMParseQueryResponse,
     RFMPredictResponse,
     RFMValidateQueryRequest,
     RFMValidateQueryResponse,
@@ -26,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)
@@ -58,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'})
@@ -82,3 +92,21 @@ class RFMAPI:
                                          json=to_json_dict(request))
         raise_on_error(response)
         return parse_response(RFMValidateQueryResponse, response)
+
+    def parse_query(
+        self,
+        request: RFMParseQueryRequest,
+    ) -> RFMParseQueryResponse:
+        """Validate a predictive query against a graph.
+
+        Args:
+            request: The request object containing
+                the query and graph definition
+
+        Returns:
+            RFMParseQueryResponse containing the QueryDefinition
+        """
+        response = self._client._request(RFMEndpoints.parse_query,
+                                         json=to_json_dict(request))
+        raise_on_error(response)
+        return parse_response(RFMParseQueryResponse, response)

kumoai/experimental/rfm/__init__.py

@@ -12,7 +12,7 @@ CPU architecture: {platform.machine()}
 glibc version: {platform.libc_ver()[1]}
 
 ✅ Supported Environments:
-* Python versions: 3.9, 3.10, 3.11, 3.12, 3.13
+* Python versions: 3.10, 3.11, 3.12, 3.13
 * Operating systems and CPU architectures:
   * Linux (x86_64)
   * macOS (arm64)
@@ -20,7 +20,7 @@ glibc version: {platform.libc_ver()[1]}
 * glibc versions: >=2.28
 
 ❌ Unsupported Environments:
-* Python versions: 3.8, 3.14
+* Python versions: 3.8, 3.9, 3.14
 * Operating systems and CPU architectures:
   * Linux (arm64)
   * macOS (x86_64)
@@ -31,14 +31,122 @@ Please create a feature request at 'https://github.com/kumo-ai/kumo-rfm'."""
 
     raise RuntimeError(_msg) from e
 
-from typing import Optional, Dict
+from dataclasses import dataclass
+from enum import Enum
+import ipaddress
+import logging
+import re
+import socket
+import threading
+from typing import Optional, Dict, Tuple
 import os
+from urllib.parse import urlparse
 import kumoai
+from kumoai.client.client import KumoClient
+from .sagemaker import (KumoClient_SageMakerAdapter,
+                        KumoClient_SageMakerProxy_Local)
 from .local_table import LocalTable
 from .local_graph import LocalGraph
-from .rfm import KumoRFM
+from .rfm import ExplainConfig, Explanation, KumoRFM
 from .authenticate import authenticate
 
+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(
     url: Optional[str] = None,
@@ -47,19 +155,54 @@ 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
+
+        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()
 
-    kumoai.init(url=url, api_key=api_key,
-                snowflake_credentials=snowflake_credentials,
-                snowflake_application=snowflake_application,
-                log_level=log_level)
+        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)
 
 
 __all__ = [
     'LocalTable',
     'LocalGraph',
     'KumoRFM',
+    'ExplainConfig',
+    'Explanation',
     'authenticate',
     'init',
 ]

kumoai/experimental/rfm/infer/timestamp.py

@@ -21,9 +21,7 @@ def contains_timestamp(ser: pd.Series, column_name: str, dtype: Dtype) -> bool:
         column_name,
         re.IGNORECASE,
     )
-
-    if match is not None:
-        return True
+    score = 0.3 if match is not None else 0.0
 
     ser = ser.iloc[:100]
     ser = ser.dropna()
@@ -37,4 +35,7 @@ def contains_timestamp(ser: pd.Series, column_name: str, dtype: Dtype) -> bool:
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', UnknownTimezoneWarning)
         warnings.filterwarnings('ignore', message='Could not infer format')
-        return pd.to_datetime(ser, errors='coerce').notna().all()
+        mask = pd.to_datetime(ser, errors='coerce').notna()
+        score += int(mask.sum()) / len(mask)
+
+    return score >= 1.0

kumoai/experimental/rfm/local_graph.py

@@ -29,45 +29,46 @@ class LocalGraph:
 
     .. code-block:: python
 
-        import pandas as pd
-        import kumoai.experimental.rfm as rfm
-
-        # Load data frames into memory:
-        df1 = pd.DataFrame(...)
-        df2 = pd.DataFrame(...)
-        df3 = pd.DataFrame(...)
-
-        # Define tables from data frames:
-        table1 = rfm.LocalTable(name="table1", data=df1)
-        table2 = rfm.LocalTable(name="table2", data=df2)
-        table3 = rfm.LocalTable(name="table3", data=df3)
-
-        # Create a graph from a dictionary of tables:
-        graph = rfm.LocalGraph({
-            "table1": table1,
-            "table2": table2,
-            "table3": table3,
-        })
-
-        # Infer table metadata:
-        graph.infer_metadata()
-
-        # Infer links/edges:
-        graph.infer_links()
-
-        # Inspect table metadata:
-        for table in graph.tables.values():
-            table.print_metadata()
-
-        # Visualize graph (if graphviz is installed):
-        graph.visualize()
-
-        # Add/Remove edges between tables:
-        graph.link(src_table="table1", fkey="id1", dst_table="table2")
-        graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
-
-        # Validate graph:
-        graph.validate()
+        >>> # doctest: +SKIP
+        >>> import pandas as pd
+        >>> import kumoai.experimental.rfm as rfm
+
+        >>> # Load data frames into memory:
+        >>> df1 = pd.DataFrame(...)
+        >>> df2 = pd.DataFrame(...)
+        >>> df3 = pd.DataFrame(...)
+
+        >>> # Define tables from data frames:
+        >>> table1 = rfm.LocalTable(name="table1", data=df1)
+        >>> table2 = rfm.LocalTable(name="table2", data=df2)
+        >>> table3 = rfm.LocalTable(name="table3", data=df3)
+
+        >>> # Create a graph from a dictionary of tables:
+        >>> graph = rfm.LocalGraph({
+        ...     "table1": table1,
+        ...     "table2": table2,
+        ...     "table3": table3,
+        ... })
+
+        >>> # Infer table metadata:
+        >>> graph.infer_metadata()
+
+        >>> # Infer links/edges:
+        >>> graph.infer_links()
+
+        >>> # Inspect table metadata:
+        >>> for table in graph.tables.values():
+        ...     table.print_metadata()
+
+        >>> # Visualize graph (if graphviz is installed):
+        >>> graph.visualize()
+
+        >>> # Add/Remove edges between tables:
+        >>> graph.link(src_table="table1", fkey="id1", dst_table="table2")
+        >>> graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
+
+        >>> # Validate graph:
+        >>> graph.validate()
     """
 
     # Constructors ############################################################
@@ -104,27 +105,28 @@ class LocalGraph:
 
         .. code-block:: python
 
-            import pandas as pd
-            import kumoai.experimental.rfm as rfm
+            >>> # doctest: +SKIP
+            >>> import pandas as pd
+            >>> import kumoai.experimental.rfm as rfm
 
-            # Load data frames into memory:
-            df1 = pd.DataFrame(...)
-            df2 = pd.DataFrame(...)
-            df3 = pd.DataFrame(...)
+            >>> # Load data frames into memory:
+            >>> df1 = pd.DataFrame(...)
+            >>> df2 = pd.DataFrame(...)
+            >>> df3 = pd.DataFrame(...)
 
-            # Create a graph from a dictionary of data frames:
-            graph = rfm.LocalGraph.from_data({
-                "table1": df1,
-                "table2": df2,
-                "table3": df3,
-            })
+            >>> # Create a graph from a dictionary of data frames:
+            >>> graph = rfm.LocalGraph.from_data({
+            ...     "table1": df1,
+            ...     "table2": df2,
+            ...     "table3": df3,
+            ... })
 
-            # Inspect table metadata:
-            for table in graph.tables.values():
-                table.print_metadata()
+            >>> # Inspect table metadata:
+            >>> for table in graph.tables.values():
+            ...     table.print_metadata()
 
-            # Visualize graph (if graphviz is installed):
-            graph.visualize()
+            >>> # Visualize graph (if graphviz is installed):
+            >>> graph.visualize()
 
         Args:
             df_dict: A dictionary of data frames, where the keys are the names
@@ -141,6 +143,7 @@ class LocalGraph:
             graph.
 
         Example:
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
             >>> df1 = pd.DataFrame(...)
             >>> df2 = pd.DataFrame(...)
@@ -150,7 +153,7 @@ class LocalGraph:
             ...     "table2": df2,
             ...     "table3": df3,
             ... })
-            ... graph.validate()
+            >>> graph.validate()
         """
         tables = [LocalTable(df, name) for name, df in df_dict.items()]
 
@@ -231,16 +234,17 @@ class LocalGraph:
         r"""Returns a :class:`pandas.DataFrame` object containing metadata
         information about the tables in this graph.
 
-        The returned dataframe has columns ``name``, ``primary_key``, and
-        ``time_column``, which provide an aggregate view of the properties of
-        the tables of this graph.
+        The returned dataframe has columns ``name``, ``primary_key``,
+        ``time_column``, and ``end_time_column``, which provide an aggregate
+        view of the properties of the tables of this graph.
 
         Example:
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
             >>> graph = rfm.LocalGraph(tables=...).infer_metadata()
-            >>> graph.metadata
-                name  primary_key time_column
-            0   users     user_id           -
+            >>> graph.metadata  # doctest: +SKIP
+                name   primary_key  time_column  end_time_column
+            0   users      user_id            -                -
         """
         tables = list(self.tables.values())
 
@@ -251,6 +255,11 @@ class LocalGraph:
             pd.Series(dtype=str, data=[t._primary_key or '-' for t in tables]),
             'time_column':
             pd.Series(dtype=str, data=[t._time_column or '-' for t in tables]),
+            'end_time_column':
+            pd.Series(
+                dtype=str,
+                data=[t._end_time_column or '-' for t in tables],
+            ),
         })
 
     def print_metadata(self) -> None:
@@ -602,8 +611,8 @@ class LocalGraph:
                 raise ValueError(f"{edge} is invalid as foreign key "
                                  f"'{fkey}' and primary key '{dst_key.name}' "
                                  f"have incompatible data types (got "
-                                 f"fkey.dtype '{dst_key.dtype}' and "
-                                 f"pkey.dtype '{src_key.dtype}')")
+                                 f"fkey.dtype '{src_key.dtype}' and "
+                                 f"pkey.dtype '{dst_key.dtype}')")
 
         return self
 
@@ -676,6 +685,11 @@ class LocalGraph:
             ]
             if time_column := table.time_column:
                 keys += [f'{time_column.name}: Time ({time_column.dtype})']
+            if end_time_column := table.end_time_column:
+                keys += [
+                    f'{end_time_column.name}: '
+                    f'End Time ({end_time_column.dtype})'
+                ]
             key_repr = left_align(keys)
 
             columns = []
@@ -683,9 +697,9 @@ class LocalGraph:
                 columns += [
                     f'{column.name}: {column.stype} ({column.dtype})'
                     for column in table.columns
-                    if column.name not in fkeys_dict[table_name]
-                    and column.name != table._primary_key
-                    and column.name != table._time_column
+                    if column.name not in fkeys_dict[table_name] and
+                    column.name != table._primary_key and column.name != table.
+                    _time_column and column.name != table._end_time_column
                 ]
             column_repr = left_align(columns)
 
@@ -752,16 +766,18 @@ class LocalGraph:
     def _to_api_graph_definition(self) -> GraphDefinition:
         tables: Dict[str, TableDefinition] = {}
         col_groups: List[ColumnKeyGroup] = []
-        for t_name, table in self.tables.items():
-            tables[t_name] = table._to_api_table_definition()
+        for table_name, table in self.tables.items():
+            tables[table_name] = table._to_api_table_definition()
             if table.primary_key is None:
                 continue
-            keys = [ColumnKey(t_name, table.primary_key.name)]
+            keys = [ColumnKey(table_name, table.primary_key.name)]
             for edge in self.edges:
-                if edge.dst_table == t_name:
+                if edge.dst_table == table_name:
                     keys.append(ColumnKey(edge.src_table, edge.fkey))
-            keys = sorted(list(set(keys)),
-                          key=lambda x: f'{x.table_name}.{x.col_name}')
+            keys = sorted(
+                list(set(keys)),
+                key=lambda x: f'{x.table_name}.{x.col_name}',
+            )
             if len(keys) > 1:
                 col_groups.append(ColumnKeyGroup(keys))
         return GraphDefinition(tables, col_groups)