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

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

@@ -1,6 +1,43 @@
 # Release History
 
-## 1.40.0
+## 1.42.0
+
+### New Features
+
+* Registry: Support `truncate_dim` for `SentenceTransformers` models. Truncation set at
+  construction (`SentenceTransformer(..., truncate_dim=N)`) is captured when the model is logged
+  and restored on reload. On clients with `sentence-transformers` 5.0.0 or later, `truncate_dim`
+  is also exposed as a runtime parameter in the model signature.
+
+* Registry: `log_model()` now captures a representative row from `sample_input_data` and stores it alongside the model
+  so inference code snippets shown in the model registry UI can be pre-filled with realistic values. Pass
+  `options={"capture_sample_input_data": False}` to opt out (e.g., for sensitive data); generic placeholder values
+  will be used in the snippets instead.
+
+### Bug Fixes
+
+* Registry: Pin `transformers<5` for additional HuggingFace pipeline tasks removed in
+  `transformers 5.x` (`summarization`, `text2text-generation`, `question-answering`, and
+  `translation_*`), preventing deployment failures from missing pipeline classes.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.41.0 (2026-05-27)
+
+### 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
 
@@ -13,6 +50,14 @@
 
 ### Behavior Changes
 
+* Registry: `log_model(..., options=...)` now rejects unknown top-level keys and unknown keys inside each
+  `method_options` entry (for example misspellings or options that belong to a different model framework).
+  Previously those keys were ignored. Validation is based on the public save-option TypedDicts and runs
+  before dependency reconciliation.
+
+* Registry: `use_gpu` is declared on the CatBoost, XGBoost, PyTorch, and TorchScript save-option
+  TypedDicts to match the save paths that already read this flag.
+
 ### Deprecations
 
 ## 1.39.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.40.0
+Version: 1.42.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: 
@@ -244,7 +244,7 @@ Requires-Dist: numpy<3,>=1.23
 Requires-Dist: packaging<26,>=20.9
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: platformdirs<5
-Requires-Dist: pyarrow<19.0.0
+Requires-Dist: pyarrow
 Requires-Dist: pydantic<3,>=2.8.2
 Requires-Dist: pyjwt<3,>=2.0.0
 Requires-Dist: pytimeparse<2,>=1.1.8
@@ -416,7 +416,44 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.40.0
+## 1.42.0
+
+### New Features
+
+* Registry: Support `truncate_dim` for `SentenceTransformers` models. Truncation set at
+  construction (`SentenceTransformer(..., truncate_dim=N)`) is captured when the model is logged
+  and restored on reload. On clients with `sentence-transformers` 5.0.0 or later, `truncate_dim`
+  is also exposed as a runtime parameter in the model signature.
+
+* Registry: `log_model()` now captures a representative row from `sample_input_data` and stores it alongside the model
+  so inference code snippets shown in the model registry UI can be pre-filled with realistic values. Pass
+  `options={"capture_sample_input_data": False}` to opt out (e.g., for sensitive data); generic placeholder values
+  will be used in the snippets instead.
+
+### Bug Fixes
+
+* Registry: Pin `transformers<5` for additional HuggingFace pipeline tasks removed in
+  `transformers 5.x` (`summarization`, `text2text-generation`, `question-answering`, and
+  `translation_*`), preventing deployment failures from missing pipeline classes.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.41.0 (2026-05-27)
+
+### 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
 
@@ -429,6 +466,14 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Behavior Changes
 
+* Registry: `log_model(..., options=...)` now rejects unknown top-level keys and unknown keys inside each
+  `method_options` entry (for example misspellings or options that belong to a different model framework).
+  Previously those keys were ignored. Validation is based on the public save-option TypedDicts and runs
+  before dependency reconciliation.
+
+* Registry: `use_gpu` is declared on the CatBoost, XGBoost, PyTorch, and TorchScript save-option
+  TypedDicts to match the save paths that already read this flag.
+
 ### Deprecations
 
 ## 1.39.0

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.42.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.14"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.42.0}/snowflake/ml/_internal/env_utils.py

@@ -57,20 +57,22 @@ def get_execution_context() -> str:
 
 
 def is_local_conda_environment() -> bool:
-    """Return True if the active Python interpreter appears to run inside a conda env
-    or under conda session context (e.g. a venv created inside an activated conda env).
+    """Return True if the active Python interpreter appears to run inside a conda env.
 
-    Uses the presence of a ``conda-meta`` directory under :py:data:`sys.prefix`, which is
-    standard for conda-created environments. A nested venv typically has ``sys.prefix``
-    pointing at the venv without ``conda-meta``; conda still sets ``CONDA_PREFIX`` when
-    an environment is activated, so a non-empty ``CONDA_PREFIX`` is treated as conda context.
+    Uses ``conda-meta`` under :py:data:`sys.prefix` for conda-created environments.
+    Standard-library virtual environments (``pyvenv.cfg`` present) are **not** treated as
+    conda even when ``CONDA_PREFIX`` is still set in the shell (e.g. conda base
+    auto-activation while a separate venv kernel is selected).
 
     Returns:
-        ``True`` if ``sys.prefix`` contains ``conda-meta`` or ``CONDA_PREFIX`` is set and
-        non-empty, else ``False``.
+        ``True`` if ``sys.prefix`` contains ``conda-meta``, or ``CONDA_PREFIX`` is set and
+        there is no ``pyvenv.cfg`` under ``sys.prefix``; else ``False``.
     """
-    if os.path.isdir(os.path.join(sys.prefix, "conda-meta")):
+    prefix = sys.prefix
+    if os.path.isdir(os.path.join(prefix, "conda-meta")):
         return True
+    if os.path.isfile(os.path.join(prefix, "pyvenv.cfg")):
+        return False
     return bool(os.environ.get("CONDA_PREFIX", "").strip())
 
 

{snowflake_ml_python-1.40.0 → snowflake_ml_python-1.42.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.42.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.42.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", "dataclasses"})
+
+# 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.42.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.42.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: