kumoai 2.13.0.dev202511131731__cp310-cp310-macosx_11_0_arm64.whl → 2.13.0.dev202511191731__cp310-cp310-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):

kumoai/_version.py

@@ -1 +1 @@
-__version__ = '2.13.0.dev202511131731'
+__version__ = '2.13.0.dev202511191731'

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/experimental/rfm/__init__.py

@@ -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 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,13 +155,46 @@ 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__ = [

kumoai/experimental/rfm/local_graph_sampler.py

@@ -2,7 +2,6 @@ from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
-from kumoapi.model_plan import RunMode
 from kumoapi.rfm.context import EdgeLayout, Link, Subgraph, Table
 from kumoapi.typing import Stype
 
@@ -33,7 +32,6 @@ class LocalGraphSampler:
         entity_table_names: Tuple[str, ...],
         node: np.ndarray,
         time: np.ndarray,
-        run_mode: RunMode,
         num_neighbors: List[int],
         exclude_cols_dict: Dict[str, List[str]],
     ) -> Subgraph:

kumoai/experimental/rfm/rfm.py

@@ -30,7 +30,7 @@ from kumoapi.rfm import (
 )
 from kumoapi.task import TaskType
 
-from kumoai import global_state
+from kumoai.client.rfm import RFMAPI
 from kumoai.exceptions import HTTPException
 from kumoai.experimental.rfm import LocalGraph
 from kumoai.experimental.rfm.local_graph_sampler import LocalGraphSampler
@@ -141,9 +141,9 @@ class KumoRFM:
 
         rfm = KumoRFM(graph)
 
-        query = ("PREDICT COUNT(transactions.*, 0, 30, days)>0 "
-                 "FOR users.user_id=0")
-        result = rfm.query(query)
+        query = ("PREDICT COUNT(orders.*, 0, 30, days)>0 "
+                 "FOR users.user_id=1")
+        result = rfm.predict(query)
 
         print(result)  # user_id  COUNT(transactions.*, 0, 30, days) > 0
                        # 1        0.85
@@ -174,6 +174,8 @@ class KumoRFM:
 
         self._batch_size: Optional[int | Literal['max']] = None
         self.num_retries: int = 0
+        from kumoai.experimental.rfm import global_state
+        self._api_client = RFMAPI(global_state.client)
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}()'
@@ -420,14 +422,14 @@ class KumoRFM:
                 for attempt in range(self.num_retries + 1):
                     try:
                         if explain_config is not None:
-                            resp = global_state.client.rfm_api.explain(
+                            resp = self._api_client.explain(
                                 request=_bytes,
                                 skip_summary=explain_config.skip_summary,
                             )
                             summary = resp.summary
                             details = resp.details
                         else:
-                            resp = global_state.client.rfm_api.predict(_bytes)
+                            resp = self._api_client.predict(_bytes)
                         df = pd.DataFrame(**resp.prediction)
 
                         # Cast 'ENTITY' to correct data type:
@@ -633,7 +635,7 @@ class KumoRFM:
                 raise ValueError(_SIZE_LIMIT_MSG.format(stats=stats_msg))
 
             try:
-                resp = global_state.client.rfm_api.evaluate(request_bytes)
+                resp = self._api_client.evaluate(request_bytes)
             except HTTPException as e:
                 try:
                     msg = json.loads(e.detail)['detail']
@@ -731,7 +733,8 @@ class KumoRFM:
                 graph_definition=self._graph_def,
             )
 
-            resp = global_state.client.rfm_api.parse_query(request)
+            resp = self._api_client.parse_query(request)
+
             # TODO Expose validation warnings.
 
             if len(resp.validation_response.warnings) > 0:
@@ -1035,7 +1038,6 @@ class KumoRFM:
                 train_time.astype('datetime64[ns]').astype(int).to_numpy(),
                 test_time.astype('datetime64[ns]').astype(int).to_numpy(),
             ]),
-            run_mode=run_mode,
             num_neighbors=num_neighbors,
             exclude_cols_dict=exclude_cols_dict,
         )

kumoai/experimental/rfm/sagemaker.py

@@ -0,0 +1,130 @@
+import base64
+import json
+from typing import Any, Dict, List, Tuple
+
+import boto3
+import requests
+from mypy_boto3_sagemaker_runtime.client import SageMakerRuntimeClient
+from mypy_boto3_sagemaker_runtime.type_defs import InvokeEndpointOutputTypeDef
+
+from kumoai.client import KumoClient
+from kumoai.client.endpoints import Endpoint, HTTPMethod
+from kumoai.exceptions import HTTPException
+
+
+class SageMakerResponseAdapter(requests.Response):
+    def __init__(self, sm_response: InvokeEndpointOutputTypeDef):
+        super().__init__()
+        # Read the body bytes
+        self._content = sm_response['Body'].read()
+        self.status_code = 200
+        self.headers['Content-Type'] = sm_response.get('ContentType',
+                                                       'application/json')
+        # Optionally, you can store original sm_response for debugging
+        self.sm_response = sm_response
+
+    @property
+    def text(self) -> str:
+        assert isinstance(self._content, bytes)
+        return self._content.decode('utf-8')
+
+    def json(self, **kwargs) -> dict[str, Any]:  # type: ignore
+        return json.loads(self.text, **kwargs)
+
+
+class KumoClient_SageMakerAdapter(KumoClient):
+    def __init__(self, region: str, endpoint_name: str):
+        self._client: SageMakerRuntimeClient = boto3.client(
+            service_name="sagemaker-runtime", region_name=region)
+        self._endpoint_name = endpoint_name
+
+        # Recording buffers.
+        self._recording_active = False
+        self._recorded_reqs: List[Dict[str, Any]] = []
+        self._recorded_resps: List[Dict[str, Any]] = []
+
+    def authenticate(self) -> None:
+        # TODO(siyang): call /ping to verify?
+        pass
+
+    def _request(self, endpoint: Endpoint, **kwargs: Any) -> requests.Response:
+        assert endpoint.method == HTTPMethod.POST
+        if 'json' in kwargs:
+            payload = json.dumps(kwargs.pop('json'))
+        elif 'data' in kwargs:
+            raw_payload = kwargs.pop('data')
+            assert isinstance(raw_payload, bytes)
+            payload = base64.b64encode(raw_payload).decode()
+        else:
+            raise HTTPException(400, 'Unable to send data to KumoRFM.')
+
+        request = {
+            'method': endpoint.get_path().rsplit('/')[-1],
+            'payload': payload,
+        }
+        response: InvokeEndpointOutputTypeDef = self._client.invoke_endpoint(
+            EndpointName=self._endpoint_name,
+            ContentType="application/json",
+            Body=json.dumps(request),
+        )
+
+        adapted_response = SageMakerResponseAdapter(response)
+
+        # If validation is active, store input/output
+        if self._recording_active:
+            self._recorded_reqs.append(request)
+            self._recorded_resps.append(adapted_response.json())
+
+        return adapted_response
+
+    def start_recording(self) -> None:
+        """Start recording requests/responses to/from sagemaker endpoint."""
+        assert not self._recording_active
+        self._recording_active = True
+        self._recorded_reqs.clear()
+        self._recorded_resps.clear()
+
+    def end_recording(self) -> List[Tuple[Dict[str, Any], Dict[str, Any]]]:
+        """Stop recording and return recorded requests/responses."""
+        assert self._recording_active
+        self._recording_active = False
+        recorded = list(zip(self._recorded_reqs, self._recorded_resps))
+        self._recorded_reqs.clear()
+        self._recorded_resps.clear()
+        return recorded
+
+
+class KumoClient_SageMakerProxy_Local(KumoClient):
+    def __init__(self, url: str):
+        self._client = KumoClient(url, api_key=None)
+        self._client._api_url = self._client._url
+        self._endpoint = Endpoint('/invocations', HTTPMethod.POST)
+
+    def authenticate(self) -> None:
+        try:
+            self._client._session.get(
+                self._url + '/ping',
+                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 _request(self, endpoint: Endpoint, **kwargs: Any) -> requests.Response:
+        assert endpoint.method == HTTPMethod.POST
+        if 'json' in kwargs:
+            payload = json.dumps(kwargs.pop('json'))
+        elif 'data' in kwargs:
+            raw_payload = kwargs.pop('data')
+            assert isinstance(raw_payload, bytes)
+            payload = base64.b64encode(raw_payload).decode()
+        else:
+            raise HTTPException(400, 'Unable to send data to KumoRFM.')
+        return self._client._request(
+            self._endpoint,
+            json={
+                'method': endpoint.get_path().rsplit('/')[-1],
+                'payload': payload,
+            },
+            **kwargs,
+        )

kumoai/spcs.py

@@ -54,9 +54,7 @@ def _refresh_spcs_token() -> None:
         api_key=global_state._api_key,
         spcs_token=spcs_token,
     )
-    if not client.authenticate():
-        raise ValueError("Client authentication failed. Please check if you "
-                         "have a valid API key.")
+    client.authenticate()
 
     # Update state:
     global_state.set_spcs_token(spcs_token)

{kumoai-2.13.0.dev202511131731.dist-info → kumoai-2.13.0.dev202511191731.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kumoai
-Version: 2.13.0.dev202511131731
+Version: 2.13.0.dev202511191731
 Summary: AI on the Modern Data Stack
 Author-email: "Kumo.AI" <hello@kumo.ai>
 License-Expression: MIT
@@ -23,11 +23,13 @@ Requires-Dist: requests>=2.28.2
 Requires-Dist: urllib3
 Requires-Dist: plotly
 Requires-Dist: typing_extensions>=4.5.0
-Requires-Dist: kumo-api==0.45.0
+Requires-Dist: kumo-api==0.46.0
 Requires-Dist: tqdm>=4.66.0
 Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: pydantic>=1.10.21
 Requires-Dist: rich>=9.0.0
+Requires-Dist: mypy-boto3-sagemaker-runtime
+Requires-Dist: boto3
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx-book-theme; extra == "doc"
@@ -38,6 +40,13 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
 Requires-Dist: requests-mock; extra == "test"
+Provides-Extra: test-sagemaker
+Requires-Dist: sagemaker; extra == "test-sagemaker"
+Requires-Dist: pandas==2.1.4; extra == "test-sagemaker"
+Requires-Dist: pyarrow==12.0.1; extra == "test-sagemaker"
+Provides-Extra: sagemaker
+Requires-Dist: boto3<2.0,>=1.30.0; extra == "sagemaker"
+Requires-Dist: mypy-boto3-sagemaker-runtime<2.0,>=1.34.0; extra == "sagemaker"
 Dynamic: license-file
 Dynamic: requires-dist
 

{kumoai-2.13.0.dev202511131731.dist-info → kumoai-2.13.0.dev202511191731.dist-info}/RECORD

@@ -1,23 +1,24 @@
 kumoai/_logging.py,sha256=U2_5ROdyk92P4xO4H2WJV8EC7dr6YxmmnM-b7QX9M7I,886
 kumoai/mixin.py,sha256=MP413xzuCqWhxAPUHmloLA3j4ZyF1tEtfi516b_hOXQ,812
-kumoai/_version.py,sha256=wvQ56Gsck9T4OuBZmYnas0mpqXe3G7yxp7naBy-NTH4,39
-kumoai/__init__.py,sha256=LU1zmKYc0KV5hy2VGKUuXgSvbJwj2rSRQ_R_bpHyl1o,10708
+kumoai/_version.py,sha256=DQMe1_l3GF0z-d0Z7gv1y4f2nJER6406wlXsARrcwqs,39
+kumoai/__init__.py,sha256=L3yOOtpSdwe3PYQlJBLkiQd3Ypp8iB5ChXkzprk3Si4,10546
 kumoai/formatting.py,sha256=jA_rLDCGKZI8WWCha-vtuLenVKTZvli99Tqpurz1H84,953
 kumoai/futures.py,sha256=oJFIfdCM_3nWIqQteBKYMY4fPhoYlYWE_JA2o6tx-ng,3737
 kumoai/jobs.py,sha256=NrdLEFNo7oeCYSy-kj2nAvCFrz9BZ_xrhkqHFHk5ksY,2496
 kumoai/exceptions.py,sha256=b-_sdbAKOg50uaJZ65GmBLdTo4HANdjl8_R0sJpwaN0,833
 kumoai/kumolib.cpython-310-darwin.so,sha256=fiuDOY8RgGyYRvHhavN6_q2MxGynnwSHiFn2HWGnhSQ,232544
 kumoai/databricks.py,sha256=e6E4lOFvZHXFwh4CO1kXU1zzDU3AapLQYMxjiHPC-HQ,476
-kumoai/spcs.py,sha256=N4ddeoHAc4I3bKrDitsb91lUx5VKvCyPyMT3zWiuCcY,4275
+kumoai/spcs.py,sha256=N31d7rLa-bgYh8e2J4YzX1ScxGLqiVXrqJnCl1y4Mts,4139
 kumoai/_singleton.py,sha256=UTwrbDkoZSGB8ZelorvprPDDv9uZkUi1q_SrmsyngpQ,836
 kumoai/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kumoai/experimental/rfm/local_graph_sampler.py,sha256=o60_sdMa_fr60DrdmCIaE6lKQAD2msp1t-GGubFNt-o,6738
+kumoai/experimental/rfm/local_graph_sampler.py,sha256=5DbhL9h0usFKSJfnx7HjLMPcG54qwJ48M2tmONqxXyY,6672
 kumoai/experimental/rfm/local_graph.py,sha256=2iJDlsGVzqCe1bD_puXWlhwGkn7YnQyJ4p4C-fwCZNE,30076
 kumoai/experimental/rfm/local_pquery_driver.py,sha256=aO7Jfwx9gxGKYvpqxZx1LLWdI1MhuZQOPtAITxoOQO0,26162
-kumoai/experimental/rfm/__init__.py,sha256=ornmi2x947jkQLptMn7ZLvTf2Sw-RMcVW73AnjVsWAo,1709
+kumoai/experimental/rfm/__init__.py,sha256=wKfMKTxfuJNH1GCWGZ7-288HXil0tsCuXqg-BAFctZE,6812
 kumoai/experimental/rfm/utils.py,sha256=3IiBvT_aLBkkcJh3H11_50yt_XlEzHR0cm9Kprrtl8k,11123
+kumoai/experimental/rfm/sagemaker.py,sha256=e0rRQ28WcgAk_ALqUyU20d193c8_68rCkSengZIHu3Y,4823
 kumoai/experimental/rfm/local_table.py,sha256=r8xZ33Mjs6JD8ud6h23tZ99Dag2DvZ4h6tWjmGrKQg4,19605
-kumoai/experimental/rfm/rfm.py,sha256=OHE6xpVREfm5GtZ4LXPY71FKzjNc94LWiBTPrmE6Xzc,48097
+kumoai/experimental/rfm/rfm.py,sha256=8SvGWfMuRYJgiz5OTplu7m47mDrHAjQ2mRZtRASnSCk,48136
 kumoai/experimental/rfm/local_graph_store.py,sha256=8BqonuaMftAAsjgZpB369i5AeNd1PkisMbbEqc0cKBo,13847
 kumoai/experimental/rfm/authenticate.py,sha256=FiuHMvP7V3zBZUlHMDMbNLhc-UgDZgz4hjVSTuQ7DRw,18888
 kumoai/experimental/rfm/pquery/__init__.py,sha256=X0O3EIq5SMfBEE-ii5Cq6iDhR3s3XMXB52Cx5htoePw,152
@@ -73,7 +74,7 @@ kumoai/pquery/predictive_query.py,sha256=oUqwdOWLLkPM-G4PhpUk_6mwSJGBtaD3t37Wp5O
 kumoai/pquery/prediction_table.py,sha256=QPDH22X1UB0NIufY7qGuV2XW7brG3Pv--FbjNezzM2g,10776
 kumoai/pquery/training_table.py,sha256=elmPDZx11kPiC_dkOhJcBUGtHKgL32GCBvZ9k6U0pMg,15809
 kumoai/client/pquery.py,sha256=R2hc-M8vPoyIDH0ywLwFVxCznVAqpZz3w2HszjdNW-o,6891
-kumoai/client/client.py,sha256=S1OfGDwTzoyf40fhg111xGQGNfEP-OnoXqFV6X9iMEc,8580
+kumoai/client/client.py,sha256=Jda8V9yiu3LbhxlcgRWPeYi7eF6jzCKcq8-B_vEd1ik,8514
 kumoai/client/graph.py,sha256=zvLEDExLT_RVbUMHqVl0m6tO6s2gXmYSoWmPF6YMlnA,3831
 kumoai/client/online.py,sha256=pkBBh_DEC3GAnPcNw6bopNRlGe7EUbIFe7_seQqZRaw,2720
 kumoai/client/source_table.py,sha256=VCsCcM7KYcnjGP7HLTb-AOSEGEVsJTWjk8bMg1JdgPU,2101
@@ -91,8 +92,8 @@ kumoai/trainer/baseline_trainer.py,sha256=LlfViNOmswNv4c6zJJLsyv0pC2mM2WKMGYx06o
 kumoai/trainer/__init__.py,sha256=zUdFl-f-sBWmm2x8R-rdVzPBeU2FaMzUY5mkcgoTa1k,939
 kumoai/trainer/online_serving.py,sha256=9cddb5paeZaCgbUeceQdAOxysCtV5XP-KcsgFz_XR5w,9566
 kumoai/trainer/trainer.py,sha256=hBXO7gwpo3t59zKFTeIkK65B8QRmWCwO33sbDuEAPlY,20133
-kumoai-2.13.0.dev202511131731.dist-info/RECORD,,
-kumoai-2.13.0.dev202511131731.dist-info/WHEEL,sha256=11kMdE9gzbsaQG30fRcsAYxBLEVRsqJo098Y5iL60Xo,136
-kumoai-2.13.0.dev202511131731.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
-kumoai-2.13.0.dev202511131731.dist-info/METADATA,sha256=jnAtMb9qlOGKD4KIpUq9Tt65dnfVaeCNZUtJ3d6-Ihw,2052
-kumoai-2.13.0.dev202511131731.dist-info/licenses/LICENSE,sha256=TbWlyqRmhq9PEzCaTI0H0nWLQCCOywQM8wYH8MbjfLo,1102
+kumoai-2.13.0.dev202511191731.dist-info/RECORD,,
+kumoai-2.13.0.dev202511191731.dist-info/WHEEL,sha256=11kMdE9gzbsaQG30fRcsAYxBLEVRsqJo098Y5iL60Xo,136
+kumoai-2.13.0.dev202511191731.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
+kumoai-2.13.0.dev202511191731.dist-info/METADATA,sha256=CMJObe3toL1kXWv7kpgS-yQ9q6egpKJmPWJPHph05Gc,2475
+kumoai-2.13.0.dev202511191731.dist-info/licenses/LICENSE,sha256=TbWlyqRmhq9PEzCaTI0H0nWLQCCOywQM8wYH8MbjfLo,1102