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

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

@@ -1,11 +1,67 @@
 # Release History
 
-## 2.4.0
+## 2.6.0
+
+### New Features
+
+* ML Jobs: Added `register_code_bundle` and `register_job_from_code_bundle` (Public Preview) to
+  create a Snowflake code bundle and run ML Jobs from it. `delete_code_bundle` drops a registered bundle.
+* Feature Store: The Postgres-backed Online Feature Store is now generally available, including tiled aggregations,
+  streaming and realtime feature views and feature groups.
+
+### Bug Fixes
+
+* ML Jobs: `submit_from_stage` accepts stage paths with double-quoted segments, such as a Git repository branch whose
+  name contains `/` (`@repo/branches/"feature/x"/src`). These paths used to fail with "does not exist".
+* ML Jobs: `MLJob.result()` no longer returns another job's result when results are fetched concurrently on one
+  machine.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.5.0 (2026-10-14)
+
+### New Features
+
+* Registry: `huggingface.TransformersPipeline` can omit `task`; when omitted, the task is inferred
+  automatically from the model's Hugging Face Hub `pipeline_tag` (requires `huggingface_hub`).
+
+### 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
+
+* Registry: `huggingface.TransformersPipeline` now takes required `model` as the first argument;
+  `task` is optional and inferred when not provided. Prefer
+  `TransformersPipeline(model="org/model")` over passing `task` explicitly.
+* Registry: Removed deprecated `huggingface_pipeline.HuggingFacePipelineModel` and its
+  `log_model_and_create_service` API. Use `huggingface.TransformersPipeline` with
+  `registry.log_model` / `ModelVersion.create_service` instead. A pickle-compat alias remains
+  for loading models logged with the old class.
+* Feature Store: Batch feature views with a Postgres online store now default `OnlineConfig.target_lag` to
+  `"1 minute"` instead of `"10 seconds"`. Setting a Postgres `target_lag` below 1 minute emits a `UserWarning`.
+  Hybrid table online stores are unchanged.
+
+### 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 +76,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.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 2.4.0
+Version: 2.6.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,68 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 2.4.0
+## 2.6.0
+
+### New Features
+
+* ML Jobs: Added `register_code_bundle` and `register_job_from_code_bundle` (Public Preview) to
+  create a Snowflake code bundle and run ML Jobs from it. `delete_code_bundle` drops a registered bundle.
+* Feature Store: The Postgres-backed Online Feature Store is now generally available, including tiled aggregations,
+  streaming and realtime feature views and feature groups.
+
+### Bug Fixes
+
+* ML Jobs: `submit_from_stage` accepts stage paths with double-quoted segments, such as a Git repository branch whose
+  name contains `/` (`@repo/branches/"feature/x"/src`). These paths used to fail with "does not exist".
+* ML Jobs: `MLJob.result()` no longer returns another job's result when results are fetched concurrently on one
+  machine.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.5.0 (2026-10-14)
+
+### New Features
+
+* Registry: `huggingface.TransformersPipeline` can omit `task`; when omitted, the task is inferred
+  automatically from the model's Hugging Face Hub `pipeline_tag` (requires `huggingface_hub`).
+
+### 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
+
+* Registry: `huggingface.TransformersPipeline` now takes required `model` as the first argument;
+  `task` is optional and inferred when not provided. Prefer
+  `TransformersPipeline(model="org/model")` over passing `task` explicitly.
+* Registry: Removed deprecated `huggingface_pipeline.HuggingFacePipelineModel` and its
+  `log_model_and_create_service` API. Use `huggingface.TransformersPipeline` with
+  `registry.log_model` / `ModelVersion.create_service` instead. A pickle-compat alias remains
+  for loading models logged with the old class.
+* Feature Store: Batch feature views with a Postgres online store now default `OnlineConfig.target_lag` to
+  `"1 minute"` instead of `"10 seconds"`. Setting a Postgres `target_lag` below 1 minute emits a `UserWarning`.
+  Hybrid table online stores are unchanged.
+
+### 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 +502,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.6.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.6.0/snowflake/cortex/_classify_text.py

@@ -0,0 +1,99 @@
+import json
+from typing import Any, cast
+
+from typing_extensions import deprecated
+
+from snowflake import snowpark
+from snowflake.cortex._util import (
+    CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
+    SnowflakeAuthenticationException,
+    warn_cortex_deprecated,
+)
+from snowflake.ml._internal import telemetry
+from snowflake.snowpark import context, functions
+
+_AI_CLASSIFY_FUNCTION_NAME = "AI_CLASSIFY"
+# AI_CLASSIFY requires its config argument to be a constant object literal. A Python dict is rendered by
+# Snowpark as PARSE_JSON('...')::OBJECT, which the server rejects ("... is not a constant"), so emit the
+# config as a SQL object constant via sql_expr -- this mirrors snowflake.snowpark.functions.ai_classify.
+# Legacy CLASSIFY_TEXT was always single-label, so set output_mode explicitly to keep that contract.
+_AI_CLASSIFY_SINGLE_LABEL_CONFIG_SQL = "{'output_mode': 'single'}"
+
+
+def _adapt_ai_classify_result(result: Any) -> str:
+    """Map an AI_CLASSIFY result to the legacy CLASSIFY_TEXT {"label": ...} JSON string."""
+    # Used for non-Column results (e.g. a dict/JSON string): reproduce the legacy single-label object shape.
+    parsed: Any = result
+    if isinstance(result, str):
+        try:
+            parsed = json.loads(result)
+        except json.JSONDecodeError:
+            return result
+    label: Any = None
+    if isinstance(parsed, dict):
+        labels = parsed.get("labels")
+        if isinstance(labels, list) and labels:
+            label = labels[0]
+        elif parsed.get("label") is not None:
+            label = parsed.get("label")
+    return json.dumps({"label": label})
+
+
+def _ai_classify_label_column(
+    str_input: str | snowpark.Column,
+    categories: list[str] | snowpark.Column,
+) -> snowpark.Column:
+    """Call AI_CLASSIFY in single-label mode and re-wrap to the legacy CLASSIFY_TEXT {"label": ...} OBJECT."""
+    result = functions.builtin(_AI_CLASSIFY_FUNCTION_NAME)(
+        str_input, categories, functions.sql_expr(_AI_CLASSIFY_SINGLE_LABEL_CONFIG_SQL)
+    )
+    # AI_CLASSIFY returns {"labels": [...]}; collapse to the legacy single {"label": ...}. Subscript access
+    # (not functions.get with a bare string, which Snowpark treats as a column identifier) uses literal keys.
+    label = functions.coalesce(result["labels"][0], result["label"])
+    return functions.object_construct(functions.lit("label"), label)
+
+
+@telemetry.send_api_usage_telemetry(
+    project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
+)
+def classify_text(
+    str_input: str | snowpark.Column,
+    categories: list[str] | snowpark.Column,
+    session: snowpark.Session | None = None,
+) -> str | snowpark.Column:
+    """Use the LLM inference service to classify the INPUT text into one of the target CATEGORIES.
+
+    Args:
+        str_input: A Column of strings to classify.
+        categories: A list of candidate categories to classify the INPUT text into.
+        session: The snowpark session to use. Will be inferred by context if not specified.
+
+    Returns:
+        A column of classification responses (legacy CLASSIFY_TEXT {"label": ...} shape).
+
+    Raises:
+        SnowflakeAuthenticationException: if no session is provided and none is active.
+    """
+    warn_cortex_deprecated("classify_text", "ai_classify")
+    column = _ai_classify_label_column(str_input, categories)
+    if isinstance(str_input, snowpark.Column) or isinstance(categories, snowpark.Column):
+        return column
+
+    # Immediate (literal) path: evaluate and return the collected OBJECT as a JSON string, exactly as the
+    # legacy CLASSIFY_TEXT immediate path did.
+    session = session or context.get_active_session()
+    if session is None:
+        raise SnowflakeAuthenticationException(
+            """Session required. Provide the session through a session=... argument or ensure an active session is
+            available in your environment."""
+        )
+    return cast(str, session.create_dataframe([snowpark.Row()]).select(column).collect()[0][0])
+
+
+ClassifyText = deprecated(
+    "ClassifyText() is deprecated and will be removed in a future release. Please use classify_text() instead."
+)(
+    telemetry.send_api_usage_telemetry(
+        project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
+    )(classify_text)
+)

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.6.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.6.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.4.0 → snowflake_ml_python-2.6.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -93,7 +93,7 @@ class PlatformCapabilities:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
     def is_lora_adapters_enabled(self) -> bool:
-        return False
+        return self._get_bool_feature(ENABLE_LORA_ADAPTERS, False)
 
     def is_single_output_native_type_enabled(self) -> bool:
         """Whether a single, non-OBJECT model FUNCTION output is registered with its native SQL type.

{snowflake_ml_python-2.4.0 → snowflake_ml_python-2.6.0}/snowflake/ml/dataset/dataset.py

@@ -341,7 +341,7 @@ class Dataset(lineage_node.LineageNode):
         metadata = dataset_metadata.DatasetMetadata(
             source_query=source_query,
             owner=self._session.sql("SELECT CURRENT_USER()").collect(statement_params=_TELEMETRY_STATEMENT_PARAMS)[0][
-                "CURRENT_USER()"
+                0
             ],
             exclude_cols=exclude_cols,
             label_cols=label_cols,

snowflake_ml_python-2.6.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.6.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)]