snowflake-ml-python 1.30.0__tar.gz → 1.32.0__tar.gz

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Release History
 
+## 1.32.0
+
+### New Features
+
+* Registry: Extended `ParamSpec` support to scikit-learn models. Parameters declared in the model signature
+  can now be passed at inference time, matching the existing support for custom models.
+* Registry: `infer_signature()` now accepts a `dict` for the `params` argument (e.g.,
+  `params={"temperature": 0.7, "max_tokens": 100}`), automatically inferring `ParamSpec` objects
+  from the Python value types. The existing `Sequence[BaseParamSpec]` form is still supported.
+
+### Bug Fixes
+
+* Experiment Tracking live logging (PrPr): Fixed a bug where the tracebacks for uncaught exceptions were not logged
+  when the code was running inside Snowflake notebooks.
+
+### Behavior Changes
+
+* Registry: The models from `huggingface.TransformersPipeline` and `transformers.Pipeline` will default to safetensors
+  file format by default by using `safe_serialization=True` parameter to the `save_pretrained` call. This creates
+  safetensors files instead of PyTorch binaries or pt files, addressing security vulnerability CVE-2025-32434.
+
+### Deprecations
+
+## 1.31.0 (2026-03-19)
+
+### New Features
+
+### Bug Fixes
+
+* Registry: Fixed custom model handler to explicitly persist `PARTITIONED=False` in model metadata for
+  `@inference_api` methods. Previously, custom models using `@inference_api` with `TABLE_FUNCTION` type
+  were incorrectly reported as partitioned.
+* Registry: Fixed sklearn and SnowML model handlers to explicitly persist `PARTITIONED=False` metadata for
+  the `explain` method, preventing it from being incorrectly reported as partitioned at read time.
+* Registry: Fixed inconsistent `infer_signature` for columns containing NaN values. Previously,
+  the inferred dtype (`DOUBLE` vs `INT64`) depended on whether NaN rows survived truncation, causing
+  downstream validation failures. Now, the original pandas column dtype is respected during `infer_signature`,
+  so columns with mix of integer and `np.nan` or `None` are consistently inferred as `DOUBLE` regardless of NaN position.
+* Registry: Fixed a bug where invalid parameter types (e.g., passing a string to an integer parameter)
+  were silently coerced instead of raising an error. Parameters are now strictly validated against their
+  declared types before inference. This may break code that relied on the silent coercion behavior
+  (e.g., `mv.run(..., params={"max_tokens": "100"})` or `mv.run(..., params={"some_int_param": True})`).
+* ML Job: Fixed explicitly named `MLJobDefinition` objects so they can be overwritten in place and invoked
+  repeatedly without job name collisions; the `generate_suffix` argument has been removed.
+* Experiment Tracking live logging (PrPr): Fixed a bug that generated too many lines of log that consist entirely of
+  whitespace.
+
+### Behavior Changes
+
+* Registry: Warehouse partitioned model inference no longer includes non-partition input columns (which were always
+  NULL) in the output. The output now contains only the model's output columns and the partition column.
+
+### Deprecations
+
 ## 1.30.0
 
 ### New Features
@@ -319,6 +373,10 @@ mv = registry.log_model(
 * Registry: Added support for `image-text-to-text` task type in `huggingface.TransformersPipeline`.
   Note: Requires vLLM inference engine while creating the service.
 
+* ML Job: Added support for custom command entrypoints. The `entrypoint` parameter now accepts a
+  `list[str]` (e.g., `["arctic_training", "run_causal.yml"]`), which is executed directly as a
+  command rather than being treated as a Python script.
+
 ### Bug Fixes
 
 ### Behavior Changes

{snowflake_ml_python-1.30.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.30.0
+Version: 1.32.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -416,6 +416,60 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.32.0
+
+### New Features
+
+* Registry: Extended `ParamSpec` support to scikit-learn models. Parameters declared in the model signature
+  can now be passed at inference time, matching the existing support for custom models.
+* Registry: `infer_signature()` now accepts a `dict` for the `params` argument (e.g.,
+  `params={"temperature": 0.7, "max_tokens": 100}`), automatically inferring `ParamSpec` objects
+  from the Python value types. The existing `Sequence[BaseParamSpec]` form is still supported.
+
+### Bug Fixes
+
+* Experiment Tracking live logging (PrPr): Fixed a bug where the tracebacks for uncaught exceptions were not logged
+  when the code was running inside Snowflake notebooks.
+
+### Behavior Changes
+
+* Registry: The models from `huggingface.TransformersPipeline` and `transformers.Pipeline` will default to safetensors
+  file format by default by using `safe_serialization=True` parameter to the `save_pretrained` call. This creates
+  safetensors files instead of PyTorch binaries or pt files, addressing security vulnerability CVE-2025-32434.
+
+### Deprecations
+
+## 1.31.0 (2026-03-19)
+
+### New Features
+
+### Bug Fixes
+
+* Registry: Fixed custom model handler to explicitly persist `PARTITIONED=False` in model metadata for
+  `@inference_api` methods. Previously, custom models using `@inference_api` with `TABLE_FUNCTION` type
+  were incorrectly reported as partitioned.
+* Registry: Fixed sklearn and SnowML model handlers to explicitly persist `PARTITIONED=False` metadata for
+  the `explain` method, preventing it from being incorrectly reported as partitioned at read time.
+* Registry: Fixed inconsistent `infer_signature` for columns containing NaN values. Previously,
+  the inferred dtype (`DOUBLE` vs `INT64`) depended on whether NaN rows survived truncation, causing
+  downstream validation failures. Now, the original pandas column dtype is respected during `infer_signature`,
+  so columns with mix of integer and `np.nan` or `None` are consistently inferred as `DOUBLE` regardless of NaN position.
+* Registry: Fixed a bug where invalid parameter types (e.g., passing a string to an integer parameter)
+  were silently coerced instead of raising an error. Parameters are now strictly validated against their
+  declared types before inference. This may break code that relied on the silent coercion behavior
+  (e.g., `mv.run(..., params={"max_tokens": "100"})` or `mv.run(..., params={"some_int_param": True})`).
+* ML Job: Fixed explicitly named `MLJobDefinition` objects so they can be overwritten in place and invoked
+  repeatedly without job name collisions; the `generate_suffix` argument has been removed.
+* Experiment Tracking live logging (PrPr): Fixed a bug that generated too many lines of log that consist entirely of
+  whitespace.
+
+### Behavior Changes
+
+* Registry: Warehouse partitioned model inference no longer includes non-partition input columns (which were always
+  NULL) in the output. The output now contains only the model's output columns and the partition column.
+
+### Deprecations
+
 ## 1.30.0
 
 ### New Features
@@ -735,6 +789,10 @@ mv = registry.log_model(
 * Registry: Added support for `image-text-to-text` task type in `huggingface.TransformersPipeline`.
   Note: Requires vLLM inference engine while creating the service.
 
+* ML Job: Added support for custom command entrypoints. The `entrypoint` parameter now accepts a
+  `list[str]` (e.g., `["arctic_training", "run_causal.yml"]`), which is executed directly as a
+  command rather than being treated as a Python script.
+
 ### Bug Fixes
 
 ### Behavior Changes

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/experiment/_logging/experiment_logger.py

@@ -20,14 +20,31 @@ class ExperimentLogger(TextIO):
         self.exp_id = exp_id
         self.run_id = run_id
         self.stream = stream
+        self._buffer = ""  # Buffer to store incomplete lines
+
+    def _write_line(self, line: str) -> None:
+        log_message = {
+            "body": line,
+            "attributes": {
+                "snow.experiment.id": self.exp_id,
+                "snow.experiment.run.id": self.run_id,
+                "snow.experiment.stream": self.stream,
+            },
+        }
+        json_data = json.dumps(log_message)
+        self.file.write(json_data + "\n")
 
     def close(self) -> None:
+        self.flush()
         self.file.close()
 
     def fileno(self) -> int:
         return self.file.fileno()
 
     def flush(self) -> None:
+        if self._buffer:
+            self._write_line(self._buffer)
+            self._buffer = ""
         self.file.flush()
 
     def isatty(self) -> bool:
@@ -61,17 +78,11 @@ class ExperimentLogger(TextIO):
         return True
 
     def write(self, data: str) -> int:
-        log_message = {
-            "body": data,
-            "attributes": {
-                "snow.experiment.id": self.exp_id,
-                "snow.experiment.run.id": self.run_id,
-                "snow.experiment.stream": self.stream,
-            },
-        }
-        json_data = json.dumps(log_message)
-        self.file.write(json_data + "\n")
-        return len(data)  # Return length of input, not JSON output
+        self._buffer += data
+        while "\n" in self._buffer:
+            line, self._buffer = self._buffer.split("\n", 1)
+            self._write_line(line)
+        return len(data)
 
     def writelines(self, lines: Iterable[str]) -> None:
         for line in lines:

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/experiment/_logging/experiment_logging_context.py

@@ -1,5 +1,6 @@
 import contextlib
 from dataclasses import dataclass
+from typing import Any, Callable, Optional
 
 from snowflake.ml._internal.utils import tee
 from snowflake.ml.experiment._logging.experiment_logger import ExperimentLogger
@@ -11,3 +12,5 @@ class ExperimentLoggingContext:
     stderr_logger: ExperimentLogger
     stdout_ctx: contextlib.redirect_stdout[tee.OutputTee]
     stderr_ctx: contextlib.redirect_stderr[tee.OutputTee]
+    ipython_instance: Optional[Any]
+    original_showtraceback: Optional[Callable[..., None]]

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -3,6 +3,7 @@ import functools
 import json
 import sys
 import warnings
+from collections.abc import Callable
 from typing import Any, Optional, Union
 from urllib.parse import quote
 
@@ -128,10 +129,17 @@ class ExperimentTracking:
         state["_session"] = None
         state["_sql_client"] = None
         state["_registry"] = None
+        # Save logger buffer state before clearing _logging_context
+        if self._logging_context:
+            state["_stdout_buffer"] = self._logging_context.stdout_logger._buffer
+            state["_stderr_buffer"] = self._logging_context.stderr_logger._buffer
         state["_logging_context"] = None
         return state
 
     def __setstate__(self, state: dict[str, Any]) -> None:
+        stdout_buffer = state.pop("_stdout_buffer", "")
+        stderr_buffer = state.pop("_stderr_buffer", "")
+
         if hasattr(super(), "__setstate__"):
             super().__setstate__(state)  # type: ignore[misc]
         else:
@@ -153,6 +161,10 @@ class ExperimentTracking:
         )
         if self._run:
             self._patch_stdout_and_stderr()
+            # _patch_stdout_and_stderr sets _logging_context if live logging is enabled
+            if self._logging_context:
+                self._logging_context.stdout_logger._buffer = stdout_buffer
+                self._logging_context.stderr_logger._buffer = stderr_buffer
 
     def set_experiment(
         self,
@@ -606,6 +618,39 @@ class ExperimentTracking:
         self._run = None
         self._unpatch_stdout_and_stderr()
 
+    def _try_patch_ipython_showtraceback(
+        self, stderr_logger: experiment_logging.ExperimentLogger
+    ) -> tuple[Any, Optional[Callable[..., None]]]:
+        try:
+            from IPython import get_ipython
+
+            ip = get_ipython()
+            if ip:
+                original_showtraceback = ip._showtraceback
+
+                def _patched_showtraceback(
+                    etype: type[BaseException],
+                    evalue: Optional[BaseException],
+                    stb: list[str],
+                ) -> None:
+                    try:
+                        text = ip.InteractiveTB.stb2text(stb)
+                        stderr_logger.write(text + "\n")
+                        stderr_logger.flush()
+                    except Exception:
+                        pass
+                    if original_showtraceback is not None:  # for mypy
+                        original_showtraceback(etype, evalue, stb)
+
+                ip._showtraceback = _patched_showtraceback
+
+                return ip, original_showtraceback
+
+        except Exception:
+            pass  # Never let IPython patching break logging setup
+
+        return None, None
+
     def _patch_stdout_and_stderr(self) -> None:
         if not self._live_logging_enabled:
             return
@@ -615,6 +660,8 @@ class ExperimentTracking:
 
         assert self._experiment is not None and self._run is not None  # for mypy
         stdout_logger, stderr_logger, stdout_ctx, stderr_ctx = None, None, None, None  # for exception handling
+        ip: Any = None
+        original_showtraceback: Optional[Callable[..., None]] = None
         try:
             exp_id = self._sql_client.get_experiment_id(self._experiment.name)
             run_id = self._sql_client.get_run_id(
@@ -625,15 +672,23 @@ class ExperimentTracking:
             stderr_logger = experiment_logging.ExperimentLogger(exp_id=exp_id, run_id=run_id, stream="STDERR")
             stdout_ctx = contextlib.redirect_stdout(tee.OutputTee(sys.stdout, stdout_logger))
             stderr_ctx = contextlib.redirect_stderr(tee.OutputTee(sys.stderr, stderr_logger))
+            stdout_ctx.__enter__()
+            stderr_ctx.__enter__()
+
+            ip, original_showtraceback = self._try_patch_ipython_showtraceback(stderr_logger)
+
             self._logging_context = experiment_logging.ExperimentLoggingContext(
                 stdout_logger=stdout_logger,
                 stderr_logger=stderr_logger,
                 stdout_ctx=stdout_ctx,
                 stderr_ctx=stderr_ctx,
+                ipython_instance=ip,
+                original_showtraceback=original_showtraceback,
             )
-            stdout_ctx.__enter__()
-            stderr_ctx.__enter__()
+
         except Exception as e:
+            if ip:
+                ip._showtraceback = original_showtraceback
             if stdout_ctx:
                 stdout_ctx.__exit__(None, None, None)
             if stderr_ctx:
@@ -650,6 +705,8 @@ class ExperimentTracking:
 
     def _unpatch_stdout_and_stderr(self) -> None:
         if self._logging_context:
+            if self._logging_context.ipython_instance:
+                self._logging_context.ipython_instance._showtraceback = self._logging_context.original_showtraceback
             self._logging_context.stdout_ctx.__exit__(None, None, None)
             self._logging_context.stderr_ctx.__exit__(None, None, None)
             self._logging_context.stdout_logger.close()

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/feature_store/feature_store.py

@@ -2772,7 +2772,7 @@ class FeatureStore:
 
         # Build SELECT and WHERE clauses using helper methods
         select_clause = self._build_select_clause_and_validate(feature_view, feature_names, include_join_keys=True)
-        where_clause = self._build_where_clause_for_keys(feature_view, keys)
+        where_clause, _ = self._build_where_clause_for_keys(feature_view, keys)
 
         query = f"SELECT {select_clause} FROM {table_name}{where_clause}"
         return self._session.sql(query)
@@ -2804,7 +2804,7 @@ class FeatureStore:
         quoted_keys_str = ", ".join(quoted_keys)
 
         # Build WHERE clause for key filtering (if any)
-        where_clause = self._build_where_clause_for_keys(feature_view, keys)
+        where_clause, _ = self._build_where_clause_for_keys(feature_view, keys)
 
         # Step 1: Create spine CTE with unique entities + CURRENT_TIMESTAMP
         spine_cte = f"""
@@ -2850,10 +2850,27 @@ class FeatureStore:
         return self._session.sql(full_query)
 
     def _read_from_online_store(
-        self, feature_view: FeatureView, keys: Optional[list[list[str]]], feature_names: Optional[list[str]]
+        self,
+        feature_view: FeatureView,
+        keys: Optional[list[list[str]]],
+        feature_names: Optional[list[str]],
     ) -> DataFrame:
-        """Read feature values from the online store with optional key filtering."""
-        # Check if online store is enabled
+        """Read feature values from the online store with optional key filtering.
+
+        Uses bind variables for single-key lookups and literal interpolation
+        for batch lookups.
+
+        Args:
+            feature_view: The registered feature view to read from.
+            keys: Optional list of key value lists to filter by.
+            feature_names: Optional list of feature names to return.
+
+        Returns:
+            Snowpark DataFrame containing the feature view data.
+
+        Raises:
+            SnowflakeMLException: If online store is not enabled.
+        """
         if not feature_view.online:
             raise snowml_exceptions.SnowflakeMLException(
                 error_code=error_codes.INVALID_ARGUMENT,
@@ -2864,11 +2881,16 @@ class FeatureStore:
 
         fully_qualified_online_name = feature_view.fully_qualified_online_table_name()
 
-        # Build SELECT and WHERE clauses using helper methods
         select_clause = self._build_select_clause_and_validate(feature_view, feature_names, include_join_keys=True)
-        where_clause = self._build_where_clause_for_keys(feature_view, keys)
+        # NOTE: We use snowflake sql query binds for single-point lookups to ensure the best performance.
+        # We don't use binds for multi-point lookups because we don't have any evidence that it improves
+        # performance, but we may need to revisit this in the future.
+        use_binds = keys is not None and len(keys) == 1
+        where_clause, params = self._build_where_clause_for_keys(feature_view, keys, use_binds=use_binds)
 
         query = f"SELECT {select_clause} FROM {fully_qualified_online_name}{where_clause}"
+        if params:
+            return self._session.sql(query, params=params)
         return self._session.sql(query)
 
     @dispatch_decorator()
@@ -5050,28 +5072,31 @@ FROM SPINE{' '.join(join_clauses)}
             # Select all columns
             return "*"
 
-    def _build_where_clause_for_keys(self, feature_view: FeatureView, keys: Optional[list[list[str]]]) -> str:
+    def _build_where_clause_for_keys(
+        self, feature_view: FeatureView, keys: Optional[list[list[Any]]], use_binds: bool = False
+    ) -> tuple[str, list[Any]]:
         """Build WHERE clause for key filtering.
 
         Args:
-            feature_view: The feature view to build the clause for
-            keys: Optional list of key value lists to filter by
+            feature_view: The feature view to build the clause for.
+            keys: Optional list of key value lists to filter by.
+            use_binds: If True, use ``?`` placeholders and return bind params.
+                If False, interpolate values as string literals.
 
         Returns:
-            WHERE clause string (empty if no keys provided)
+            Tuple of (WHERE clause string, bind params list). Params is empty
+            when use_binds is False or no keys are provided.
 
         Raises:
-            SnowflakeMLException: If key structure is invalid
+            SnowflakeMLException: If key structure is invalid.
         """
         if not keys:
-            return ""
+            return "", []
 
-        # Get join keys from entities for key filtering
         all_join_keys = []
         for entity in feature_view.entities:
             all_join_keys.extend([key.resolved() for key in entity.join_keys])
 
-        # Validate key structure
         for key_values in keys:
             if len(key_values) != len(all_join_keys):
                 raise snowml_exceptions.SnowflakeMLException(
@@ -5082,15 +5107,20 @@ FROM SPINE{' '.join(join_clauses)}
                     ),
                 )
 
+        params: list[Any] = []
         where_conditions = []
         for key_values in keys:
             key_conditions = []
             for join_key, value in zip(all_join_keys, key_values):
-                safe_value = str(value).replace("'", "''")
-                key_conditions.append(f"\"{join_key}\" = '{safe_value}'")
+                if use_binds:
+                    key_conditions.append(f'"{join_key}" = ?')
+                    params.append(value)
+                else:
+                    safe_value = str(value).replace("'", "''")
+                    key_conditions.append(f"\"{join_key}\" = '{safe_value}'")
             where_conditions.append(f"({' AND '.join(key_conditions)})")
 
-        return f" WHERE {' OR '.join(where_conditions)}"
+        return f" WHERE {' OR '.join(where_conditions)}", params
 
     def _get_store_type(self, store_type: Union[fv_mod.StoreType, str]) -> fv_mod.StoreType:
         """Return a StoreType enum from a Union[StoreType, str].

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/jobs/__init__.py

@@ -1,5 +1,5 @@
 from snowflake.ml.jobs._interop.exception_utils import install_exception_display_hooks
-from snowflake.ml.jobs._utils.types import JOB_STATUS
+from snowflake.ml.jobs._utils.type_utils import JOB_STATUS
 from snowflake.ml.jobs.decorators import remote
 from snowflake.ml.jobs.job import MLJob
 from snowflake.ml.jobs.job_definition import MLJobDefinition

{snowflake_ml_python-1.30.0 → snowflake_ml_python-1.32.0}/snowflake/ml/jobs/_utils/constants.py

@@ -1,5 +1,5 @@
 from snowflake.ml._internal.utils.snowflake_env import SnowflakeCloudType
-from snowflake.ml.jobs._utils.types import ComputeResources
+from snowflake.ml.jobs._utils.type_utils import ComputeResources
 
 # SPCS specification constants
 DEFAULT_CONTAINER_NAME = "main"