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

snowflake/ml/registry/registry.py

@@ -1,3 +1,5 @@
+import logging
+import os
 import warnings
 from types import ModuleType
 from typing import Any, Optional, Union, overload
@@ -11,10 +13,11 @@ from snowflake.ml.model import (
     Model,
     ModelVersion,
     model_signature,
+    task,
     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
@@ -29,7 +32,54 @@ _MODEL_MONITORING_DISABLED_ERROR = (
 )
 
 
+class _NullStatusContext:
+    """A fallback context manager that logs status updates."""
+
+    def __init__(self, label: str) -> None:
+        self._label = label
+
+    def __enter__(self) -> "_NullStatusContext":
+        logging.info(f"Starting: {self._label}")
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        pass
+
+    def update(self, label: str, *, state: str = "running", expanded: bool = True) -> None:
+        """Update the status by logging the message."""
+        logging.info(f"Status update: {label} (state: {state})")
+
+
+class RegistryEventHandler:
+    def __init__(self) -> None:
+        try:
+            import streamlit as st
+
+            if not st.runtime.exists():
+                self._streamlit = None
+            else:
+                self._streamlit = st
+            USE_STREAMLIT_WIDGETS = os.getenv("USE_STREAMLIT_WIDGETS", "1") == "1"
+            if not USE_STREAMLIT_WIDGETS:
+                self._streamlit = None
+        except ImportError:
+            self._streamlit = None
+
+    def update(self, message: str) -> None:
+        """Write a message using streamlit if available, otherwise do nothing."""
+        if self._streamlit is not None:
+            self._streamlit.write(message)
+
+    def status(self, label: str, *, state: str = "running", expanded: bool = True) -> Any:
+        """Context manager that provides status updates with optional enhanced display capabilities."""
+        if self._streamlit is None:
+            return _NullStatusContext(label)
+        else:
+            return self._streamlit.status(label, state=state, expanded=expanded)
+
+
 class Registry:
+    @telemetry.send_api_usage_telemetry(project=_TELEMETRY_PROJECT, subproject=_MODEL_TELEMETRY_SUBPROJECT)
     def __init__(
         self,
         session: session.Session,
@@ -74,6 +124,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,
@@ -119,7 +185,7 @@ class Registry:
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
+        task: model_types.Task = task.Task.UNKNOWN,
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
@@ -142,12 +208,12 @@ class Registry:
                 to specify a dependency. It is a recommended way to specify your dependencies using conda. When channel
                 is not specified, Snowflake Anaconda Channel will be used. Defaults to None.
             pip_requirements: List of Pip package specifications. Defaults to None.
-                Models with pip requirements are currently only runnable in Snowpark Container Services.
-                See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
-                Models with pip requirements specified will not be executable in Snowflake Warehouse where all
-                dependencies must be retrieved from Snowflake Anaconda Channel.
+                Models running in a Snowflake Warehouse must also specify a pip artifact repository (see
+                `artifact_repository_map`). Otherwise, models with pip requirements are runnable only in Snowpark
+                Container Services. See
+                https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
-                repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
+                repositories. Defaults to None. Currently, the mapping applies only to Warehouse execution.
                 Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
                    - channel_name: Currently must be 'pip'.
@@ -155,7 +221,14 @@ 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", or a target platform constant:
+                - ["WAREHOUSE"] or snowflake.ml.model.target_platform.WAREHOUSE_ONLY (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY
+                  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.BOTH_WAREHOUSE_AND_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
@@ -259,7 +332,7 @@ class Registry:
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
+        task: model_types.Task = task.Task.UNKNOWN,
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
@@ -282,12 +355,12 @@ class Registry:
                 to specify a dependency. It is a recommended way to specify your dependencies using conda. When channel
                 is not specified, Snowflake Anaconda Channel will be used. Defaults to None.
             pip_requirements: List of Pip package specifications. Defaults to None.
-                Models with pip requirements are currently only runnable in Snowpark Container Services.
-                See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
-                Models with pip requirements specified will not be executable in Snowflake Warehouse where all
-                dependencies must be retrieved from Snowflake Anaconda Channel.
+                Models running in a Snowflake Warehouse must also specify a pip artifact repository (see
+                `artifact_repository_map`). Otherwise, models with pip requirements are runnable only in Snowpark
+                Container Services. See
+                https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
-                repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
+                repositories. Defaults to None. Currently, the mapping applies only to Warehouse execution.
                 Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
                    - channel_name: Currently must be 'pip'.
@@ -295,8 +368,14 @@ 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", or a target platform constant:
+                - ["WAREHOUSE"] or snowflake.ml.model.target_platform.WAREHOUSE_ONLY (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY
+                  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.BOTH_WAREHOUSE_AND_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
@@ -342,6 +421,7 @@ class Registry:
 
         Raises:
             ValueError: If extra arguments are specified ModelVersion is provided.
+            Exception: If the model logging fails.
 
         Returns:
             ModelVersion: ModelVersion object corresponding to the model just logged.
@@ -397,35 +477,47 @@ 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 and self._targets_warehouse(target_platforms):
             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,
             )
-        return self._model_manager.log_model(
-            model=model,
-            model_name=model_name,
-            version_name=version_name,
-            comment=comment,
-            metrics=metrics,
-            conda_dependencies=conda_dependencies,
-            pip_requirements=pip_requirements,
-            artifact_repository_map=artifact_repository_map,
-            resource_constraint=resource_constraint,
-            target_platforms=target_platforms,
-            python_version=python_version,
-            signatures=signatures,
-            sample_input_data=sample_input_data,
-            user_files=user_files,
-            code_paths=code_paths,
-            ext_modules=ext_modules,
-            task=task,
-            options=options,
-            statement_params=statement_params,
-        )
+
+        event_handler = RegistryEventHandler()
+        with event_handler.status("Logging model to registry...") as status:
+            # Perform the actual model logging
+            try:
+                result = self._model_manager.log_model(
+                    model=model,
+                    model_name=model_name,
+                    version_name=version_name,
+                    comment=comment,
+                    metrics=metrics,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    artifact_repository_map=artifact_repository_map,
+                    resource_constraint=resource_constraint,
+                    target_platforms=target_platforms,
+                    python_version=python_version,
+                    signatures=signatures,
+                    sample_input_data=sample_input_data,
+                    user_files=user_files,
+                    code_paths=code_paths,
+                    ext_modules=ext_modules,
+                    task=task,
+                    options=options,
+                    statement_params=statement_params,
+                    event_handler=event_handler,
+                )
+                status.update(label="Model logged successfully!", state="complete", expanded=False)
+                return result
+            except Exception as e:
+                event_handler.update("❌ Model logging failed!")
+                status.update(label="Model logging failed!", state="error", expanded=False)
+                raise e
 
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -500,7 +592,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 +616,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 +625,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 +637,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 +665,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 +682,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.
 
@@ -606,3 +694,12 @@ class Registry:
         if not self.enable_monitoring:
             raise ValueError(_MODEL_MONITORING_DISABLED_ERROR)
         self._model_monitor_manager.delete_monitor(name)
+
+    @staticmethod
+    def _targets_warehouse(target_platforms: Optional[list[model_types.SupportedTargetPlatformType]]) -> bool:
+        """Returns True if warehouse is a target platform (None defaults to True)."""
+        return (
+            target_platforms is None
+            or model_types.TargetPlatform.WAREHOUSE in target_platforms
+            or "WAREHOUSE" in target_platforms
+        )

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.
 

snowflake/ml/utils/html_utils.py

@@ -0,0 +1,263 @@
+"""Utilities for generating consistent HTML representations across model classes."""
+
+from typing import Any, Sequence
+
+# Common CSS styles used across model classes
+BASE_CONTAINER_STYLE = (
+    "font-family: Helvetica, Arial, sans-serif; font-size: 14px; line-height: 1.5; "
+    "color: #333; background-color: #f9f9f9; border: 1px solid #ddd; "
+    "border-radius: 4px; padding: 15px; margin-bottom: 15px;"
+)
+
+HEADER_STYLE = "margin-top: 0; margin-bottom: 10px; font-size: 16px; color: #007bff;"
+
+SECTION_HEADER_STYLE = "margin: 15px 0 10px; color: #007bff;"
+
+GRID_CONTAINER_STYLE = "display: grid; grid-template-columns: 150px 1fr; gap: 10px;"
+
+GRID_LABEL_STYLE = "font-weight: bold;"
+
+DETAILS_STYLE = "margin: 5px 0; border: 1px solid #e0e0e0; border-radius: 4px;"
+
+SUMMARY_STYLE = "padding: 8px; cursor: pointer; background-color: #f5f5f5; border-radius: 3px;"
+
+SUMMARY_LABEL_STYLE = "font-weight: bold; color: #007bff;"
+
+CONTENT_SECTION_STYLE = "margin-left: 10px;"
+
+VERSION_ITEM_STYLE = "margin: 5px 0; padding: 5px; background-color: #f5f5f5; border-radius: 3px;"
+
+NESTED_GROUP_STYLE = "border-left: 2px solid #e0e0e0; margin-left: 8px;"
+
+ERROR_STYLE = "color: #888; font-style: italic;"
+
+
+def create_base_container(title: str, content: str) -> str:
+    """Create a base HTML container with consistent styling.
+
+    Args:
+        title: The main title for the container.
+        content: The HTML content to include in the container.
+
+    Returns:
+        HTML string with the base container structure.
+    """
+    return f"""
+    <div style="{BASE_CONTAINER_STYLE}">
+        <h3 style="{HEADER_STYLE}">
+            {title}
+        </h3>
+        {content}
+    </div>
+    """
+
+
+def create_grid_section(items: list[tuple[str, str]]) -> str:
+    """Create a grid layout section for key-value pairs.
+
+    Args:
+        items: List of (label, value) tuples to display in the grid.
+
+    Returns:
+        HTML string with grid layout.
+    """
+    grid_items = ""
+    for label, value in items:
+        grid_items += f"""
+            <div style="{GRID_LABEL_STYLE}">{label}:</div>
+            <div>{value}</div>
+        """
+
+    return f"""
+    <div style="{GRID_CONTAINER_STYLE}">
+        {grid_items}
+    </div>
+    """
+
+
+def create_section_header(title: str) -> str:
+    """Create a section header with consistent styling.
+
+    Args:
+        title: The section title.
+
+    Returns:
+        HTML string for the section header.
+    """
+    return f'<h4 style="{SECTION_HEADER_STYLE}">{title}</h4>'
+
+
+def create_content_section(content: str) -> str:
+    """Create a content section with consistent indentation.
+
+    Args:
+        content: The content to include in the section.
+
+    Returns:
+        HTML string with content section styling.
+    """
+    return f"""
+    <div style="{CONTENT_SECTION_STYLE}">
+        {content}
+    </div>
+    """
+
+
+def create_collapsible_section(title: str, content: str, open_by_default: bool = True) -> str:
+    """Create a collapsible section with consistent styling.
+
+    Args:
+        title: The title for the collapsible section.
+        content: The content to include in the collapsible section.
+        open_by_default: Whether the section should be open by default.
+
+    Returns:
+        HTML string for the collapsible section.
+    """
+    open_attr = "open" if open_by_default else ""
+
+    return f"""
+    <details style="{DETAILS_STYLE}" {open_attr}>
+        <summary style="{SUMMARY_STYLE}">
+            <span style="{SUMMARY_LABEL_STYLE}">{title}</span>
+        </summary>
+        <div style="padding: 10px; border-top: 1px solid #e0e0e0;">
+            {content}
+        </div>
+    </details>
+    """
+
+
+def create_version_item(version_name: str, created_on: str, comment: str, is_default: bool = False) -> str:
+    """Create a version item with consistent styling.
+
+    Args:
+        version_name: The name of the version.
+        created_on: The creation timestamp.
+        comment: The version comment.
+        is_default: Whether this is the default version.
+
+    Returns:
+        HTML string for the version item.
+    """
+    default_text = " (Default)" if is_default else ""
+
+    return f"""
+    <div style="{VERSION_ITEM_STYLE}">
+        <strong>Version:</strong> {version_name}{default_text}<br/>
+        <strong>Created:</strong> {created_on}<br/>
+        <strong>Comment:</strong> {comment}<br/>
+    </div>
+    """
+
+
+def create_tag_item(tag_name: str, tag_value: str) -> str:
+    """Create a tag item with consistent styling.
+
+    Args:
+        tag_name: The name of the tag.
+        tag_value: The value of the tag.
+
+    Returns:
+        HTML string for the tag item.
+    """
+    return f"""
+    <div style="margin: 5px 0;">
+        <strong>{tag_name}:</strong> {tag_value}
+    </div>
+    """
+
+
+def create_metric_item(metric_name: str, value: Any) -> str:
+    """Create a metric item with consistent styling.
+
+    Args:
+        metric_name: The name of the metric.
+        value: The value of the metric.
+
+    Returns:
+        HTML string for the metric item.
+    """
+    value_str = "N/A" if value is None else str(value)
+    return f"""
+    <div style="margin: 5px 0;">
+        <strong>{metric_name}:</strong> {value_str}
+    </div>
+    """
+
+
+def create_error_message(message: str) -> str:
+    """Create an error message with consistent styling.
+
+    Args:
+        message: The error message to display.
+
+    Returns:
+        HTML string for the error message.
+    """
+    return f'<em style="{ERROR_STYLE}">{message}</em>'
+
+
+def create_feature_spec_html(spec: Any, indent: int = 0) -> str:
+    """Create HTML representation for a feature specification.
+
+    Args:
+        spec: The feature specification (FeatureSpec or FeatureGroupSpec).
+        indent: The indentation level for nested features.
+
+    Returns:
+        HTML string for the feature specification.
+    """
+    # Import here to avoid circular imports
+    from snowflake.ml.model._signatures import core
+
+    if isinstance(spec, core.FeatureSpec):
+        shape_str = f" shape={spec._shape}" if spec._shape else ""
+        nullable_str = "" if spec._nullable else ", not nullable"
+        return f"""
+            <div style="margin: 3px 0; padding-left: {indent * 16}px;">
+                <strong>{spec.name}</strong>: {spec._dtype}{shape_str}{nullable_str}
+            </div>
+        """
+    elif isinstance(spec, core.FeatureGroupSpec):
+        group_html = f"""
+            <div style="margin: 8px 0;">
+                <div style="margin: 3px 0; padding-left: {indent * 16}px;">
+                    <strong>{spec.name}</strong> <span style="color: #666;">(group)</span>
+                </div>
+                <div style="border-left: 2px solid #e0e0e0; margin-left: {indent * 16 + 8}px;">
+        """
+        for sub_spec in spec._specs:
+            group_html += create_feature_spec_html(sub_spec, indent + 1)
+        group_html += """
+                </div>
+            </div>
+        """
+        return group_html
+    return ""
+
+
+def create_features_html(features: Sequence[Any], title: str) -> str:
+    """Create HTML representation for a collection of features.
+
+    Args:
+        features: The sequence of feature specifications.
+        title: The title for the feature collection.
+
+    Returns:
+        HTML string for the features collection.
+    """
+    if not features:
+        return f"""
+            <div style="margin: 5px 0; padding: 5px;">
+                <em>No {title.lower()} features defined</em>
+            </div>
+        """
+
+    html = """
+        <div style="margin: 5px 0; padding: 5px;">
+    """
+    for feature in features:
+        html += create_feature_spec_html(feature)
+    html += "</div>"
+    return html

snowflake/ml/version.py

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