snowflake-ml-python 1.8.1__py3-none-any.whl → 1.8.3__py3-none-any.whl

snowflake/ml/model/_client/model/model_version_impl.py

@@ -2,10 +2,11 @@ import enum
 import pathlib
 import tempfile
 import warnings
-from typing import Any, Callable, Dict, List, Optional, Union, overload
+from typing import Any, Callable, Optional, Union, overload
 
 import pandas as pd
 
+from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.lineage import lineage_node
@@ -32,7 +33,7 @@ class ModelVersion(lineage_node.LineageNode):
     _service_ops: service_ops.ServiceOperator
     _model_name: sql_identifier.SqlIdentifier
     _version_name: sql_identifier.SqlIdentifier
-    _functions: List[model_manifest_schema.ModelFunctionInfo]
+    _functions: list[model_manifest_schema.ModelFunctionInfo]
 
     def __init__(self) -> None:
         raise RuntimeError("ModelVersion's initializer is not meant to be used. Use `version` from model instead.")
@@ -152,7 +153,7 @@ class ModelVersion(lineage_node.LineageNode):
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
     )
-    def show_metrics(self) -> Dict[str, Any]:
+    def show_metrics(self) -> dict[str, Any]:
         """Show all metrics logged with the model version.
 
         Returns:
@@ -293,7 +294,7 @@ class ModelVersion(lineage_node.LineageNode):
             statement_params=statement_params,
         )
 
-    def _get_functions(self) -> List[model_manifest_schema.ModelFunctionInfo]:
+    def _get_functions(self) -> list[model_manifest_schema.ModelFunctionInfo]:
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_TELEMETRY_SUBPROJECT,
@@ -327,7 +328,7 @@ class ModelVersion(lineage_node.LineageNode):
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
     )
-    def show_functions(self) -> List[model_manifest_schema.ModelFunctionInfo]:
+    def show_functions(self) -> list[model_manifest_schema.ModelFunctionInfo]:
         """Show all functions information in a model version that is callable.
 
         Returns:
@@ -405,11 +406,6 @@ class ModelVersion(lineage_node.LineageNode):
             strict_input_validation: Enable stricter validation for the input data. This will result value range based
                 type validation to make sure your input data won't overflow when providing to the model.
 
-        Raises:
-            ValueError: When no method with the corresponding name is available.
-            ValueError: When there are more than 1 target methods available in the model but no function name specified.
-            ValueError: When the partition column is not a valid Snowflake identifier.
-
         Returns:
             The prediction data. It would be the same type dataframe as your input.
         """
@@ -422,29 +418,7 @@ class ModelVersion(lineage_node.LineageNode):
             # Partition column must be a valid identifier
             partition_column = sql_identifier.SqlIdentifier(partition_column)
 
-        functions: List[model_manifest_schema.ModelFunctionInfo] = self._functions
-
-        if function_name:
-            req_method_name = sql_identifier.SqlIdentifier(function_name).identifier()
-            find_method: Callable[[model_manifest_schema.ModelFunctionInfo], bool] = (
-                lambda method: method["name"] == req_method_name
-            )
-            target_function_info = next(
-                filter(find_method, functions),
-                None,
-            )
-            if target_function_info is None:
-                raise ValueError(
-                    f"There is no method with name {function_name} available in the model"
-                    f" {self.fully_qualified_model_name} version {self.version_name}"
-                )
-        elif len(functions) != 1:
-            raise ValueError(
-                f"There are more than 1 target methods available in the model {self.fully_qualified_model_name}"
-                f" version {self.version_name}. Please specify a `function_name` when calling the `run` method."
-            )
-        else:
-            target_function_info = functions[0]
+        target_function_info = self._get_function_info(function_name=function_name)
 
         if service_name:
             database_name_id, schema_name_id, service_name_id = sql_identifier.parse_fully_qualified_name(service_name)
@@ -475,6 +449,33 @@ class ModelVersion(lineage_node.LineageNode):
                 is_partitioned=target_function_info["is_partitioned"],
             )
 
+    def _get_function_info(self, function_name: Optional[str]) -> model_manifest_schema.ModelFunctionInfo:
+        functions: list[model_manifest_schema.ModelFunctionInfo] = self._functions
+
+        if function_name:
+            req_method_name = sql_identifier.SqlIdentifier(function_name).identifier()
+            find_method: Callable[[model_manifest_schema.ModelFunctionInfo], bool] = (
+                lambda method: method["name"] == req_method_name
+            )
+            target_function_info = next(
+                filter(find_method, functions),
+                None,
+            )
+            if target_function_info is None:
+                raise ValueError(
+                    f"There is no method with name {function_name} available in the model"
+                    f" {self.fully_qualified_model_name} version {self.version_name}"
+                )
+        elif len(functions) != 1:
+            raise ValueError(
+                f"There are more than 1 target methods available in the model {self.fully_qualified_model_name}"
+                f" version {self.version_name}. Please specify a `function_name` when calling the `run` method."
+            )
+        else:
+            target_function_info = functions[0]
+
+        return target_function_info
+
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT, subproject=_TELEMETRY_SUBPROJECT, func_params_to_log=["export_mode"]
     )
@@ -684,7 +685,7 @@ class ModelVersion(lineage_node.LineageNode):
         num_workers: Optional[int] = None,
         max_batch_rows: Optional[int] = None,
         force_rebuild: bool = False,
-        build_external_access_integrations: Optional[List[str]] = None,
+        build_external_access_integrations: Optional[list[str]] = None,
         block: bool = True,
     ) -> Union[str, async_job.AsyncJob]:
         """Create an inference service with the given spec.
@@ -751,7 +752,7 @@ class ModelVersion(lineage_node.LineageNode):
         max_batch_rows: Optional[int] = None,
         force_rebuild: bool = False,
         build_external_access_integration: Optional[str] = None,
-        build_external_access_integrations: Optional[List[str]] = None,
+        build_external_access_integrations: Optional[list[str]] = None,
         block: bool = True,
     ) -> Union[str, async_job.AsyncJob]:
         """Create an inference service with the given spec.
@@ -914,5 +915,72 @@ class ModelVersion(lineage_node.LineageNode):
             statement_params=statement_params,
         )
 
+    @snowpark._internal.utils.private_preview(version="1.8.3")
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def run_job(
+        self,
+        X: Union[pd.DataFrame, "dataframe.DataFrame"],
+        *,
+        job_name: str,
+        compute_pool: str,
+        image_repo: str,
+        output_table_name: str,
+        function_name: Optional[str] = None,
+        cpu_requests: Optional[str] = None,
+        memory_requests: Optional[str] = None,
+        gpu_requests: Optional[Union[str, int]] = None,
+        num_workers: Optional[int] = None,
+        max_batch_rows: Optional[int] = None,
+        force_rebuild: bool = False,
+        build_external_access_integrations: Optional[list[str]] = None,
+    ) -> Union[pd.DataFrame, dataframe.DataFrame]:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        target_function_info = self._get_function_info(function_name=function_name)
+        job_db_id, job_schema_id, job_id = sql_identifier.parse_fully_qualified_name(job_name)
+        image_repo_db_id, image_repo_schema_id, image_repo_id = sql_identifier.parse_fully_qualified_name(image_repo)
+        output_table_db_id, output_table_schema_id, output_table_id = sql_identifier.parse_fully_qualified_name(
+            output_table_name
+        )
+        warehouse = self._service_ops._session.get_current_warehouse()
+        assert warehouse, "No active warehouse selected in the current session."
+        return self._service_ops.invoke_job_method(
+            target_method=target_function_info["target_method"],
+            signature=target_function_info["signature"],
+            X=X,
+            database_name=None,
+            schema_name=None,
+            model_name=self._model_name,
+            version_name=self._version_name,
+            job_database_name=job_db_id,
+            job_schema_name=job_schema_id,
+            job_name=job_id,
+            compute_pool_name=sql_identifier.SqlIdentifier(compute_pool),
+            warehouse_name=sql_identifier.SqlIdentifier(warehouse),
+            image_repo_database_name=image_repo_db_id,
+            image_repo_schema_name=image_repo_schema_id,
+            image_repo_name=image_repo_id,
+            output_table_database_name=output_table_db_id,
+            output_table_schema_name=output_table_schema_id,
+            output_table_name=output_table_id,
+            cpu_requests=cpu_requests,
+            memory_requests=memory_requests,
+            gpu_requests=gpu_requests,
+            num_workers=num_workers,
+            max_batch_rows=max_batch_rows,
+            force_rebuild=force_rebuild,
+            build_external_access_integrations=(
+                None
+                if build_external_access_integrations is None
+                else [sql_identifier.SqlIdentifier(eai) for eai in build_external_access_integrations]
+            ),
+            statement_params=statement_params,
+        )
+
 
 lineage_node.DOMAIN_LINEAGE_REGISTRY["model"] = ModelVersion

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

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional, TypedDict
+from typing import Any, Optional, TypedDict
 
 from typing_extensions import NotRequired
 
@@ -14,7 +14,7 @@ MODEL_VERSION_METADATA_SCHEMA_VERSION = "2024-01-01"
 
 
 class ModelVersionMetadataSchema(TypedDict):
-    metrics: NotRequired[Dict[str, Any]]
+    metrics: NotRequired[dict[str, Any]]
 
 
 class MetadataOperator:
@@ -44,7 +44,7 @@ class MetadataOperator:
         )
 
     @staticmethod
-    def _parse(metadata_dict: Dict[str, Any]) -> ModelVersionMetadataSchema:
+    def _parse(metadata_dict: dict[str, Any]) -> ModelVersionMetadataSchema:
         loaded_metadata_schema_version = metadata_dict.get("snowpark_ml_schema_version", None)
         if loaded_metadata_schema_version is None:
             return ModelVersionMetadataSchema(metrics={})
@@ -65,8 +65,8 @@ class MetadataOperator:
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         version_info_list = self._model_client.show_versions(
             database_name=database_name,
             schema_name=schema_name,
@@ -89,7 +89,7 @@ class MetadataOperator:
         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,
     ) -> ModelVersionMetadataSchema:
         metadata_dict = self._get_current_metadata_dict(
             database_name=database_name,
@@ -108,7 +108,7 @@ class MetadataOperator:
         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:
         metadata_dict = self._get_current_metadata_dict(
             database_name=database_name,

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(