snowflake-ml-python 1.45.0__tar.gz → 1.47.0__tar.gz

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.0}/CHANGELOG.md

@@ -1,6 +1,55 @@
 # Release History
 
-## 1.45.0
+## 1.47.0
+
+### New Features
+
+* Experiment Tracking: Added `ExperimentTracking.list_model_versions` to retrieve the model versions that were
+  logged under a run. Models logged via `log_model` inside a run are linked to that run through Snowflake lineage,
+  and this method traverses that lineage to return the corresponding `ModelVersion` objects.
+
+```python
+from snowflake.ml.experiment import ExperimentTracking
+
+exp = ExperimentTracking(session)
+exp.set_experiment("MY_EXPERIMENT")
+with exp.start_run(run_name="MY_RUN"):
+    exp.log_model(model, model_name="MY_MODEL", sample_input_data=X)
+
+model_versions = exp.list_model_versions(run_name="MY_RUN")
+```
+
+### Bug Fixes
+
+* Experiment Tracking: Fix a bug where `.set_experiment` does not recreate an experiment deleted in Snowsight
+
+### Behavior Changes
+
+* Registry: `enable_explainability` now defaults to `False` for all model types when logging a model. Previously it
+  defaulted to `True` for XGBoost, LightGBM, and CatBoost models and was auto-enabled for supported scikit-learn and
+  Snowpark ML modeling models when running in the Warehouse. To generate an `explain` method, explicitly pass
+  `options={"enable_explainability": True}` to `log_model` (this requires `sample_input_data` for supported model
+  types).
+
+### Deprecations
+
+## 1.46.0 (2026-07-07)
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: For Snowpark ML Pipeline models with explainability enabled, explanations now cover only the columns the
+  final estimator was actually trained on (its `input_cols`). Untransformed passthrough columns (e.g. raw string
+  columns left in place by an encoder using new `output_cols`, or the label column) are no longer included in the
+  explain output. This also fixes a failure where such passthrough columns could reach the SHAP explainer and raise an
+  error during `log_model(..., enable_explainability=True)`.
+
+### Deprecations
+
+## 1.45.0 (2026-07-01)
 
 ### New Features
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.45.0
+Version: 1.47.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: 
@@ -250,7 +250,7 @@ Requires-Dist: pyjwt<3,>=2.0.0
 Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
-Requires-Dist: scikit-learn<1.8
+Requires-Dist: scikit-learn<1.9
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: shap<1,>=0.46.0
 Requires-Dist: snowflake-connector-python[pandas]<5,>=3.17.3
@@ -416,7 +416,56 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.45.0
+## 1.47.0
+
+### New Features
+
+* Experiment Tracking: Added `ExperimentTracking.list_model_versions` to retrieve the model versions that were
+  logged under a run. Models logged via `log_model` inside a run are linked to that run through Snowflake lineage,
+  and this method traverses that lineage to return the corresponding `ModelVersion` objects.
+
+```python
+from snowflake.ml.experiment import ExperimentTracking
+
+exp = ExperimentTracking(session)
+exp.set_experiment("MY_EXPERIMENT")
+with exp.start_run(run_name="MY_RUN"):
+    exp.log_model(model, model_name="MY_MODEL", sample_input_data=X)
+
+model_versions = exp.list_model_versions(run_name="MY_RUN")
+```
+
+### Bug Fixes
+
+* Experiment Tracking: Fix a bug where `.set_experiment` does not recreate an experiment deleted in Snowsight
+
+### Behavior Changes
+
+* Registry: `enable_explainability` now defaults to `False` for all model types when logging a model. Previously it
+  defaulted to `True` for XGBoost, LightGBM, and CatBoost models and was auto-enabled for supported scikit-learn and
+  Snowpark ML modeling models when running in the Warehouse. To generate an `explain` method, explicitly pass
+  `options={"enable_explainability": True}` to `log_model` (this requires `sample_input_data` for supported model
+  types).
+
+### Deprecations
+
+## 1.46.0 (2026-07-07)
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: For Snowpark ML Pipeline models with explainability enabled, explanations now cover only the columns the
+  final estimator was actually trained on (its `input_cols`). Untransformed passthrough columns (e.g. raw string
+  columns left in place by an encoder using new `output_cols`, or the label column) are no longer included in the
+  explain output. This also fixes a failure where such passthrough columns could reach the SHAP explainer and raise an
+  error during `log_model(..., enable_explainability=True)`.
+
+### Deprecations
+
+## 1.45.0 (2026-07-01)
 
 ### New Features
 

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.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", "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.9", "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.45.0 → snowflake_ml_python-1.47.0}/snowflake/ml/_internal/utils/jwt_generator.py

@@ -1,3 +1,7 @@
+# Annotations are lazy so ``types.PrivateKeyTypes`` (added in cryptography 40.0, replacing the
+# now-removed ``PRIVATE_KEY_TYPES``) is never evaluated at runtime and stays version-tolerant.
+from __future__ import annotations
+
 import base64
 import hashlib
 import logging
@@ -30,7 +34,7 @@ class JWTGenerator:
         self,
         account: str,
         user: str,
-        private_key: types.PRIVATE_KEY_TYPES,
+        private_key: types.PrivateKeyTypes,
         lifetime: Optional[timedelta] = None,
         renewal_delay: Optional[timedelta] = None,
     ) -> None:
@@ -125,7 +129,7 @@ class JWTGenerator:
         return token
 
     @staticmethod
-    def _calculate_public_key_fingerprint(private_key: types.PRIVATE_KEY_TYPES) -> str:
+    def _calculate_public_key_fingerprint(private_key: types.PrivateKeyTypes) -> str:
         # Get the raw bytes of public key.
         public_key_raw = private_key.public_key().public_bytes(
             serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -24,6 +24,7 @@ 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
 
@@ -196,21 +197,22 @@ class ExperimentTracking:
         schema_name = sql_identifier.SqlIdentifier(schema_name) if schema_name is not None else self._schema_name
 
         experiment_name = sql_identifier.SqlIdentifier(experiment_name)
-        if (
+        if not (
             self._experiment
             and self._experiment.name == experiment_name
             and self._database_name == database_name
             and self._schema_name == schema_name
         ):
-            return self._experiment
+            # If the requested experiment differs from the current one, switch context (and drop any active run)
+            self._update_database_and_schema(database_name, schema_name)
+            self._experiment = entities.Experiment(experiment_name=experiment_name)
+            self._unset_run()
 
-        self._update_database_and_schema(database_name, schema_name)
+        # Always attempt to create idempotently so an experiment that was deleted (e.g. via the UI) is restored.
         self._sql_client.create_experiment(
             experiment_name=experiment_name,
             creation_mode=sql_client_utils.CreationMode(if_not_exists=True),
         )
-        self._experiment = entities.Experiment(experiment_name=experiment_name)
-        self._unset_run()
         return self._experiment
 
     def delete_experiment(
@@ -267,6 +269,44 @@ class ExperimentTracking:
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
             return self._registry.log_model(model, model_name=model_name, **kwargs)
 
+    def list_model_versions(self, run_name: Optional[str] = None) -> list[ml_model.ModelVersion]:
+        """
+        List the model versions that were logged under a run.
+
+        Models logged via ``log_model`` inside a run are linked to that run through Snowflake lineage. This method
+        traverses that lineage to return the corresponding model versions.
+
+        Args:
+            run_name: The name of the run to list model versions from. If None, uses the currently active run.
+
+        Returns:
+            A list of ModelVersion objects that were logged under the run.
+
+        Raises:
+            RuntimeError: If no experiment is set, or if no run_name is provided and no run is active.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please set an experiment before listing model versions.")
+
+        if run_name:
+            resolved_run_name = sql_identifier.SqlIdentifier(run_name)
+        elif self._run:
+            resolved_run_name = self._run.name
+        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(),
+        )
+        logged_models = run_node.lineage(direction="downstream", domain_filter={"model"})
+        return [model for model in logged_models if isinstance(model, ml_model.ModelVersion)]
+
     def start_run(
         self,
         run_name: Optional[str] = None,

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/aggregation.py

@@ -19,6 +19,11 @@ from snowflake.ml.feature_store.interval_utils import (  # noqa: F401 - re-expor
     parse_interval as parse_interval,
 )
 
+# Product-wide upper bound on ``n`` for the ordered-N list aggregations
+# (last_n / first_n / last_distinct_n / first_distinct_n). Enforced at authoring
+# time so users get a clear error, and matched by the engine's own bound.
+_MAX_ORDERED_N = 100
+
 
 class AggregationType(Enum):
     """Supported aggregation functions for tiled feature views.
@@ -161,6 +166,11 @@ class AggregationSpec:
                 raise ValueError(
                     f"Parameter 'n' must be a positive integer for aggregation " f"'{self.output_column}', got: {n}"
                 )
+            if n > _MAX_ORDERED_N:
+                raise ValueError(
+                    f"Parameter 'n' must be between 1 and {_MAX_ORDERED_N} for "
+                    f"{self.function.value} aggregation '{self.output_column}', got: {n}"
+                )
 
         # Validate params for approx_percentile
         if self.function == AggregationType.APPROX_PERCENTILE:

{snowflake_ml_python-1.45.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/feature_group.py

@@ -730,6 +730,26 @@ def _resolve_fg_output_columns(fg: FeatureGroup) -> list[str]:
     return cols
 
 
+def _normalize_join_key_datatype(datatype: Any) -> Any:
+    """Collapse ``StringType`` VARCHAR length so join keys compare by logical type.
+
+    A shared string join key can surface with different VARCHAR lengths across
+    sources -- e.g. a tiled FeatureView exposes the unbounded ``StringType()``
+    default while a batch FeatureView read back through its materialized dynamic
+    table reports a length narrowed to its stored data. The length is irrelevant
+    to join semantics and to the response schema, so all ``StringType`` variants
+    normalize to the unbounded ``StringType()``. Other datatypes pass through
+    unchanged.
+
+    Args:
+        datatype: A Snowpark datatype from a source's join-key column.
+
+    Returns:
+        ``StringType()`` for any ``StringType`` input; ``datatype`` otherwise.
+    """
+    return StringType() if isinstance(datatype, StringType) else datatype
+
+
 def _fg_join_key_field_types(fg: FeatureGroup, *, strict: bool = False) -> dict[str, Any]:
     """Resolve ``{join_key -> Snowpark datatype}`` across every source FV.
 
@@ -787,6 +807,7 @@ def _fg_join_key_field_types(fg: FeatureGroup, *, strict: bool = False) -> dict[
         else:
             iterator = ((f.name, f.datatype) for f in fv.output_schema.fields if f.name in pk)
         for name, datatype in iterator:
+            datatype = _normalize_join_key_datatype(datatype)
             previous = type_by_name.get(name)
             if previous is None:
                 type_by_name[name] = datatype