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

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