snowflake-ml-python 1.53.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

snowflake/ml/_internal/env_utils.py

@@ -689,22 +689,30 @@ def save_requirements_file(
     path: pathlib.Path,
     pip_deps: list[requirements.Requirement],
     cuda_version: Optional[str] = None,
-) -> None:
+) -> list[str]:
     """Generate Python requirements.txt file in the given directory path.
 
     Args:
         path: Path to the requirements.txt file.
         pip_deps: List of dependencies after validation.
         cuda_version: Optional CUDA version for GPU models. If provided and torch is in
-            dependencies, adds PyTorch CUDA index URL and pins torch to CUDA variant.
+            dependencies, pins torch to CUDA variant.
+
+    Returns:
+        List of extra pip index URLs (e.g. ``["https://download.pytorch.org/whl/cu124"]``)
+        that were NOT written to requirements.txt because SPCS rejects non-PEP-508 lines.
+        Callers should persist these via model metadata so the build step can apply them.
     """
     assert path.suffix in [".txt"], "PIP requirement file should have extension of txt."
     path.parent.mkdir(parents=True, exist_ok=True)
 
     lines: list[str] = []
+    pip_extra_index_urls: list[str] = []
 
     if cuda_version and _has_torch_dependency(pip_deps):
-        lines.append(_get_pytorch_cuda_index_url(cuda_version))
+        # Strip the "--extra-index-url " prefix to store just the URL.
+        raw = _get_pytorch_cuda_index_url(cuda_version)
+        pip_extra_index_urls.append(raw.removeprefix("--extra-index-url "))
         pip_deps = _pin_torch_to_cuda_variant(pip_deps, cuda_version)
 
     lines.extend(map(str, pip_deps))
@@ -712,6 +720,8 @@ def save_requirements_file(
     with open(path, "w", encoding="utf-8") as out:
         out.write("\n".join(lines))
 
+    return pip_extra_index_urls
+
 
 def load_conda_env_file(
     path: pathlib.Path,

snowflake/ml/_internal/platform_capabilities.py

@@ -84,7 +84,7 @@ class PlatformCapabilities:
         return self._get_bool_feature(LIVE_COMMIT_PARAMETER, False)
 
     def is_hidden_live_commit_enabled(self) -> bool:
-        return False
+        return self._get_bool_feature(HIDDEN_LIVE_COMMIT_PARAMETER, False)
 
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)

snowflake/ml/_internal/telemetry.py

@@ -9,7 +9,8 @@ import sys
 import time
 import traceback
 import types
-from typing import Any, Callable, Iterable, Mapping, Optional, TypeVar, Union, cast
+from collections.abc import Iterable, Mapping
+from typing import Any, Callable, Optional, TypeVar, Union, cast
 
 from typing_extensions import ParamSpec
 
@@ -119,6 +120,7 @@ class TelemetryField(enum.Enum):
     TYPE_FUNCTION_USAGE = "function_usage"
     TYPE_SNOWML_SPCS_USAGE = "snowml_spcs_usage"
     TYPE_SNOWML_PIPELINE_USAGE = "snowml_pipeline_usage"
+    TYPE_SNOWML_LOADED_MODEL_USAGE = "snowml_loaded_model_usage"
     # message keys for telemetry
     KEY_PROJECT = "project"
     KEY_SUBPROJECT = "subproject"
@@ -717,6 +719,12 @@ def _extract_arg_value(field: str, sig: inspect.Signature, args: Any, kwargs: An
         Tuple: First value indicates if `field` exists.
         Second value is the extracted value if existed.
     """
+    # Check keyword arguments first. The field may have no named parameter of its own and instead be
+    # absorbed by a variadic keyword parameter (**kwargs), in which case the signature lookup below
+    # would not find it even though the caller passed a value.
+    if field in kwargs:
+        return True, kwargs[field]
+
     if field not in sig.parameters:
         return False, None
 
@@ -729,10 +737,6 @@ def _extract_arg_value(field: str, sig: inspect.Signature, args: Any, kwargs: An
         if idx < len(args):
             return True, args[idx]
 
-    # Check if value was passed as keyword argument
-    if field in kwargs:
-        return True, kwargs[field]
-
     # Fall back to default value if available
     if param.default is not inspect.Parameter.empty:
         return True, param.default

snowflake/ml/experiment/_source_info.py

@@ -44,6 +44,11 @@ _SNOWFLAKE_FILE_DOMAIN_TYPE_ENV = "SNOWFLAKE_FILE_DOMAIN_TYPE"
 _SNOWFLAKE_FILE_DOMAIN_NAME_ENV = "SNOWFLAKE_FILE_DOMAIN_NAME"
 _SNOWFLAKE_MAIN_FILE_PATH_ENV = "SNOWFLAKE_MAIN_FILE_PATH"
 
+# Environment variable Snowflake injects into an ML job's container, carrying the
+# job's fully-qualified id. Its presence is how we recognize that the run was
+# created from inside an ML job.
+_ML_JOB_ID_ENV = "MLRS_JOB_ID"
+
 
 @dataclasses.dataclass(frozen=True)
 class GitInfo:
@@ -72,6 +77,9 @@ class SourceInfo:
     # ``entry_point``, not duplicated here.
     snowflake_file_domain_type: Optional[str] = None
     snowflake_file_domain_name: Optional[str] = None
+    # The fully-qualified id of the ML job this run was created from, taken from
+    # the environment. ``None`` when not running inside an ML job.
+    ml_job_id: Optional[str] = None
 
     def is_empty(self) -> bool:
         """Return True when there is nothing useful to send."""
@@ -80,6 +88,7 @@ class SourceInfo:
             and (self.git is None or self.git.is_empty())
             and self.snowflake_file_domain_type is None
             and self.snowflake_file_domain_name is None
+            and self.ml_job_id is None
         )
 
     def to_json_dict(self) -> dict[str, Any]:
@@ -92,8 +101,9 @@ class SourceInfo:
 
         Returns:
             A JSON-serializable dict whose keys (``entry_point``, ``git``,
-            ``snowflake_file_domain_type``, ``snowflake_file_domain_name``) are
-            included only when resolved. May be empty when nothing was collected.
+            ``snowflake_file_domain_type``, ``snowflake_file_domain_name``,
+            ``ml_job_id``) are included only when resolved. May be empty when
+            nothing was collected.
         """
         out: dict[str, Any] = {}
         if self.entry_point is not None and "$$" not in self.entry_point:
@@ -110,6 +120,8 @@ class SourceInfo:
             out["snowflake_file_domain_type"] = self.snowflake_file_domain_type
         if self.snowflake_file_domain_name is not None and "$$" not in self.snowflake_file_domain_name:
             out["snowflake_file_domain_name"] = self.snowflake_file_domain_name
+        if self.ml_job_id is not None and "$$" not in self.ml_job_id:
+            out["ml_job_id"] = self.ml_job_id
         return out
 
     @classmethod
@@ -121,24 +133,39 @@ class SourceInfo:
             be resolved or collection failed.
         """
         try:
+            # An ML job id is orthogonal to how the entry point is described, so
+            # it is resolved once and attached to whichever shape is returned.
+            ml_job_id = _collect_ml_job_id()
+
             # Snowflake-managed files (notebooks or .py workspace files) describe
             # the running file via environment variables rather than a resolvable
             # local path, so they are handled first and independently of the
             # git/notebook-path machinery.
             snowflake_file = _collect_snowflake_file()
             if snowflake_file is not None:
-                return snowflake_file
+                return dataclasses.replace(snowflake_file, ml_job_id=ml_job_id)
 
             # Resolve the notebook once so entry-point and git agree on the same file.
             notebook_path = _resolve_notebook_path() if _in_ipython_kernel() else None
             return cls(
                 entry_point=_detect_entry_point(notebook_path),
                 git=_collect_git(notebook_path),
+                ml_job_id=ml_job_id,
             )
         except Exception:
             return cls()
 
 
+def _collect_ml_job_id() -> Optional[str]:
+    """Collect the fully-qualified id of the enclosing ML job.
+
+    Returns:
+        The ML job id from the environment, or ``None`` when not running inside
+        an ML job (or when the server does not expose the id).
+    """
+    return os.environ.get(_ML_JOB_ID_ENV) or None
+
+
 def _collect_snowflake_file() -> Optional[SourceInfo]:
     """Collect source info when running inside a Snowflake-managed file.
 

snowflake/ml/experiment/experiment_tracking.py

@@ -63,9 +63,10 @@ class ExperimentTracking:
             schema_name: The name of the schema. If None, the current schema of the session
                 will be used. If there is no active schema, the PUBLIC schema will be used. Defaults to None.
             capture_source_info: If True, each new run records best-effort source provenance — the
-                entry-point filename and any surrounding git commit, branch, and remote URL. Set to
-                False to skip collection entirely. Collection is always non-fatal and never blocks
-                run creation. Defaults to True.
+                entry-point filename, any surrounding git commit, branch, and remote URL, and the id
+                of the enclosing ML job when running inside one. Set to False to skip collection
+                entirely. Collection is always non-fatal and never blocks run creation. Defaults to
+                True.
 
         Raises:
             ValueError: If no database is provided and no active database exists in the session.

snowflake/ml/feature_store/aggregation.py

@@ -33,6 +33,12 @@ class AggregationType(Enum):
     - Sketch aggregations (APPROX_COUNT_DISTINCT, APPROX_PERCENTILE): Stored as mergeable state in tiles
     - List aggregations (LAST_N, LAST_DISTINCT_N, FIRST_N, FIRST_DISTINCT_N): Stored as arrays in tiles
     - Secondary-key array (_SECONDARY_KEY_ARRAY): Internal-only ARRAY_AGG of the secondary-key column
+
+    Each value is the short function token used in the imperative metadata
+    tag / FeatureView JSON and in auto-generated output column names. Snowflake
+    ``DESCRIBE ... TYPE = SPECIFICATION`` reports its own SQL spelling for some
+    functions (e.g. ``stddev`` for ``STD``); the declarative layer reconciles
+    that spelling on read/hash rather than changing these values.
     """
 
     SUM = "sum"
@@ -50,6 +56,25 @@ class AggregationType(Enum):
     FIRST_DISTINCT_N = "first_distinct_n"
     _SECONDARY_KEY_ARRAY = "secondary_key_array"
 
+    @classmethod
+    def _missing_(cls, value: object) -> AggregationType | None:
+        """Accept Snowflake's SPECIFICATION spelling ``stddev`` as ``STD``.
+
+        The imperative wire token stays ``"std"``; ``DESCRIBE ... TYPE =
+        SPECIFICATION`` reports ``"stddev"`` for the same function, so reads of
+        the applied spec must resolve that spelling back to ``STD``.
+
+        Args:
+            value: The raw value that failed direct enum lookup.
+
+        Returns:
+            ``STD`` when ``value`` is the string ``"stddev"`` (case-insensitive),
+            otherwise ``None`` to preserve the standard ``ValueError``.
+        """
+        if isinstance(value, str) and value.lower() == "stddev":
+            return cls.STD
+        return None
+
     def is_simple(self) -> bool:
         """Check if this is a simple aggregation (scalar result per tile).
 
@@ -223,7 +248,7 @@ class AggregationSpec:
                 AggregationType.VAR,
             )
             if self.function not in supported_lifetime_types:
-                supported_names = ", ".join(t.value.upper() for t in supported_lifetime_types)
+                supported_names = ", ".join(t.name for t in supported_lifetime_types)
                 raise ValueError(
                     f"Lifetime window is not supported for {self.function.value} aggregation "
                     f"'{self.output_column}'. Lifetime is only supported for: {supported_names}."

snowflake/ml/feature_store/feature.py

@@ -17,8 +17,8 @@ from snowflake.ml.feature_store.aggregation import (
 )
 
 _NO_OFFSET = "0"
-_KEYS = "keys"
 _LIFETIME = "lifetime"
+_KEYS = "keys"
 
 
 class Feature: