kumoai 2.14.0.dev202512141732__py3-none-any.whl → 2.15.0.dev202601131732__py3-none-any.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.14.0.dev202512141732'
+__version__ = '2.15.0.dev202601131732'

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

@@ -1,13 +1,12 @@
-import warnings
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 from kumoapi.rfm.context import Subgraph
-from kumoapi.typing import Stype
 
 from kumoai.experimental.rfm.backend.local import LocalTable
-from kumoai.utils import InteractiveProgressLogger, ProgressLogger
+from kumoai.experimental.rfm.base import Table
+from kumoai.utils import ProgressLogger
 
 try:
     import torch
@@ -23,12 +22,12 @@ class LocalGraphStore:
     def __init__(
         self,
         graph: 'Graph',
-        verbose: Union[bool, ProgressLogger] = True,
+        verbose: bool | ProgressLogger = True,
     ) -> None:
 
         if not isinstance(verbose, ProgressLogger):
-            verbose = InteractiveProgressLogger(
-                "Materializing graph",
+            verbose = ProgressLogger.default(
+                msg="Materializing graph",
                 verbose=verbose,
             )
 
@@ -94,7 +93,7 @@ class LocalGraphStore:
     def sanitize(
         self,
         graph: 'Graph',
-    ) -> Tuple[Dict[str, pd.DataFrame], Dict[str, np.ndarray]]:
+    ) -> tuple[dict[str, pd.DataFrame], dict[str, np.ndarray]]:
         r"""Sanitizes raw data according to table schema definition:
 
         In particular, it:
@@ -103,30 +102,24 @@ class LocalGraphStore:
         * drops duplicate primary keys
         * removes rows with missing primary keys or time values
         """
-        df_dict: Dict[str, pd.DataFrame] = {}
+        df_dict: dict[str, pd.DataFrame] = {}
         for table_name, table in graph.tables.items():
             assert isinstance(table, LocalTable)
-            df = table._data
-            df_dict[table_name] = df.copy(deep=False).reset_index(drop=True)
+            df_dict[table_name] = Table._sanitize(
+                df=table._data.copy(deep=False).reset_index(drop=True),
+                dtype_dict={
+                    column.name: column.dtype
+                    for column in table.columns
+                },
+                stype_dict={
+                    column.name: column.stype
+                    for column in table.columns
+                },
+            )
 
-        mask_dict: Dict[str, np.ndarray] = {}
+        mask_dict: dict[str, np.ndarray] = {}
         for table in graph.tables.values():
-            for col in table.columns:
-                if col.stype == Stype.timestamp:
-                    ser = df_dict[table.name][col.name]
-                    if not pd.api.types.is_datetime64_any_dtype(ser):
-                        with warnings.catch_warnings():
-                            warnings.filterwarnings(
-                                'ignore',
-                                message='Could not infer format',
-                            )
-                            ser = pd.to_datetime(ser, errors='coerce')
-                        df_dict[table.name][col.name] = ser
-                    if isinstance(ser.dtype, pd.DatetimeTZDtype):
-                        ser = ser.dt.tz_localize(None)
-                        df_dict[table.name][col.name] = ser
-
-            mask: Optional[np.ndarray] = None
+            mask: np.ndarray | None = None
             if table._time_column is not None:
                 ser = df_dict[table.name][table._time_column]
                 mask = ser.notna().to_numpy()
@@ -144,8 +137,8 @@ class LocalGraphStore:
     def get_pkey_map_dict(
         self,
         graph: 'Graph',
-    ) -> Dict[str, pd.DataFrame]:
-        pkey_map_dict: Dict[str, pd.DataFrame] = {}
+    ) -> dict[str, pd.DataFrame]:
+        pkey_map_dict: dict[str, pd.DataFrame] = {}
 
         for table in graph.tables.values():
             if table._primary_key is None:
@@ -177,19 +170,17 @@ class LocalGraphStore:
     def get_time_data(
         self,
         graph: 'Graph',
-    ) -> Tuple[
-            Dict[str, np.ndarray],
-            Dict[str, Tuple[pd.Timestamp, pd.Timestamp]],
+    ) -> tuple[
+            dict[str, np.ndarray],
+            dict[str, tuple[pd.Timestamp, pd.Timestamp]],
     ]:
-        time_dict: Dict[str, np.ndarray] = {}
-        min_max_time_dict: Dict[str, tuple[pd.Timestamp, pd.Timestamp]] = {}
+        time_dict: dict[str, np.ndarray] = {}
+        min_max_time_dict: dict[str, tuple[pd.Timestamp, pd.Timestamp]] = {}
         for table in graph.tables.values():
             if table._time_column is None:
                 continue
 
             time = self.df_dict[table.name][table._time_column]
-            if time.dtype != 'datetime64[ns]':
-                time = time.astype('datetime64[ns]')
             time_dict[table.name] = time.astype(int).to_numpy() // 1000**3
 
             if table.name in self.mask_dict.keys():
@@ -207,15 +198,15 @@ class LocalGraphStore:
     def get_csc(
         self,
         graph: 'Graph',
-    ) -> Tuple[
-            Dict[Tuple[str, str, str], np.ndarray],
-            Dict[Tuple[str, str, str], np.ndarray],
+    ) -> tuple[
+            dict[tuple[str, str, str], np.ndarray],
+            dict[tuple[str, str, str], np.ndarray],
     ]:
         # A mapping from raw primary keys to node indices (0 to N-1):
-        map_dict: Dict[str, pd.CategoricalDtype] = {}
+        map_dict: dict[str, pd.CategoricalDtype] = {}
         # A dictionary to manage offsets of node indices for invalid rows:
-        offset_dict: Dict[str, np.ndarray] = {}
-        for table_name in set(edge.dst_table for edge in graph.edges):
+        offset_dict: dict[str, np.ndarray] = {}
+        for table_name in {edge.dst_table for edge in graph.edges}:
             ser = self.df_dict[table_name][graph[table_name]._primary_key]
             if table_name in self.mask_dict.keys():
                 mask = self.mask_dict[table_name]
@@ -224,8 +215,8 @@ class LocalGraphStore:
             map_dict[table_name] = pd.CategoricalDtype(ser, ordered=True)
 
         # Build CSC graph representation:
-        row_dict: Dict[Tuple[str, str, str], np.ndarray] = {}
-        colptr_dict: Dict[Tuple[str, str, str], np.ndarray] = {}
+        row_dict: dict[tuple[str, str, str], np.ndarray] = {}
+        colptr_dict: dict[tuple[str, str, str], np.ndarray] = {}
         for src_table, fkey, dst_table in graph.edges:
             src_df = self.df_dict[src_table]
             dst_df = self.df_dict[dst_table]
@@ -287,7 +278,7 @@ def _argsort(input: np.ndarray) -> np.ndarray:
     return torch.from_numpy(input).argsort().numpy()
 
 
-def _lexsort(inputs: List[np.ndarray]) -> np.ndarray:
+def _lexsort(inputs: list[np.ndarray]) -> np.ndarray:
     assert len(inputs) >= 1
 
     if not WITH_TORCH:

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

@@ -19,7 +19,7 @@ class LocalSampler(Sampler):
         graph: 'Graph',
         verbose: bool | ProgressLogger = True,
     ) -> None:
-        super().__init__(graph=graph)
+        super().__init__(graph=graph, verbose=verbose)
 
         import kumoai.kumolib as kumolib
 
@@ -191,6 +191,8 @@ class LocalSampler(Sampler):
 
         return train_y, train_mask, test_y, test_mask
 
+    # Helper Methods ##########################################################
+
     def _sample_target_set(
         self,
         query: ValidatedPredictiveQuery,
@@ -217,9 +219,6 @@ class LocalSampler(Sampler):
         for edge_type in set(self.edge_types) - set(time_offset_dict.keys()):
             num_neighbors_dict['__'.join(edge_type)] = [0] * num_hops
 
-        if anchor_time.dtype != 'datetime64[ns]':
-            anchor_time = anchor_time.astype('datetime64')
-
         count = 0
         ys: list[pd.Series] = []
         mask = np.full(len(index), False, dtype=bool)
@@ -272,7 +271,7 @@ class LocalSampler(Sampler):
         return y, mask
 
 
-# Helper Methods ##############################################################
+# Helper Functions ############################################################
 
 
 def date_offset_to_seconds(offset: pd.DateOffset) -> int: