snowflake-ml-python 1.9.2__py3-none-any.whl → 1.11.0__py3-none-any.whl

snowflake/ml/model/_model_composer/model_composer.py

@@ -1,17 +1,12 @@
 import pathlib
 import tempfile
 import uuid
-import warnings
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Optional, Union
 from urllib import parse
 
-from absl import logging
-from packaging import requirements
-
 from snowflake import snowpark
-from snowflake.ml import version as snowml_version
-from snowflake.ml._internal import env as snowml_env, env_utils, file_utils
+from snowflake.ml._internal import file_utils
 from snowflake.ml._internal.lineage import lineage_utils
 from snowflake.ml.data import data_source
 from snowflake.ml.model import model_signature, type_hints as model_types
@@ -19,7 +14,6 @@ from snowflake.ml.model._model_composer.model_manifest import model_manifest
 from snowflake.ml.model._packager import model_packager
 from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import Session
-from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
     from snowflake.ml.experiment._experiment_info import ExperimentInfo
@@ -142,73 +136,10 @@ class ModelComposer:
         experiment_info: Optional["ExperimentInfo"] = None,
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> model_meta.ModelMetadata:
-        # set enable_explainability=False if the model is not runnable in WH or the target platforms include SPCS
-        conda_dep_dict = env_utils.validate_conda_dependency_string_list(
-            conda_dependencies if conda_dependencies else []
-        )
-
-        enable_explainability = None
-
-        if options:
-            enable_explainability = options.get("enable_explainability", None)
-
-        # skip everything if user said False explicitly
-        if enable_explainability is None or enable_explainability is True:
-            is_warehouse_runnable = (
-                not conda_dep_dict
-                or all(
-                    chan == env_utils.DEFAULT_CHANNEL_NAME or chan == env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
-                    for chan in conda_dep_dict
-                )
-            ) and (not pip_requirements)
-
-            only_spcs = (
-                target_platforms
-                and len(target_platforms) == 1
-                and model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES in target_platforms
-            )
-            if only_spcs or (not is_warehouse_runnable):
-                # if only SPCS and user asked for explainability we fail
-                if enable_explainability is True:
-                    raise ValueError(
-                        "`enable_explainability` cannot be set to True when the model is not runnable in WH "
-                        "or the target platforms include SPCS."
-                    )
-                elif not options:  # explicitly set flag to false in these cases if not specified
-                    options = model_types.BaseModelSaveOption()
-                    options["enable_explainability"] = False
-            elif (
-                target_platforms
-                and len(target_platforms) > 1
-                and model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES in target_platforms
-            ):  # if both then only available for WH
-                if enable_explainability is True:
-                    warnings.warn(
-                        ("Explain function will only be available for model deployed to warehouse."),
-                        category=UserWarning,
-                        stacklevel=2,
-                    )
 
         if not options:
             options = model_types.BaseModelSaveOption()
 
-        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}")],
-                python_version=python_version or snowml_env.PYTHON_VERSION,
-                statement_params=self._statement_params,
-            ).get(env_utils.SNOWPARK_ML_PKG_NAME, [])
-
-            if len(snowml_matched_versions) < 1 and options.get("embed_local_ml_library", False) is False:
-                logging.info(
-                    f"Local snowflake-ml-python library has version {snowml_version.VERSION},"
-                    " which is not available in the Snowflake server, embedding local ML library automatically."
-                )
-                options["embed_local_ml_library"] = True
-
         model_metadata: model_meta.ModelMetadata = self.packager.save(
             name=name,
             model=model,

snowflake/ml/model/_model_composer/model_manifest/model_manifest.py

@@ -1,13 +1,11 @@
 import collections
 import logging
 import pathlib
-import warnings
 from typing import TYPE_CHECKING, Optional, cast
 
 import yaml
 
 from snowflake.ml._internal import env_utils
-from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml.data import data_source
 from snowflake.ml.model import type_hints
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
@@ -55,47 +53,8 @@ class ModelManifest:
         experiment_info: Optional["ExperimentInfo"] = None,
         target_platforms: Optional[list[type_hints.TargetPlatform]] = None,
     ) -> None:
-        if options is None:
-            options = {}
-
-        has_pip_requirements = len(model_meta.env.pip_requirements) > 0
-        only_spcs = (
-            target_platforms
-            and len(target_platforms) == 1
-            and target_platforms[0] == type_hints.TargetPlatform.SNOWPARK_CONTAINER_SERVICES
-        )
-
-        if "relax_version" not in options:
-            if has_pip_requirements or only_spcs:
-                logger.info(
-                    "Setting `relax_version=False` as this model will run in Snowpark Container Services "
-                    "or in Warehouse with a specified artifact_repository_map where exact version "
-                    " specifications will be honored."
-                )
-                relax_version = False
-            else:
-                warnings.warn(
-                    (
-                        "`relax_version` is not set and therefore defaulted to True. Dependency version constraints"
-                        " relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility,"
-                        " reproducibility, etc., set `options={'relax_version': False}` when logging the model."
-                    ),
-                    category=UserWarning,
-                    stacklevel=2,
-                )
-                relax_version = True
-            options["relax_version"] = relax_version
-        else:
-            relax_version = options.get("relax_version", True)
-            if relax_version and (has_pip_requirements or only_spcs):
-                raise exceptions.SnowflakeMLException(
-                    error_code=error_codes.INVALID_ARGUMENT,
-                    original_exception=ValueError(
-                        "Setting `relax_version=True` is only allowed for models to be run in Warehouse with "
-                        "Snowflake Conda Channel dependencies. It cannot be used with pip requirements or when "
-                        "targeting only Snowpark Container Services."
-                    ),
-                )
+        assert options is not None, "ModelParameterReconciler should have set options with relax_version"
+        relax_version = options["relax_version"]
 
         runtime_to_use = model_runtime.ModelRuntime(
             name=self._DEFAULT_RUNTIME_NAME,

snowflake/ml/model/event_handler.py

@@ -23,12 +23,24 @@ class _TqdmStatusContext:
         if state == "complete":
             self._progress_bar.update(self._progress_bar.total - self._progress_bar.n)
             self._progress_bar.set_description(label)
+        elif state == "error":
+            # For error state, use the label as-is and mark with ERROR prefix
+            # Don't update progress bar position for errors - leave it where it was
+            self._progress_bar.set_description(f"❌ ERROR: {label}")
         else:
-            self._progress_bar.set_description(f"{self._label}: {label}")
+            combined_desc = f"{self._label}: {label}" if label != self._label else self._label
+            self._progress_bar.set_description(combined_desc)
 
-    def increment(self, n: int = 1) -> None:
+    def increment(self) -> None:
         """Increment the progress bar."""
-        self._progress_bar.update(n)
+        self._progress_bar.update(1)
+
+    def complete(self) -> None:
+        """Complete the progress bar to full state."""
+        if self._total:
+            remaining = self._total - self._progress_bar.n
+            if remaining > 0:
+                self._progress_bar.update(remaining)
 
 
 class _StreamlitStatusContext:
@@ -39,6 +51,7 @@ class _StreamlitStatusContext:
         self._streamlit = streamlit_module
         self._total = total
         self._current = 0
+        self._current_label = label
         self._progress_bar = None
 
     def __enter__(self) -> "_StreamlitStatusContext":
@@ -49,26 +62,70 @@ class _StreamlitStatusContext:
         return self
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        self._status_container.update(state="complete")
+        # Only update to complete if there was no exception
+        if exc_type is None:
+            self._status_container.update(state="complete")
 
     def update(self, label: str, *, state: str = "running", expanded: bool = True) -> None:
         """Update the status label."""
-        if state != "complete":
-            label = f"{self._label}: {label}"
-        self._status_container.update(label=label, state=state, expanded=expanded)
-        if self._progress_bar is not None:
-            self._progress_bar.progress(
-                self._current / self._total if self._total > 0 else 0,
-                text=f"{label} - {self._current}/{self._total}",
-            )
-
-    def increment(self, n: int = 1) -> None:
+        if state == "complete" or state == "error":
+            # For completion/error, use the message as-is and update main status
+            self._status_container.update(label=label, state=state, expanded=expanded)
+            self._current_label = label
+
+            # For error state, update progress bar text but preserve position
+            if state == "error" and self._total is not None and self._progress_bar is not None:
+                self._progress_bar.progress(
+                    self._current / self._total if self._total > 0 else 0,
+                    text=f"ERROR - ({self._current}/{self._total})",
+                )
+        else:
+            combined_label = f"{self._label}: {label}" if label != self._label else self._label
+            self._status_container.update(label=combined_label, state=state, expanded=expanded)
+            self._current_label = label
+            if self._total is not None and self._progress_bar is not None:
+                progress_value = self._current / self._total if self._total > 0 else 0
+                self._progress_bar.progress(progress_value, text=f"({self._current}/{self._total})")
+
+    def increment(self) -> None:
         """Increment the progress."""
         if self._total is not None:
-            self._current = min(self._current + n, self._total)
+            self._current = min(self._current + 1, self._total)
             if self._progress_bar is not None:
                 progress_value = self._current / self._total if self._total > 0 else 0
-                self._progress_bar.progress(progress_value, text=f"{self._current}/{self._total}")
+                self._progress_bar.progress(progress_value, text=f"({self._current}/{self._total})")
+
+    def complete(self) -> None:
+        """Complete the progress bar to full state."""
+        if self._total is not None:
+            self._current = self._total
+            if self._progress_bar is not None:
+                self._progress_bar.progress(1.0, text=f"({self._current}/{self._total})")
+
+
+class _NoOpStatusContext:
+    """A no-op context manager for when status updates should be disabled."""
+
+    def __init__(self, label: str) -> None:
+        self._label = label
+
+    def __enter__(self) -> "_NoOpStatusContext":
+        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:
+        """No-op update method."""
+        pass
+
+    def increment(self) -> None:
+        """No-op increment method."""
+        pass
+
+    def complete(self) -> None:
+        """No-op complete method."""
+        pass
 
 
 class ModelEventHandler:
@@ -99,7 +156,15 @@ class ModelEventHandler:
         else:
             self._tqdm.tqdm.write(message)
 
-    def status(self, label: str, *, state: str = "running", expanded: bool = True, total: Optional[int] = None) -> Any:
+    def status(
+        self,
+        label: str,
+        *,
+        state: str = "running",
+        expanded: bool = True,
+        total: Optional[int] = None,
+        block: bool = True,
+    ) -> Any:
         """Context manager that provides status updates with optional enhanced display capabilities.
 
         Args:
@@ -107,10 +172,14 @@ class ModelEventHandler:
             state: The initial state ("running", "complete", "error")
             expanded: Whether to show expanded view (streamlit only)
             total: Total number of steps for progress tracking (optional)
+            block: Whether to show progress updates (no-op if False)
 
         Returns:
-            Status context (Streamlit or Tqdm)
+            Status context (Streamlit, Tqdm, or NoOp based on availability and block parameter)
         """
+        if not block:
+            return _NoOpStatusContext(label)
+
         if self._streamlit is not None:
             return _StreamlitStatusContext(label, self._streamlit, total)
         else:

snowflake/ml/model/inference_engine.py

@@ -0,0 +1,5 @@
+import enum
+
+
+class InferenceEngine(enum.Enum):
+    VLLM = "vllm"

snowflake/ml/model/models/huggingface_pipeline.py

@@ -258,7 +258,7 @@ class HuggingFacePipelineModel:
         # model_version_impl.create_service parameters
         service_name: str,
         service_compute_pool: str,
-        image_repo: str,
+        image_repo: Optional[str] = None,
         image_build_compute_pool: Optional[str] = None,
         ingress_enabled: bool = False,
         max_instances: int = 1,
@@ -282,7 +282,8 @@ class HuggingFacePipelineModel:
             comment: Comment for the model. Defaults to None.
             service_name: The name of the service to create.
             service_compute_pool: The compute pool for the service.
-            image_repo: The name of the image repository.
+            image_repo: The name of the image repository. This can be None, in that case a default hidden image
+                repository will be used.
             image_build_compute_pool: The name of the compute pool used to build the model inference image. It uses
             the service compute pool if None.
             ingress_enabled: Whether ingress is enabled. Defaults to False.
@@ -299,6 +300,7 @@ class HuggingFacePipelineModel:
         Raises:
             ValueError: if database and schema name is not provided and session doesn't have a
             database and schema name.
+            exceptions.SnowparkSQLException: if service already exists.
 
         Returns:
             The service ID or an async job object.
@@ -327,7 +329,6 @@ class HuggingFacePipelineModel:
             version_name = name_generator.generate()[1]
 
         service_db_id, service_schema_id, service_id = sql_identifier.parse_fully_qualified_name(service_name)
-        image_repo_db_id, image_repo_schema_id, image_repo_id = sql_identifier.parse_fully_qualified_name(image_repo)
 
         service_operator = service_ops.ServiceOperator(
             session=session,
@@ -336,51 +337,73 @@ class HuggingFacePipelineModel:
         )
         logger.info(f"A service job is going to register the hf model as: {model_name}.{version_name}")
 
-        return service_operator.create_service(
-            database_name=database_name_id,
-            schema_name=schema_name_id,
-            model_name=model_name_id,
-            version_name=sql_identifier.SqlIdentifier(version_name),
-            service_database_name=service_db_id,
-            service_schema_name=service_schema_id,
-            service_name=service_id,
-            image_build_compute_pool_name=(
-                sql_identifier.SqlIdentifier(image_build_compute_pool)
-                if image_build_compute_pool
-                else sql_identifier.SqlIdentifier(service_compute_pool)
-            ),
-            service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
-            image_repo_database_name=image_repo_db_id,
-            image_repo_schema_name=image_repo_schema_id,
-            image_repo_name=image_repo_id,
-            ingress_enabled=ingress_enabled,
-            max_instances=max_instances,
-            cpu_requests=cpu_requests,
-            memory_requests=memory_requests,
-            gpu_requests=gpu_requests,
-            num_workers=num_workers,
-            max_batch_rows=max_batch_rows,
-            force_rebuild=force_rebuild,
-            build_external_access_integrations=(
-                None
-                if build_external_access_integrations is None
-                else [sql_identifier.SqlIdentifier(eai) for eai in build_external_access_integrations]
-            ),
-            block=block,
-            statement_params=statement_params,
-            # hf model
-            hf_model_args=service_ops.HFModelArgs(
-                hf_model_name=self.model,
-                hf_task=self.task,
-                hf_tokenizer=self.tokenizer,
-                hf_revision=self.revision,
-                hf_token=self.token,
-                hf_trust_remote_code=bool(self.trust_remote_code),
-                hf_model_kwargs=self.model_kwargs,
-                pip_requirements=pip_requirements,
-                conda_dependencies=conda_dependencies,
-                comment=comment,
-                # TODO: remove warehouse in the next release
-                warehouse=session.get_current_warehouse(),
-            ),
-        )
+        from snowflake.ml.model import event_handler
+        from snowflake.snowpark import exceptions
+
+        hf_event_handler = event_handler.ModelEventHandler()
+        with hf_event_handler.status("Creating HuggingFace model service", total=6, block=block) as status:
+            try:
+                result = service_operator.create_service(
+                    database_name=database_name_id,
+                    schema_name=schema_name_id,
+                    model_name=model_name_id,
+                    version_name=sql_identifier.SqlIdentifier(version_name),
+                    service_database_name=service_db_id,
+                    service_schema_name=service_schema_id,
+                    service_name=service_id,
+                    image_build_compute_pool_name=(
+                        sql_identifier.SqlIdentifier(image_build_compute_pool)
+                        if image_build_compute_pool
+                        else sql_identifier.SqlIdentifier(service_compute_pool)
+                    ),
+                    service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
+                    image_repo_name=image_repo,
+                    ingress_enabled=ingress_enabled,
+                    max_instances=max_instances,
+                    cpu_requests=cpu_requests,
+                    memory_requests=memory_requests,
+                    gpu_requests=gpu_requests,
+                    num_workers=num_workers,
+                    max_batch_rows=max_batch_rows,
+                    force_rebuild=force_rebuild,
+                    build_external_access_integrations=(
+                        None
+                        if build_external_access_integrations is None
+                        else [sql_identifier.SqlIdentifier(eai) for eai in build_external_access_integrations]
+                    ),
+                    block=block,
+                    progress_status=status,
+                    statement_params=statement_params,
+                    # hf model
+                    hf_model_args=service_ops.HFModelArgs(
+                        hf_model_name=self.model,
+                        hf_task=self.task,
+                        hf_tokenizer=self.tokenizer,
+                        hf_revision=self.revision,
+                        hf_token=self.token,
+                        hf_trust_remote_code=bool(self.trust_remote_code),
+                        hf_model_kwargs=self.model_kwargs,
+                        pip_requirements=pip_requirements,
+                        conda_dependencies=conda_dependencies,
+                        comment=comment,
+                        # TODO: remove warehouse in the next release
+                        warehouse=session.get_current_warehouse(),
+                    ),
+                )
+                status.update(label="HuggingFace model service created successfully", state="complete", expanded=False)
+                return result
+            except exceptions.SnowparkSQLException as e:
+                # Check if the error is because the service already exists
+                if "already exists" in str(e).lower() or "100132" in str(
+                    e
+                ):  # 100132 is Snowflake error code for object already exists
+                    # Update progress to show service already exists (preserve exception behavior)
+                    status.update("service already exists")
+                    status.complete()  # Complete progress to full state
+                    status.update(label="Service already exists", state="error", expanded=False)
+                    # Re-raise the exception to preserve existing API behavior
+                    raise
+                else:
+                    # Re-raise other SQL exceptions
+                    status.update(label="Service creation failed", state="error", expanded=False)
+                    raise

snowflake/ml/model/type_hints.py

@@ -1,5 +1,14 @@
 # mypy: disable-error-code="import"
-from typing import TYPE_CHECKING, Literal, Sequence, TypedDict, TypeVar, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    Protocol,
+    Sequence,
+    TypedDict,
+    TypeVar,
+    Union,
+)
 
 import numpy.typing as npt
 from typing_extensions import NotRequired
@@ -326,4 +335,20 @@ ModelLoadOption = Union[
 SupportedTargetPlatformType = Union[TargetPlatform, str]
 
 
+class ProgressStatus(Protocol):
+    """Protocol for tracking progress during long-running operations."""
+
+    def update(self, message: str, *, state: str = "running", expanded: bool = True, **kwargs: Any) -> None:
+        """Update the progress status with a new message."""
+        ...
+
+    def increment(self) -> None:
+        """Increment the progress by one step."""
+        ...
+
+    def complete(self) -> None:
+        """Complete the progress bar to full state."""
+        ...
+
+
 __all__ = ["TargetPlatform", "Task"]