snowflake-ml-python 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

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

@@ -4,7 +4,7 @@ import os
 import pathlib
 import tempfile
 import warnings
-from typing import Any, Dict, List, Literal, Optional, TypedDict, Union, cast, overload
+from typing import Any, Literal, Optional, TypedDict, Union, cast, overload
 
 import yaml
 
@@ -104,7 +104,7 @@ class ModelOperator:
         *,
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> str:
         stage_name = sql_identifier.SqlIdentifier(
             snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
@@ -137,7 +137,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> ModelAction:
         if self.validate_existence(
             database_name=database_name,
@@ -169,7 +169,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         model_action = self.get_model_action_from_model_name_and_version(
             database_name=database_name,
@@ -205,7 +205,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
         use_live_commit: Optional[bool] = False,
     ) -> None:
 
@@ -263,7 +263,7 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         model_exists: bool,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         if model_exists:
             return self._model_version_client.add_version_from_model_version(
@@ -296,8 +296,8 @@ class ModelOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> List[row.Row]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> list[row.Row]:
         if model_name:
             return self._model_client.show_versions(
                 database_name=database_name,
@@ -320,8 +320,8 @@ class ModelOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> List[sql_identifier.SqlIdentifier]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> list[sql_identifier.SqlIdentifier]:
         res = self.show_models_or_versions(
             database_name=database_name,
             schema_name=schema_name,
@@ -341,7 +341,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> bool:
         if version_name:
             res = self._model_client.show_versions(
@@ -369,7 +369,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> str:
         if version_name:
             res = self._model_client.show_versions(
@@ -398,7 +398,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         if version_name:
             self._model_version_client.set_comment(
@@ -426,7 +426,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._model_version_client.set_alias(
             alias_name=alias_name,
@@ -444,7 +444,7 @@ class ModelOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._model_version_client.unset_alias(
             database_name=database_name,
@@ -461,7 +461,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         if not self.validate_existence(
             database_name=database_name,
@@ -485,7 +485,7 @@ class ModelOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> sql_identifier.SqlIdentifier:
         res = self._model_client.show_models(
             database_name=database_name,
@@ -504,7 +504,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         alias_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> Optional[sql_identifier.SqlIdentifier]:
         res = self._model_client.show_versions(
             database_name=database_name,
@@ -528,7 +528,7 @@ class ModelOperator:
         tag_database_name: Optional[sql_identifier.SqlIdentifier],
         tag_schema_name: Optional[sql_identifier.SqlIdentifier],
         tag_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> Optional[str]:
         r = self._tag_client.get_tag_value(
             database_name=database_name,
@@ -550,15 +550,15 @@ class ModelOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, str]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> dict[str, str]:
         tags_info = self._tag_client.get_tag_list(
             database_name=database_name,
             schema_name=schema_name,
             model_name=model_name,
             statement_params=statement_params,
         )
-        res: Dict[str, str] = {
+        res: dict[str, str] = {
             identifier.get_schema_level_object_identifier(
                 sql_identifier.SqlIdentifier(r.TAG_DATABASE, case_sensitive=True),
                 sql_identifier.SqlIdentifier(r.TAG_SCHEMA, case_sensitive=True),
@@ -578,7 +578,7 @@ class ModelOperator:
         tag_schema_name: Optional[sql_identifier.SqlIdentifier],
         tag_name: sql_identifier.SqlIdentifier,
         tag_value: str,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._tag_client.set_tag_on_model(
             database_name=database_name,
@@ -600,7 +600,7 @@ class ModelOperator:
         tag_database_name: Optional[sql_identifier.SqlIdentifier],
         tag_schema_name: Optional[sql_identifier.SqlIdentifier],
         tag_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._tag_client.unset_tag_on_model(
             database_name=database_name,
@@ -619,8 +619,8 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> List[ServiceInfo]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> list[ServiceInfo]:
         res = self._model_client.show_versions(
             database_name=database_name,
             schema_name=schema_name,
@@ -682,7 +682,7 @@ class ModelOperator:
         service_database_name: Optional[sql_identifier.SqlIdentifier],
         service_schema_name: Optional[sql_identifier.SqlIdentifier],
         service_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         services = self.show_services(
             database_name=database_name,
@@ -724,7 +724,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> model_manifest_schema.ModelManifestDict:
         with tempfile.TemporaryDirectory() as tmpdir:
             self._model_version_client.get_file(
@@ -741,9 +741,9 @@ class ModelOperator:
 
     @staticmethod
     def _match_model_spec_with_sql_functions(
-        sql_functions_names: List[sql_identifier.SqlIdentifier], target_methods: List[str]
-    ) -> Dict[sql_identifier.SqlIdentifier, str]:
-        res: Dict[sql_identifier.SqlIdentifier, str] = {}
+        sql_functions_names: list[sql_identifier.SqlIdentifier], target_methods: list[str]
+    ) -> dict[sql_identifier.SqlIdentifier, str]:
+        res: dict[sql_identifier.SqlIdentifier, str] = {}
 
         for target_method in target_methods:
             # Here we need to find the SQL function corresponding to the Python function.
@@ -766,7 +766,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> model_meta_schema.ModelMetadataDict:
         raw_model_spec_res = self._model_client.show_versions(
             database_name=database_name,
@@ -787,7 +787,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> type_hints.Task:
         model_version = self._model_client.show_versions(
             database_name=database_name,
@@ -809,8 +809,8 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> List[model_manifest_schema.ModelFunctionInfo]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> list[model_manifest_schema.ModelFunctionInfo]:
         model_spec = self._fetch_model_spec(
             database_name=database_name,
             schema_name=schema_name,
@@ -907,7 +907,7 @@ class ModelOperator:
         version_name: sql_identifier.SqlIdentifier,
         strict_input_validation: bool = False,
         partition_column: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, str]] = None,
+        statement_params: Optional[dict[str, str]] = None,
         is_partitioned: Optional[bool] = None,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         ...
@@ -923,7 +923,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         service_name: sql_identifier.SqlIdentifier,
         strict_input_validation: bool = False,
-        statement_params: Optional[Dict[str, str]] = None,
+        statement_params: Optional[dict[str, str]] = None,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         ...
 
@@ -941,7 +941,7 @@ class ModelOperator:
         service_name: Optional[sql_identifier.SqlIdentifier] = None,
         strict_input_validation: bool = False,
         partition_column: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, str]] = None,
+        statement_params: Optional[dict[str, str]] = None,
         is_partitioned: Optional[bool] = None,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         identifier_rule = model_signature.SnowparkIdentifierRule.INFERRED
@@ -1059,7 +1059,7 @@ class ModelOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: Optional[sql_identifier.SqlIdentifier] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         if version_name:
             self._model_version_client.drop_version(
@@ -1086,7 +1086,7 @@ class ModelOperator:
         new_model_db: Optional[sql_identifier.SqlIdentifier],
         new_model_schema: Optional[sql_identifier.SqlIdentifier],
         new_model_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._model_client.rename(
             database_name=database_name,
@@ -1121,7 +1121,7 @@ class ModelOperator:
         version_name: sql_identifier.SqlIdentifier,
         target_path: pathlib.Path,
         mode: Literal["full", "model", "minimal"] = "model",
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         for remote_rel_path, is_dir in self.MODEL_FILE_DOWNLOAD_PATTERN[mode].items():
             list_file_res = self._model_version_client.list_file(

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

@@ -6,14 +6,16 @@ import re
 import tempfile
 import threading
 import time
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Optional, Union, cast
 
 from snowflake import snowpark
 from snowflake.ml._internal import file_utils, platform_capabilities as pc
-from snowflake.ml._internal.utils import service_logger, sql_identifier
+from snowflake.ml._internal.utils import identifier, service_logger, sql_identifier
+from snowflake.ml.model import model_signature, type_hints
 from snowflake.ml.model._client.service import model_deployment_spec
 from snowflake.ml.model._client.sql import service as service_sql, stage as stage_sql
-from snowflake.snowpark import async_job, exceptions, row, session
+from snowflake.ml.model._signatures import snowpark_handler
+from snowflake.snowpark import async_job, dataframe, exceptions, row, session
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 module_logger = service_logger.get_logger(__name__, service_logger.LogColor.GREY)
@@ -104,9 +106,9 @@ class ServiceOperator:
         num_workers: Optional[int],
         max_batch_rows: Optional[int],
         force_rebuild: bool,
-        build_external_access_integrations: Optional[List[sql_identifier.SqlIdentifier]],
+        build_external_access_integrations: Optional[list[sql_identifier.SqlIdentifier]],
         block: bool,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> Union[str, async_job.AsyncJob]:
 
         # Fall back to the registry's database and schema if not provided
@@ -120,32 +122,28 @@ class ServiceOperator:
         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
         if self._workspace:
-            # create a temp stage
-            stage_name = sql_identifier.SqlIdentifier(
-                snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
-            )
-            self._stage_client.create_tmp_stage(
-                database_name=database_name,
-                schema_name=schema_name,
-                stage_name=stage_name,
-                statement_params=statement_params,
-            )
-            stage_path = self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)
+            stage_path = self._create_temp_stage(database_name, schema_name, statement_params)
         else:
             stage_path = None
-        spec_yaml_str_or_path = self._model_deployment_spec.save(
+        self._model_deployment_spec.add_model_spec(
             database_name=database_name,
             schema_name=schema_name,
             model_name=model_name,
             version_name=version_name,
-            service_database_name=service_database_name,
-            service_schema_name=service_schema_name,
-            service_name=service_name,
+        )
+        self._model_deployment_spec.add_image_build_spec(
             image_build_compute_pool_name=image_build_compute_pool_name,
-            service_compute_pool_name=service_compute_pool_name,
             image_repo_database_name=image_repo_database_name,
             image_repo_schema_name=image_repo_schema_name,
             image_repo_name=image_repo_name,
+            force_rebuild=force_rebuild,
+            external_access_integrations=build_external_access_integrations,
+        )
+        self._model_deployment_spec.add_service_spec(
+            service_database_name=service_database_name,
+            service_schema_name=service_schema_name,
+            service_name=service_name,
+            inference_compute_pool_name=service_compute_pool_name,
             ingress_enabled=ingress_enabled,
             max_instances=max_instances,
             cpu=cpu_requests,
@@ -153,9 +151,8 @@ class ServiceOperator:
             gpu=gpu_requests,
             num_workers=num_workers,
             max_batch_rows=max_batch_rows,
-            force_rebuild=force_rebuild,
-            external_access_integrations=build_external_access_integrations,
         )
+        spec_yaml_str_or_path = self._model_deployment_spec.save()
         if self._workspace:
             assert stage_path is not None
             file_utils.upload_directory_to_stage(
@@ -210,7 +207,7 @@ class ServiceOperator:
         if block:
             log_thread.join()
 
-            res = cast(str, cast(List[row.Row], async_job.result())[0][0])
+            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:
@@ -219,10 +216,10 @@ class ServiceOperator:
     def _start_service_log_streaming(
         self,
         async_job: snowpark.AsyncJob,
-        services: List[ServiceLogInfo],
+        services: list[ServiceLogInfo],
         model_inference_service_exists: bool,
         force_rebuild: bool,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> threading.Thread:
         """Start the service log streaming in a separate thread."""
         log_thread = threading.Thread(
@@ -241,14 +238,14 @@ class ServiceOperator:
     def _stream_service_logs(
         self,
         async_job: snowpark.AsyncJob,
-        services: List[ServiceLogInfo],
+        services: list[ServiceLogInfo],
         model_inference_service_exists: bool,
         force_rebuild: bool,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Stream service logs while the async job is running."""
 
-        def fetch_logs(service: ServiceLogInfo, offset: int) -> Tuple[str, int]:
+        def fetch_logs(service: ServiceLogInfo, offset: int) -> tuple[str, int]:
             service_logs = self._service_client.get_service_logs(
                 database_name=service.database_name,
                 schema_name=service.schema_name,
@@ -393,7 +390,7 @@ class ServiceOperator:
         service_logger: logging.Logger,
         service: ServiceLogInfo,
         offset: int,
-        statement_params: Optional[Dict[str, Any]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Fetch service logs after the async job is done to ensure no logs are missed."""
         try:
@@ -425,8 +422,8 @@ class ServiceOperator:
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         service_name: sql_identifier.SqlIdentifier,
-        service_status_list_if_exists: Optional[List[service_sql.ServiceStatus]] = None,
-        statement_params: Optional[Dict[str, Any]] = None,
+        service_status_list_if_exists: Optional[list[service_sql.ServiceStatus]] = None,
+        statement_params: Optional[dict[str, Any]] = None,
     ) -> bool:
         if service_status_list_if_exists is None:
             service_status_list_if_exists = [
@@ -448,3 +445,191 @@ class ServiceOperator:
             return any(service_status == status for status in service_status_list_if_exists)
         except exceptions.SnowparkSQLException:
             return False
+
+    def invoke_job_method(
+        self,
+        target_method: str,
+        signature: model_signature.ModelSignature,
+        X: Union[type_hints.SupportedDataType, dataframe.DataFrame],
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        job_database_name: Optional[sql_identifier.SqlIdentifier],
+        job_schema_name: Optional[sql_identifier.SqlIdentifier],
+        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,
+        output_table_database_name: Optional[sql_identifier.SqlIdentifier],
+        output_table_schema_name: Optional[sql_identifier.SqlIdentifier],
+        output_table_name: sql_identifier.SqlIdentifier,
+        cpu_requests: Optional[str],
+        memory_requests: Optional[str],
+        gpu_requests: Optional[Union[int, str]],
+        num_workers: Optional[int],
+        max_batch_rows: Optional[int],
+        force_rebuild: bool,
+        build_external_access_integrations: Optional[list[sql_identifier.SqlIdentifier]],
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
+        # 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
+
+        # fall back to the model's database and schema if not provided then to the registry's database and schema
+        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
+
+        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
+
+        input_table_database_name = job_database_name
+        input_table_schema_name = job_schema_name
+        output_table_database_name = output_table_database_name or database_name or self._database_name
+        output_table_schema_name = output_table_schema_name or schema_name or self._schema_name
+
+        if self._workspace:
+            stage_path = self._create_temp_stage(database_name, schema_name, statement_params)
+        else:
+            stage_path = None
+
+        # validate and prepare input
+        if not isinstance(X, dataframe.DataFrame):
+            keep_order = True
+            output_with_input_features = False
+            df = model_signature._convert_and_validate_local_data(X, signature.inputs)
+            s_df = snowpark_handler.SnowparkDataFrameHandler.convert_from_df(
+                self._session, df, keep_order=keep_order, features=signature.inputs
+            )
+        else:
+            keep_order = False
+            output_with_input_features = True
+            s_df = X
+
+        # only write the index and feature input columns
+        cols = [snowpark_handler._KEEP_ORDER_COL_NAME] if snowpark_handler._KEEP_ORDER_COL_NAME in s_df.columns else []
+        cols += [
+            sql_identifier.SqlIdentifier(feature.name, case_sensitive=True).identifier() for feature in signature.inputs
+        ]
+        s_df = s_df.select(cols)
+        original_cols = s_df.columns
+
+        # input/output tables
+        fq_output_table_name = identifier.get_schema_level_object_identifier(
+            output_table_database_name.identifier(),
+            output_table_schema_name.identifier(),
+            output_table_name.identifier(),
+        )
+        tmp_input_table_id = sql_identifier.SqlIdentifier(
+            snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
+        )
+        fq_tmp_input_table_name = identifier.get_schema_level_object_identifier(
+            job_database_name.identifier(),
+            job_schema_name.identifier(),
+            tmp_input_table_id.identifier(),
+        )
+        s_df.write.save_as_table(
+            table_name=fq_tmp_input_table_name,
+            mode="errorifexists",
+            statement_params=statement_params,
+        )
+
+        try:
+            # save the spec
+            self._model_deployment_spec.add_model_spec(
+                database_name=database_name,
+                schema_name=schema_name,
+                model_name=model_name,
+                version_name=version_name,
+            )
+            self._model_deployment_spec.add_job_spec(
+                job_database_name=job_database_name,
+                job_schema_name=job_schema_name,
+                job_name=job_name,
+                inference_compute_pool_name=compute_pool_name,
+                cpu=cpu_requests,
+                memory=memory_requests,
+                gpu=gpu_requests,
+                num_workers=num_workers,
+                max_batch_rows=max_batch_rows,
+                warehouse=warehouse_name,
+                target_method=target_method,
+                input_table_database_name=input_table_database_name,
+                input_table_schema_name=input_table_schema_name,
+                input_table_name=tmp_input_table_id,
+                output_table_database_name=output_table_database_name,
+                output_table_schema_name=output_table_schema_name,
+                output_table_name=output_table_name,
+            )
+
+            self._model_deployment_spec.add_image_build_spec(
+                image_build_compute_pool_name=compute_pool_name,
+                image_repo_database_name=image_repo_database_name,
+                image_repo_schema_name=image_repo_schema_name,
+                image_repo_name=image_repo_name,
+                force_rebuild=force_rebuild,
+                external_access_integrations=build_external_access_integrations,
+            )
+
+            spec_yaml_str_or_path = self._model_deployment_spec.save()
+            if self._workspace:
+                assert stage_path is not None
+                file_utils.upload_directory_to_stage(
+                    self._session,
+                    local_path=pathlib.Path(self._workspace.name),
+                    stage_path=pathlib.PurePosixPath(stage_path),
+                    statement_params=statement_params,
+                )
+
+            # deploy the job
+            query_id, async_job = self._service_client.deploy_model(
+                stage_path=stage_path if self._workspace else None,
+                model_deployment_spec_file_rel_path=(
+                    model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH if self._workspace else None
+                ),
+                model_deployment_spec_yaml_str=None if self._workspace else spec_yaml_str_or_path,
+                statement_params=statement_params,
+            )
+
+            while not async_job.is_done():
+                time.sleep(5)
+        finally:
+            self._session.table(fq_tmp_input_table_name).drop_table()
+
+        # handle the output
+        df_res = self._session.table(fq_output_table_name)
+        if keep_order:
+            df_res = df_res.sort(
+                snowpark_handler._KEEP_ORDER_COL_NAME,
+                ascending=True,
+            )
+            df_res = df_res.drop(snowpark_handler._KEEP_ORDER_COL_NAME)
+
+        if not output_with_input_features:
+            df_res = df_res.drop(*original_cols)
+
+        # get final result
+        if not isinstance(X, dataframe.DataFrame):
+            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(df_res, features=signature.outputs)
+        else:
+            return df_res
+
+    def _create_temp_stage(
+        self,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> str:
+        stage_name = sql_identifier.SqlIdentifier(
+            snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
+        )
+        self._stage_client.create_tmp_stage(
+            database_name=database_name,
+            schema_name=schema_name,
+            stage_name=stage_name,
+            statement_params=statement_params,
+        )
+        return self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)  # stage path