snowflake-ml-python 1.40.0__tar.gz → 1.41.0__tar.gz

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Release History
 
-## 1.40.0
+## 1.41.0
+
+### New Features
+
+* Registry: Extended `ParamSpec` support to MLflow PyFunc, LightGBM, XGBoost, and CatBoost models.
+  Parameters declared in the model signature can now be passed at inference time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.40.0 (2026-05-19)
 
 ### New Features
 

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.40.0
+Version: 1.41.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,7 +416,20 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.40.0
+## 1.41.0
+
+### New Features
+
+* Registry: Extended `ParamSpec` support to MLflow PyFunc, LightGBM, XGBoost, and CatBoost models.
+  Parameters declared in the model signature can now be passed at inference time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.40.0 (2026-05-19)
 
 ### New Features
 

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -19,6 +19,7 @@ LIVE_COMMIT_PARAMETER = "ENABLE_LIVE_VERSION_IN_SDK"
 INLINE_DEPLOYMENT_SPEC_PARAMETER = "ENABLE_INLINE_DEPLOYMENT_SPEC_FROM_CLIENT_VERSION"
 SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST = "SET_MODULE_FUNCTIONS_VOLATILITY_FROM_MANIFEST"
 ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS = "ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS"
+ENABLE_PIP_ONLY_PACKAGING = "ENABLE_PIP_ONLY_PACKAGING"
 
 
 class PlatformCapabilities:
@@ -82,6 +83,18 @@ class PlatformCapabilities:
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
+    def is_pip_only_packaging_enabled(self) -> bool:
+        """Whether pip-only model packaging is enabled for this account.
+
+        Defaults to enabled when ``ENABLE_PIP_ONLY_PACKAGING`` is absent from
+        ``SYSTEM$ML_PLATFORM_CAPABILITIES()`` (e.g. older servers). When the
+        capability is present, defaults to enabled unless explicitly set to false.
+
+        Returns:
+            True if pip-only packaging is enabled for this account; otherwise False.
+        """
+        return self._get_bool_feature(ENABLE_PIP_ONLY_PACKAGING, default_value=True)
+
     @staticmethod
     def _get_features(session: snowpark_session.Session) -> dict[str, Any]:
         try:

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/snowflake/ml/feature_store/__init__.py

@@ -5,6 +5,8 @@ from snowflake.ml._internal import init_utils
 from .access_manager import setup_feature_store
 from .feature import Feature
 from .feature_view import RollupConfig
+from .realtime_config import RealtimeConfig
+from .request_source import RequestSource
 from .spec.enums import FeatureAggregationMethod
 from .stream_config import StreamConfig
 from .stream_source import StreamSource
@@ -19,6 +21,8 @@ __all__ = list(exportable_classes.keys()) + [
     "setup_feature_store",
     "Feature",
     "FeatureAggregationMethod",
+    "RealtimeConfig",
+    "RequestSource",
     "RollupConfig",
     "StreamConfig",
     "StreamSource",

snowflake_ml_python-1.41.0/snowflake/ml/feature_store/_compute_fn_validation.py

@@ -0,0 +1,253 @@
+"""Unified ``compute_fn`` / ``transformation_fn`` validation.
+
+This module is the single source of truth for the policy applied to user
+functions registered on a streaming feature view (``StreamConfig``) or a
+realtime feature view (``RealtimeConfig``). The policy is split into two
+layers, intentionally complementary:
+
+- :func:`validate_compute_fn_source` — static AST checks on the dedented
+  source text. Enforces that the source is a single top-level
+  ``def``-style function, with no nested ``def`` / ``async def`` / lambda,
+  no calls to forbidden builtins, and only imports from
+  :data:`ALLOWED_MODULES`.
+- :func:`validate_compute_fn_callable` — closure-vars / free-name check on
+  the live callable. Enforces that every free name resolves to a key in
+  :data:`ALLOWED_NAMESPACE_KEYS` (or ``__builtins__``), with no closure
+  references to enclosing scopes.
+
+Each error message starts with the caller-supplied ``kind`` label
+(``streaming feature view`` or ``realtime feature view``) so the user gets
+a domain-appropriate prefix.
+
+This is a deterministic guardrail, not a security sandbox — obfuscated
+bypasses (``getattr(builtins, "__import__")``, etc.) are out of scope.
+"""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import textwrap
+from typing import Any, Callable, Optional
+
+# Top-level packages permitted in import statements inside compute_fn.
+ALLOWED_MODULES: frozenset[str] = frozenset({"numpy", "pandas", "re", "copy"})
+
+# Names that may appear as free globals inside compute_fn. Mirrors the
+# runtime namespace populated by RTFV reconstruction so the same source
+# code runs identically at author time and at warehouse-side execution.
+ALLOWED_NAMESPACE_KEYS: frozenset[str] = frozenset({"pd", "pandas", "np", "numpy", "re", "copy"})
+
+# Builtins whose call is rejected by the AST layer. Union of the two
+# pre-existing per-subsystem sets — the strict / RTFV-superset policy.
+FORBIDDEN_BUILTINS: frozenset[str] = frozenset(
+    {
+        "__import__",
+        "eval",
+        "exec",
+        "compile",
+        "open",
+        "globals",
+        "locals",
+        "vars",
+        "getattr",
+        "setattr",
+        "delattr",
+        "breakpoint",
+        "input",
+    }
+)
+
+
+def validate_compute_fn_source(source: str, *, kind: str) -> None:
+    """Run the AST layer of compute_fn validation against *source*.
+
+    Enforces, in this order:
+
+    1. *source* is valid Python.
+    2. *source* contains exactly one top-level ``ast.FunctionDef`` (no
+       multi-statement modules, no decorators-only modules, no top-level
+       ``async def``).
+    3. No nested ``ast.FunctionDef`` / ``ast.AsyncFunctionDef`` and no
+       ``ast.Lambda`` anywhere inside the body.
+    4. No ``ast.Call`` whose target name (Name or Attribute) is in
+       :data:`FORBIDDEN_BUILTINS`.
+    5. Every ``ast.Import`` / ``ast.ImportFrom`` references a top-level
+       package in :data:`ALLOWED_MODULES`.
+
+    Args:
+        source: Plain-text Python source for the user function (will be
+            dedented internally).
+        kind: Domain prefix prepended to every error message; one of
+            ``"streaming feature view"`` / ``"realtime feature view"``.
+
+    Raises:
+        ValueError: If any rule above is violated. The error message
+            names the offending construct and its line number.
+    """
+    dedented = textwrap.dedent(source)
+    try:
+        tree = ast.parse(dedented)
+    except SyntaxError as e:
+        raise ValueError(f"{kind}: compute_fn source is not valid Python: {e.msg} (line {e.lineno}).") from e
+
+    if len(tree.body) != 1 or not isinstance(tree.body[0], ast.FunctionDef):
+        raise ValueError(
+            f"{kind}: compute_fn source must contain exactly one top-level "
+            "function definition. Decorators-only modules, multi-statement "
+            "modules, and async function definitions at the top level are "
+            "not supported."
+        )
+    outer_fn = tree.body[0]
+
+    for node in ast.walk(outer_fn):
+        if node is outer_fn:
+            continue
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            raise ValueError(
+                f"{kind}: compute_fn must not contain nested function "
+                f"definitions; found {node.name!r} at line {node.lineno}. "
+                f"Inline the logic or import helpers from one of the allowed "
+                f"runtime namespace modules: {sorted(ALLOWED_NAMESPACE_KEYS)}."
+            )
+        if isinstance(node, ast.Lambda):
+            raise ValueError(
+                f"{kind}: compute_fn must not contain lambda expressions; " f"found one at line {node.lineno}."
+            )
+        if isinstance(node, ast.Call):
+            func = node.func
+            fname: Optional[str]
+            if isinstance(func, ast.Name):
+                fname = func.id
+            elif isinstance(func, ast.Attribute):
+                fname = func.attr
+            else:
+                fname = None
+            if fname is not None and fname in FORBIDDEN_BUILTINS:
+                raise ValueError(
+                    f"{kind}: compute_fn must not call {fname!r}; found call "
+                    f"at line {node.lineno}. Forbidden builtins: "
+                    f"{sorted(FORBIDDEN_BUILTINS)}."
+                )
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                module = alias.name.split(".")[0]
+                if module not in ALLOWED_MODULES:
+                    raise ValueError(
+                        f"{kind}: import {alias.name!r} is not allowed in "
+                        f"compute_fn. Allowed modules: {sorted(ALLOWED_MODULES)}."
+                    )
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                module = node.module.split(".")[0]
+                if module not in ALLOWED_MODULES:
+                    raise ValueError(
+                        f"{kind}: import from {node.module!r} is not allowed "
+                        f"in compute_fn. Allowed modules: {sorted(ALLOWED_MODULES)}."
+                    )
+
+
+def validate_compute_fn_callable(fn: Callable[..., Any], *, kind: str) -> None:
+    """Run the closure-vars layer of compute_fn validation against *fn*.
+
+    Uses :func:`inspect.getclosurevars` to inspect the live callable. Names
+    bound by in-body imports and attribute lookups are filtered out before
+    the namespace check (see :func:`_collect_ast_local_names`) so
+    ``import pandas`` and ``pd.DataFrame`` do not trip the check.
+
+    Three rules are enforced:
+
+    - ``cvars.nonlocals`` is empty: no closure references to an enclosing
+      scope.
+    - ``cvars.unbound`` (after filtering) is empty: every free name
+      resolves somewhere.
+    - ``cvars.globals`` (after filtering) live inside
+      :data:`ALLOWED_NAMESPACE_KEYS` ∪ ``{"__builtins__"}``.
+
+    Args:
+        fn: The user-supplied callable.
+        kind: Domain prefix prepended to every error message.
+
+    Raises:
+        ValueError: If *fn* references closures, unbound names, or globals
+            outside the runtime namespace. The message names each offender.
+    """
+    try:
+        cvars = inspect.getclosurevars(fn)
+    except TypeError as e:
+        raise ValueError(f"{kind}: compute_fn closure variables are not inspectable: {e}") from e
+
+    if cvars.nonlocals:
+        offenders = sorted(cvars.nonlocals.keys())
+        raise ValueError(
+            f"{kind}: compute_fn must not reference enclosing-scope variables "
+            f"(closures); offending names: {offenders}. Inline the values or "
+            f"import from one of the allowed runtime namespace modules: "
+            f"{sorted(ALLOWED_NAMESPACE_KEYS)}."
+        )
+
+    try:
+        source = inspect.getsource(fn)
+    except (OSError, TypeError):
+        source = ""
+    import_names, attr_names = _collect_ast_local_names(source)
+    filterable = import_names | attr_names
+
+    effective_unbound = cvars.unbound - filterable
+    if effective_unbound:
+        offenders = sorted(effective_unbound)
+        raise ValueError(
+            f"{kind}: compute_fn references names that resolve nowhere: "
+            f"{offenders}. Check for typos, or import the symbol from one of "
+            f"the allowed runtime namespace modules: {sorted(ALLOWED_NAMESPACE_KEYS)}."
+        )
+
+    allowed_globals = set(ALLOWED_NAMESPACE_KEYS) | {"__builtins__"}
+    effective_globals = set(cvars.globals.keys()) - filterable
+    extra_globals = sorted(effective_globals - allowed_globals)
+    if extra_globals:
+        raise ValueError(
+            f"{kind}: compute_fn references symbols outside the allowed "
+            f"runtime namespace: {extra_globals}. Allowed namespace keys: "
+            f"{sorted(ALLOWED_NAMESPACE_KEYS)}. Inline the values or import "
+            f"the symbol from one of the allowed modules."
+        )
+
+
+def _collect_ast_local_names(source: str) -> tuple[set[str], set[str]]:
+    """Return ``(import-name set, attribute-name set)`` for free-name filtering.
+
+    :func:`inspect.getclosurevars` reports every name read from
+    ``co_names`` as either resolved or unbound. That set includes module
+    names from ``import x`` (``IMPORT_NAME`` reads them) and attribute
+    names from ``obj.attr`` (``LOAD_ATTR`` reads them). Neither class is
+    a real free name, so callers strip them before applying the namespace
+    check.
+
+    Args:
+        source: Dedented source of the user function. An empty / unparsable
+            string yields two empty sets (the closure check still runs).
+
+    Returns:
+        Tuple ``(imported_module_names, attribute_names)``.
+    """
+    try:
+        tree = ast.parse(textwrap.dedent(source))
+    except SyntaxError:
+        return set(), set()
+    import_names: set[str] = set()
+    attr_names: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                root = alias.name.split(".")[0]
+                import_names.add(root)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                import_names.add(node.module.split(".")[0])
+            for alias in node.names:
+                if alias.name != "*":
+                    import_names.add(alias.name)
+        elif isinstance(node, ast.Attribute):
+            attr_names.add(node.attr)
+    return import_names, attr_names

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/snowflake/ml/feature_store/aggregation.py

@@ -175,6 +175,19 @@ class AggregationSpec:
                     f"'{self.output_column}', got: {percentile}"
                 )
 
+        # Validate params for approx_count_distinct (HLL precision)
+        if self.function == AggregationType.APPROX_COUNT_DISTINCT:
+            if "hll_lg_k" not in self.params:
+                raise ValueError(
+                    f"Parameter 'precision' is required for approx_count_distinct aggregation '{self.output_column}'"
+                )
+            hll_lg_k = self.params["hll_lg_k"]
+            if not isinstance(hll_lg_k, int) or not (4 <= hll_lg_k <= 21):
+                raise ValueError(
+                    f"Parameter 'precision' must be an integer between 4 and 21 for aggregation "
+                    f"'{self.output_column}', got: {hll_lg_k}"
+                )
+
         # Validate _SECONDARY_KEY_ARRAY specs
         if self.function.is_secondary_key_array():
             if self.params:
@@ -232,7 +245,7 @@ class AggregationSpec:
         Similar to get_tile_column_name but with _CUM_ prefix instead of _PARTIAL_.
 
         Args:
-            partial_type: One of "SUM", "COUNT", "SUM_SQ", "HLL", "TDIGEST", "MIN", "MAX", "FIRST".
+            partial_type: One of "SUM", "COUNT", "SUM_SQ", "DS_HLL", "TDIGEST", "MIN", "MAX", "FIRST".
 
         Returns:
             Column name used in the tile table (prefixed with _CUM_).
@@ -247,13 +260,13 @@ class AggregationSpec:
         - _PARTIAL_SUM_{col}: SUM(col) - used by SUM, AVG, STD, VAR
         - _PARTIAL_COUNT_{col}: COUNT(col) - used by COUNT, AVG, STD, VAR
         - _PARTIAL_SUM_SQ_{col}: SUM(col*col) - used by STD, VAR
-        - _PARTIAL_HLL_{col}: HLL state - used by APPROX_COUNT_DISTINCT
+        - _PARTIAL_DS_HLL_{col}: Datasketches HLL sketch (BINARY) - used by APPROX_COUNT_DISTINCT
         - _PARTIAL_TDIGEST_{col}: T-Digest state - used by APPROX_PERCENTILE
 
         This allows sharing columns across aggregation types on the same column.
 
         Args:
-            partial_type: One of "SUM", "COUNT", "SUM_SQ", "HLL", "TDIGEST", "LAST", "FIRST".
+            partial_type: One of "SUM", "COUNT", "SUM_SQ", "DS_HLL", "TDIGEST", "LAST", "FIRST".
 
         Returns:
             Column name used in the tile table (prefixed with _PARTIAL_).

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.41.0}/snowflake/ml/feature_store/feature.py

@@ -327,16 +327,20 @@ class Feature:
         return cls(AggregationType.FIRST_DISTINCT_N, column, window, offset, n=n)
 
     @classmethod
-    def approx_count_distinct(cls, column: str, window: str, offset: str = "0") -> Feature:
+    def approx_count_distinct(cls, column: str, window: str, offset: str = "0", *, precision: int = 8) -> Feature:
         """Create an APPROX_COUNT_DISTINCT aggregation feature.
 
-        Estimates the number of distinct values using HyperLogLog algorithm.
-        This is approximate but highly efficient for large datasets.
+        Estimates the number of distinct values using the Apache Datasketches
+        HyperLogLog algorithm. This is approximate but highly efficient for
+        large datasets.
 
         Args:
             column: The column to count distinct values.
             window: The lookback window.
             offset: Offset to shift window into past. Default is "0" (no offset).
+            precision: Log-base-2 of the number of buckets in the HLL sketch.
+                Controls the trade-off between accuracy and memory. Valid range
+                is 4 to 21. Default is 8.
 
         Returns:
             A Feature configured for APPROX_COUNT_DISTINCT aggregation.
@@ -344,8 +348,9 @@ class Feature:
         Example::
 
             >>> unique_users = Feature.approx_count_distinct("user_id", "24h")
+            >>> precise_uniques = Feature.approx_count_distinct("user_id", "24h", precision=12)
         """
-        return cls(AggregationType.APPROX_COUNT_DISTINCT, column, window, offset)
+        return cls(AggregationType.APPROX_COUNT_DISTINCT, column, window, offset, hll_lg_k=precision)
 
     @classmethod
     def approx_percentile(cls, column: str, window: str, *, percentile: float = 0.5, offset: str = "0") -> Feature: