kumoai 2.13.0.dev202512041731__cp310-cp310-win_amd64.whl → 2.15.0.dev202601141731__cp310-cp310-win_amd64.whl

kumoai/__init__.py

@@ -1,3 +1,4 @@
+import warnings
 import os
 import sys
 import threading
@@ -68,9 +69,8 @@ class GlobalState(metaclass=Singleton):
         if self._url is None or (self._api_key is None
                                  and self._spcs_token is None
                                  and self._snowpark_session is None):
-            raise ValueError(
-                "Client creation or authentication failed; please re-create "
-                "your client before proceeding.")
+            raise ValueError("Client creation or authentication failed. "
+                             "Please re-create your client before proceeding.")
 
         if hasattr(self.thread_local, '_client'):
             # Set the spcs token in the client to ensure it has the latest.
@@ -123,10 +123,9 @@ def init(
     """  # noqa
     # Avoid mutations to the global state after it is set:
     if global_state.initialized:
-        print(
-            "Client has already been created. To re-initialize Kumo, please "
-            "start a new interpreter. No changes will be made to the current "
-            "session.")
+        warnings.warn("Kumo SDK already initialized. To re-initialize the "
+                      "SDK, please start a new interpreter. No changes will "
+                      "be made to the current session.")
         return
 
     set_log_level(os.getenv(_ENV_KUMO_LOG, log_level))
@@ -138,15 +137,15 @@ def init(
     if snowflake_application:
         if url is not None:
             raise ValueError(
-                "Client creation failed: both snowflake_application and url "
-                "are specified. If running from a snowflake notebook, specify"
-                "only snowflake_application.")
+                "Kumo SDK initialization failed. Both 'snowflake_application' "
+                "and 'url' are specified. If running from a Snowflake "
+                "notebook, specify only 'snowflake_application'.")
         snowpark_session = _get_active_session()
         if not snowpark_session:
             raise ValueError(
-                "Client creation failed: snowflake_application is specified "
-                "without an active snowpark session. If running outside "
-                "a snowflake notebook, specify a URL and credentials.")
+                "Kumo SDK initialization failed. 'snowflake_application' is "
+                "specified without an active Snowpark session. If running "
+                "outside a Snowflake notebook, specify a URL and credentials.")
         description = snowpark_session.sql(
             f"DESCRIBE SERVICE {snowflake_application}."
             "USER_SCHEMA.KUMO_SERVICE").collect()[0]
@@ -155,14 +154,14 @@ def init(
     if api_key is None and not snowflake_application:
         if snowflake_credentials is None:
             raise ValueError(
-                "Client creation failed: Neither API key nor snowflake "
-                "credentials provided. Please either set the 'KUMO_API_KEY' "
-                "or explicitly call `kumoai.init(...)`.")
+                "Kumo SDK initialization failed. Neither an API key nor "
+                "Snowflake credentials provided. Please either set the "
+                "'KUMO_API_KEY' or explicitly call `kumoai.init(...)`.")
         if (set(snowflake_credentials.keys())
                 != {'user', 'password', 'account'}):
             raise ValueError(
-                f"Provided credentials should be a dictionary with keys "
-                f"'user', 'password', and 'account'. Only "
+                f"Provided Snowflake credentials should be a dictionary with "
+                f"keys 'user', 'password', and 'account'. Only "
                 f"{set(snowflake_credentials.keys())} were provided.")
 
     # Get or infer URL:
@@ -173,10 +172,10 @@ def init(
     except KeyError:
         pass
     if url is None:
-        raise ValueError(
-            "Client creation failed: endpoint URL not provided. Please "
-            "either set the 'KUMO_API_ENDPOINT' environment variable or "
-            "explicitly call `kumoai.init(...)`.")
+        raise ValueError("Kumo SDK initialization failed since no endpoint "
+                         "URL was provided. Please either set the "
+                         "'KUMO_API_ENDPOINT' environment variable or "
+                         "explicitly call `kumoai.init(...)`.")
 
     # Assign global state after verification that client can be created and
     # authenticated successfully:
@@ -198,10 +197,8 @@ def init(
     logger = logging.getLogger('kumoai')
     log_level = logging.getLevelName(logger.getEffectiveLevel())
 
-    logger.info(
-        f"Successfully initialized the Kumo SDK (version {__version__}) "
-        f"against deployment {url}, with "
-        f"log level {log_level}.")
+    logger.info(f"Initialized Kumo SDK v{__version__} against deployment "
+                f"'{url}'")
 
 
 def set_log_level(level: str) -> None:

kumoai/_version.py

@@ -1 +1 @@
-__version__ = '2.13.0.dev202512041731'
+__version__ = '2.15.0.dev202601141731'

kumoai/client/client.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
         ArtifactExportJobAPI,
         BaselineJobAPI,
         BatchPredictionJobAPI,
+        DistillationJobAPI,
         GeneratePredictionTableJobAPI,
         GenerateTrainTableJobAPI,
         LLMJobAPI,
@@ -132,6 +133,11 @@ class KumoClient:
         from kumoai.client.jobs import TrainingJobAPI
         return TrainingJobAPI(self)
 
+    @property
+    def distillation_job_api(self) -> 'DistillationJobAPI':
+        from kumoai.client.jobs import DistillationJobAPI
+        return DistillationJobAPI(self)
+
     @property
     def batch_prediction_job_api(self) -> 'BatchPredictionJobAPI':
         from kumoai.client.jobs import BatchPredictionJobAPI

kumoai/client/jobs.py

@@ -22,6 +22,8 @@ from kumoapi.jobs import (
     BatchPredictionRequest,
     CancelBatchPredictionJobResponse,
     CancelTrainingJobResponse,
+    DistillationJobRequest,
+    DistillationJobResource,
     ErrorDetails,
     GeneratePredictionTableJobResource,
     GeneratePredictionTableRequest,
@@ -171,6 +173,28 @@ class TrainingJobAPI(CommonJobAPI[TrainingJobRequest, TrainingJobResource]):
         return resource.config
 
 
+class DistillationJobAPI(CommonJobAPI[DistillationJobRequest,
+                                      DistillationJobResource]):
+    r"""Typed API definition for the distillation job resource."""
+    def __init__(self, client: KumoClient) -> None:
+        super().__init__(client, '/training_jobs/distilled_training_job',
+                         DistillationJobResource)
+
+    def get_config(self, job_id: str) -> DistillationJobRequest:
+        raise NotImplementedError(
+            "Getting the configuration for a distillation job is "
+            "not implemented yet.")
+
+    def get_progress(self, id: str) -> AutoTrainerProgress:
+        raise NotImplementedError(
+            "Getting the progress for a distillation job is not "
+            "implemented yet.")
+
+    def cancel(self, id: str) -> CancelTrainingJobResponse:
+        raise NotImplementedError(
+            "Cancelling a distillation job is not implemented yet.")
+
+
 class BatchPredictionJobAPI(CommonJobAPI[BatchPredictionRequest,
                                          BatchPredictionJobResource]):
     r"""Typed API definition for the prediction job resource."""
@@ -320,12 +344,14 @@ class GenerateTrainTableJobAPI(CommonJobAPI[GenerateTrainTableRequest,
         id: str,
         source_table_type: SourceTableType,
         train_table_mod: TrainingTableSpec,
+        extensive_validation: bool,
     ) -> ValidationResponse:
         response = self._client._post(
             f'{self._base_endpoint}/{id}/validate_custom_train_table',
             json=to_json_dict({
                 'custom_table': source_table_type,
                 'train_table_mod': train_table_mod,
+                'extensive_validation': extensive_validation,
             }),
         )
         return parse_response(ValidationResponse, response)

kumoai/client/pquery.py

@@ -176,8 +176,12 @@ def filter_model_plan(
                     # Undefined
                     pass
 
-            new_opt_fields.append((field.name, _type, default))
-            new_opts.append(getattr(section, field.name))
+            # Forward compatibility - Remove any newly introduced arguments not
+            # returned yet by the backend:
+            value = getattr(section, field.name)
+            if value != MissingType.VALUE:
+                new_opt_fields.append((field.name, _type, default))
+                new_opts.append(value)
 
         Section = dataclass(
             config=dict(validate_assignment=True),

kumoai/connector/utils.py

@@ -1,10 +1,10 @@
 import asyncio
 import csv
-import gc
 import io
 import math
 import os
 import re
+import sys
 import tempfile
 import threading
 import time
@@ -920,7 +920,10 @@ def _read_remote_file_with_progress(
     if capture_first_line and not seen_nl:
         header_line = bytes(header_acc)
 
-    mv = buf.getbuffer()  # zero-copy view of BytesIO internal buffer
+    if sys.version_info >= (3, 13):
+        mv = memoryview(buf.getvalue())
+    else:
+        mv = buf.getbuffer()  # zero-copy view of BytesIO internal buffer
     return buf, mv, header_line
 
 
@@ -999,7 +1002,10 @@ def _iter_mv_chunks(mv: memoryview,
     n = mv.nbytes
     while pos < n:
         nxt = min(n, pos + part_size)
-        yield mv[pos:nxt]  # zero-copy slice
+        if sys.version_info >= (3, 13):
+            yield mv[pos:nxt].tobytes()
+        else:
+            yield mv[pos:nxt]  # zero-copy slice
         pos = nxt
 
 
@@ -1473,13 +1479,17 @@ def _remote_upload_file(name: str, fs: Filesystem, url: str, info: dict,
     if renamed_cols_msg:
         logger.info(renamed_cols_msg)
 
+    try:
+        if isinstance(data_mv, memoryview):
+            data_mv.release()
+    except Exception:
+        pass
+
     try:
         if buf:
             buf.close()
     except Exception:
         pass
-    del buf, data_mv, header_line
-    gc.collect()
 
     logger.info("Upload complete. Validated table %s.", name)
 
@@ -1719,13 +1729,17 @@ def _remote_upload_directory(
                     else:
                         break
 
+                try:
+                    if isinstance(data_mv, memoryview):
+                        data_mv.release()
+                except Exception:
+                    pass
+
                 try:
                     if buf:
                         buf.close()
                 except Exception:
                     pass
-                del buf, data_mv, header_line
-                gc.collect()
 
                 _safe_bar_update(file_bar, 1)
                 _merge_status_update(fpath)

kumoai/experimental/rfm/__init__.py

@@ -6,11 +6,11 @@ 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 kumoai.client.client import KumoClient
+from kumoai.spcs import _get_active_session
 
 from .authenticate import authenticate
 from .sagemaker import (
@@ -20,6 +20,7 @@ from .sagemaker import (
 from .base import Table
 from .backend.local import LocalTable
 from .graph import Graph
+from .task_table import TaskTable
 from .rfm import ExplainConfig, Explanation, KumoRFM
 
 logger = logging.getLogger('kumoai_rfm')
@@ -49,7 +50,8 @@ class InferenceBackend(str, Enum):
 
 
 def _detect_backend(
-        url: str) -> Tuple[InferenceBackend, Optional[str], Optional[str]]:
+        url: str,  #
+) -> tuple[InferenceBackend, str | None, str | None]:
     parsed = urlparse(url)
 
     # Remote SageMaker
@@ -73,12 +75,27 @@ def _detect_backend(
     return InferenceBackend.REST, None, None
 
 
+def _get_snowflake_url(snowflake_application: str) -> str:
+    snowpark_session = _get_active_session()
+    if not snowpark_session:
+        raise ValueError(
+            "KumoRFM initialization failed. 'snowflake_application' is "
+            "specified without an active Snowpark session. If running outside "
+            "a Snowflake notebook, specify a URL and credentials.")
+    with snowpark_session.connection.cursor() as cur:
+        cur.execute(
+            f"DESCRIBE SERVICE {snowflake_application}.user_schema.rfm_service"
+            f" ->> SELECT \"dns_name\" from $1")
+        dns_name: str = cur.fetchone()[0]
+    return f"http://{dns_name}:8000/api"
+
+
 @dataclass
 class RfmGlobalState:
     _url: str = '__url_not_provided__'
     _backend: InferenceBackend = InferenceBackend.UNKNOWN
-    _region: Optional[str] = None
-    _endpoint_name: Optional[str] = None
+    _region: str | None = None
+    _endpoint_name: str | None = None
     _thread_local = threading.local()
 
     # Thread-safe init-once.
@@ -87,6 +104,9 @@ class RfmGlobalState:
 
     @property
     def client(self) -> KumoClient:
+        if self._backend == InferenceBackend.UNKNOWN:
+            raise RuntimeError("KumoRFM is not yet initialized")
+
         if self._backend == InferenceBackend.REST:
             return kumoai.global_state.client
 
@@ -121,52 +141,58 @@ global_state = RfmGlobalState()
 
 
 def init(
-    url: Optional[str] = None,
-    api_key: Optional[str] = None,
-    snowflake_credentials: Optional[Dict[str, str]] = None,
-    snowflake_application: Optional[str] = None,
+    url: str | None = None,
+    api_key: str | None = None,
+    snowflake_credentials: dict[str, str] | None = None,
+    snowflake_application: str | None = None,
     log_level: str = "INFO",
 ) -> None:
     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 "
+                raise RuntimeError(
+                    "KumoRFM has already been initialized with a different "
+                    "API URL. Re-initialization with a different URL is not "
                     "supported.")
             return
 
+        if snowflake_application:
+            if url is not None:
+                raise ValueError(
+                    "KumoRFM initialization failed. Both "
+                    "'snowflake_application' and 'url' are specified. If "
+                    "running from a Snowflake notebook, specify only "
+                    "'snowflake_application'.")
+            url = _get_snowflake_url(snowflake_application)
+            api_key = "test:DISABLED"
+
         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)
+            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()
+            logger.info("KumoRFM initialized in AWS SageMaker")
         else:
             assert backend == InferenceBackend.LOCAL_SAGEMAKER
             KumoClient_SageMakerProxy_Local(url).authenticate()
+            logger.info(f"KumoRFM initialized in local SageMaker at '{url}'")
 
         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.
@@ -177,6 +203,7 @@ __all__ = [
     'Table',
     'LocalTable',
     'Graph',
+    'TaskTable',
     'KumoRFM',
     'ExplainConfig',
     'Explanation',

kumoai/experimental/rfm/authenticate.py

@@ -2,12 +2,11 @@ import logging
 import os
 import platform
 from datetime import datetime
-from typing import Optional
 
 from kumoai import in_notebook
 
 
-def authenticate(api_url: Optional[str] = None) -> None:
+def authenticate(api_url: str | None = None) -> None:
     """Authenticates the user and sets the Kumo API key for the SDK.
 
     This function detects the current environment and launches the appropriate
@@ -65,11 +64,11 @@ def _authenticate_local(api_url: str, redirect_port: int = 8765) -> None:
     import webbrowser
     from getpass import getpass
     from socketserver import TCPServer
-    from typing import Any, Dict
+    from typing import Any
 
     logger = logging.getLogger('kumoai')
 
-    token_status: Dict[str, Any] = {
+    token_status: dict[str, Any] = {
         'token': None,
         'token_name': None,
         'failed': False

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

@@ -32,7 +32,11 @@ Please create a feature request at 'https://github.com/kumo-ai/kumo-rfm'."""
     raise RuntimeError(_msg) from e
 
 from .table import LocalTable
+from .graph_store import LocalGraphStore
+from .sampler import LocalSampler
 
 __all__ = [
     'LocalTable',
+    'LocalGraphStore',
+    'LocalSampler',
 ]