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

snowflake/ml/jobs/job.py

@@ -1,3 +1,5 @@
+import logging
+import os
 import time
 from functools import cached_property
 from typing import Any, Generic, Literal, Optional, TypeVar, Union, cast, overload
@@ -16,6 +18,8 @@ TERMINAL_JOB_STATUSES = {"FAILED", "DONE", "INTERNAL_ERROR"}
 
 T = TypeVar("T")
 
+logger = logging.getLogger(__name__)
+
 
 class MLJob(Generic[T]):
     def __init__(
@@ -36,8 +40,15 @@ class MLJob(Generic[T]):
         return identifier.parse_schema_level_object_identifier(self.id)[-1]
 
     @cached_property
-    def num_instances(self) -> int:
-        return _get_num_instances(self._session, self.id)
+    def target_instances(self) -> int:
+        return _get_target_instances(self._session, self.id)
+
+    @cached_property
+    def min_instances(self) -> int:
+        try:
+            return int(self._container_spec["env"].get(constants.MIN_INSTANCES_ENV_VAR, 1))
+        except TypeError:
+            return 1
 
     @property
     def id(self) -> str:
@@ -52,6 +63,12 @@ class MLJob(Generic[T]):
             self._status = _get_status(self._session, self.id)
         return self._status
 
+    @cached_property
+    def _compute_pool(self) -> str:
+        """Get the job's compute pool name."""
+        row = _get_service_info(self._session, self.id)
+        return cast(str, row["compute_pool"])
+
     @property
     def _service_spec(self) -> dict[str, Any]:
         """Get the job's service spec."""
@@ -82,15 +99,34 @@ class MLJob(Generic[T]):
         return f"{self._stage_path}/{result_path}"
 
     @overload
-    def get_logs(self, limit: int = -1, instance_id: Optional[int] = None, *, as_list: Literal[True]) -> list[str]:
+    def get_logs(
+        self,
+        limit: int = -1,
+        instance_id: Optional[int] = None,
+        *,
+        as_list: Literal[True],
+        verbose: bool = constants.DEFAULT_VERBOSE_LOG,
+    ) -> list[str]:
         ...
 
     @overload
-    def get_logs(self, limit: int = -1, instance_id: Optional[int] = None, *, as_list: Literal[False] = False) -> str:
+    def get_logs(
+        self,
+        limit: int = -1,
+        instance_id: Optional[int] = None,
+        *,
+        as_list: Literal[False] = False,
+        verbose: bool = constants.DEFAULT_VERBOSE_LOG,
+    ) -> str:
         ...
 
     def get_logs(
-        self, limit: int = -1, instance_id: Optional[int] = None, *, as_list: bool = False
+        self,
+        limit: int = -1,
+        instance_id: Optional[int] = None,
+        *,
+        as_list: bool = False,
+        verbose: bool = constants.DEFAULT_VERBOSE_LOG,
     ) -> Union[str, list[str]]:
         """
         Return the job's execution logs.
@@ -100,17 +136,20 @@ class MLJob(Generic[T]):
             instance_id: Optional instance ID to get logs from a specific instance.
                          If not provided, returns logs from the head node.
             as_list: If True, returns logs as a list of lines. Otherwise, returns logs as a single string.
+            verbose: Whether to return the full log or just the user log.
 
         Returns:
             The job's execution logs.
         """
-        logs = _get_logs(self._session, self.id, limit, instance_id)
+        logs = _get_logs(self._session, self.id, limit, instance_id, verbose)
         assert isinstance(logs, str)  # mypy
         if as_list:
             return logs.splitlines()
         return logs
 
-    def show_logs(self, limit: int = -1, instance_id: Optional[int] = None) -> None:
+    def show_logs(
+        self, limit: int = -1, instance_id: Optional[int] = None, verbose: bool = constants.DEFAULT_VERBOSE_LOG
+    ) -> None:
         """
         Display the job's execution logs.
 
@@ -118,8 +157,9 @@ class MLJob(Generic[T]):
             limit: The maximum number of lines to display. Negative values are treated as no limit.
             instance_id: Optional instance ID to get logs from a specific instance.
                          If not provided, displays logs from the head node.
+            verbose: Whether to return the full log or just the user log.
         """
-        print(self.get_logs(limit, instance_id, as_list=False))  # noqa: T201: we need to print here.
+        print(self.get_logs(limit, instance_id, as_list=False, verbose=verbose))  # noqa: T201: we need to print here.
 
     @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["timeout"])
     def wait(self, timeout: float = -1) -> types.JOB_STATUS:
@@ -137,7 +177,16 @@ class MLJob(Generic[T]):
         """
         delay = constants.JOB_POLL_INITIAL_DELAY_SECONDS  # Start with 100ms delay
         start_time = time.monotonic()
-        while self.status not in TERMINAL_JOB_STATUSES:
+        warning_shown = False
+        while (status := self.status) not in TERMINAL_JOB_STATUSES:
+            if status == "PENDING" and not warning_shown:
+                pool_info = _get_compute_pool_info(self._session, self._compute_pool)
+                if (pool_info.max_nodes - pool_info.active_nodes) < self.min_instances:
+                    logger.warning(
+                        f"Compute pool busy ({pool_info.active_nodes}/{pool_info.max_nodes} nodes in use)."
+                        " Job execution may be delayed."
+                    )
+                    warning_shown = True
             if timeout >= 0 and (elapsed := time.monotonic() - start_time) >= timeout:
                 raise TimeoutError(f"Job {self.name} did not complete within {elapsed} seconds")
             time.sleep(delay)
@@ -195,7 +244,9 @@ def _get_service_spec(session: snowpark.Session, job_id: str) -> dict[str, Any]:
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id", "limit", "instance_id"])
-def _get_logs(session: snowpark.Session, job_id: str, limit: int = -1, instance_id: Optional[int] = None) -> str:
+def _get_logs(
+    session: snowpark.Session, job_id: str, limit: int = -1, instance_id: Optional[int] = None, verbose: bool = True
+) -> str:
     """
     Retrieve the job's execution logs.
 
@@ -204,24 +255,20 @@ def _get_logs(session: snowpark.Session, job_id: str, limit: int = -1, instance_
         limit: The maximum number of lines to return. Negative values are treated as no limit.
         session: The Snowpark session to use. If none specified, uses active session.
         instance_id: Optional instance ID to get logs from a specific instance.
+        verbose: Whether to return the full log or just the portion between START and END messages.
 
     Returns:
         The job's execution logs.
 
     Raises:
-        SnowparkSQLException: if the container is pending
         RuntimeError: if failed to get head instance_id
-
     """
     # If instance_id is not specified, try to get the head instance ID
     if instance_id is None:
         try:
             instance_id = _get_head_instance_id(session, job_id)
         except RuntimeError:
-            raise RuntimeError(
-                "Failed to retrieve job logs. "
-                "Logs may be inaccessible due to job expiration and can be retrieved from Event Table instead."
-            )
+            instance_id = None
 
     # Assemble params: [job_id, instance_id, container_name, (optional) limit]
     params: list[Any] = [
@@ -231,7 +278,6 @@ def _get_logs(session: snowpark.Session, job_id: str, limit: int = -1, instance_
     ]
     if limit > 0:
         params.append(limit)
-
     try:
         (row,) = session.sql(
             f"SELECT SYSTEM$GET_SERVICE_LOGS(?, ?, ?{f', ?' if limit > 0 else ''})",
@@ -239,9 +285,43 @@ def _get_logs(session: snowpark.Session, job_id: str, limit: int = -1, instance_
         ).collect()
     except SnowparkSQLException as e:
         if "Container Status: PENDING" in e.message:
-            return "Warning: Waiting for container to start. Logs will be shown when available."
-        raise
-    return str(row[0])
+            logger.warning("Waiting for container to start. Logs will be shown when available.")
+            return ""
+        else:
+            # event table accepts job name, not fully qualified name
+            # cast is to resolve the type check error
+            db, schema, name = identifier.parse_schema_level_object_identifier(job_id)
+            db = cast(str, db or session.get_current_database())
+            schema = cast(str, schema or session.get_current_schema())
+            logs = _get_service_log_from_event_table(
+                session, db, schema, name, limit, instance_id if instance_id else None
+            )
+            if len(logs) == 0:
+                raise RuntimeError(
+                    "No logs were found. Please verify that the database, schema, and job ID are correct."
+                )
+            return os.linesep.join(row[0] for row in logs)
+
+    full_log = str(row[0])
+
+    # If verbose is True, return the complete log
+    if verbose:
+        return full_log
+
+    # Otherwise, extract only the portion between LOG_START_MSG and LOG_END_MSG
+    start_idx = full_log.find(constants.LOG_START_MSG)
+    if start_idx != -1:
+        start_idx += len(constants.LOG_START_MSG)
+    else:
+        # If start message not found, start from the beginning
+        start_idx = 0
+
+    end_idx = full_log.find(constants.LOG_END_MSG, start_idx)
+    if end_idx == -1:
+        # If end message not found, return everything after start
+        end_idx = len(full_log)
+
+    return full_log[start_idx:end_idx].strip()
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id"])
@@ -256,13 +336,18 @@ def _get_head_instance_id(session: snowpark.Session, job_id: str) -> Optional[in
     Returns:
         Optional[int]: The head instance ID of the job, or None if the head instance has not started yet.
 
-    Raises:
+     Raises:
         RuntimeError: If the instances died or if some instances disappeared.
+
     """
-    rows = session.sql("SHOW SERVICE INSTANCES IN SERVICE IDENTIFIER(?)", params=(job_id,)).collect()
+    try:
+        rows = session.sql("SHOW SERVICE INSTANCES IN SERVICE IDENTIFIER(?)", params=(job_id,)).collect()
+    except SnowparkSQLException:
+        # service may be deleted
+        raise RuntimeError("Couldn’t retrieve instances")
     if not rows:
         return None
-    if _get_num_instances(session, job_id) > len(rows):
+    if _get_target_instances(session, job_id) > len(rows):
         raise RuntimeError("Couldn’t retrieve head instance due to missing instances.")
 
     # Sort by start_time first, then by instance_id
@@ -270,7 +355,6 @@ def _get_head_instance_id(session: snowpark.Session, job_id: str) -> Optional[in
         sorted_instances = sorted(rows, key=lambda x: (x["start_time"], int(x["instance_id"])))
     except TypeError:
         raise RuntimeError("Job instance information unavailable.")
-
     head_instance = sorted_instances[0]
     if not head_instance["start_time"]:
         # If head instance hasn't started yet, return None
@@ -281,12 +365,61 @@ def _get_head_instance_id(session: snowpark.Session, job_id: str) -> Optional[in
         return 0
 
 
+def _get_service_log_from_event_table(
+    session: snowpark.Session, database: str, schema: str, name: str, limit: int, instance_id: Optional[int]
+) -> list[Row]:
+    params: list[Any] = [
+        database,
+        schema,
+        name,
+    ]
+    query = [
+        "SELECT VALUE FROM snowflake.telemetry.events_view",
+        'WHERE RESOURCE_ATTRIBUTES:"snow.database.name" = ?',
+        'AND RESOURCE_ATTRIBUTES:"snow.schema.name" = ?',
+        'AND RESOURCE_ATTRIBUTES:"snow.service.name" = ?',
+    ]
+
+    if instance_id:
+        query.append('AND RESOURCE_ATTRIBUTES:"snow.service.container.instance" = ?')
+        params.append(instance_id)
+
+    query.append("AND RECORD_TYPE = 'LOG'")
+    # sort by TIMESTAMP; although OBSERVED_TIMESTAMP is for log, it is NONE currently when record_type is log
+    query.append("ORDER BY TIMESTAMP")
+
+    if limit > 0:
+        query.append("LIMIT ?")
+        params.append(limit)
+
+    rows = session.sql(
+        "\n".join(line for line in query if line),
+        params=params,
+    ).collect()
+    return rows
+
+
 def _get_service_info(session: snowpark.Session, job_id: str) -> Row:
     (row,) = session.sql("DESCRIBE SERVICE IDENTIFIER(?)", params=(job_id,)).collect()
     return row
 
 
+def _get_compute_pool_info(session: snowpark.Session, compute_pool: str) -> Row:
+    """
+    Check if the compute pool has enough available instances.
+
+    Args:
+        session (Session): The Snowpark session to use.
+        compute_pool (str): The name of the compute pool.
+
+    Returns:
+        Row: The compute pool information.
+    """
+    (pool_info,) = session.sql("SHOW COMPUTE POOLS LIKE ?", params=(compute_pool,)).collect()
+    return pool_info
+
+
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id"])
-def _get_num_instances(session: snowpark.Session, job_id: str) -> int:
+def _get_target_instances(session: snowpark.Session, job_id: str) -> int:
     row = _get_service_info(session, job_id)
     return int(row["target_instances"]) if row["target_instances"] else 0

snowflake/ml/jobs/manager.py

@@ -108,7 +108,8 @@ def submit_file(
     external_access_integrations: Optional[list[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[dict[str, Any]] = None,
-    num_instances: Optional[int] = None,
+    target_instances: int = 1,
+    min_instances: int = 1,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -127,7 +128,8 @@ def submit_file(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
-        num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        target_instances: The number of instances to use for the job. If none specified, single node job is created.
+        min_instances: The minimum number of nodes required to start the job. If none specified, defaults to 1.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -146,7 +148,8 @@ def submit_file(
         external_access_integrations=external_access_integrations,
         query_warehouse=query_warehouse,
         spec_overrides=spec_overrides,
-        num_instances=num_instances,
+        target_instances=target_instances,
+        min_instances=min_instances,
         enable_metrics=enable_metrics,
         database=database,
         schema=schema,
@@ -167,7 +170,8 @@ def submit_directory(
     external_access_integrations: Optional[list[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[dict[str, Any]] = None,
-    num_instances: Optional[int] = None,
+    target_instances: int = 1,
+    min_instances: int = 1,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -187,7 +191,8 @@ def submit_directory(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
-        num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        target_instances: The number of instances to use for the job. If none specified, single node job is created.
+        min_instances: The minimum number of nodes required to start the job. If none specified, defaults to 1.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -207,7 +212,8 @@ def submit_directory(
         external_access_integrations=external_access_integrations,
         query_warehouse=query_warehouse,
         spec_overrides=spec_overrides,
-        num_instances=num_instances,
+        target_instances=target_instances,
+        min_instances=min_instances,
         enable_metrics=enable_metrics,
         database=database,
         schema=schema,
@@ -228,7 +234,8 @@ def _submit_job(
     external_access_integrations: Optional[list[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[dict[str, Any]] = None,
-    num_instances: Optional[int] = None,
+    target_instances: int = 1,
+    min_instances: int = 1,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -250,7 +257,8 @@ def _submit_job(
     external_access_integrations: Optional[list[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[dict[str, Any]] = None,
-    num_instances: Optional[int] = None,
+    target_instances: int = 1,
+    min_instances: int = 1,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -267,7 +275,7 @@ def _submit_job(
         # TODO: Log lengths of args, env_vars, and spec_overrides values
         "pip_requirements",
         "external_access_integrations",
-        "num_instances",
+        "target_instances",
         "enable_metrics",
     ],
 )
@@ -283,7 +291,8 @@ def _submit_job(
     external_access_integrations: Optional[list[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[dict[str, Any]] = None,
-    num_instances: Optional[int] = None,
+    target_instances: int = 1,
+    min_instances: int = 1,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -303,7 +312,8 @@ def _submit_job(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
-        num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        target_instances: The number of instances to use for the job. If none specified, single node job is created.
+        min_instances: The minimum number of nodes required to start the job. If none specified, defaults to 1.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -316,13 +326,12 @@ def _submit_job(
         RuntimeError: If required Snowflake features are not enabled.
         ValueError: If database or schema value(s) are invalid
     """
-    # Display warning about PrPr parameters
-    if num_instances is not None:
-        logger.warning(
-            "_submit_job() parameter 'num_instances' is in private preview since 1.8.2. Do not use it in production.",
-        )
     if database and not schema:
         raise ValueError("Schema must be specified if database is specified.")
+    if target_instances < 1 or min_instances < 1:
+        raise ValueError("target_instances and min_instances must be greater than 0.")
+    if min_instances > target_instances:
+        raise ValueError("min_instances must be less than or equal to target_instances.")
 
     session = session or get_active_session()
 
@@ -350,7 +359,8 @@ def _submit_job(
         compute_pool=compute_pool,
         payload=uploaded_payload,
         args=args,
-        num_instances=num_instances,
+        target_instances=target_instances,
+        min_instances=min_instances,
         enable_metrics=enable_metrics,
     )
     spec_overrides = spec_utils.generate_spec_overrides(
@@ -381,9 +391,9 @@ def _submit_job(
     if query_warehouse:
         query.append("QUERY_WAREHOUSE = IDENTIFIER(?)")
         params.append(query_warehouse)
-    if num_instances:
+    if target_instances > 1:
         query.append("REPLICAS = ?")
-        params.append(num_instances)
+        params.append(target_instances)
 
     # Submit job
     query_text = "\n".join(line for line in query if line)

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

@@ -125,6 +125,7 @@ class ServiceOperator:
             stage_path = self._create_temp_stage(database_name, schema_name, statement_params)
         else:
             stage_path = None
+        self._model_deployment_spec.clear()
         self._model_deployment_spec.add_model_spec(
             database_name=database_name,
             schema_name=schema_name,
@@ -168,7 +169,7 @@ class ServiceOperator:
             schema_name=service_schema_name,
             service_name=service_name,
             service_status_list_if_exists=[
-                service_sql.ServiceStatus.READY,
+                service_sql.ServiceStatus.RUNNING,
                 service_sql.ServiceStatus.SUSPENDING,
                 service_sql.ServiceStatus.SUSPENDED,
             ],
@@ -331,7 +332,7 @@ class ServiceOperator:
                     include_message=True,
                     statement_params=statement_params,
                 )
-                if (service_status != service_sql.ServiceStatus.READY) or (
+                if (service_status != service_sql.ServiceStatus.RUNNING) or (
                     service_status != service_log_meta.service_status
                 ):
                     service_log_meta.service_status = service_status
@@ -428,7 +429,7 @@ class ServiceOperator:
         if service_status_list_if_exists is None:
             service_status_list_if_exists = [
                 service_sql.ServiceStatus.PENDING,
-                service_sql.ServiceStatus.READY,
+                service_sql.ServiceStatus.RUNNING,
                 service_sql.ServiceStatus.SUSPENDING,
                 service_sql.ServiceStatus.SUSPENDED,
                 service_sql.ServiceStatus.DONE,
@@ -538,6 +539,7 @@ class ServiceOperator:
         )
 
         try:
+            self._model_deployment_spec.clear()
             # save the spec
             self._model_deployment_spec.add_model_spec(
                 database_name=database_name,

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

@@ -29,6 +29,17 @@ class ModelDeploymentSpec:
         self.database: Optional[sql_identifier.SqlIdentifier] = None
         self.schema: Optional[sql_identifier.SqlIdentifier] = None
 
+    def clear(self) -> None:
+        """Reset the deployment spec to its initial state."""
+        self._models = []
+        self._image_build = None
+        self._service = None
+        self._job = None
+        self._model_loggings = None
+        self._inference_spec = {}
+        self.database = None
+        self.schema = None
+
     def add_model_spec(
         self,
         database_name: sql_identifier.SqlIdentifier,

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

@@ -293,7 +293,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         if snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
             options = {"parallel": 10}
             cursor = self._session._conn._cursor
-            cursor._download(stage_location_url, str(target_path), options)  # type: ignore[union-attr]
+            cursor._download(stage_location_url, str(target_path), options)
             cursor.fetchall()
         else:
             query_result_checker.SqlResultValidator(

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

@@ -1,5 +1,4 @@
 import enum
-import json
 import textwrap
 from typing import Any, Optional, Union
 
@@ -15,22 +14,25 @@ from snowflake.snowpark import dataframe, functions as F, row, types as spt
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 
+# 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
-    READY = "READY"  # resource set has been deployed.
     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
-    NOT_FOUND = "NOT_FOUND"  # not found or deleted
     INTERNAL_ERROR = "INTERNAL_ERROR"  # there was an internal service error.
+    RUNNING = "RUNNING"
+    DELETED = "DELETED"
 
 
 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"
 
     def build_model_container(
         self,
@@ -199,22 +201,17 @@ class ServiceSQLClient(_base._BaseSQLClient):
         include_message: bool = False,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> tuple[ServiceStatus, Optional[str]]:
-        system_func = "SYSTEM$GET_SERVICE_STATUS"
-        rows = (
-            query_result_checker.SqlResultValidator(
-                self._session,
-                f"CALL {system_func}('{self.fully_qualified_object_name(database_name, schema_name, service_name)}')",
-                statement_params=statement_params,
-            )
-            .has_dimensions(expected_rows=1, expected_cols=1)
-            .validate()
-        )
-        metadata = json.loads(rows[0][system_func])[0]
-        if metadata and metadata["status"]:
-            service_status = ServiceStatus(metadata["status"])
-            message = metadata["message"] if include_message else None
-            return service_status, message
-        return ServiceStatus.UNKNOWN, None
+        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
 
     def drop_service(
         self,

snowflake/ml/model/_model_composer/model_composer.py

@@ -188,7 +188,9 @@ class ModelComposer:
         if not options:
             options = model_types.BaseModelSaveOption()
 
-        if not snowpark_utils.is_in_stored_procedure():  # type: ignore[no-untyped-call]
+        if not snowpark_utils.is_in_stored_procedure() and target_platforms != [  # type: ignore[no-untyped-call]
+            model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES  # no information schema check for SPCS-only models
+        ]:
             snowml_matched_versions = env_utils.get_matched_package_versions_in_information_schema(
                 self.session,
                 reqs=[requirements.Requirement(f"{env_utils.SNOWPARK_ML_PKG_NAME}=={snowml_version.VERSION}")],

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

@@ -216,7 +216,7 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                         explain_fn=cls._build_explain_fn(model, background_data, input_signature),
                         output_feature_names=transformed_background_data.columns,
                     )
-                except ValueError:
+                except Exception:
                     if kwargs.get("enable_explainability", None):
                         # user explicitly enabled explainability, so we should raise the error
                         raise ValueError(

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -12,7 +12,7 @@ REQUIREMENTS = [
     "importlib_resources>=6.1.1, <7",
     "numpy>=1.23,<2",
     "packaging>=20.9,<25",
-    "pandas>=1.0.0,<3",
+    "pandas>=2.1.4,<3",
     "pyarrow",
     "pydantic>=2.8.2, <3",
     "pyjwt>=2.0.0, <3",
@@ -24,9 +24,10 @@ REQUIREMENTS = [
     "scikit-learn<1.6",
     "scipy>=1.9,<2",
     "shap>=0.46.0,<1",
-    "snowflake-connector-python>=3.14.0,<4",
+    "snowflake-connector-python>=3.15.0,<4",
     "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0",
     "snowflake.core>=1.0.2,<2",
     "sqlparse>=0.4,<1",
     "typing-extensions>=4.1.0,<5",
+    "xgboost>=1.7.3,<3",
 ]