snowflake-ml-python 1.8.5__py3-none-any.whl → 1.8.6__py3-none-any.whl

snowflake/ml/model/_client/ops/service_ops.py

@@ -325,13 +325,14 @@ class ServiceOperator:
                         )
                         continue
 
-                service_status, message = self._service_client.get_service_status(
+                statuses = self._service_client.get_service_container_statuses(
                     database_name=service_log_meta.service.database_name,
                     schema_name=service_log_meta.service.schema_name,
                     service_name=service_log_meta.service.service_name,
                     include_message=True,
                     statement_params=statement_params,
                 )
+                service_status = statuses[0].service_status
                 if (service_status != service_sql.ServiceStatus.RUNNING) or (
                     service_status != service_log_meta.service_status
                 ):
@@ -341,7 +342,19 @@ class ServiceOperator:
                         f"{service_log_meta.service.display_service_name} is "
                         f"{service_log_meta.service_status.value}."
                     )
-                    module_logger.info(f"Service message: {message}")
+                    for status in statuses:
+                        if status.instance_id is not None:
+                            instance_status, container_status = None, None
+                            if status.instance_status is not None:
+                                instance_status = status.instance_status.value
+                            if status.container_status is not None:
+                                container_status = status.container_status.value
+                            module_logger.info(
+                                f"Instance[{status.instance_id}]: "
+                                f"instance status: {instance_status}, "
+                                f"container status: {container_status}, "
+                                f"message: {status.message}"
+                            )
 
                 new_logs, new_offset = fetch_logs(
                     service_log_meta.service,
@@ -353,13 +366,14 @@ class ServiceOperator:
 
                 # check if model build service is done
                 if not service_log_meta.is_model_build_service_done:
-                    service_status, _ = self._service_client.get_service_status(
+                    statuses = self._service_client.get_service_container_statuses(
                         database_name=model_build_service.database_name,
                         schema_name=model_build_service.schema_name,
                         service_name=model_build_service.service_name,
                         include_message=False,
                         statement_params=statement_params,
                     )
+                    service_status = statuses[0].service_status
 
                     if service_status == service_sql.ServiceStatus.DONE:
                         set_service_log_metadata_to_model_inference(
@@ -436,13 +450,14 @@ class ServiceOperator:
                 service_sql.ServiceStatus.FAILED,
             ]
         try:
-            service_status, _ = self._service_client.get_service_status(
+            statuses = self._service_client.get_service_container_statuses(
                 database_name=database_name,
                 schema_name=schema_name,
                 service_name=service_name,
                 include_message=False,
                 statement_params=statement_params,
             )
+            service_status = statuses[0].service_status
             return any(service_status == status for status in service_status_list_if_exists)
         except exceptions.SnowparkSQLException:
             return False

snowflake/ml/model/_client/sql/service.py

@@ -1,4 +1,6 @@
+import dataclasses
 import enum
+import logging
 import textwrap
 from typing import Any, Optional, Union
 
@@ -13,26 +15,59 @@ from snowflake.ml.model._model_composer.model_method import constants
 from snowflake.snowpark import dataframe, functions as F, row, types as spt
 from snowflake.snowpark._internal import utils as snowpark_utils
 
+logger = logging.getLogger(__name__)
+
 
-# The enum comes from https://docs.snowflake.com/en/sql-reference/sql/show-service-containers-in-service#output
-# except UNKNOWN
 class ServiceStatus(enum.Enum):
-    UNKNOWN = "UNKNOWN"  # status is unknown because we have not received enough data from K8s yet.
-    PENDING = "PENDING"  # resource set is being created, can't be used yet
-    SUSPENDING = "SUSPENDING"  # the service is set to suspended but the resource set is still in deleting state
-    SUSPENDED = "SUSPENDED"  # the service is suspended and the resource set is deleted
-    DELETING = "DELETING"  # resource set is being deleted
-    FAILED = "FAILED"  # resource set has failed and cannot be used anymore
-    DONE = "DONE"  # resource set has finished running
-    INTERNAL_ERROR = "INTERNAL_ERROR"  # there was an internal service error.
+    PENDING = "PENDING"
     RUNNING = "RUNNING"
+    FAILED = "FAILED"
+    DONE = "DONE"
+    SUSPENDING = "SUSPENDING"
+    SUSPENDED = "SUSPENDED"
+    DELETING = "DELETING"
     DELETED = "DELETED"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+
+
+class InstanceStatus(enum.Enum):
+    PENDING = "PENDING"
+    READY = "READY"
+    FAILED = "FAILED"
+    TERMINATING = "TERMINATING"
+    SUCCEEDED = "SUCCEEDED"
+
+
+class ContainerStatus(enum.Enum):
+    PENDING = "PENDING"
+    READY = "READY"
+    DONE = "DONE"
+    FAILED = "FAILED"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclasses.dataclass
+class ServiceStatusInfo:
+    """
+    Class containing information about service container status.
+    Reference: https://docs.snowflake.com/en/sql-reference/sql/show-service-containers-in-service
+    """
+
+    service_status: ServiceStatus
+    instance_id: Optional[int] = None
+    instance_status: Optional[InstanceStatus] = None
+    container_status: Optional[ContainerStatus] = None
+    message: Optional[str] = None
 
 
 class ServiceSQLClient(_base._BaseSQLClient):
     MODEL_INFERENCE_SERVICE_ENDPOINT_NAME_COL_NAME = "name"
     MODEL_INFERENCE_SERVICE_ENDPOINT_INGRESS_URL_COL_NAME = "ingress_url"
     SERVICE_STATUS = "service_status"
+    INSTANCE_ID = "instance_id"
+    INSTANCE_STATUS = "instance_status"
+    CONTAINER_STATUS = "status"
+    MESSAGE = "message"
 
     def build_model_container(
         self,
@@ -81,6 +116,10 @@ class ServiceSQLClient(_base._BaseSQLClient):
     ) -> tuple[str, snowpark.AsyncJob]:
         assert model_deployment_spec_yaml_str or model_deployment_spec_file_rel_path
         if model_deployment_spec_yaml_str:
+            model_deployment_spec_yaml_str = snowpark_utils.escape_single_quotes(
+                model_deployment_spec_yaml_str
+            )  # type: ignore[no-untyped-call]
+            logger.info(f"Deploying model with spec={model_deployment_spec_yaml_str}")
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('{model_deployment_spec_yaml_str}')"
         else:
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
@@ -192,7 +231,7 @@ class ServiceSQLClient(_base._BaseSQLClient):
         )
         return str(rows[0][system_func])
 
-    def get_service_status(
+    def get_service_container_statuses(
         self,
         *,
         database_name: Optional[sql_identifier.SqlIdentifier],
@@ -200,18 +239,27 @@ class ServiceSQLClient(_base._BaseSQLClient):
         service_name: sql_identifier.SqlIdentifier,
         include_message: bool = False,
         statement_params: Optional[dict[str, Any]] = None,
-    ) -> tuple[ServiceStatus, Optional[str]]:
+    ) -> list[ServiceStatusInfo]:
         fully_qualified_object_name = self.fully_qualified_object_name(database_name, schema_name, service_name)
         query = f"SHOW SERVICE CONTAINERS IN SERVICE {fully_qualified_object_name}"
         rows = self._session.sql(query).collect(statement_params=statement_params)
-        if len(rows) == 0:
-            return ServiceStatus.UNKNOWN, None
-        row = rows[0]
-        service_status = row[ServiceSQLClient.SERVICE_STATUS]
-        message = row["message"] if include_message else None
-        if not isinstance(service_status, ServiceStatus):
-            return ServiceStatus.UNKNOWN, message
-        return ServiceStatus(service_status), message
+        statuses = []
+        for r in rows:
+            instance_status, container_status = None, None
+            if r[ServiceSQLClient.INSTANCE_STATUS] is not None:
+                instance_status = InstanceStatus(r[ServiceSQLClient.INSTANCE_STATUS])
+            if r[ServiceSQLClient.CONTAINER_STATUS] is not None:
+                container_status = ContainerStatus(r[ServiceSQLClient.CONTAINER_STATUS])
+            statuses.append(
+                ServiceStatusInfo(
+                    service_status=ServiceStatus(r[ServiceSQLClient.SERVICE_STATUS]),
+                    instance_id=r[ServiceSQLClient.INSTANCE_ID],
+                    instance_status=instance_status,
+                    container_status=container_status,
+                    message=r[ServiceSQLClient.MESSAGE] if include_message else None,
+                )
+            )
+        return statuses
 
     def drop_service(
         self,

snowflake/ml/model/_client/sql/stage.py

@@ -12,9 +12,12 @@ class StageSQLClient(_base._BaseSQLClient):
         schema_name: Optional[sql_identifier.SqlIdentifier],
         stage_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[dict[str, Any]] = None,
-    ) -> None:
+    ) -> str:
+        fq_stage_name = self.fully_qualified_object_name(database_name, schema_name, stage_name)
         query_result_checker.SqlResultValidator(
             self._session,
-            f"CREATE SCOPED TEMPORARY STAGE {self.fully_qualified_object_name(database_name, schema_name, stage_name)}",
+            f"CREATE SCOPED TEMPORARY STAGE {fq_stage_name}",
             statement_params=statement_params,
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+        return fq_stage_name

snowflake/ml/model/_packager/model_handlers/snowmlmodel.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable, Optional, cast, final
 import cloudpickle
 import numpy as np
 import pandas as pd
+import shap
 from typing_extensions import TypeGuard, Unpack
 
 from snowflake.ml._internal import type_utils
@@ -25,6 +26,19 @@ if TYPE_CHECKING:
     from snowflake.ml.modeling.framework.base import BaseEstimator
 
 
+def _apply_transforms_up_to_last_step(
+    model: "BaseEstimator",
+    data: model_types.SupportedDataType,
+) -> pd.DataFrame:
+    """Apply all transformations in the snowml pipeline model up to the last step."""
+    if type_utils.LazyType("snowflake.ml.modeling.pipeline.Pipeline").isinstance(model):
+        for step_name, step in model.steps[:-1]:  # type: ignore[attr-defined]
+            if not hasattr(step, "transform"):
+                raise ValueError(f"Step '{step_name}' does not have a 'transform' method.")
+            data = pd.DataFrame(step.transform(data))
+    return data
+
+
 @final
 class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
     """Handler for SnowML based model.
@@ -39,7 +53,7 @@ class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
     _HANDLER_MIGRATOR_PLANS: dict[str, type[base_migrator.BaseModelHandlerMigrator]] = {}
 
     DEFAULT_TARGET_METHODS = ["predict", "transform", "predict_proba", "predict_log_proba", "decision_function"]
-    EXPLAIN_TARGET_METHODS = ["predict", "predict_proba", "predict_log_proba"]
+    EXPLAIN_TARGET_METHODS = ["predict_proba", "predict", "predict_log_proba"]
 
     IS_AUTO_SIGNATURE = True
 
@@ -97,11 +111,6 @@ class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
                     return result
                 except exceptions.SnowflakeMLException:
                     pass  # Do nothing and continue to the next method
-
-        if enable_explainability:
-            raise ValueError(
-                "Explain only supported for xgboost, lightgbm and sklearn (not pipeline) Snowpark ML models."
-            )
         return None
 
     @classmethod
@@ -189,23 +198,46 @@ class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
             else:
                 enable_explainability = True
         if enable_explainability:
-            model_task_and_output_type = model_task_utils.resolve_model_task_and_output_type(
-                python_base_obj, model_meta.task
-            )
-            model_meta.task = model_task_and_output_type.task
-            model_meta = handlers_utils.add_explain_method_signature(
-                model_meta=model_meta,
-                explain_method="explain",
-                target_method=explain_target_method,
-                output_return_type=model_task_and_output_type.output_type,
-            )
-            background_data = handlers_utils.get_explainability_supported_background(
-                sample_input_data, model_meta, explain_target_method
-            )
-            if background_data is not None:
-                handlers_utils.save_background_data(
-                    model_blobs_dir_path, cls.EXPLAIN_ARTIFACTS_DIR, cls.BG_DATA_FILE_SUFFIX, name, background_data
+            try:
+                model_task_and_output_type = model_task_utils.resolve_model_task_and_output_type(
+                    python_base_obj, model_meta.task
+                )
+                model_meta.task = model_task_and_output_type.task
+                background_data = handlers_utils.get_explainability_supported_background(
+                    sample_input_data, model_meta, explain_target_method
                 )
+                if type_utils.LazyType("snowflake.ml.modeling.pipeline.Pipeline").isinstance(model):
+                    transformed_df = _apply_transforms_up_to_last_step(model, sample_input_data)
+                    explain_fn = cls._build_explain_fn(model, background_data)
+                    model_meta = handlers_utils.add_inferred_explain_method_signature(
+                        model_meta=model_meta,
+                        explain_method="explain",
+                        target_method=explain_target_method,  # type: ignore[arg-type]
+                        background_data=background_data,
+                        explain_fn=explain_fn,
+                        output_feature_names=transformed_df.columns,
+                    )
+                else:
+                    model_meta = handlers_utils.add_explain_method_signature(
+                        model_meta=model_meta,
+                        explain_method="explain",
+                        target_method=explain_target_method,
+                        output_return_type=model_task_and_output_type.output_type,
+                    )
+                if background_data is not None:
+                    handlers_utils.save_background_data(
+                        model_blobs_dir_path,
+                        cls.EXPLAIN_ARTIFACTS_DIR,
+                        cls.BG_DATA_FILE_SUFFIX,
+                        name,
+                        background_data,
+                    )
+            except Exception:
+                if kwargs.get("enable_explainability", None):
+                    # user explicitly enabled explainability, so we should raise the error
+                    raise ValueError(
+                        "Explainability for this model is not supported. Please set `enable_explainability=False`"
+                    )
 
         model_blob_path = os.path.join(model_blobs_dir_path, name)
         os.makedirs(model_blob_path, exist_ok=True)
@@ -251,6 +283,53 @@ class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
         assert isinstance(m, BaseEstimator)
         return m
 
+    @classmethod
+    def _build_explain_fn(
+        cls, model: "BaseEstimator", background_data: model_types.SupportedDataType
+    ) -> Callable[[model_types.SupportedDataType], pd.DataFrame]:
+
+        predictor = model
+        is_pipeline = type_utils.LazyType("snowflake.ml.modeling.pipeline.Pipeline").isinstance(model)
+        if is_pipeline:
+            background_data = _apply_transforms_up_to_last_step(model, background_data)
+            predictor = model.steps[-1][1]  # type: ignore[attr-defined]
+
+        def explain_fn(data: model_types.SupportedDataType) -> pd.DataFrame:
+            data = _apply_transforms_up_to_last_step(model, data)
+            tree_methods = ["to_xgboost", "to_lightgbm"]
+            non_tree_methods = ["to_sklearn", None]  # None just uses the predictor directly
+            for method_name in tree_methods:
+                try:
+                    base_model = getattr(predictor, method_name)()
+                    explainer = shap.TreeExplainer(base_model)
+                    return handlers_utils.convert_explanations_to_2D_df(model, explainer.shap_values(data))
+                except exceptions.SnowflakeMLException:
+                    pass  # Do nothing and continue to the next method
+            for method_name in non_tree_methods:  # type: ignore[assignment]
+                try:
+                    base_model = getattr(predictor, method_name)() if method_name is not None else predictor
+                    try:
+                        explainer = shap.Explainer(base_model, masker=background_data)
+                        return handlers_utils.convert_explanations_to_2D_df(base_model, explainer(data).values)
+                    except TypeError:
+                        for explain_target_method in cls.EXPLAIN_TARGET_METHODS:
+                            if not hasattr(base_model, explain_target_method):
+                                continue
+                            explain_target_method_fn = getattr(base_model, explain_target_method)
+                            if isinstance(data, np.ndarray):
+                                explainer = shap.Explainer(
+                                    explain_target_method_fn,
+                                    background_data.values,  # type: ignore[union-attr]
+                                )
+                            else:
+                                explainer = shap.Explainer(explain_target_method_fn, background_data)
+                            return handlers_utils.convert_explanations_to_2D_df(base_model, explainer(data).values)
+                except Exception:
+                    pass  # Do nothing and continue to the next method
+            raise ValueError("Explainability for this model is not supported.")
+
+        return explain_fn
+
     @classmethod
     def convert_as_custom_model(
         cls,
@@ -286,57 +365,8 @@ class SnowMLModelHandler(_base.BaseModelHandler["BaseEstimator"]):
 
                 @custom_model.inference_api
                 def explain_fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
-                    import shap
-
-                    tree_methods = ["to_xgboost", "to_lightgbm"]
-                    non_tree_methods = ["to_sklearn"]
-                    for method_name in tree_methods:
-                        try:
-                            base_model = getattr(raw_model, method_name)()
-                            explainer = shap.TreeExplainer(base_model)
-                            df = handlers_utils.convert_explanations_to_2D_df(raw_model, explainer.shap_values(X))
-                            return model_signature_utils.rename_pandas_df(df, signature.outputs)
-                        except exceptions.SnowflakeMLException:
-                            pass  # Do nothing and continue to the next method
-                    for method_name in non_tree_methods:
-                        try:
-                            base_model = getattr(raw_model, method_name)()
-                            try:
-                                explainer = shap.Explainer(base_model, masker=background_data)
-                                df = handlers_utils.convert_explanations_to_2D_df(base_model, explainer(X).values)
-                            except TypeError:
-                                try:
-                                    dtype_map = {
-                                        spec.name: spec.as_dtype(force_numpy_dtype=True) for spec in signature.inputs
-                                    }
-
-                                    if isinstance(X, pd.DataFrame):
-                                        X = X.astype(dtype_map, copy=False)
-                                    if hasattr(base_model, "predict_proba"):
-                                        if isinstance(X, np.ndarray):
-                                            explainer = shap.Explainer(
-                                                base_model.predict_proba,
-                                                background_data.values,  # type: ignore[union-attr]
-                                            )
-                                        else:
-                                            explainer = shap.Explainer(base_model.predict_proba, background_data)
-                                    elif hasattr(base_model, "predict"):
-                                        if isinstance(X, np.ndarray):
-                                            explainer = shap.Explainer(
-                                                base_model.predict, background_data.values  # type: ignore[union-attr]
-                                            )
-                                        else:
-                                            explainer = shap.Explainer(base_model.predict, background_data)
-                                    else:
-                                        raise ValueError("Missing any supported target method to explain.")
-                                    df = handlers_utils.convert_explanations_to_2D_df(base_model, explainer(X).values)
-                                except TypeError as e:
-                                    raise ValueError(f"Explanation for this model type not supported yet: {str(e)}")
-                            return model_signature_utils.rename_pandas_df(df, signature.outputs)
-
-                        except exceptions.SnowflakeMLException:
-                            pass  # Do nothing and continue to the next method
-                    raise ValueError("The model must be an xgboost, lightgbm or sklearn (not pipeline) estimator.")
+                    fn = cls._build_explain_fn(raw_model, background_data)
+                    return model_signature_utils.rename_pandas_df(fn(X), signature.outputs)
 
                 if target_method == "explain":
                     return explain_fn

snowflake/ml/model/_signatures/core.py

@@ -559,6 +559,30 @@ class ModelSignature:
                 )"""
         )
 
+    def _repr_html_(self) -> str:
+        """Generate an HTML representation of the model signature.
+
+        Returns:
+            str: HTML string containing formatted signature details.
+        """
+        from snowflake.ml.utils import html_utils
+
+        # Create collapsible sections for inputs and outputs
+        inputs_content = html_utils.create_features_html(self.inputs, "Input")
+        outputs_content = html_utils.create_features_html(self.outputs, "Output")
+
+        inputs_section = html_utils.create_collapsible_section("Inputs", inputs_content, open_by_default=True)
+        outputs_section = html_utils.create_collapsible_section("Outputs", outputs_content, open_by_default=True)
+
+        content = f"""
+        <div style="margin-top: 10px;">
+            {inputs_section}
+            {outputs_section}
+        </div>
+        """
+
+        return html_utils.create_base_container("Model Signature", content)
+
     @classmethod
     def from_mlflow_sig(cls, mlflow_sig: "mlflow.models.ModelSignature") -> "ModelSignature":
         return ModelSignature(

snowflake/ml/monitoring/explain_visualize.py

@@ -272,8 +272,8 @@ def plot_influence_sensitivity(
     If Streamlit is not available and a DataFrame is passed in, an ImportError will be raised.
 
     Args:
-        feature_values: pandas Series or 2D array containing the feature values for a specific feature
-        shap_values: pandas Series or 2D array containing the SHAP values for the same feature
+        shap_values: pandas Series or 2D array containing the SHAP values for a specific feature
+        feature_values: pandas Series or 2D array containing the feature values for the same feature
         figsize: tuple of (width, height) for the plot
 
     Returns:

snowflake/ml/monitoring/model_monitor.py

@@ -1,7 +1,5 @@
-from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.monitoring import model_monitor_version
 from snowflake.ml.monitoring._client import model_monitor_sql_client
 
 
@@ -29,7 +27,6 @@ class ModelMonitor:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def suspend(self) -> None:
         """Suspend the Model Monitor"""
         statement_params = telemetry.get_statement_params(
@@ -42,7 +39,6 @@ class ModelMonitor:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def resume(self) -> None:
         """Resume the Model Monitor"""
         statement_params = telemetry.get_statement_params(

snowflake/ml/registry/registry.py

@@ -14,7 +14,7 @@ from snowflake.ml.model import (
     type_hints as model_types,
 )
 from snowflake.ml.model._client.model import model_version_impl
-from snowflake.ml.monitoring import model_monitor, model_monitor_version
+from snowflake.ml.monitoring import model_monitor
 from snowflake.ml.monitoring._manager import model_monitor_manager
 from snowflake.ml.monitoring.entities import model_monitor_config
 from snowflake.ml.registry._manager import model_manager
@@ -30,6 +30,7 @@ _MODEL_MONITORING_DISABLED_ERROR = (
 
 
 class Registry:
+    @telemetry.send_api_usage_telemetry(project=_TELEMETRY_PROJECT, subproject=_MODEL_TELEMETRY_SUBPROJECT)
     def __init__(
         self,
         session: session.Session,
@@ -74,6 +75,22 @@ class Registry:
                 else sql_identifier.SqlIdentifier("PUBLIC")
             )
 
+        database_exists = session.sql(
+            f"""SELECT 1 FROM INFORMATION_SCHEMA.DATABASES WHERE DATABASE_NAME = '{self._database_name.resolved()}';"""
+        ).collect()
+
+        if not database_exists:
+            raise ValueError(f"Database {self._database_name} does not exist.")
+
+        schema_exists = session.sql(
+            f"""
+            SELECT 1 FROM {self._database_name.identifier()}.INFORMATION_SCHEMA.SCHEMATA
+            WHERE SCHEMA_NAME = '{self._schema_name.resolved()}';"""
+        ).collect()
+
+        if not schema_exists:
+            raise ValueError(f"Schema {self._schema_name} does not exist.")
+
         self._model_manager = model_manager.ModelManager(
             session,
             database_name=self._database_name,
@@ -155,7 +172,11 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                {"WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"}. Defaults to None.
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
+                - ["WAREHOUSE"]  (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
                 sample_input_data would be used to infer the signatures for those models that cannot automatically
@@ -295,8 +316,11 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"]. Defaults to None. When None, the target platforms will be
-                both.
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
+                - ["WAREHOUSE"]  (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
                 sample_input_data would be used to infer the signatures for those models that cannot automatically
@@ -397,11 +421,11 @@ class Registry:
             if task is not model_types.Task.UNKNOWN:
                 raise ValueError("`task` cannot be specified when calling log_model with a ModelVersion.")
 
-        if pip_requirements:
+        if pip_requirements and not artifact_repository_map:
             warnings.warn(
-                "Models logged specifying `pip_requirements` can not be executed "
-                "in Snowflake Warehouse where all dependencies are required to be retrieved "
-                "from Snowflake Anaconda Channel.",
+                "Models logged specifying `pip_requirements` cannot be executed in a Snowflake Warehouse "
+                "without specifying `artifact_repository_map`. This model can be run in Snowpark Container "
+                "Services. See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container.",
                 category=UserWarning,
                 stacklevel=1,
             )
@@ -500,7 +524,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def add_monitor(
         self,
         name: str,
@@ -525,7 +548,7 @@ class Registry:
         return self._model_monitor_manager.add_monitor(name, source_config, model_monitor_config)
 
     @overload
-    def get_monitor(self, model_version: model_version_impl.ModelVersion) -> model_monitor.ModelMonitor:
+    def get_monitor(self, *, model_version: model_version_impl.ModelVersion) -> model_monitor.ModelMonitor:
         """Get a Model Monitor on a Model Version from the Registry.
 
         Args:
@@ -534,7 +557,7 @@ class Registry:
         ...
 
     @overload
-    def get_monitor(self, name: str) -> model_monitor.ModelMonitor:
+    def get_monitor(self, *, name: str) -> model_monitor.ModelMonitor:
         """Get a Model Monitor by name from the Registry.
 
         Args:
@@ -546,7 +569,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def get_monitor(
         self, *, name: Optional[str] = None, model_version: Optional[model_version_impl.ModelVersion] = None
     ) -> model_monitor.ModelMonitor:
@@ -575,7 +597,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def show_model_monitors(self) -> list[snowpark.Row]:
         """Show all model monitors in the registry.
 
@@ -593,7 +614,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def delete_monitor(self, name: str) -> None:
         """Delete a Model Monitor by name from the Registry.
 

snowflake/ml/utils/connection_params.py

@@ -136,7 +136,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
     return conn_params
 
 
-@snowpark._internal.utils.private_preview(version="0.2.0")
+@snowpark._internal.utils.deprecated(version="1.8.5")
 def SnowflakeLoginOptions(connection_name: str = "", login_file: Optional[str] = None) -> dict[str, Union[str, bytes]]:
     """Returns a dict that can be used directly into snowflake python connector or Snowpark session config.