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

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

@@ -7,6 +7,7 @@ from typing import 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
@@ -53,17 +54,44 @@ class ModelManifest:
         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:
-            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 = options.get("relax_version", True)
+            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."
+                    ),
+                )
 
         runtime_to_use = model_runtime.ModelRuntime(
             name=self._DEFAULT_RUNTIME_NAME,

snowflake/ml/model/_packager/model_env/model_env.py

@@ -9,6 +9,7 @@ from packaging import requirements, version
 
 from snowflake.ml import version as snowml_version
 from snowflake.ml._internal import env as snowml_env, env_utils
+from snowflake.ml.model import type_hints as model_types
 from snowflake.ml.model._packager.model_meta import model_meta_schema
 
 # requirement: Full version requirement where name is conda package name.
@@ -30,6 +31,7 @@ class ModelEnv:
         conda_env_rel_path: Optional[str] = None,
         pip_requirements_rel_path: Optional[str] = None,
         prefer_pip: bool = False,
+        target_platforms: Optional[list[model_types.TargetPlatform]] = None,
     ) -> None:
         if conda_env_rel_path is None:
             conda_env_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_CONDA_ENV_FILENAME)
@@ -45,6 +47,8 @@ class ModelEnv:
         self._python_version: version.Version = version.parse(snowml_env.PYTHON_VERSION)
         self._cuda_version: Optional[version.Version] = None
         self._snowpark_ml_version: version.Version = version.parse(snowml_version.VERSION)
+        self._target_platforms = target_platforms
+        self._warnings_shown: set[str] = set()
 
     @property
     def conda_dependencies(self) -> list[str]:
@@ -116,6 +120,17 @@ class ModelEnv:
         if snowpark_ml_version:
             self._snowpark_ml_version = version.parse(snowpark_ml_version)
 
+    @property
+    def targets_warehouse(self) -> bool:
+        """Returns True if warehouse is a target platform."""
+        return self._target_platforms is None or model_types.TargetPlatform.WAREHOUSE in self._target_platforms
+
+    def _warn_once(self, message: str, stacklevel: int = 2) -> None:
+        """Show warning only once per ModelEnv instance."""
+        if message not in self._warnings_shown:
+            warnings.warn(message, category=UserWarning, stacklevel=stacklevel)
+            self._warnings_shown.add(message)
+
     def include_if_absent(
         self,
         pkgs: list[ModelDependency],
@@ -130,14 +145,14 @@ class ModelEnv:
         """
         if (self.pip_requirements or self.prefer_pip) and not self.conda_dependencies and pkgs:
             pip_pkg_reqs: list[str] = []
-            warnings.warn(
-                (
-                    "Dependencies specified from pip requirements."
-                    " This may prevent model deploying to Snowflake Warehouse."
-                ),
-                category=UserWarning,
-                stacklevel=2,
-            )
+            if self.targets_warehouse:
+                self._warn_once(
+                    (
+                        "Dependencies specified from pip requirements."
+                        " This may prevent model deploying to Snowflake Warehouse."
+                    ),
+                    stacklevel=2,
+                )
             for conda_req_str, pip_name in pkgs:
                 _, conda_req = env_utils._validate_conda_dependency_string(conda_req_str)
                 pip_req = requirements.Requirement(f"{pip_name}{conda_req.specifier}")
@@ -162,16 +177,15 @@ class ModelEnv:
                 req_to_add.name = conda_req.name
             else:
                 req_to_add = conda_req
-            show_warning_message = conda_req_channel == env_utils.DEFAULT_CHANNEL_NAME
+            show_warning_message = conda_req_channel == env_utils.DEFAULT_CHANNEL_NAME and self.targets_warehouse
 
             if any(added_pip_req.name == pip_name for added_pip_req in self._pip_requirements):
                 if show_warning_message:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Basic dependency {req_to_add.name} specified from pip requirements."
                             " This may prevent model deploying to Snowflake Warehouse."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
                 continue
@@ -182,12 +196,11 @@ class ModelEnv:
                 pass
             except env_utils.DuplicateDependencyInMultipleChannelsError:
                 if show_warning_message:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Basic dependency {req_to_add.name} specified from non-Snowflake channel."
                             + " This may prevent model deploying to Snowflake Warehouse."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
 
@@ -272,22 +285,20 @@ class ModelEnv:
         )
 
         for channel, channel_dependencies in conda_dependencies_dict.items():
-            if channel != env_utils.DEFAULT_CHANNEL_NAME:
-                warnings.warn(
+            if channel != env_utils.DEFAULT_CHANNEL_NAME and self.targets_warehouse:
+                self._warn_once(
                     (
                         "Found dependencies specified in the conda file from non-Snowflake channel."
                         " This may prevent model deploying to Snowflake Warehouse."
                     ),
-                    category=UserWarning,
                     stacklevel=2,
                 )
-            if len(channel_dependencies) == 0 and channel not in self._conda_dependencies:
-                warnings.warn(
+            if len(channel_dependencies) == 0 and channel not in self._conda_dependencies and self.targets_warehouse:
+                self._warn_once(
                     (
                         f"Found additional conda channel {channel} specified in the conda file."
                         " This may prevent model deploying to Snowflake Warehouse."
                     ),
-                    category=UserWarning,
                     stacklevel=2,
                 )
                 self._conda_dependencies[channel] = []
@@ -298,22 +309,20 @@ class ModelEnv:
                 except env_utils.DuplicateDependencyError:
                     pass
                 except env_utils.DuplicateDependencyInMultipleChannelsError:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Dependency {channel_dependency.name} appeared in multiple channels as conda dependency."
                             " This may be unintentional."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
 
-        if pip_requirements_list:
-            warnings.warn(
+        if pip_requirements_list and self.targets_warehouse:
+            self._warn_once(
                 (
                     "Found dependencies specified as pip requirements."
                     " This may prevent model deploying to Snowflake Warehouse."
                 ),
-                category=UserWarning,
                 stacklevel=2,
             )
             for pip_dependency in pip_requirements_list:
@@ -333,13 +342,12 @@ class ModelEnv:
     def load_from_pip_file(self, pip_requirements_path: pathlib.Path) -> None:
         pip_requirements_list = env_utils.load_requirements_file(pip_requirements_path)
 
-        if pip_requirements_list:
-            warnings.warn(
+        if pip_requirements_list and self.targets_warehouse:
+            self._warn_once(
                 (
                     "Found dependencies specified as pip requirements."
                     " This may prevent model deploying to Snowflake Warehouse."
                 ),
-                category=UserWarning,
                 stacklevel=2,
             )
             for pip_dependency in pip_requirements_list:

snowflake/ml/model/_packager/model_handlers/pytorch.py

@@ -167,7 +167,11 @@ class PyTorchHandler(_base.BaseModelHandler["torch.nn.Module"]):
         model_blob_metadata = model_blobs_metadata[name]
         model_blob_filename = model_blob_metadata.path
         with open(os.path.join(model_blob_path, model_blob_filename), "rb") as f:
-            m = torch.load(f, map_location="cuda" if kwargs.get("use_gpu", False) else "cpu")
+            m = torch.load(
+                f,
+                map_location="cuda" if kwargs.get("use_gpu", False) else "cpu",
+                weights_only=False,
+            )
         assert isinstance(m, torch.nn.Module)
 
         return m

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -110,6 +110,7 @@ def create_model_metadata(
         python_version=python_version,
         embed_local_ml_library=embed_local_ml_library,
         prefer_pip=prefer_pip,
+        target_platforms=target_platforms,
     )
 
     if embed_local_ml_library:
@@ -162,8 +163,9 @@ def _create_env_for_model_metadata(
     python_version: Optional[str] = None,
     embed_local_ml_library: bool = False,
     prefer_pip: bool = False,
+    target_platforms: Optional[list[model_types.TargetPlatform]] = None,
 ) -> model_env.ModelEnv:
-    env = model_env.ModelEnv(prefer_pip=prefer_pip)
+    env = model_env.ModelEnv(prefer_pip=prefer_pip, target_platforms=target_platforms)
 
     # Mypy doesn't like getter and setter have different types. See python/mypy #3004
     env.conda_dependencies = conda_dependencies  # type: ignore[assignment]

snowflake/ml/model/_signatures/snowpark_handler.py

@@ -60,12 +60,19 @@ class SnowparkDataFrameHandler(base_handler.BaseDataHandler[snowflake.snowpark.D
         data: snowflake.snowpark.DataFrame,
         ensure_serializable: bool = True,
         features: Optional[Sequence[core.BaseFeatureSpec]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> pd.DataFrame:
         # This method do things on top of to_pandas, to make sure the local dataframe got is in correct shape.
         dtype_map = {}
+
         if features:
+            quoted_identifiers_ignore_case = SnowparkDataFrameHandler._is_quoted_identifiers_ignore_case_enabled(
+                data.session, statement_params
+            )
             for feature in features:
-                dtype_map[feature.name] = feature.as_dtype()
+                feature_name = feature.name.upper() if quoted_identifiers_ignore_case else feature.name
+                dtype_map[feature_name] = feature.as_dtype()
+
         df_local = data.to_pandas()
 
         # This is because Array will become string (Even though the correct schema is set)
@@ -93,6 +100,7 @@ class SnowparkDataFrameHandler(base_handler.BaseDataHandler[snowflake.snowpark.D
         df: pd.DataFrame,
         keep_order: bool = False,
         features: Optional[Sequence[core.BaseFeatureSpec]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> snowflake.snowpark.DataFrame:
         # This method is necessary to create the Snowpark Dataframe in correct schema.
         # However, in this case, the order could not be preserved. Thus, a _ID column has to be added,
@@ -100,6 +108,12 @@ class SnowparkDataFrameHandler(base_handler.BaseDataHandler[snowflake.snowpark.D
         # Although in this case, the column with array type can get correct ARRAY type, however, the element
         # type is not preserved, and will become string type. This affect the implementation of convert_from_df.
         df = pandas_handler.PandasDataFrameHandler.convert_to_df(df)
+        quoted_identifiers_ignore_case = SnowparkDataFrameHandler._is_quoted_identifiers_ignore_case_enabled(
+            session, statement_params
+        )
+        if quoted_identifiers_ignore_case:
+            df.columns = [str(col).upper() for col in df.columns]
+
         df_cols = df.columns
         if df_cols.dtype != np.object_:
             raise snowml_exceptions.SnowflakeMLException(
@@ -116,9 +130,47 @@ class SnowparkDataFrameHandler(base_handler.BaseDataHandler[snowflake.snowpark.D
         column_names = []
         columns = []
         for feature in features:
-            column_names.append(identifier.get_inferred_name(feature.name))
-            columns.append(F.col(identifier.get_inferred_name(feature.name)).cast(feature.as_snowpark_type()))
+            feature_name = identifier.get_inferred_name(feature.name)
+            if quoted_identifiers_ignore_case:
+                feature_name = feature_name.upper()
+            column_names.append(feature_name)
+            columns.append(F.col(feature_name).cast(feature.as_snowpark_type()))
 
         sp_df = sp_df.with_columns(column_names, columns)
 
         return sp_df
+
+    @staticmethod
+    def _is_quoted_identifiers_ignore_case_enabled(
+        session: snowflake.snowpark.Session, statement_params: Optional[dict[str, Any]] = None
+    ) -> bool:
+        """
+        Check if QUOTED_IDENTIFIERS_IGNORE_CASE parameter is enabled.
+
+        Args:
+            session: Snowpark session to check parameter for
+            statement_params: Optional statement parameters to check first
+
+        Returns:
+            bool: True if QUOTED_IDENTIFIERS_IGNORE_CASE is enabled, False otherwise
+            Returns False if the parameter cannot be retrieved (e.g., in stored procedures)
+        """
+        if statement_params is not None:
+            for key, value in statement_params.items():
+                if key.upper() == "QUOTED_IDENTIFIERS_IGNORE_CASE":
+                    parameter_value = str(value)
+                    return parameter_value.lower() == "true"
+
+        try:
+            result = session.sql(
+                "SHOW PARAMETERS LIKE 'QUOTED_IDENTIFIERS_IGNORE_CASE' IN SESSION",
+                _emit_ast=False,
+            ).collect(_emit_ast=False)
+
+            parameter_value = str(result[0].value)
+            return parameter_value.lower() == "true"
+
+        except Exception:
+            # Parameter query can fail in certain environments (e.g., in stored procedures)
+            # In that case, assume default behavior (case-sensitive)
+            return False

snowflake/ml/model/target_platform.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class TargetPlatform(Enum):
+    WAREHOUSE = "WAREHOUSE"
+    SNOWPARK_CONTAINER_SERVICES = "SNOWPARK_CONTAINER_SERVICES"
+
+
+WAREHOUSE_ONLY = [TargetPlatform.WAREHOUSE]
+SNOWPARK_CONTAINER_SERVICES_ONLY = [TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
+BOTH_WAREHOUSE_AND_SNOWPARK_CONTAINER_SERVICES = [TargetPlatform.WAREHOUSE, TargetPlatform.SNOWPARK_CONTAINER_SERVICES]

snowflake/ml/model/task.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class Task(Enum):
+    UNKNOWN = "UNKNOWN"
+    TABULAR_BINARY_CLASSIFICATION = "TABULAR_BINARY_CLASSIFICATION"
+    TABULAR_MULTI_CLASSIFICATION = "TABULAR_MULTI_CLASSIFICATION"
+    TABULAR_REGRESSION = "TABULAR_REGRESSION"
+    TABULAR_RANKING = "TABULAR_RANKING"

snowflake/ml/model/type_hints.py

@@ -1,10 +1,12 @@
 # mypy: disable-error-code="import"
-from enum import Enum
 from typing import TYPE_CHECKING, Literal, Sequence, TypedDict, TypeVar, Union
 
 import numpy.typing as npt
 from typing_extensions import NotRequired
 
+from snowflake.ml.model.target_platform import TargetPlatform
+from snowflake.ml.model.task import Task
+
 if TYPE_CHECKING:
     import catboost
     import keras
@@ -321,17 +323,7 @@ ModelLoadOption = Union[
 ]
 
 
-class Task(Enum):
-    UNKNOWN = "UNKNOWN"
-    TABULAR_BINARY_CLASSIFICATION = "TABULAR_BINARY_CLASSIFICATION"
-    TABULAR_MULTI_CLASSIFICATION = "TABULAR_MULTI_CLASSIFICATION"
-    TABULAR_REGRESSION = "TABULAR_REGRESSION"
-    TABULAR_RANKING = "TABULAR_RANKING"
-
-
-class TargetPlatform(Enum):
-    WAREHOUSE = "WAREHOUSE"
-    SNOWPARK_CONTAINER_SERVICES = "SNOWPARK_CONTAINER_SERVICES"
+SupportedTargetPlatformType = Union[TargetPlatform, str]
 
 
-SupportedTargetPlatformType = Union[TargetPlatform, str]
+__all__ = ["TargetPlatform", "Task"]

snowflake/ml/modeling/metrics/metrics_utils.py

@@ -60,6 +60,7 @@ def register_accumulator_udtf(*, session: Session, statement_params: dict[str, A
         ),
         input_types=[T.BinaryType()],
         packages=[f"numpy=={np.__version__}", f"cloudpickle=={cloudpickle.__version__}"],
+        imports=[],  # Prevents unnecessary import resolution.
         name=accumulator,
         is_permanent=False,
         replace=True,
@@ -175,6 +176,7 @@ def register_sharded_dot_sum_computer(*, session: Session, statement_params: dic
         ),
         input_types=[T.ArrayType(), T.IntegerType(), T.IntegerType()],
         packages=[f"numpy=={np.__version__}", f"cloudpickle=={cloudpickle.__version__}"],
+        imports=[],  # Prevents unnecessary import resolution.
         name=sharded_dot_and_sum_computer,
         is_permanent=False,
         replace=True,

snowflake/ml/registry/_manager/model_manager.py

@@ -1,5 +1,5 @@
 from types import ModuleType
-from typing import Any, Optional, Union
+from typing import Any, Optional, Protocol, Union
 
 import pandas as pd
 from absl.logging import logging
@@ -8,7 +8,7 @@ from snowflake.ml._internal import env, platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.model import model_signature, type_hints as model_types
+from snowflake.ml.model import model_signature, target_platform, task, type_hints
 from snowflake.ml.model._client.model import model_impl, model_version_impl
 from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
 from snowflake.ml.model._model_composer import model_composer
@@ -20,6 +20,14 @@ from snowflake.snowpark._internal import utils as snowpark_utils
 logger = logging.getLogger(__name__)
 
 
+class EventHandler(Protocol):
+    """Protocol defining the interface for event handlers used during model operations."""
+
+    def update(self, message: str) -> None:
+        """Update with a progress message."""
+        ...
+
+
 class ModelManager:
     def __init__(
         self,
@@ -41,7 +49,7 @@ class ModelManager:
     def log_model(
         self,
         *,
-        model: Union[model_types.SupportedModelType, model_version_impl.ModelVersion],
+        model: Union[type_hints.SupportedModelType, model_version_impl.ModelVersion],
         model_name: str,
         version_name: Optional[str] = None,
         comment: Optional[str] = None,
@@ -50,16 +58,17 @@ class ModelManager:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         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,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: type_hints.Task = task.Task.UNKNOWN,
+        options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
+        event_handler: EventHandler,
     ) -> model_version_impl.ModelVersion:
 
         database_name_id, schema_name_id, model_name_id = self._parse_fully_qualified_name(model_name)
@@ -143,11 +152,12 @@ class ModelManager:
             task=task,
             options=options,
             statement_params=statement_params,
+            event_handler=event_handler,
         )
 
     def _log_model(
         self,
-        model: model_types.SupportedModelType,
+        model: type_hints.SupportedModelType,
         *,
         model_name: str,
         version_name: str,
@@ -157,16 +167,17 @@ class ModelManager:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         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,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: type_hints.Task = task.Task.UNKNOWN,
+        options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
+        event_handler: EventHandler,
     ) -> 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)
@@ -215,7 +226,7 @@ class ModelManager:
         # User specified target platforms are defaulted to None and will not show up in the generated manifest.
         if target_platforms:
             # Convert any string target platforms to TargetPlatform objects
-            platforms = [model_types.TargetPlatform(platform) for platform in target_platforms]
+            platforms = [type_hints.TargetPlatform(platform) for platform in target_platforms]
         else:
             # Default the target platform to warehouse if not specified and any table function exists
             if options and (
@@ -231,7 +242,7 @@ class ModelManager:
                     "Logging a partitioned model with a table function without specifying `target_platforms`. "
                     'Default to `target_platforms=["WAREHOUSE"]`.'
                 )
-                platforms = [model_types.TargetPlatform.WAREHOUSE]
+                platforms = [target_platform.TargetPlatform.WAREHOUSE]
 
             # Default the target platform to SPCS if not specified when running in ML runtime
             if not platforms and env.IN_ML_RUNTIME:
@@ -239,7 +250,7 @@ class ModelManager:
                     "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
                     'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
                 )
-                platforms = [model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
+                platforms = [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
 
         if artifact_repository_map:
             for channel, artifact_repository_name in artifact_repository_map.items():
@@ -254,6 +265,7 @@ class ModelManager:
                 )
 
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
+        event_handler.update("📦 Packaging model...")
 
         # Extract save_location from options if present
         save_location = None
@@ -292,6 +304,7 @@ class ModelManager:
         )
 
         logger.info("Start creating MODEL object for you in the Snowflake.")
+        event_handler.update("🏗️ Creating model object in Snowflake...")
 
         self._model_ops.create_from_stage(
             composed_model=mc,
@@ -331,6 +344,8 @@ class ModelManager:
                 statement_params=statement_params,
             )
 
+        event_handler.update("✅ Model logged successfully!")
+
         return mv
 
     def get_model(