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

snowflake/ml/model/_client/ops/service_ops.py

@@ -96,11 +96,13 @@ class ServiceLogMetadata:
         msg: str,
         is_model_build_service_done: bool,
         is_model_logger_service_done: bool,
+        operation_id: str,
         propagate: bool = False,
     ) -> None:
         to_service_logger = service_logger.get_logger(
             f"{to_service.display_service_name}-{to_service.instance_id}",
             to_service.log_color,
+            operation_id=operation_id,
         )
         to_service_logger.propagate = propagate
         self.service_logger = to_service_logger
@@ -178,9 +180,7 @@ class ServiceOperator:
         service_name: sql_identifier.SqlIdentifier,
         image_build_compute_pool_name: sql_identifier.SqlIdentifier,
         service_compute_pool_name: sql_identifier.SqlIdentifier,
-        image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_name: sql_identifier.SqlIdentifier,
+        image_repo: str,
         ingress_enabled: bool,
         max_instances: int,
         cpu_requests: Optional[str],
@@ -191,11 +191,15 @@ class ServiceOperator:
         force_rebuild: bool,
         build_external_access_integrations: Optional[list[sql_identifier.SqlIdentifier]],
         block: bool,
+        progress_status: type_hints.ProgressStatus,
         statement_params: Optional[dict[str, Any]] = None,
         # hf model
         hf_model_args: Optional[HFModelArgs] = None,
     ) -> Union[str, async_job.AsyncJob]:
 
+        # Generate operation ID for this deployment
+        operation_id = service_logger.get_operation_id()
+
         # Fall back to the registry's database and schema if not provided
         database_name = database_name or self._database_name
         schema_name = schema_name or self._schema_name
@@ -204,8 +208,17 @@ class ServiceOperator:
         service_database_name = service_database_name or database_name or self._database_name
         service_schema_name = service_schema_name or schema_name or self._schema_name
 
+        # Parse image repo
+        image_repo_database_name, image_repo_schema_name, image_repo_name = sql_identifier.parse_fully_qualified_name(
+            image_repo
+        )
         image_repo_database_name = image_repo_database_name or database_name or self._database_name
         image_repo_schema_name = image_repo_schema_name or schema_name or self._schema_name
+
+        # Step 1: Preparing deployment artifacts
+        progress_status.update("preparing deployment artifacts...")
+        progress_status.increment()
+
         if self._workspace:
             stage_path = self._create_temp_stage(database_name, schema_name, statement_params)
         else:
@@ -254,6 +267,11 @@ class ServiceOperator:
                 **(hf_model_args.hf_model_kwargs if hf_model_args.hf_model_kwargs else {}),
             )
         spec_yaml_str_or_path = self._model_deployment_spec.save()
+
+        # Step 2: Uploading deployment artifacts
+        progress_status.update("uploading deployment artifacts...")
+        progress_status.increment()
+
         if self._workspace:
             assert stage_path is not None
             file_utils.upload_directory_to_stage(
@@ -276,6 +294,10 @@ class ServiceOperator:
             statement_params=statement_params,
         )
 
+        # Step 3: Initiating model deployment
+        progress_status.update("initiating model deployment...")
+        progress_status.increment()
+
         # deploy the model service
         query_id, async_job = self._service_client.deploy_model(
             stage_path=stage_path if self._workspace else None,
@@ -327,17 +349,68 @@ class ServiceOperator:
             model_inference_service=model_inference_service,
             model_inference_service_exists=model_inference_service_exists,
             force_rebuild=force_rebuild,
+            operation_id=operation_id,
             statement_params=statement_params,
         )
 
         if block:
-            log_thread.join()
+            try:
+                # Step 4: Starting model build: waits for build to start
+                progress_status.update("starting model image build...")
+                progress_status.increment()
+
+                # Poll for model build to start if not using existing service
+                if not model_inference_service_exists:
+                    self._wait_for_service_status(
+                        model_build_service_name,
+                        service_sql.ServiceStatus.RUNNING,
+                        service_database_name,
+                        service_schema_name,
+                        async_job,
+                        statement_params,
+                    )
 
-            res = cast(str, cast(list[row.Row], async_job.result())[0][0])
-            module_logger.info(f"Inference service {service_name} deployment complete: {res}")
-            return res
-        else:
-            return async_job
+                # Step 5: Building model image
+                progress_status.update("building model image...")
+                progress_status.increment()
+
+                # Poll for model build completion
+                if not model_inference_service_exists:
+                    self._wait_for_service_status(
+                        model_build_service_name,
+                        service_sql.ServiceStatus.DONE,
+                        service_database_name,
+                        service_schema_name,
+                        async_job,
+                        statement_params,
+                    )
+
+                # Step 6: Deploying model service (push complete, starting inference service)
+                progress_status.update("deploying model service...")
+                progress_status.increment()
+
+                log_thread.join()
+
+                res = cast(str, cast(list[row.Row], async_job.result())[0][0])
+                module_logger.info(f"Inference service {service_name} deployment complete: {res}")
+                return res
+
+            except RuntimeError as e:
+                # Handle service creation/deployment failures
+                error_msg = f"Model service deployment failed: {str(e)}"
+                module_logger.error(error_msg)
+
+                # Update progress status to show failure
+                progress_status.update(error_msg, state="error")
+
+                # Stop the log thread if it's running
+                if "log_thread" in locals() and log_thread.is_alive():
+                    log_thread.join(timeout=5)  # Give it a few seconds to finish gracefully
+
+                # Re-raise the exception to propagate the error
+                raise RuntimeError(error_msg) from e
+
+        return async_job
 
     def _start_service_log_streaming(
         self,
@@ -347,6 +420,7 @@ class ServiceOperator:
         model_inference_service: ServiceLogInfo,
         model_inference_service_exists: bool,
         force_rebuild: bool,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> threading.Thread:
         """Start the service log streaming in a separate thread."""
@@ -360,6 +434,7 @@ class ServiceOperator:
                 model_inference_service,
                 model_inference_service_exists,
                 force_rebuild,
+                operation_id,
                 statement_params,
             ),
         )
@@ -372,6 +447,7 @@ class ServiceOperator:
         service_log_meta: ServiceLogMetadata,
         model_build_service: ServiceLogInfo,
         model_inference_service: ServiceLogInfo,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Helper function to fetch logs and update the service log metadata if needed.
@@ -386,6 +462,7 @@ class ServiceOperator:
             service_log_meta: The ServiceLogMetadata holds the state of the service log metadata.
             model_build_service: The ServiceLogInfo for the model build service.
             model_inference_service: The ServiceLogInfo for the model inference service.
+            operation_id: The operation ID for the service, e.g. "model_deploy_a1b2c3d4_1703875200"
             statement_params: The statement parameters to use for the service client.
         """
 
@@ -415,6 +492,7 @@ class ServiceOperator:
                     "Model build is not rebuilding the inference image, but using a previously built image.",
                     is_model_build_service_done=True,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
 
         try:
@@ -488,6 +566,7 @@ class ServiceOperator:
                     f"Model Logger service {service.display_service_name} complete.",
                     is_model_build_service_done=False,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
             # check if model build service is done
             # and transition the service log metadata to the model inference service
@@ -497,6 +576,7 @@ class ServiceOperator:
                     f"Image build service {service.display_service_name} complete.",
                     is_model_build_service_done=True,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
             else:
                 module_logger.warning(f"Service {service.display_service_name} is done, but not transitioning.")
@@ -509,6 +589,7 @@ class ServiceOperator:
         model_inference_service: ServiceLogInfo,
         model_inference_service_exists: bool,
         force_rebuild: bool,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Stream service logs while the async job is running."""
@@ -516,14 +597,14 @@ class ServiceOperator:
         model_build_service_logger = service_logger.get_logger(  # BuildJobName
             model_build_service.display_service_name,
             model_build_service.log_color,
+            operation_id=operation_id,
         )
-        model_build_service_logger.propagate = False
         if model_logger_service:
             model_logger_service_logger = service_logger.get_logger(  # ModelLoggerName
                 model_logger_service.display_service_name,
                 model_logger_service.log_color,
+                operation_id=operation_id,
             )
-            model_logger_service_logger.propagate = False
 
             service_log_meta = ServiceLogMetadata(
                 service_logger=model_logger_service_logger,
@@ -557,6 +638,7 @@ class ServiceOperator:
                     force_rebuild=force_rebuild,
                     model_build_service=model_build_service,
                     model_inference_service=model_inference_service,
+                    operation_id=operation_id,
                     statement_params=statement_params,
                 )
             except Exception as ex:
@@ -564,6 +646,7 @@ class ServiceOperator:
                 is_snowpark_sql_exception = isinstance(ex, exceptions.SnowparkSQLException)
                 contains_msg = any(msg in str(ex) for msg in ["Pending scheduling", "Waiting to start"])
                 matches_pattern = service_log_meta.service_status is None and re.search(pattern, str(ex)) is not None
+
                 if not (is_snowpark_sql_exception and (contains_msg or matches_pattern)):
                     module_logger.warning(f"Caught an exception when logging: {repr(ex)}")
                 time.sleep(5)
@@ -603,6 +686,101 @@ class ServiceOperator:
         except Exception as ex:
             module_logger.warning(f"Caught an exception when logging: {repr(ex)}")
 
+    def _wait_for_service_status(
+        self,
+        service_name: sql_identifier.SqlIdentifier,
+        target_status: service_sql.ServiceStatus,
+        service_database_name: Optional[sql_identifier.SqlIdentifier],
+        service_schema_name: Optional[sql_identifier.SqlIdentifier],
+        async_job: snowpark.AsyncJob,
+        statement_params: Optional[dict[str, Any]] = None,
+        timeout_minutes: int = 30,
+    ) -> None:
+        """Wait for service to reach the specified status while monitoring async job for failures.
+
+        Args:
+            service_name: The service to monitor
+            target_status: The target status to wait for
+            service_database_name: Database containing the service
+            service_schema_name: Schema containing the service
+            async_job: The async job to monitor for completion/failure
+            statement_params: SQL statement parameters
+            timeout_minutes: Maximum time to wait before timing out
+
+        Raises:
+            RuntimeError: If service fails, times out, or enters an error state
+        """
+        start_time = time.time()
+        timeout_seconds = timeout_minutes * 60
+        service_seen_before = False
+
+        while True:
+            # Check if async job has failed (but don't return on success - we need specific service status)
+            if async_job.is_done():
+                try:
+                    async_job.result()
+                    # Async job completed successfully, but we're waiting for a specific service status
+                    # This might mean the service completed and was cleaned up
+                    module_logger.debug(
+                        f"Async job completed but we're still waiting for {service_name} to reach {target_status.value}"
+                    )
+                except Exception as e:
+                    raise RuntimeError(f"Service deployment failed: {e}")
+
+            try:
+                statuses = self._service_client.get_service_container_statuses(
+                    database_name=service_database_name,
+                    schema_name=service_schema_name,
+                    service_name=service_name,
+                    include_message=True,
+                    statement_params=statement_params,
+                )
+
+                if statuses:
+                    service_seen_before = True
+                    current_status = statuses[0].service_status
+
+                    # Check if we've reached the target status
+                    if current_status == target_status:
+                        return
+
+                    # Check for failure states
+                    if current_status in [service_sql.ServiceStatus.FAILED, service_sql.ServiceStatus.INTERNAL_ERROR]:
+                        error_msg = f"Service {service_name} failed with status {current_status.value}"
+                        if statuses[0].message:
+                            error_msg += f": {statuses[0].message}"
+                        raise RuntimeError(error_msg)
+
+            except exceptions.SnowparkSQLException as e:
+                # Service might not exist yet - this is expected during initial deployment
+                if "does not exist" in str(e) or "002003" in str(e):
+                    # If we're waiting for DONE status and we've seen the service before,
+                    # it likely completed and was cleaned up
+                    if target_status == service_sql.ServiceStatus.DONE and service_seen_before:
+                        module_logger.debug(
+                            f"Service {service_name} disappeared after being seen, "
+                            f"assuming it reached {target_status.value} and was cleaned up"
+                        )
+                        return
+
+                    module_logger.debug(f"Service {service_name} not found yet, continuing to wait...")
+                else:
+                    # Re-raise unexpected SQL exceptions
+                    raise RuntimeError(f"Error checking service status: {e}")
+            except Exception as e:
+                # Re-raise unexpected exceptions instead of masking them
+                raise RuntimeError(f"Unexpected error while waiting for service status: {e}")
+
+            # Check timeout
+            elapsed_time = time.time() - start_time
+            if elapsed_time > timeout_seconds:
+                raise RuntimeError(
+                    f"Timeout waiting for service {service_name} to reach status {target_status.value} "
+                    f"after {timeout_minutes} minutes"
+                )
+
+            time.sleep(2)  # Poll every 2 seconds
+
     @staticmethod
     def _get_service_id_from_deployment_step(query_id: str, deployment_step: DeploymentStep) -> str:
         """Get the service ID through the server-side logic."""
@@ -660,9 +838,7 @@ class ServiceOperator:
         job_name: sql_identifier.SqlIdentifier,
         compute_pool_name: sql_identifier.SqlIdentifier,
         warehouse_name: sql_identifier.SqlIdentifier,
-        image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_name: sql_identifier.SqlIdentifier,
+        image_repo: str,
         output_table_database_name: Optional[sql_identifier.SqlIdentifier],
         output_table_schema_name: Optional[sql_identifier.SqlIdentifier],
         output_table_name: sql_identifier.SqlIdentifier,
@@ -683,6 +859,10 @@ class ServiceOperator:
         job_database_name = job_database_name or database_name or self._database_name
         job_schema_name = job_schema_name or schema_name or self._schema_name
 
+        # Parse image repo
+        image_repo_database_name, image_repo_schema_name, image_repo_name = sql_identifier.parse_fully_qualified_name(
+            image_repo
+        )
         image_repo_database_name = image_repo_database_name or database_name or self._database_name
         image_repo_schema_name = image_repo_schema_name or schema_name or self._schema_name
 

snowflake/ml/model/_client/sql/service.py

@@ -2,7 +2,7 @@ import dataclasses
 import enum
 import logging
 import textwrap
-from typing import Any, Optional, Union
+from typing import Any, Optional
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import (
@@ -69,43 +69,6 @@ class ServiceSQLClient(_base._BaseSQLClient):
     CONTAINER_STATUS = "status"
     MESSAGE = "message"
 
-    def build_model_container(
-        self,
-        *,
-        database_name: Optional[sql_identifier.SqlIdentifier],
-        schema_name: Optional[sql_identifier.SqlIdentifier],
-        model_name: sql_identifier.SqlIdentifier,
-        version_name: sql_identifier.SqlIdentifier,
-        compute_pool_name: sql_identifier.SqlIdentifier,
-        image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_name: sql_identifier.SqlIdentifier,
-        gpu: Optional[Union[str, int]],
-        force_rebuild: bool,
-        external_access_integration: sql_identifier.SqlIdentifier,
-        statement_params: Optional[dict[str, Any]] = None,
-    ) -> None:
-        actual_image_repo_database = image_repo_database_name or self._database_name
-        actual_image_repo_schema = image_repo_schema_name or self._schema_name
-        actual_model_database = database_name or self._database_name
-        actual_model_schema = schema_name or self._schema_name
-        fq_model_name = self.fully_qualified_object_name(actual_model_database, actual_model_schema, model_name)
-        fq_image_repo_name = identifier.get_schema_level_object_identifier(
-            actual_image_repo_database.identifier(),
-            actual_image_repo_schema.identifier(),
-            image_repo_name.identifier(),
-        )
-        is_gpu_str = "TRUE" if gpu else "FALSE"
-        force_rebuild_str = "TRUE" if force_rebuild else "FALSE"
-        query_result_checker.SqlResultValidator(
-            self._session,
-            (
-                f"CALL SYSTEM$BUILD_MODEL_CONTAINER('{fq_model_name}', '{version_name}', '{compute_pool_name}',"
-                f" '{fq_image_repo_name}', '{is_gpu_str}', '{force_rebuild_str}', '', '{external_access_integration}')"
-            ),
-            statement_params=statement_params,
-        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
-
     def deploy_model(
         self,
         *,

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

@@ -1,3 +1,4 @@
+import logging
 import os
 import warnings
 from typing import TYPE_CHECKING, Callable, Optional, Sequence, Union, cast, final
@@ -24,6 +25,8 @@ if TYPE_CHECKING:
     import sklearn.base
     import sklearn.pipeline
 
+logger = logging.getLogger(__name__)
+
 
 def _unpack_container_runtime_pipeline(model: "sklearn.pipeline.Pipeline") -> "sklearn.pipeline.Pipeline":
     new_steps = []
@@ -201,13 +204,13 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                 explain_target_method = str(explain_target_method)  # mypy complains if we don't cast to str here
 
                 input_signature = handlers_utils.get_input_signature(model_meta, explain_target_method)
-                transformed_background_data = _apply_transforms_up_to_last_step(
-                    model=model,
-                    data=background_data,
-                    input_feature_names=[spec.name for spec in input_signature],
-                )
 
                 try:
+                    transformed_background_data = _apply_transforms_up_to_last_step(
+                        model=model,
+                        data=background_data,
+                        input_feature_names=[spec.name for spec in input_signature],
+                    )
                     model_meta = handlers_utils.add_inferred_explain_method_signature(
                         model_meta=model_meta,
                         explain_method="explain",
@@ -217,6 +220,7 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                         output_feature_names=transformed_background_data.columns,
                     )
                 except Exception:
+                    logger.debug("Explainability is disabled due to an exception.", exc_info=True)
                     if kwargs.get("enable_explainability", None):
                         # user explicitly enabled explainability, so we should raise the error
                         raise ValueError(

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -13,6 +13,7 @@ REQUIREMENTS = [
     "numpy>=1.23,<3",
     "packaging>=20.9,<25",
     "pandas>=2.1.4,<3",
+    "platformdirs<5",
     "pyarrow",
     "pydantic>=2.8.2, <3",
     "pyjwt>=2.0.0, <3",

snowflake/ml/model/_signatures/pandas_handler.py

@@ -86,6 +86,9 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
                 df_col_data = utils.series_dropna(df_col_data)
                 df_col_dtype = df_col_data.dtype
 
+            if utils.check_if_series_is_empty(df_col_data):
+                continue
+
             if df_col_dtype == np.dtype("O"):
                 # Check if all objects have the same type
                 if not all(isinstance(data_row, type(df_col_data.iloc[0])) for data_row in df_col_data):

snowflake/ml/model/_signatures/utils.py

@@ -412,3 +412,7 @@ def infer_dict(name: str, data: dict[str, Any]) -> core.FeatureGroupSpec:
             specs.append(core.FeatureSpec(name=key, dtype=core.DataType.from_numpy_type(np.array(value).dtype)))
 
     return core.FeatureGroupSpec(name=name, specs=specs)
+
+
+def check_if_series_is_empty(series: Optional[pd.Series]) -> bool:
+    return series is None or series.empty

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/model_signature.py

@@ -272,6 +272,8 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
                     ),
                 )
         else:
+            if utils.check_if_series_is_empty(data_col):
+                continue
             if isinstance(data_col.iloc[0], list):
                 if not ft_shape:
                     raise snowml_exceptions.SnowflakeMLException(