snowflake-ml-python 2.4.0__tar.gz → 2.5.0__tar.gz

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/CHANGELOG.md

@@ -1,11 +1,33 @@
 # Release History
 
-## 2.4.0
+## 2.5.0
+
+### New Features
+
+### Bug Fixes
+
+* Modeling: The `snowflake.ml.modeling` estimators and preprocessing transformers are not deprecated.
+  The `DeprecationWarning` emitted when importing a `snowflake.ml.modeling` subpackage, announced in
+  2.0.0, has been removed.
+* ML Jobs: `MLJob.get_logs(verbose=False)` no longer returns container startup and shutdown logs when other log
+  lines land between the lines of the job start or end banner.
+* Dependencies: Raised the `fsspec` requirement ceiling from `<2026` to `<2027` so `fsspec`
+  2026.6.0, which fixes CVE-2026-104851, can be installed.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.4.0 (2026-10-06)
 
 ### New Features
 
 * Generic: Support Python 3.14.
 
+* Registry: `create_service` now accepts `FeatureGroup` objects in `feature_sources_per_function`
+  alongside `FeatureView`s. Snowflake resolves the `FeatureGroup`'s online feature tables at
+  deploy time, so callers no longer need to enumerate the underlying feature views manually.
+
 * Registry: `FeatureSpec(dtype=DataType.OBJECT)` now accepts schema-free Python dictionaries as a
   model input or output (SQL `OBJECT`). Callers can pass a dict to `ModelVersion.run`, an object
   literal in SQL, or a JSON object over REST, without stringifying to JSON. Use `shape=(-1,)` for
@@ -20,6 +42,11 @@
 * Experiment Tracking: `ExperimentTracking` accepts an optional `warnings_as_errors` parameter. When True,
   conditions that are normally reported as warnings are raised instead.
 
+* Experiment Tracking: Experiment runs now appear as first-class objects in lineage. Calling
+  `model_version.lineage(direction="upstream", domain_filter={"experiment"})` returns `Run` instances
+  with `database_name`, `schema_name`, `experiment_name`, and `name` properties that can be passed straight back
+  into experiment tracking.
+
 ### Bug Fixes
 
 ### Behavior Changes

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 2.4.0
+Version: 2.5.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: 
@@ -237,7 +237,7 @@ License-File: LICENSE.txt
 Requires-Dist: anyio<5,>=3.5.0
 Requires-Dist: cachetools>=3.1.1
 Requires-Dist: cloudpickle>=2.0.0
-Requires-Dist: fsspec[http]<2026,>=2024.6.1
+Requires-Dist: fsspec[http]<2027,>=2024.6.1
 Requires-Dist: importlib_resources<7,>=6.1.1
 Requires-Dist: jinja2<4,>=3.1.0
 Requires-Dist: numpy<3,>=1.23
@@ -251,7 +251,7 @@ Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
 Requires-Dist: snowflake-connector-python[pandas]<5,>=3.17.3
-Requires-Dist: snowflake-snowpark-python<2,>=1.37.0
+Requires-Dist: snowflake-snowpark-python<2,>=1.43.0
 Requires-Dist: sqlparse<1,>=0.4
 Requires-Dist: tqdm<5
 Requires-Dist: typing-extensions<5,>=4.1.0
@@ -426,12 +426,34 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 2.4.0
+## 2.5.0
+
+### New Features
+
+### Bug Fixes
+
+* Modeling: The `snowflake.ml.modeling` estimators and preprocessing transformers are not deprecated.
+  The `DeprecationWarning` emitted when importing a `snowflake.ml.modeling` subpackage, announced in
+  2.0.0, has been removed.
+* ML Jobs: `MLJob.get_logs(verbose=False)` no longer returns container startup and shutdown logs when other log
+  lines land between the lines of the job start or end banner.
+* Dependencies: Raised the `fsspec` requirement ceiling from `<2026` to `<2027` so `fsspec`
+  2026.6.0, which fixes CVE-2026-104851, can be installed.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.4.0 (2026-10-06)
 
 ### New Features
 
 * Generic: Support Python 3.14.
 
+* Registry: `create_service` now accepts `FeatureGroup` objects in `feature_sources_per_function`
+  alongside `FeatureView`s. Snowflake resolves the `FeatureGroup`'s online feature tables at
+  deploy time, so callers no longer need to enumerate the underlying feature views manually.
+
 * Registry: `FeatureSpec(dtype=DataType.OBJECT)` now accepts schema-free Python dictionaries as a
   model input or output (SQL `OBJECT`). Callers can pass a dict to `ModelVersion.run`, an object
   literal in SQL, or a JSON object over REST, without stringifying to JSON. Use `shape=(-1,)` for
@@ -446,6 +468,11 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 * Experiment Tracking: `ExperimentTracking` accepts an optional `warnings_as_errors` parameter. When True,
   conditions that are normally reported as warnings are raised instead.
 
+* Experiment Tracking: Experiment runs now appear as first-class objects in lineage. Calling
+  `model_version.lineage(direction="upstream", domain_filter={"experiment"})` returns `Run` instances
+  with `database_name`, `schema_name`, `experiment_name`, and `name` properties that can be passed straight back
+  into experiment tracking.
+
 ### Bug Fixes
 
 ### Behavior Changes

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.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.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "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.10, <3.15"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1", "cloudpickle>=2.0.0", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "jinja2>=3.1.0,<4", "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", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.37.0,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1", "cloudpickle>=2.0.0", "fsspec[http]>=2024.6.1,<2027", "importlib_resources>=6.1.1, <7", "jinja2>=3.1.0,<4", "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", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.43.0,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/_internal/env_utils.py

@@ -90,6 +90,9 @@ def _validate_pip_requirement_string(req_str: str) -> requirements.Requirement:
     Returns:
         A requirements.Requirement object containing the requirement information.
     """
+    # A requirement string must not carry surrounding whitespace: packaging>=26 accepts only a
+    # requirement that ends at the end of the string, so a trailing newline is a parse error.
+    req_str = req_str.strip()
     try:
         r = requirements.Requirement(req_str)
 
@@ -780,8 +783,9 @@ def load_requirements_file(path: pathlib.Path) -> list[requirements.Requirement]
     with open(path, encoding="utf-8") as f:
         reqs = f.readlines()
 
-    # Filter out pip options
-    reqs = [line for line in reqs if line.strip() and not line.strip().startswith(("-", "#"))]
+    # "-" lines are pip options (e.g. --extra-index-url) and "#" lines are comments; neither is a
+    # requirement. Strip as well, since a requirement string must not keep readlines()' newline.
+    reqs = [stripped for line in reqs if (stripped := line.strip()) and not stripped.startswith(("-", "#"))]
 
     return validate_pip_requirement_string_list(reqs)
 

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/_internal/file_utils.py

@@ -120,7 +120,21 @@ def make_archive(
     )
 
 
-def zip_python_package(zipfile_path: str, package_name: str, ignore_generated_py_file: bool = True) -> None:
+def zip_python_package(
+    zipfile_path: str,
+    package_name: str,
+    ignore_generated_py_file: bool = True,
+    *,
+    exclude_dir_names: tuple[str, ...] = (),
+) -> None:
+    """Zip an imported Python package.
+
+    Args:
+        zipfile_path: Destination zip path.
+        package_name: Dotted package name to zip.
+        ignore_generated_py_file: When True, omit generated bytecode and stub files.
+        exclude_dir_names: Directory names to omit anywhere in the package. The directory entry itself is not written.
+    """
     import importlib_resources
     from importlib_resources import abc as importlib_resources_abc
 
@@ -131,6 +145,7 @@ def zip_python_package(zipfile_path: str, package_name: str, ignore_generated_py
 
     base_dirs = package_name.split(".")
     assert len(base_dirs) >= 1, "Invalid package name."
+    excluded_dirs = set(exclude_dir_names)
 
     with zipfile.ZipFile(zipfile_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
         for i in range(len(base_dirs)):
@@ -141,6 +156,8 @@ def zip_python_package(zipfile_path: str, package_name: str, ignore_generated_py
         def _add_to_zip(
             zf: zipfile.ZipFile, path_info: importlib_resources_abc.Traversable, base_arcname: pathlib.PurePosixPath
         ) -> None:
+            if path_info.name in excluded_dirs:
+                return
             if path_info.is_file():
                 if ignore_generated_py_file and path_info.name.endswith(GENERATED_PY_FILE_EXT):
                     return

snowflake_ml_python-2.5.0/snowflake/ml/experiment/_entities/run.py

@@ -0,0 +1,128 @@
+import types
+import warnings
+from typing import TYPE_CHECKING
+
+from snowflake import snowpark
+from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.ml.experiment import _experiment_info as experiment_info
+from snowflake.ml.experiment._entities import run_metadata
+from snowflake.ml.lineage import lineage_node
+
+if TYPE_CHECKING:
+    from snowflake.ml.experiment import experiment_tracking
+
+METADATA_SIZE_WARNING_MESSAGE = "It is likely that no further metrics or parameters will be logged for this run."
+
+
+class Run(lineage_node.LineageNode):
+    """An experiment run.
+
+    When created by ``ExperimentTracking.start_run``, the run is an active context manager that
+    patches model logging and ends the run on exit. When returned by the lineage system
+    (``model_version.lineage(direction="upstream", domain_filter={"experiment"})``), it is a
+    read-only handle exposing the identifiers needed to look up metrics and parameters.
+    """
+
+    def __init__(
+        self,
+        experiment_tracking: "experiment_tracking.ExperimentTracking | None" = None,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+        session: snowpark.Session | None = None,
+        database_name: str | None = None,
+        schema_name: str | None = None,
+    ) -> None:
+        self._experiment_tracking = experiment_tracking
+        self.experiment_name = experiment_name
+        self.name = run_name
+
+        # Whether we've already shown the user a warning about exceeding the run metadata size limit.
+        self._warned_about_metadata_size = False
+
+        if experiment_tracking is not None:
+            _session = experiment_tracking._session
+            self.database_name = str(experiment_tracking._database_name)
+            self.schema_name = str(experiment_tracking._schema_name)
+        else:
+            if session is None or database_name is None or schema_name is None:
+                raise ValueError(
+                    "session, database_name, and schema_name are required when experiment_tracking is None"
+                )
+            _session = session
+            self.database_name = database_name
+            self.schema_name = schema_name
+
+        self._patcher = experiment_info.ExperimentInfoPatcher(
+            experiment_info=self._get_experiment_info(),
+        )
+
+        # A run is modelled in lineage as a version of its experiment, so the node name is the experiment's.
+        super().__init__(
+            session=_session,
+            name=self._fully_qualified_experiment_name(),
+            domain="experiment",
+            version=str(run_name),
+        )
+
+    def __enter__(self) -> "Run":
+        self._patcher.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None:
+        self._patcher.__exit__(exc_type, exc_value, tb)
+        if self._experiment_tracking is not None and self._experiment_tracking._run is self:
+            if exc_type is not None:
+                self._experiment_tracking._try_log_exception(exc_type, exc_value, tb)
+                self._experiment_tracking.end_run(status=run_metadata.RunStatus.FAILED.value)
+            else:
+                self._experiment_tracking.end_run()
+
+    def _fully_qualified_experiment_name(self) -> str:
+        return sql_identifier.get_fully_qualified_name(self.database_name, self.schema_name, self.experiment_name)
+
+    def _get_experiment_info(self) -> experiment_info.ExperimentInfo:
+        return experiment_info.ExperimentInfo(
+            fully_qualified_name=self._fully_qualified_experiment_name(),
+            run_name=self.name.identifier(),
+        )
+
+    def _handle_run_metadata_size_limit(self, sql_error_msg: str) -> None:
+        """Report that run metadata exceeded the size limit.
+
+        Args:
+            sql_error_msg: The error message returned by Snowflake.
+
+        Raises:
+            RuntimeWarning: If the experiment tracking instance was created with warnings_as_errors=True.
+        """
+        message = f"{sql_error_msg}. {METADATA_SIZE_WARNING_MESSAGE}"
+        if self._experiment_tracking is not None and self._experiment_tracking._warnings_as_errors:
+            raise RuntimeWarning(message)
+        # Once the limit is hit every subsequent log attempt fails the same way, so warn only once.
+        if not self._warned_about_metadata_size:
+            warnings.warn(message, RuntimeWarning, stacklevel=2)
+            self._warned_about_metadata_size = True
+
+    @staticmethod
+    def _load_from_lineage_node(
+        session: snowpark.Session,
+        name: str,
+        version: str,
+    ) -> "Run":
+        database_name, schema_name, experiment_name = identifier.parse_schema_level_object_identifier(name)
+        return Run(
+            experiment_name=sql_identifier.SqlIdentifier(experiment_name),
+            run_name=sql_identifier.SqlIdentifier(version),
+            session=session,
+            database_name=database_name,
+            schema_name=schema_name,
+        )
+
+
+lineage_node.DOMAIN_LINEAGE_REGISTRY["experiment"] = Run

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -25,7 +25,6 @@ from snowflake.ml.experiment._client import (
     experiment_tracking_sql_client as sql_client,
 )
 from snowflake.ml.experiment._entities import run_metadata
-from snowflake.ml.lineage import lineage_node
 from snowflake.ml.model import type_hints
 from snowflake.ml.utils import sql_client as sql_client_utils
 from snowflake.snowpark import functions
@@ -328,15 +327,14 @@ class ExperimentTracking:
         else:
             raise RuntimeError("No run is active. Please provide a run_name or start a run.")
 
-        experiment_fqn = self._sql_client.fully_qualified_object_name(
-            self._database_name, self._schema_name, self._experiment.name
-        )
-        run_node = lineage_node.LineageNode(
-            session=self._session,
-            name=experiment_fqn,
-            domain="experiment",
-            version=resolved_run_name.identifier(),
-        )
+        if self._run and self._run.name == resolved_run_name:
+            run_node = self._run
+        else:
+            run_node = entities.Run(
+                experiment_tracking=self,
+                experiment_name=self._experiment.name,
+                run_name=resolved_run_name,
+            )
         logged_models = run_node.lineage(direction="downstream", domain_filter={"model"})
         return [model for model in logged_models if isinstance(model, ml_model.ModelVersion)]
 

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/jobs/job.py

@@ -1,3 +1,4 @@
+import bisect
 import json
 import logging
 import os
@@ -583,20 +584,49 @@ def _get_logs(
     if verbose:
         return full_log
 
-    # Otherwise, extract only the portion between LOG_START_MSG and LOG_END_MSG
-    start_idx = full_log.find(constants.LOG_START_MSG)
-    if start_idx != -1:
-        start_idx += len(constants.LOG_START_MSG)
-    else:
-        # If start message not found, start from the beginning
-        start_idx = 0
+    return _extract_payload_logs(full_log)
+
 
-    end_idx = full_log.find(constants.LOG_END_MSG, start_idx)
-    if end_idx == -1:
-        # If end message not found, return everything after start
-        end_idx = len(full_log)
+def _extract_payload_logs(full_log: str) -> str:
+    """Return the payload output between the LOG_START_MSG and LOG_END_MSG banners.
 
-    return full_log[start_idx:end_idx].strip()
+    A banner is a separator line, the marker line, and a separator line, in that order. Other
+    lines may sit between those parts because the job log interleaves stdout with stderr. The
+    first start banner and the last end banner after it are used, so marker text that the payload
+    prints before the launcher's end banner is kept as output.
+
+    Args:
+        full_log: The complete job log.
+
+    Returns:
+        The log lines between the banners, stripped of surrounding whitespace.
+    """
+    separator, start_marker, _ = constants.LOG_START_MSG.split("\n")
+    end_marker = constants.LOG_END_MSG.split("\n")[1]
+    lines = full_log.splitlines(keepends=True)
+    separators = [i for i, line in enumerate(lines) if line.strip() == separator]
+
+    def banners(marker: str) -> list[tuple[int, int]]:
+        """Return the (opening, closing) separator indices of every banner for ``marker``."""
+        found = []
+        for i, line in enumerate(lines):
+            if line.strip() != marker:
+                continue
+            opening_idx = bisect.bisect_left(separators, i) - 1
+            closing_idx = bisect.bisect_right(separators, i)
+            if opening_idx >= 0 and closing_idx < len(separators):
+                found.append((separators[opening_idx], separators[closing_idx]))
+        return found
+
+    # If start message not found, start from the beginning
+    start_banners = banners(start_marker)
+    start = start_banners[0][1] + 1 if start_banners else 0
+
+    # If end message not found, return everything after start
+    end_banners = [banner for banner in banners(end_marker) if banner[0] >= start]
+    end = end_banners[-1][0] if end_banners else len(lines)
+
+    return "".join(lines[start:end]).strip()
 
 
 def _read_instance_record(session: snowpark.Session, result_path: str, instance_id: int) -> dict[str, Any] | None:

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/lineage/lineage_node.py

@@ -1,3 +1,4 @@
+import importlib
 import json
 from datetime import datetime
 from typing import TYPE_CHECKING, Literal, Union
@@ -86,7 +87,7 @@ class LineageNode(mixins.SerializableSessionMixin):
     def lineage(
         self,
         direction: Literal["upstream", "downstream"] = "downstream",
-        domain_filter: set[Literal["feature_view", "dataset", "model", "table", "view"]] | None = None,
+        domain_filter: set[Literal["feature_view", "dataset", "model", "table", "view", "experiment"]] | None = None,
     ) -> list[Union["feature_view.FeatureView", "dataset.Dataset", "ModelVersion", "LineageNode"]]:
         """
         Retrieves the lineage nodes connected to this node.
@@ -122,6 +123,13 @@ class LineageNode(mixins.SerializableSessionMixin):
                     for s in identifier.parse_schema_level_object_identifier(lineage_object["name"])
                     if s is not None
                 )
+                if domain not in DOMAIN_LINEAGE_REGISTRY:
+                    match domain:
+                        case "experiment":
+                            try:
+                                importlib.import_module("snowflake.ml.experiment._entities.run")
+                            except ImportError:
+                                pass
                 if domain in DOMAIN_LINEAGE_REGISTRY and lineage_object["status"] == "ACTIVE":
                     lineage_nodes.append(
                         DOMAIN_LINEAGE_REGISTRY[domain]._load_from_lineage_node(

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/model/_client/model/model_version_impl.py

@@ -10,7 +10,7 @@ import pandas as pd
 from snowflake.ml._internal import platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.feature_store import feature_view
+from snowflake.ml.feature_store import feature_group, feature_view
 from snowflake.ml.jobs import job
 from snowflake.ml.lineage import lineage_node
 from snowflake.ml.model import inference_engine, openai_signatures, task, type_hints
@@ -163,14 +163,13 @@ class ModelVersion(lineage_node.LineageNode):
         service_ops: service_ops.ServiceOperator,
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        retry: bool | None = False,
     ) -> "ModelVersion":
         self: "ModelVersion" = object.__new__(cls)
         self._model_ops = model_ops
         self._service_ops = service_ops
         self._model_name = model_name
         self._version_name = version_name
-        self._functions = self._get_functions(**({"retry": True} if retry else {}))
+        self._functions = self._get_functions()
         self._model_spec = None
         self._target_platforms = None
         super(cls, cls).__init__(
@@ -419,7 +418,7 @@ class ModelVersion(lineage_node.LineageNode):
             statement_params=statement_params,
         )
 
-    def _get_functions(self, *, retry: bool | None = False) -> list[model_manifest_schema.ModelFunctionInfo]:
+    def _get_functions(self) -> list[model_manifest_schema.ModelFunctionInfo]:
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_TELEMETRY_SUBPROJECT,
@@ -430,7 +429,6 @@ class ModelVersion(lineage_node.LineageNode):
             model_name=self._model_name,
             version_name=self._version_name,
             statement_params=statement_params,
-            **({"retry": True} if retry else {}),
         )
 
     @telemetry.send_api_usage_telemetry(
@@ -1414,7 +1412,8 @@ class ModelVersion(lineage_node.LineageNode):
         autocapture: bool | None = None,
         inference_engine_options: dict[str, Any] | None = None,
         experimental_options: dict[str, Any] | None = None,
-        feature_sources_per_function: dict[str, list[feature_view.FeatureView]] | None = None,
+        feature_sources_per_function: dict[str, list[feature_view.FeatureView | feature_group.FeatureGroup]]
+        | None = None,
         adapters: dict[str, "ModelVersion"] | list["ModelVersion"] | None = None,
     ) -> str | async_job.AsyncJob:
         """Create an inference service with the given spec.
@@ -1460,9 +1459,9 @@ class ModelVersion(lineage_node.LineageNode):
                 `engine_args_override` is a list of string arguments to pass to the inference engine.
             experimental_options: Experimental options for the service creation.
             feature_sources_per_function: Optional mapping from model function name (e.g. ``"predict"``) to the list of
-                registered :class:`FeatureView` objects whose columns should be looked up at inference time. The model
-                service will fetch any missing feature columns from these sources before invoking the model. Currently
-                only one FeatureView per function is supported.
+                registered :class:`FeatureView` or :class:`FeatureGroup` objects whose columns should be looked up at
+                inference time. The model service will fetch any missing feature columns from these sources before
+                invoking the model. Currently only one source per function is supported.
             adapters: Optional mapping from service alias (``model =>`` / REST ``params.model``) to adapter
                 :class:`ModelVersion` objects, or a list of adapter versions. Dict keys become ``alias`` on each
                 emitted list item. A nonempty list and adapter-as-target omit ``alias`` (GS defaults each to
@@ -1492,7 +1491,8 @@ class ModelVersion(lineage_node.LineageNode):
         autocapture: bool | None = None,
         inference_engine_options: dict[str, Any] | None = None,
         experimental_options: dict[str, Any] | None = None,
-        feature_sources_per_function: dict[str, list[feature_view.FeatureView]] | None = None,
+        feature_sources_per_function: dict[str, list[feature_view.FeatureView | feature_group.FeatureGroup]]
+        | None = None,
         adapters: dict[str, "ModelVersion"] | list["ModelVersion"] | None = None,
     ) -> str | async_job.AsyncJob:
         """Create an inference service with the given spec.
@@ -1538,9 +1538,9 @@ class ModelVersion(lineage_node.LineageNode):
                 `engine_args_override` is a list of string arguments to pass to the inference engine.
             experimental_options: Experimental options for the service creation.
             feature_sources_per_function: Optional mapping from model function name (e.g. ``"predict"``) to the list of
-                registered :class:`FeatureView` objects whose columns should be looked up at inference time. The model
-                service will fetch any missing feature columns from these sources before invoking the model. Currently
-                only one FeatureView per function is supported.
+                registered :class:`FeatureView` or :class:`FeatureGroup` objects whose columns should be looked up at
+                inference time. The model service will fetch any missing feature columns from these sources before
+                invoking the model. Currently only one source per function is supported.
             adapters: Optional mapping from service alias (``model =>`` / REST ``params.model``) to adapter
                 :class:`ModelVersion` objects, or a list of adapter versions. Dict keys become ``alias`` on each
                 emitted list item. A nonempty list and adapter-as-target omit ``alias`` (GS defaults each to
@@ -1575,7 +1575,8 @@ class ModelVersion(lineage_node.LineageNode):
         autocapture: bool | None = None,
         inference_engine_options: dict[str, Any] | None = None,
         experimental_options: dict[str, Any] | None = None,
-        feature_sources_per_function: dict[str, list[feature_view.FeatureView]] | None = None,
+        feature_sources_per_function: dict[str, list[feature_view.FeatureView | feature_group.FeatureGroup]]
+        | None = None,
         adapters: dict[str, "ModelVersion"] | list["ModelVersion"] | None = None,
     ) -> str | async_job.AsyncJob:
         """Create an inference service with the given spec.
@@ -1623,9 +1624,9 @@ class ModelVersion(lineage_node.LineageNode):
                 `engine_args_override` is a list of string arguments to pass to the inference engine.
             experimental_options: Experimental options for the service creation.
             feature_sources_per_function: Optional mapping from model function name (e.g. ``"predict"``) to the list of
-                registered :class:`FeatureView` objects whose columns should be looked up at inference time. The model
-                service will fetch any missing feature columns from these sources before invoking the model. Currently
-                only one FeatureView per function is supported.
+                registered :class:`FeatureView` or :class:`FeatureGroup` objects whose columns should be looked up at
+                inference time. The model service will fetch any missing feature columns from these sources before
+                invoking the model. Currently only one source per function is supported.
             adapters: Optional mapping from service alias (``model =>`` / REST ``params.model``) to adapter
                 :class:`ModelVersion` objects, or a list of adapter versions. Dict keys become ``alias`` on each
                 emitted list item. A nonempty list and adapter-as-target omit ``alias`` (GS defaults each to

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.5.0}/snowflake/ml/model/_client/ops/model_ops.py

@@ -59,7 +59,9 @@ class ServiceInfo(TypedDict):
 
 class ModelOperator:
     INFERENCE_SERVICE_ENDPOINT_NAME = "inference"
-    INGRESS_ENDPOINT_URL_SUFFIX = "snowflakecomputing.app"
+    # Accounts on the per-account public URL policy get a URL under "snowflake.app"; the others keep
+    # the original "snowflakecomputing.app". Both are live, so both have to be accepted.
+    INGRESS_ENDPOINT_URL_SUFFIXES = ("snowflakecomputing.app", "snowflake.app")
     # app-service-privatelink might not contain "snowflakecomputing" in the url - using the minimum required substring
     PRIVATELINK_INGRESS_ENDPOINT_URL_SUBSTRING = "privatelink.snowflake"
 
@@ -706,7 +708,7 @@ class ModelOperator:
         if url_value is None:
             return None
         url_str = str(url_value)
-        return url_str if url_str.endswith(ModelOperator.INGRESS_ENDPOINT_URL_SUFFIX) else None
+        return url_str if url_str.endswith(ModelOperator.INGRESS_ENDPOINT_URL_SUFFIXES) else None
 
     def _extract_and_validate_privatelink_url(self, res_row: "row.Row") -> str | None:
         """Extract and validate privatelink ingress URL from endpoint row."""
@@ -908,7 +910,6 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: dict[str, Any] | None = None,
-        retry: bool | None = False,
     ) -> tuple[model_spec.ModelSpec, list[str] | None]:
         """Fetch both model spec and target platforms from a single SQL query.
 
@@ -918,23 +919,19 @@ class ModelOperator:
             model_name: The model name.
             version_name: The version name.
             statement_params: Optional dictionary of statement parameters.
-            retry: If True, retry SHOW VERSIONS when the version row is not yet visible.
 
         Returns:
             A tuple of (model_spec, target_platforms) where target_platforms is a list of
             platform strings (e.g., ["WAREHOUSE"]) or None if not available.
         """
-        show_versions_kwargs: dict[str, Any] = {
-            "database_name": database_name,
-            "schema_name": schema_name,
-            "model_name": model_name,
-            "version_name": version_name,
-            "check_model_details": True,
-            "statement_params": {**(statement_params or {}), "SHOW_MODEL_DETAILS_IN_SHOW_VERSIONS_IN_MODEL": True},
-        }
-        if retry:
-            show_versions_kwargs["retry"] = True
-        version_row = self._model_client.show_versions(**show_versions_kwargs)[0]
+        version_row = self._model_client.show_versions(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            check_model_details=True,
+            statement_params={**(statement_params or {}), "SHOW_MODEL_DETAILS_IN_SHOW_VERSIONS_IN_MODEL": True},
+        )[0]
 
         # Extract model spec
         raw_model_spec_res = version_row[self._model_client.MODEL_VERSION_MODEL_SPEC_COL_NAME]
@@ -958,7 +955,6 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: dict[str, Any] | None = None,
-        retry: bool | None = False,
     ) -> model_spec.ModelSpec:
         parsed_model_spec, _ = self._fetch_model_spec_and_target_platforms(
             database_name=database_name,
@@ -966,7 +962,6 @@ class ModelOperator:
             model_name=model_name,
             version_name=version_name,
             statement_params=statement_params,
-            **({"retry": True} if retry else {}),
         )
         return parsed_model_spec
 
@@ -1214,7 +1209,6 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: dict[str, Any] | None = None,
-        retry: bool | None = False,
     ) -> list[model_manifest_schema.ModelFunctionInfo]:
         parsed_model_spec = self._fetch_model_spec(
             database_name=database_name,
@@ -1222,7 +1216,6 @@ class ModelOperator:
             model_name=model_name,
             version_name=version_name,
             statement_params=statement_params,
-            **({"retry": True} if retry else {}),
         )
         show_functions_res = self._model_version_client.show_functions(
             database_name=database_name,