snowflake-ml-python 1.9.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

snowflake/ml/model/models/huggingface_pipeline.py

@@ -299,6 +299,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 +328,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 +336,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=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"]

snowflake/ml/registry/_manager/model_manager.py

@@ -14,6 +14,7 @@ from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
 from snowflake.ml.model._model_composer import model_composer
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
 from snowflake.ml.model._packager.model_meta import model_meta
+from snowflake.ml.registry._manager import model_parameter_reconciler
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
 from snowflake.snowpark._internal import utils as snowpark_utils
 
@@ -46,6 +47,7 @@ class ModelManager:
         *,
         model: Union[type_hints.SupportedModelType, model_version_impl.ModelVersion],
         model_name: str,
+        progress_status: type_hints.ProgressStatus,
         version_name: Optional[str] = None,
         comment: Optional[str] = None,
         metrics: Optional[dict[str, Any]] = None,
@@ -64,7 +66,6 @@ class ModelManager:
         experiment_info: Optional["ExperimentInfo"] = None,
         options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
-        progress_status: Optional[Any] = None,
     ) -> model_version_impl.ModelVersion:
 
         database_name_id, schema_name_id, model_name_id = self._parse_fully_qualified_name(model_name)
@@ -158,6 +159,7 @@ class ModelManager:
         *,
         model_name: str,
         version_name: str,
+        progress_status: type_hints.ProgressStatus,
         comment: Optional[str] = None,
         metrics: Optional[dict[str, Any]] = None,
         conda_dependencies: Optional[list[str]] = None,
@@ -175,7 +177,6 @@ class ModelManager:
         experiment_info: Optional["ExperimentInfo"] = None,
         options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
-        progress_status: Optional[Any] = None,
     ) -> model_version_impl.ModelVersion:
         database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
         version_name_id = sql_identifier.SqlIdentifier(version_name)
@@ -250,27 +251,27 @@ class ModelManager:
                 )
                 platforms = [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
 
-        if artifact_repository_map:
-            for channel, artifact_repository_name in artifact_repository_map.items():
-                db_id, schema_id, repo_id = sql_identifier.parse_fully_qualified_name(artifact_repository_name)
+        reconciler = model_parameter_reconciler.ModelParameterReconciler(
+            database_name=self._database_name,
+            schema_name=self._schema_name,
+            conda_dependencies=conda_dependencies,
+            pip_requirements=pip_requirements,
+            target_platforms=target_platforms,
+            artifact_repository_map=artifact_repository_map,
+            options=options,
+        )
 
-                artifact_repository_map[channel] = sql_identifier.get_fully_qualified_name(
-                    db_id,
-                    schema_id,
-                    repo_id,
-                    self._database_name,
-                    self._schema_name,
-                )
+        model_params = reconciler.reconcile()
+
+        # Use reconciled parameters
+        artifact_repository_map = model_params.artifact_repository_map
+        save_location = model_params.save_location
 
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
-        if progress_status:
-            progress_status.update("packaging model...")
-            progress_status.increment()
-
-        # Extract save_location from options if present
-        save_location = None
-        if options and "save_location" in options:
-            save_location = options.get("save_location")
+        progress_status.update("packaging model...")
+        progress_status.increment()
+
+        if save_location:
             logger.info(f"Model will be saved to local directory: {save_location}")
 
         mc = model_composer.ModelComposer(
@@ -280,9 +281,8 @@ class ModelManager:
             save_location=save_location,
         )
 
-        if progress_status:
-            progress_status.update("creating model manifest...")
-            progress_status.increment()
+        progress_status.update("creating model manifest...")
+        progress_status.increment()
 
         model_metadata: model_meta.ModelMetadata = mc.save(
             name=model_name_id.resolved(),
@@ -303,9 +303,8 @@ class ModelManager:
             experiment_info=experiment_info,
         )
 
-        if progress_status:
-            progress_status.update("uploading model files...")
-            progress_status.increment()
+        progress_status.update("uploading model files...")
+        progress_status.increment()
         statement_params = telemetry.add_statement_params_custom_tags(
             statement_params, model_metadata.telemetry_metadata()
         )
@@ -313,10 +312,8 @@ class ModelManager:
             statement_params, {"model_version_name": version_name_id}
         )
 
-        logger.info("Start creating MODEL object for you in the Snowflake.")
-        if progress_status:
-            progress_status.update("creating model object in Snowflake...")
-            progress_status.increment()
+        progress_status.update("creating model object in Snowflake...")
+        progress_status.increment()
 
         self._model_ops.create_from_stage(
             composed_model=mc,
@@ -343,9 +340,8 @@ class ModelManager:
             version_name=version_name_id,
         )
 
-        if progress_status:
-            progress_status.update("setting model metadata...")
-            progress_status.increment()
+        progress_status.update("setting model metadata...")
+        progress_status.increment()
 
         if comment:
             mv.comment = comment
@@ -360,8 +356,7 @@ class ModelManager:
                 statement_params=statement_params,
             )
 
-        if progress_status:
-            progress_status.update("model logged successfully!")
+        progress_status.update("model logged successfully!")
 
         return mv
 

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -0,0 +1,105 @@
+import warnings
+from dataclasses import dataclass
+from typing import Optional
+
+from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml.model import type_hints as model_types
+
+
+@dataclass
+class ReconciledParameters:
+    """Holds the reconciled and validated parameters after processing."""
+
+    conda_dependencies: Optional[list[str]] = None
+    pip_requirements: Optional[list[str]] = None
+    target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None
+    artifact_repository_map: Optional[dict[str, str]] = None
+    options: Optional[model_types.ModelSaveOption] = None
+    save_location: Optional[str] = None
+
+
+class ModelParameterReconciler:
+    """Centralizes all complex log_model parameter validation, transformation, and reconciliation logic."""
+
+    def __init__(
+        self,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+        conda_dependencies: Optional[list[str]] = None,
+        pip_requirements: Optional[list[str]] = None,
+        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        artifact_repository_map: Optional[dict[str, str]] = None,
+        options: Optional[model_types.ModelSaveOption] = None,
+    ) -> None:
+        self._database_name = database_name
+        self._schema_name = schema_name
+        self._conda_dependencies = conda_dependencies
+        self._pip_requirements = pip_requirements
+        self._target_platforms = target_platforms
+        self._artifact_repository_map = artifact_repository_map
+        self._options = options
+
+    def reconcile(self) -> ReconciledParameters:
+        """Perform all parameter reconciliation and return clean parameters."""
+        reconciled_artifact_repository_map = self._reconcile_artifact_repository_map()
+        reconciled_save_location = self._extract_save_location()
+
+        self._validate_pip_requirements_warehouse_compatibility(reconciled_artifact_repository_map)
+
+        return ReconciledParameters(
+            conda_dependencies=self._conda_dependencies,
+            pip_requirements=self._pip_requirements,
+            target_platforms=self._target_platforms,
+            artifact_repository_map=reconciled_artifact_repository_map,
+            options=self._options,
+            save_location=reconciled_save_location,
+        )
+
+    def _reconcile_artifact_repository_map(self) -> Optional[dict[str, str]]:
+        """Transform artifact_repository_map to use fully qualified names."""
+        if not self._artifact_repository_map:
+            return None
+
+        transformed_map = {}
+
+        for channel, artifact_repository_name in self._artifact_repository_map.items():
+            db_id, schema_id, repo_id = sql_identifier.parse_fully_qualified_name(artifact_repository_name)
+
+            transformed_map[channel] = sql_identifier.get_fully_qualified_name(
+                db_id,
+                schema_id,
+                repo_id,
+                self._database_name,
+                self._schema_name,
+            )
+
+        return transformed_map
+
+    def _extract_save_location(self) -> Optional[str]:
+        """Extract save_location from options."""
+        if self._options and "save_location" in self._options:
+            return self._options.get("save_location")
+
+        return None
+
+    def _validate_pip_requirements_warehouse_compatibility(
+        self, artifact_repository_map: Optional[dict[str, str]]
+    ) -> None:
+        """Validate pip_requirements compatibility with warehouse deployment."""
+        if self._pip_requirements and not artifact_repository_map and self._targets_warehouse(self._target_platforms):
+            warnings.warn(
+                "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,
+            )
+
+    @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/registry/registry.py

@@ -1,4 +1,3 @@
-import warnings
 from types import ModuleType
 from typing import Any, Optional, Union, overload
 
@@ -442,15 +441,6 @@ class Registry:
             if task is not type_hints.Task.UNKNOWN:
                 raise ValueError("`task` cannot be specified when calling log_model with a ModelVersion.")
 
-        if pip_requirements and not artifact_repository_map and self._targets_warehouse(target_platforms):
-            warnings.warn(
-                "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,
-            )
-
         registry_event_handler = event_handler.ModelEventHandler()
         with registry_event_handler.status("Logging model", total=6) as status:
             # Step 1: Validation and setup
@@ -662,12 +652,3 @@ 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[type_hints.SupportedTargetPlatformType]]) -> bool:
-        """Returns True if warehouse is a target platform (None defaults to True)."""
-        return (
-            target_platforms is None
-            or type_hints.TargetPlatform.WAREHOUSE in target_platforms
-            or "WAREHOUSE" in target_platforms
-        )

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.9.1"
+VERSION = "1.10.0"