snowflake-ml-python 1.48.0__tar.gz → 1.49.0__tar.gz

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Release History
 
-## 1.48.0
+## 1.49.0
+
+### New Features
+
+### Bug Fixes
+
+* Registry: Fixed a bug where logging a model with explainability enabled could fail with a data validation error
+  ("There is no non-null data in column ...") when a numeric input column was entirely null within the background
+  sample. The `explain` method now reuses the model's existing input signature instead of re-inferring it from the
+  sample.
+
+* Feature Store: Fixed a bug where `get_feature_view()` could return stale metadata after re-registering a feature
+  view with `overwrite=True`. Metadata reads now select the most recently written row.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.48.0 (2026-07-22)
 
 ### New Features
 

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.48.0
+Version: 1.49.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: 
@@ -234,7 +234,7 @@ Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: anyio<5,>=3.5.0
-Requires-Dist: cachetools<6,>=3.1.1
+Requires-Dist: cachetools>=3.1.1
 Requires-Dist: cloudpickle>=2.0.0
 Requires-Dist: cryptography
 Requires-Dist: fsspec[http]<2026,>=2024.6.1
@@ -417,7 +417,25 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.48.0
+## 1.49.0
+
+### New Features
+
+### Bug Fixes
+
+* Registry: Fixed a bug where logging a model with explainability enabled could fail with a data validation error
+  ("There is no non-null data in column ...") when a numeric input column was entirely null within the background
+  sample. The `explain` method now reuses the model's existing input signature instead of re-inferring it from the
+  sample.
+
+* Feature Store: Fixed a bug where `get_feature_view()` could return stale metadata after re-registering a feature
+  view with `overwrite=True`. Metadata reads now select the most recently written row.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.48.0 (2026-07-22)
 
 ### New Features
 

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.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", "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", "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",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "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", "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.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/_internal/platform_capabilities.py

@@ -16,6 +16,7 @@ from snowflake.snowpark import (
 logger = logging.getLogger(__name__)
 
 LIVE_COMMIT_PARAMETER = "ENABLE_LIVE_VERSION_IN_SDK"
+HIDDEN_LIVE_COMMIT_PARAMETER = "ENABLE_HIDDEN_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"
@@ -80,6 +81,9 @@ class PlatformCapabilities:
     def is_live_commit_enabled(self) -> bool:
         return self._get_bool_feature(LIVE_COMMIT_PARAMETER, False)
 
+    def is_hidden_live_commit_enabled(self) -> bool:
+        return False
+
     def is_model_method_signature_parameters_enabled(self) -> bool:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
@@ -127,7 +131,7 @@ class PlatformCapabilities:
         self, *, session: Optional[snowpark_session.Session] = None, features: Optional[dict[str, Any]] = None
     ) -> None:
         # This is for testing purposes only.
-        if features:
+        if features is not None:
             self.features = features
             return
         if not session:

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/_internal/utils/query_result_checker.py

@@ -242,23 +242,32 @@ class SqlResultValidator(ResultValidator):
         result = (
             SqlResultValidator(
                 session=self._session,
-                query="UPDATE table SET NAME = 'name'",
+                query="UPDATE table SET NAME = ?",
                 statement_params=statement_params,
+                params=["name"],
             )
             .has_dimensions(expected_rows=1, expected_cols=1)
             .has_partial_match(row_idx=0, col_idx=0, expected_value="number of rows updated=1")
             .validate()
         )
+
+    ``params`` are bound as SQL query parameters (``?`` placeholders) rather than interpolated into the query.
     """
 
     def __init__(
-        self, session: snowpark.Session, query: str, statement_params: Optional[dict[str, Any]] = None
+        self,
+        session: snowpark.Session,
+        query: str,
+        statement_params: Optional[dict[str, Any]] = None,
+        *,
+        params: Optional[list[Any]] = None,
     ) -> None:
         self._session: snowpark.Session = session
         self._query: str = query
         self._success_matchers: list[Callable[[list[snowpark.Row], Optional[str]], bool]] = []
         self._statement_params: Optional[dict[str, Any]] = statement_params
+        self._params: Optional[list[Any]] = params
 
     def _get_result(self) -> list[snowpark.Row]:
         """Collect the result of the given SQL query."""
-        return self._session.sql(self._query).collect(statement_params=self._statement_params)
+        return self._session.sql(self._query, params=self._params).collect(statement_params=self._statement_params)

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/feature_store/feature_store.py

@@ -8274,8 +8274,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 (e.g. ``"get_feature_view"``, ``"get_feature_group"``).
 
         Returns:
-            The query endpoint URL when the Online Service is RUNNING and
-            advertises a ``query`` endpoint; ``None`` otherwise.
+            The query endpoint URL when the Online Service is RUNNING or
+            UPDATING and advertises a ``query`` endpoint; ``None`` otherwise.
         """
         try:
             st = online_service.fetch_online_service_status(
@@ -8293,7 +8293,8 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
             )
             return None
         query_url = online_service.endpoint_url(st, "query", access=self._online_service_access)
-        if st.status == "RUNNING" and query_url:
+        # UPDATING (redeploy in progress) still serves the query endpoint, so accept it too.
+        if st.status in ("RUNNING", "UPDATING") and query_url:
             # Temporary: SYSTEM$ may return host-only query URLs until server sends full https URLs.
             return query_url
         warnings.warn(

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/feature_store/metadata_manager.py

@@ -1377,6 +1377,9 @@ class FeatureStoreMetadataManager:
         # Strip surrounding quotes if present; callers pass resolved() which handles casing.
         normalized_name = object_name.strip('"')
 
+        # Writes append via INSERT and Snowflake does not enforce the primary
+        # key, so multiple rows can share a key after a re-register. Return the
+        # most recently written row so reads reflect the latest registration.
         result = self._session.sql(
             f"""
             SELECT METADATA
@@ -1385,6 +1388,8 @@ class FeatureStoreMetadataManager:
             AND OBJECT_NAME = '{normalized_name}'
             AND VERSION = '{version}'
             AND METADATA_TYPE = '{metadata_type.value}'
+            ORDER BY UPDATED_AT DESC, CREATED_AT DESC
+            LIMIT 1
             """
         ).collect(statement_params=self._telemetry_stmp)
 

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/feature_store/online_service.py

@@ -533,7 +533,9 @@ def _assert_online_service_running(
                 "then poll get_online_service_status() until RUNNING."
             ),
         )
-    if st.status != "RUNNING":
+    # UPDATING means a redeploy is in progress; the service is still operational and
+    # serves reads/writes, so treat it like RUNNING as long as an endpoint is available.
+    if st.status not in ("RUNNING", "UPDATING"):
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.INVALID_ARGUMENT,
             original_exception=ValueError(

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/feature_store/tile_sql_generator.py

@@ -1077,11 +1077,9 @@ class MergingSqlGenerator:
 
             elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                 col_name = spec.get_tile_column_name("DS_HLL")
-                agg_columns.append(
-                    f"DATASKETCHES_HLL_ESTIMATE(DATASKETCHES_HLL_COMBINE("
-                    f"CASE WHEN {tile_filter} THEN {col_name} ELSE NULL END"
-                    f")) AS {output_col}"
-                )
+                # Round the HLL estimate to a BIGINT for online/offline parity.
+                sketch_expr = f"DATASKETCHES_HLL_COMBINE(CASE WHEN {tile_filter} THEN {col_name} ELSE NULL END)"
+                agg_columns.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE({sketch_expr}))::BIGINT AS {output_col}")
 
             elif spec.function == AggregationType.APPROX_PERCENTILE:
                 # Combine T-Digest states and estimate percentile
@@ -1209,9 +1207,9 @@ class MergingSqlGenerator:
                     )
                 elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                     partial = spec.get_tile_column_name("DS_HLL")
-                    inner_exprs.append(
-                        f"DATASKETCHES_HLL_ESTIMATE(DATASKETCHES_HLL_COMBINE({partial})) AS {output_col}"
-                    )
+                    # Round the HLL estimate to a BIGINT for online/offline parity.
+                    sketch_expr = f"DATASKETCHES_HLL_COMBINE({partial})"
+                    inner_exprs.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE({sketch_expr}))::BIGINT AS {output_col}")
                 elif spec.function == AggregationType.APPROX_PERCENTILE:
                     # T-Digest states are likewise mergeable across tiles per
                     # (entity, sk): combine then estimate at the requested
@@ -1378,7 +1376,8 @@ class MergingSqlGenerator:
 
             elif spec.function == AggregationType.APPROX_COUNT_DISTINCT:
                 cum_col = spec.get_cumulative_column_name("DS_HLL")
-                select_cols.append(f"DATASKETCHES_HLL_ESTIMATE(TILES.{cum_col}) AS {output_col}")
+                # Round the HLL estimate to a BIGINT for online/offline parity.
+                select_cols.append(f"ROUND(DATASKETCHES_HLL_ESTIMATE(TILES.{cum_col}))::BIGINT AS {output_col}")
 
             elif spec.function == AggregationType.APPROX_PERCENTILE:
                 cum_col = spec.get_cumulative_column_name("TDIGEST")

snowflake_ml_python-1.49.0/snowflake/ml/model/_client/ops/live_commit_naming.py

@@ -0,0 +1,19 @@
+from uuid import uuid4
+
+from snowflake.ml._internal.utils import sql_identifier
+
+_CHECKOUT_NAME_SUFFIX_LEN = 8
+
+
+def _checkout_name_suffix() -> str:
+    return uuid4().hex[:_CHECKOUT_NAME_SUFFIX_LEN].upper()
+
+
+def generate_pending_model_name() -> sql_identifier.SqlIdentifier:
+    """Generate a hidden pending model name for checkout (CREATE path)."""
+    return sql_identifier.SqlIdentifier(f"PENDING_{_checkout_name_suffix()}_MODEL")
+
+
+def generate_live_version_name() -> sql_identifier.SqlIdentifier:
+    """Generate a hidden live version name for checkout."""
+    return sql_identifier.SqlIdentifier(f"LIVE_{_checkout_name_suffix()}_VERSION")

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/model/_client/ops/model_ops.py

@@ -170,6 +170,40 @@ class ModelOperator:
         else:
             return ModelAction.CREATE
 
+    def create_live_version(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self._model_version_client.create_live_version(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+
+    def add_live_version(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self._model_version_client.add_live_version(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+
     def add_or_create_live_version(
         self,
         *,
@@ -187,7 +221,7 @@ class ModelOperator:
             statement_params=statement_params,
         )
         if model_action == ModelAction.CREATE:
-            self._model_version_client.create_live_version(
+            self.create_live_version(
                 database_name=database_name,
                 schema_name=schema_name,
                 model_name=model_name,
@@ -195,7 +229,7 @@ class ModelOperator:
                 statement_params=statement_params,
             )
         elif model_action == ModelAction.ALTER:
-            self._model_version_client.add_live_version(
+            self.add_live_version(
                 database_name=database_name,
                 schema_name=schema_name,
                 model_name=model_name,
@@ -205,6 +239,27 @@ class ModelOperator:
         else:
             raise AssertionError(f"The model_action is {model_action}. Expected CREATE or ALTER.")
 
+    def commit_live_version(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        checkout_model_name: sql_identifier.SqlIdentifier,
+        checkout_version_name: sql_identifier.SqlIdentifier,
+        rename_model_to: Optional[sql_identifier.SqlIdentifier] = None,
+        rename_version_to: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self._model_version_client.commit_version(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=checkout_model_name,
+            version_name=checkout_version_name,
+            rename_model_to=rename_model_to,
+            rename_version_to=rename_version_to,
+            statement_params=statement_params,
+        )
+
     def create_from_stage(
         self,
         composed_model: model_composer.ModelComposer,
@@ -214,49 +269,35 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[dict[str, Any]] = None,
-        use_live_commit: Optional[bool] = False,
     ) -> None:
-        if use_live_commit:
-            # if the model version is live, we can only commit the version
-            self._model_version_client.commit_version(
+        stage_path = str(composed_model.stage_path)
+        model_action = self.get_model_action_from_model_name_and_version(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        if model_action == ModelAction.ALTER:
+            self._model_version_client.add_version_from_stage(
                 database_name=database_name,
                 schema_name=schema_name,
+                stage_path=stage_path,
                 model_name=model_name,
                 version_name=version_name,
                 statement_params=statement_params,
             )
-        else:
-            stage_path = str(composed_model.stage_path)
-            # if the model version is not live,
-            # find whether the model exists and whether the version exists
-            # and then decide whether to create or alter the model
-            model_action = self.get_model_action_from_model_name_and_version(
+        elif model_action == ModelAction.CREATE:
+            self._model_version_client.create_from_stage(
                 database_name=database_name,
                 schema_name=schema_name,
+                stage_path=stage_path,
                 model_name=model_name,
                 version_name=version_name,
                 statement_params=statement_params,
             )
-            if model_action == ModelAction.ALTER:
-                self._model_version_client.add_version_from_stage(
-                    database_name=database_name,
-                    schema_name=schema_name,
-                    stage_path=stage_path,
-                    model_name=model_name,
-                    version_name=version_name,
-                    statement_params=statement_params,
-                )
-            elif model_action == ModelAction.CREATE:
-                self._model_version_client.create_from_stage(
-                    database_name=database_name,
-                    schema_name=schema_name,
-                    stage_path=stage_path,
-                    model_name=model_name,
-                    version_name=version_name,
-                    statement_params=statement_params,
-                )
-            else:
-                raise AssertionError(f"The model_action is {model_action}. Expected CREATE or ALTER.")
+        else:
+            raise AssertionError(f"The model_action is {model_action}. Expected CREATE or ALTER.")
 
     def create_from_model_version(
         self,

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/model/_client/sql/model_version.py

@@ -117,12 +117,18 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
+        rename_model_to: Optional[sql_identifier.SqlIdentifier] = None,
+        rename_version_to: Optional[sql_identifier.SqlIdentifier] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         sql = (
             f"ALTER MODEL {self.fully_qualified_object_name(database_name, schema_name, model_name)}"
             f" COMMIT VERSION {version_name.identifier()}"
         )
+        if rename_model_to is not None:
+            sql += f" RENAME TO {self.fully_qualified_object_name(database_name, schema_name, rename_model_to)}"
+        if rename_version_to is not None:
+            sql += f" RENAME VERSION TO {rename_version_to.identifier()}"
 
         query_result_checker.SqlResultValidator(
             self._session,

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/model/_packager/model_handlers/_utils.py

@@ -1,3 +1,4 @@
+import copy
 import importlib
 import json
 import logging
@@ -130,16 +131,19 @@ def add_inferred_explain_method_signature(
         suffixed_output_names = [f"{name}_explanation" for name in output_feature_names]
 
     truncated_background_data = get_truncated_sample_data(background_data, 5)
-    sig = model_signature.infer_signature(
-        input_data=truncated_background_data,
-        output_data=explain_fn(truncated_background_data),
-        input_feature_names=[spec.name for spec in inputs],
-        output_feature_names=suffixed_output_names,
+
+    # The target method's signature already describes the model inputs, so reuse those specs for the explain
+    # signature (copied so it owns independent objects). The background sample is used only to infer the shape and
+    # data types of the explanation outputs.
+    explain_inputs = copy.deepcopy(list(inputs))
+    explain_outputs = model_signature_utils.rename_features(
+        model_signature._infer_signature(explain_fn(truncated_background_data), role="output"),
+        feature_names=list(suffixed_output_names),
     )
 
     target_sig = model_meta.signatures.get(target_method)
-    if target_sig is not None and target_sig.params is not None:
-        sig = model_signature.ModelSignature(inputs=sig.inputs, outputs=sig.outputs, params=target_sig.params)
+    params = target_sig.params if target_sig is not None else None
+    sig = model_signature.ModelSignature(inputs=explain_inputs, outputs=explain_outputs, params=params)
 
     model_meta.signatures[explain_method] = sig
     return model_meta

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -4,7 +4,7 @@
 REQUIREMENTS = [
     "aiohttp!=4.0.0a0, !=4.0.0a1",
     "anyio>=3.5.0,<5",
-    "cachetools>=3.1.1,<6",
+    "cachetools>=3.1.1",
     "cloudpickle>=2.0.0",
     "cryptography",
     "fsspec>=2024.6.1,<2026",

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/registry/_manager/model_manager.py

@@ -12,7 +12,12 @@ from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.model import model_signature, task, type_hints
 from snowflake.ml.model._client.model import model_impl, model_version_impl
-from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
+from snowflake.ml.model._client.ops import (
+    live_commit_naming,
+    metadata_ops,
+    model_ops,
+    service_ops,
+)
 from snowflake.ml.model._client.service import (
     import_model_spec_schema,
     model_deployment_spec_schema,
@@ -154,6 +159,7 @@ class ModelManager:
             model=model,
             model_name=model_name,
             version_name=version_name,
+            model_exists=model_exists,
             comment=comment,
             metrics=metrics,
             conda_dependencies=conda_dependencies,
@@ -180,6 +186,7 @@ class ModelManager:
         *,
         model_name: str,
         version_name: str,
+        model_exists: bool,
         progress_status: type_hints.ProgressStatus,
         comment: Optional[str] = None,
         metrics: Optional[dict[str, Any]] = None,
@@ -230,36 +237,58 @@ class ModelManager:
             )
 
         # TODO(SNOW-2091317): Remove this when the snowpark enables file PUT operation for snowurls
-        use_live_commit = (
+        use_hidden_live_commit = (
             not snowpark_utils.is_in_stored_procedure()  # type: ignore[no-untyped-call]
-        ) and platform_capabilities.PlatformCapabilities.get_instance().is_live_commit_enabled()
-        if use_live_commit:
-            logger.info("Using live commit model version")
+        ) and platform_capabilities.PlatformCapabilities.get_instance().is_hidden_live_commit_enabled()
+        if use_hidden_live_commit:
+            logger.info("Using hidden live commit model version")
         else:
             logger.info("Using non-live commit model version")
 
-        if use_live_commit:
-            # This step creates the live model version, and the files can be written directly to the stage
-            # after this.
+        checkout_model_name_id = model_name_id
+        checkout_version_name_id: Optional[sql_identifier.SqlIdentifier] = None
+        rename_model_to_id: Optional[sql_identifier.SqlIdentifier] = None
+
+        if use_hidden_live_commit:
+            model_action = model_ops.ModelAction.ALTER if model_exists else model_ops.ModelAction.CREATE
+            live_version_name_id = live_commit_naming.generate_live_version_name()
+            checkout_version_name_id = live_version_name_id
+            if model_action == model_ops.ModelAction.CREATE:
+                checkout_model_name_id = live_commit_naming.generate_pending_model_name()
+                rename_model_to_id = model_name_id
             try:
-                self._model_ops.add_or_create_live_version(
-                    database_name=database_name_id,
-                    schema_name=schema_name_id,
-                    model_name=model_name_id,
-                    version_name=version_name_id,
-                    statement_params=statement_params,
-                )
+                if model_action == model_ops.ModelAction.CREATE:
+                    self._model_ops.create_live_version(
+                        database_name=database_name_id,
+                        schema_name=schema_name_id,
+                        model_name=checkout_model_name_id,
+                        version_name=live_version_name_id,
+                        statement_params=statement_params,
+                    )
+                else:
+                    self._model_ops.add_live_version(
+                        database_name=database_name_id,
+                        schema_name=schema_name_id,
+                        model_name=checkout_model_name_id,
+                        version_name=live_version_name_id,
+                        statement_params=statement_params,
+                    )
             except (AssertionError, snowpark_exceptions.SnowparkSQLException) as e:
-                logger.info(f"Failed to create live model version: {e}, falling back to regular model version creation")
-                use_live_commit = False
+                logger.info(
+                    f"Failed to create hidden live model version: {e}, falling back to regular model version creation"
+                )
+                use_hidden_live_commit = False
+                checkout_model_name_id = model_name_id
+                checkout_version_name_id = None
+                rename_model_to_id = None
 
-        if use_live_commit:
-            # using model version's stage path to write files directly to the stage
+        if use_hidden_live_commit:
+            assert checkout_version_name_id is not None
             stage_path = self._model_ops.get_model_version_stage_path(
                 database_name=database_name_id,
                 schema_name=schema_name_id,
-                model_name=model_name_id,
-                version_name=version_name_id,
+                model_name=checkout_model_name_id,
+                version_name=checkout_version_name_id,
             )
         else:
             # using a temp path to write files and then upload to the model version's stage
@@ -307,6 +336,7 @@ class ModelManager:
         progress_status.increment()
 
         model_metadata: model_meta.ModelMetadata = mc.save(
+            # Artifact identity must use the target model name, not checkout (pending/live) names.
             name=model_name_id.resolved(),
             model=model,
             signatures=signatures,
@@ -338,15 +368,26 @@ class ModelManager:
         progress_status.update("creating model object in Snowflake...")
         progress_status.increment()
 
-        self._model_ops.create_from_stage(
-            composed_model=mc,
-            database_name=database_name_id,
-            schema_name=schema_name_id,
-            model_name=model_name_id,
-            version_name=version_name_id,
-            statement_params=statement_params,
-            use_live_commit=use_live_commit,
-        )
+        if use_hidden_live_commit:
+            assert checkout_version_name_id is not None
+            self._model_ops.commit_live_version(
+                database_name=database_name_id,
+                schema_name=schema_name_id,
+                checkout_model_name=checkout_model_name_id,
+                checkout_version_name=checkout_version_name_id,
+                rename_model_to=rename_model_to_id,
+                rename_version_to=version_name_id,
+                statement_params=statement_params,
+            )
+        else:
+            self._model_ops.create_from_stage(
+                composed_model=mc,
+                database_name=database_name_id,
+                schema_name=schema_name_id,
+                model_name=model_name_id,
+                version_name=version_name_id,
+                statement_params=statement_params,
+            )
 
         mv = self._create_model_version_ref(
             database_name_id=database_name_id,

{snowflake_ml_python-1.48.0 → snowflake_ml_python-1.49.0}/snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.48.0"
+VERSION = "1.49.0"