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

snowflake/ml/jobs/manager.py

@@ -1,18 +1,21 @@
 import logging
 import pathlib
 import textwrap
-from typing import Any, Callable, Literal, Optional, TypeVar, Union, cast, overload
+from typing import Any, Callable, Optional, TypeVar, Union, cast, overload
 from uuid import uuid4
 
+import pandas as pd
 import yaml
 
 from snowflake import snowpark
+from snowflake.connector import errors
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import identifier
 from snowflake.ml.jobs import job as jb
-from snowflake.ml.jobs._utils import payload_utils, spec_utils
+from snowflake.ml.jobs._utils import payload_utils, query_helper, spec_utils
 from snowflake.snowpark.context import get_active_session
 from snowflake.snowpark.exceptions import SnowparkSQLException
+from snowflake.snowpark.functions import coalesce, col, lit, when
 
 logger = logging.getLogger(__name__)
 
@@ -25,39 +28,127 @@ T = TypeVar("T")
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["limit", "scope"])
 def list_jobs(
     limit: int = 10,
-    scope: Union[Literal["account", "database", "schema"], str, None] = None,
+    database: Optional[str] = None,
+    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
-) -> snowpark.DataFrame:
+) -> pd.DataFrame:
     """
-    Returns a Snowpark DataFrame with the list of jobs in the current session.
+    Returns a Pandas DataFrame with the list of jobs in the current session.
 
     Args:
         limit: The maximum number of jobs to return. Non-positive values are treated as no limit.
-        scope: The scope to list jobs from, such as "schema" or "compute pool <pool_name>".
+        database: The database to use. If not specified, uses the current database.
+        schema: The schema to use. If not specified, uses the current schema.
         session: The Snowpark session to use. If none specified, uses active session.
 
     Returns:
         A DataFrame with the list of jobs.
 
+    Raises:
+        SnowparkSQLException: if there is an error retrieving the job history.
+
     Examples:
         >>> from snowflake.ml.jobs import list_jobs
-        >>> list_jobs(limit=5).show()
+        >>> list_jobs(limit=5)
     """
     session = session or get_active_session()
+    try:
+        df = _get_job_history_spcs(
+            session,
+            limit=limit,
+            database=database,
+            schema=schema,
+        )
+        return df.to_pandas()
+    except SnowparkSQLException as spcs_error:
+        if spcs_error.sql_error_code == 2143:
+            logger.debug("Job history is not enabled. Please enable it to use this feature.")
+            df = _get_job_services(session, limit=limit, database=database, schema=schema)
+            return df.to_pandas()
+        raise
+
+
+def _get_job_services(
+    session: snowpark.Session, limit: int = 10, database: Optional[str] = None, schema: Optional[str] = None
+) -> snowpark.DataFrame:
     query = "SHOW JOB SERVICES"
     query += f" LIKE '{JOB_ID_PREFIX}%'"
-    if scope:
-        query += f" IN {scope}"
+    database = database or session.get_current_database()
+    schema = schema or session.get_current_schema()
+    if database is None and schema is None:
+        query += "IN account"
+    elif not schema:
+        query += f" IN DATABASE {database}"
+    else:
+        query += f" IN {database}.{schema}"
     if limit > 0:
         query += f" LIMIT {limit}"
     df = session.sql(query)
     df = df.select(
         df['"name"'],
-        df['"owner"'],
         df['"status"'],
-        df['"created_on"'],
+        lit(None).alias('"message"'),
+        df['"database_name"'],
+        df['"schema_name"'],
+        df['"owner"'],
         df['"compute_pool"'],
-    ).order_by('"created_on"', ascending=False)
+        df['"target_instances"'],
+        df['"created_on"'].alias('"created_time"'),
+        when(col('"status"').isin(jb.TERMINAL_JOB_STATUSES), col('"updated_on"'))
+        .otherwise(lit(None))
+        .alias('"completed_time"'),
+    ).order_by('"created_time"', ascending=False)
+    return df
+
+
+def _get_job_history_spcs(
+    session: snowpark.Session,
+    limit: int = 10,
+    database: Optional[str] = None,
+    schema: Optional[str] = None,
+    include_deleted: bool = False,
+    created_time_start: Optional[str] = None,
+    created_time_end: Optional[str] = None,
+) -> snowpark.DataFrame:
+    query = ["select * from table(snowflake.spcs.get_job_history("]
+    query_params = []
+    if created_time_start:
+        query_params.append(f"created_time_start => TO_TIMESTAMP_LTZ('{created_time_start}')")
+    if created_time_end:
+        query_params.append(f"created_time_end => TO_TIMESTAMP_LTZ('{created_time_end}')")
+    query.append(",".join(query_params))
+    query.append("))")
+    condition = []
+    database = database or session.get_current_database()
+    schema = schema or session.get_current_schema()
+
+    # format database and schema identifiers
+    if database:
+        condition.append(f"DATABASE_NAME = '{identifier.resolve_identifier(database)}'")
+
+    if schema:
+        condition.append(f"SCHEMA_NAME = '{identifier.resolve_identifier(schema)}'")
+
+    if not include_deleted:
+        condition.append("DELETED_TIME IS NULL")
+
+    if len(condition) > 0:
+        query.append("WHERE " + " AND ".join(condition))
+    if limit > 0:
+        query.append(f"LIMIT {limit}")
+    df = session.sql("\n".join(query))
+    df = df.select(
+        df["NAME"].alias('"name"'),
+        df["STATUS"].alias('"status"'),
+        df["MESSAGE"].alias('"message"'),
+        df["DATABASE_NAME"].alias('"database_name"'),
+        df["SCHEMA_NAME"].alias('"schema_name"'),
+        df["OWNER"].alias('"owner"'),
+        df["COMPUTE_POOL_NAME"].alias('"compute_pool"'),
+        coalesce(df["PARAMETERS"]["REPLICAS"], lit(1)).alias('"target_instances"'),
+        df["CREATED_TIME"].alias('"created_time"'),
+        df["COMPLETED_TIME"].alias('"completed_time"'),
+    )
     return df
 
 
@@ -74,12 +165,12 @@ def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob
 
     job_id = f"{database}.{schema}.{job_name}"
     try:
-        # Validate that job exists by doing a status check
+        # Validate that job exists by doing a spec lookup
         job = jb.MLJob[Any](job_id, session=session)
-        _ = job.status
+        _ = job._service_spec
         return job
-    except SnowparkSQLException as e:
-        if "does not exist" in e.message:
+    except errors.ProgrammingError as e:
+        if "does not exist" in str(e):
             raise ValueError(f"Job does not exist: {job_id}") from e
         raise
 
@@ -87,13 +178,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._conn.run_query("DROP SERVICE IDENTIFIER(?)", params=(job.id,), _force_qmark_paramstyle=True)
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT)
@@ -103,17 +196,11 @@ def submit_file(
     *,
     stage_name: str,
     args: Optional[list[str]] = None,
-    env_vars: Optional[dict[str, str]] = None,
+    target_instances: int = 1,
     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: int = 1,
-    enable_metrics: bool = False,
-    database: Optional[str] = None,
-    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
 ) -> jb.MLJob[None]:
     """
     Submit a Python file as a job to the compute pool.
@@ -123,17 +210,20 @@ def submit_file(
         compute_pool: The compute pool to use for the job.
         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
+        target_instances: The number of nodes in the job. If none specified, create a single node job.
         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 1.
-        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.
+        kwargs: Additional keyword arguments. Supported arguments:
+            database (str): The database to use for the job.
+            schema (str): The schema to use for the job.
+            min_instances (int): 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.
+            env_vars (dict): Environment variables to set in container.
+            enable_metrics (bool): Whether to enable metrics publishing for the job.
+            query_warehouse (str): The query warehouse to use. Defaults to session warehouse.
+            spec_overrides (dict): A dictionary of overrides for the service spec.
 
     Returns:
         An object representing the submitted job.
@@ -143,17 +233,11 @@ def submit_file(
         args=args,
         compute_pool=compute_pool,
         stage_name=stage_name,
-        env_vars=env_vars,
+        target_instances=target_instances,
         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,
         session=session,
+        **kwargs,
     )
 
 
@@ -165,17 +249,11 @@ def submit_directory(
     entrypoint: str,
     stage_name: str,
     args: Optional[list[str]] = None,
-    env_vars: Optional[dict[str, str]] = None,
+    target_instances: int = 1,
     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: int = 1,
-    enable_metrics: bool = False,
-    database: Optional[str] = None,
-    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
 ) -> jb.MLJob[None]:
     """
     Submit a directory containing Python script(s) as a job to the compute pool.
@@ -186,17 +264,20 @@ def submit_directory(
         entrypoint: The relative path to 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
+        target_instances: The number of nodes in the job. If none specified, create a single node job.
         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 1.
-        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.
+        kwargs: Additional keyword arguments. Supported arguments:
+            database (str): The database to use for the job.
+            schema (str): The schema to use for the job.
+            min_instances (int): 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.
+            env_vars (dict): Environment variables to set in container.
+            enable_metrics (bool): Whether to enable metrics publishing for the job.
+            query_warehouse (str): The query warehouse to use. Defaults to session warehouse.
+            spec_overrides (dict): A dictionary of overrides for the service spec.
 
     Returns:
         An object representing the submitted job.
@@ -207,17 +288,66 @@ def submit_directory(
         args=args,
         compute_pool=compute_pool,
         stage_name=stage_name,
-        env_vars=env_vars,
+        target_instances=target_instances,
         pip_requirements=pip_requirements,
         external_access_integrations=external_access_integrations,
-        query_warehouse=query_warehouse,
-        spec_overrides=spec_overrides,
+        session=session,
+        **kwargs,
+    )
+
+
+@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,
+    target_instances: int = 1,
+    pip_requirements: Optional[list[str]] = None,
+    external_access_integrations: Optional[list[str]] = None,
+    session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
+) -> 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.
+        target_instances: The number of nodes in the job. If none specified, create a single node job.
+        pip_requirements: A list of pip requirements for the job.
+        external_access_integrations: A list of external access integrations.
+        session: The Snowpark session to use. If none specified, uses active session.
+        kwargs: Additional keyword arguments. Supported arguments:
+            database (str): The database to use for the job.
+            schema (str): The schema to use for the job.
+            min_instances (int): 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.
+            env_vars (dict): Environment variables to set in container.
+            enable_metrics (bool): Whether to enable metrics publishing for the job.
+            query_warehouse (str): The query warehouse to use. Defaults to session warehouse.
+            spec_overrides (dict): A dictionary of overrides for the service spec.
+
+    Returns:
+        An object representing the submitted job.
+    """
+    return _submit_job(
+        source=source,
+        entrypoint=entrypoint,
+        args=args,
+        compute_pool=compute_pool,
+        stage_name=stage_name,
         target_instances=target_instances,
-        min_instances=min_instances,
-        enable_metrics=enable_metrics,
-        database=database,
-        schema=schema,
+        pip_requirements=pip_requirements,
+        external_access_integrations=external_access_integrations,
         session=session,
+        **kwargs,
     )
 
 
@@ -229,17 +359,11 @@ def _submit_job(
     stage_name: str,
     entrypoint: Optional[str] = None,
     args: Optional[list[str]] = None,
-    env_vars: Optional[dict[str, str]] = None,
+    target_instances: int = 1,
     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: int = 1,
-    enable_metrics: bool = False,
-    database: Optional[str] = None,
-    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
 ) -> jb.MLJob[None]:
     ...
 
@@ -252,17 +376,11 @@ def _submit_job(
     stage_name: str,
     entrypoint: Optional[str] = None,
     args: Optional[list[str]] = None,
-    env_vars: Optional[dict[str, str]] = None,
+    target_instances: int = 1,
     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: int = 1,
-    enable_metrics: bool = False,
-    database: Optional[str] = None,
-    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
 ) -> jb.MLJob[T]:
     ...
 
@@ -275,8 +393,9 @@ def _submit_job(
         # TODO: Log lengths of args, env_vars, and spec_overrides values
         "pip_requirements",
         "external_access_integrations",
+        "num_instances",  # deprecated
         "target_instances",
-        "enable_metrics",
+        "min_instances",
     ],
 )
 def _submit_job(
@@ -286,17 +405,9 @@ def _submit_job(
     stage_name: str,
     entrypoint: Optional[str] = None,
     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: int = 1,
-    enable_metrics: bool = False,
-    database: Optional[str] = None,
-    schema: Optional[str] = None,
     session: Optional[snowpark.Session] = None,
+    **kwargs: Any,
 ) -> jb.MLJob[T]:
     """
     Submit a job to the compute pool.
@@ -307,17 +418,9 @@ def _submit_job(
         stage_name: The name of the stage where the job payload will be uploaded.
         entrypoint: The entry point for the job execution. Required if source is a directory.
         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 1.
-        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.
+        kwargs: Additional keyword arguments.
 
     Returns:
         An object representing the submitted job.
@@ -325,23 +428,52 @@ def _submit_job(
     Raises:
         RuntimeError: If required Snowflake features are not enabled.
         ValueError: If database or schema value(s) are invalid
+        errors.ProgrammingError: if the SQL query or its parameters are invalid
     """
-    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()
 
-    # 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()))
-    schema = identifier.resolve_identifier(cast(str, schema or session.get_current_schema()))
+    # Use kwargs for less common optional parameters
+    database = kwargs.pop("database", None)
+    schema = kwargs.pop("schema", None)
+    min_instances = kwargs.pop("min_instances", target_instances)
+    pip_requirements = kwargs.pop("pip_requirements", None)
+    external_access_integrations = kwargs.pop("external_access_integrations", None)
+    env_vars = kwargs.pop("env_vars", None)
+    spec_overrides = kwargs.pop("spec_overrides", None)
+    enable_metrics = kwargs.pop("enable_metrics", True)
+    query_warehouse = kwargs.pop("query_warehouse", None)
+
+    # Check for deprecated args
+    if "num_instances" in kwargs:
+        logger.warning(
+            "'num_instances' is deprecated and will be removed in a future release. Use 'target_instances' instead."
+        )
+        target_instances = max(target_instances, kwargs.pop("num_instances"))
+
+    # Warn if there are unknown kwargs
+    if kwargs:
+        logger.warning(f"Ignoring unknown kwargs: {kwargs.keys()}")
+
+    # Validate parameters
+    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.")
+    if not (0 < min_instances <= target_instances):
+        raise ValueError("min_instances must be greater than 0 and less than or equal to target_instances.")
+    if min_instances > 1:
+        # Validate min_instances against compute pool max_nodes
+        pool_info = jb._get_compute_pool_info(session, compute_pool)
+        requested_attributes = query_helper.get_attribute_map(session, {"max_nodes": 3})
+        max_nodes = int(pool_info[requested_attributes["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."
+            )
 
     job_name = f"{JOB_ID_PREFIX}{str(uuid4()).replace('-', '_').upper()}"
-    job_id = f"{database}.{schema}.{job_name}"
+    job_id = identifier.get_schema_level_object_identifier(database, schema, job_name)
     stage_path_parts = identifier.parse_snowflake_stage_path(stage_name.lstrip("@"))
     stage_name = f"@{'.'.join(filter(None, stage_path_parts[:3]))}"
     stage_path = pathlib.PurePosixPath(f"{stage_name}{stage_path_parts[-1].rstrip('/')}/{job_name}")
@@ -399,12 +531,12 @@ def _submit_job(
     query_text = "\n".join(line for line in query if line)
 
     try:
-        _ = session.sql(query_text, params=params).collect()
-    except SnowparkSQLException as e:
-        if "invalid property 'ASYNC'" in e.message:
+        _ = session._conn.run_query(query_text, params=params, _force_qmark_paramstyle=True)
+    except errors.ProgrammingError as e:
+        if "invalid property 'ASYNC'" in str(e):
             raise RuntimeError(
                 "SPCS Async Jobs not enabled. Set parameter `ENABLE_SNOWSERVICES_ASYNC_JOBS = TRUE` to enable."
             ) from e
         raise
 
-    return jb.MLJob(job_id, service_spec=spec, session=session)
+    return get_job(job_id, session=session)

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)