snowflake-ml-python 1.8.4__py3-none-any.whl → 1.8.6__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
@@ -12,10 +14,12 @@ from snowflake.snowpark import Row, context as sp_context
 from snowflake.snowpark.exceptions import SnowparkSQLException
 
 _PROJECT = "MLJob"
-TERMINAL_JOB_STATUSES = {"FAILED", "DONE", "INTERNAL_ERROR"}
+TERMINAL_JOB_STATUSES = {"FAILED", "DONE", "CANCELLED", "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,11 +177,20 @@ 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, "
+                        f"{self.min_instances} nodes required). 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)
-            delay = min(delay * 2, constants.JOB_POLL_MAX_DELAY_SECONDS)  # Exponential backoff
+            delay = min(delay * 1.2, constants.JOB_POLL_MAX_DELAY_SECONDS)  # Exponential backoff
         return self.status
 
     @snowpark._internal.utils.private_preview(version="1.8.2")
@@ -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,25 @@ 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()
+
+    target_instances = _get_target_instances(session, job_id)
+
+    if target_instances == 1:
+        return 0
+
+    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 target_instances > len(rows):
         raise RuntimeError("Couldn’t retrieve head instance due to missing instances.")
 
     # Sort by start_time first, then by instance_id
@@ -270,7 +362,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 +372,69 @@ 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.
+
+    Raises:
+        ValueError: If the compute pool is not found.
+    """
+    try:
+        (pool_info,) = session.sql("SHOW COMPUTE POOLS LIKE ?", params=(compute_pool,)).collect()
+        return pool_info
+    except ValueError as e:
+        if "not enough values to unpack" in str(e):
+            raise ValueError(f"Compute pool '{compute_pool}' not found")
+        raise
+
+
 @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
+    return int(row["target_instances"])

snowflake/ml/jobs/manager.py

@@ -87,13 +87,15 @@ def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob
 @telemetry.send_api_usage_telemetry(project=_PROJECT)
 def delete_job(job: Union[str, jb.MLJob[Any]], session: Optional[snowpark.Session] = None) -> None:
     """Delete a job service from the backend. Status and logs will be lost."""
-    if isinstance(job, jb.MLJob):
-        job_id = job.id
-        session = job._session or session
-    else:
-        job_id = job
-    session = session or get_active_session()
-    session.sql("DROP SERVICE IDENTIFIER(?)", params=(job_id,)).collect()
+    job = job if isinstance(job, jb.MLJob) else get_job(job, session=session)
+    session = job._session
+    try:
+        stage_path = job._stage_path
+        session.sql(f"REMOVE {stage_path}/").collect()
+        logger.info(f"Successfully cleaned up stage files for job {job.id} at {stage_path}")
+    except Exception as e:
+        logger.warning(f"Failed to clean up stage files for job {job.id}: {e}")
+    session.sql("DROP SERVICE IDENTIFIER(?)", params=(job.id,)).collect()
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT)
@@ -108,7 +110,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: Optional[int] = None,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -127,7 +130,9 @@ 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 target_instances. If set, the job will not start until the minimum number of nodes is available.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -146,7 +151,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 +173,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: Optional[int] = None,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -187,7 +194,9 @@ 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 target_instances. If set, the job will not start until the minimum number of nodes is available.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -207,7 +216,74 @@ 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,
+        session=session,
+    )
+
+
+@telemetry.send_api_usage_telemetry(project=_PROJECT)
+def submit_from_stage(
+    source: str,
+    compute_pool: str,
+    *,
+    entrypoint: str,
+    stage_name: str,
+    args: Optional[list[str]] = None,
+    env_vars: Optional[dict[str, str]] = None,
+    pip_requirements: Optional[list[str]] = None,
+    external_access_integrations: Optional[list[str]] = None,
+    query_warehouse: Optional[str] = None,
+    spec_overrides: Optional[dict[str, Any]] = None,
+    target_instances: int = 1,
+    min_instances: Optional[int] = None,
+    enable_metrics: bool = False,
+    database: Optional[str] = None,
+    schema: Optional[str] = None,
+    session: Optional[snowpark.Session] = None,
+) -> jb.MLJob[None]:
+    """
+    Submit a directory containing Python script(s) as a job to the compute pool.
+
+    Args:
+        source: a stage path or a stage containing the job payload.
+        compute_pool: The compute pool to use for the job.
+        entrypoint: a stage path containing the entry point script inside the source directory.
+        stage_name: The name of the stage where the job payload will be uploaded.
+        args: A list of arguments to pass to the job.
+        env_vars: Environment variables to set in container
+        pip_requirements: A list of pip requirements for the 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.
+        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 target_instances. If set, the job will not start until the minimum number of nodes is available.
+        enable_metrics: Whether to enable metrics publishing for the job.
+        database: The database to use.
+        schema: The schema to use.
+        session: The Snowpark session to use. If none specified, uses active session.
+
+
+    Returns:
+        An object representing the submitted job.
+    """
+    return _submit_job(
+        source=source,
+        entrypoint=entrypoint,
+        args=args,
+        compute_pool=compute_pool,
+        stage_name=stage_name,
+        env_vars=env_vars,
+        pip_requirements=pip_requirements,
+        external_access_integrations=external_access_integrations,
+        query_warehouse=query_warehouse,
+        spec_overrides=spec_overrides,
+        target_instances=target_instances,
+        min_instances=min_instances,
         enable_metrics=enable_metrics,
         database=database,
         schema=schema,
@@ -228,7 +304,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: Optional[int] = None,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -250,7 +327,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: Optional[int] = None,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -267,7 +345,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 +361,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: Optional[int] = None,
     enable_metrics: bool = False,
     database: Optional[str] = None,
     schema: Optional[str] = None,
@@ -303,7 +382,9 @@ 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 target_instances. If set, the job will not start until the minimum number of nodes is available.
         enable_metrics: Whether to enable metrics publishing for the job.
         database: The database to use.
         schema: The schema to use.
@@ -316,16 +397,27 @@ 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:
+        raise ValueError("target_instances must be greater than 0.")
+
+    min_instances = target_instances if min_instances is None else min_instances
+    if not (0 < min_instances <= target_instances):
+        raise ValueError("min_instances must be greater than 0 and less than or equal to target_instances.")
 
     session = session or get_active_session()
 
+    if min_instances > 1:
+        # Validate min_instances against compute pool max_nodes
+        pool_info = jb._get_compute_pool_info(session, compute_pool)
+        max_nodes = int(pool_info["max_nodes"])
+        if min_instances > max_nodes:
+            raise ValueError(
+                f"The requested min_instances ({min_instances}) exceeds the max_nodes ({max_nodes}) "
+                f"of compute pool '{compute_pool}'. Reduce min_instances or increase max_nodes."
+            )
+
     # Validate database and schema identifiers on client side since
     # SQL parser for EXECUTE JOB SERVICE seems to struggle with this
     database = identifier.resolve_identifier(cast(str, database or session.get_current_database()))
@@ -350,7 +442,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 +474,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/model/model_impl.py

@@ -426,3 +426,61 @@ class Model:
             schema_name=new_schema or self._model_ops._model_client._schema_name,
         )
         self._model_name = new_model
+
+    def _repr_html_(self) -> str:
+        """Generate an HTML representation of the model.
+
+        Returns:
+            str: HTML string containing formatted model details.
+        """
+        from snowflake.ml.utils import html_utils
+
+        # Get default version
+        default_version = self.default.version_name
+
+        # Get versions info
+        try:
+            versions_df = self.show_versions()
+            versions_html = ""
+
+            for _, row in versions_df.iterrows():
+                versions_html += html_utils.create_version_item(
+                    version_name=row["name"],
+                    created_on=str(row["created_on"]),
+                    comment=str(row.get("comment", "")),
+                    is_default=bool(row["is_default_version"]),
+                )
+        except Exception:
+            versions_html = html_utils.create_error_message("Error retrieving versions")
+
+        # Get tags
+        try:
+            tags = self.show_tags()
+            if not tags:
+                tags_html = html_utils.create_error_message("No tags available")
+            else:
+                tags_html = ""
+                for tag_name, tag_value in tags.items():
+                    tags_html += html_utils.create_tag_item(tag_name, tag_value)
+        except Exception:
+            tags_html = html_utils.create_error_message("Error retrieving tags")
+
+        # Create main content sections
+        main_info = html_utils.create_grid_section(
+            [
+                ("Model Name", self.name),
+                ("Full Name", self.fully_qualified_name),
+                ("Description", self.description),
+                ("Default Version", default_version),
+            ]
+        )
+
+        versions_section = html_utils.create_section_header("Versions") + html_utils.create_content_section(
+            versions_html
+        )
+
+        tags_section = html_utils.create_section_header("Tags") + html_utils.create_content_section(tags_html)
+
+        content = main_info + versions_section + tags_section
+
+        return html_utils.create_base_container("Model Details", content)