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

snowflake/cortex/__init__.py

@@ -1,5 +1,10 @@
 from snowflake.cortex._classify_text import ClassifyText, classify_text
-from snowflake.cortex._complete import Complete, CompleteOptions, complete
+from snowflake.cortex._complete import (
+    Complete,
+    CompleteOptions,
+    ConversationMessage,
+    complete,
+)
 from snowflake.cortex._embed_text_768 import EmbedText768, embed_text_768
 from snowflake.cortex._embed_text_1024 import EmbedText1024, embed_text_1024
 from snowflake.cortex._extract_answer import ExtractAnswer, extract_answer
@@ -14,6 +19,7 @@ __all__ = [
     "Complete",
     "complete",
     "CompleteOptions",
+    "ConversationMessage",
     "EmbedText768",
     "embed_text_768",
     "EmbedText1024",

snowflake/cortex/_classify_text.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union, cast
+from typing import Optional, Union, cast
 
 from typing_extensions import deprecated
 
@@ -12,7 +12,7 @@ from snowflake.ml._internal import telemetry
 )
 def classify_text(
     str_input: Union[str, snowpark.Column],
-    categories: Union[List[str], snowpark.Column],
+    categories: Union[list[str], snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     """Use the LLM inference service to classify the INPUT text into one of the target CATEGORIES.
@@ -32,7 +32,7 @@ def classify_text(
 def _classify_text_impl(
     function: str,
     str_input: Union[str, snowpark.Column],
-    categories: Union[List[str], snowpark.Column],
+    categories: Union[list[str], snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     return cast(Union[str, snowpark.Column], call_sql_function(function, session, str_input, categories))

snowflake/cortex/_complete.py

@@ -3,7 +3,7 @@ import logging
 import time
 import typing
 from io import BytesIO
-from typing import Any, Callable, Dict, Iterator, List, Optional, TypedDict, Union, cast
+from typing import Any, Callable, Iterator, Optional, TypedDict, Union, cast
 from urllib.parse import urlunparse
 
 import requests
@@ -30,7 +30,7 @@ class ResponseFormat(TypedDict):
 
     type: str
     """The response format type (e.g. "json")"""
-    schema: Dict[str, Any]
+    schema: dict[str, Any]
     """The schema defining the structure of the response. For json it should be a valid json schema object"""
 
 
@@ -71,12 +71,11 @@ class CompleteOptions(TypedDict):
 class ResponseParseException(Exception):
     """This exception is raised when the server response cannot be parsed."""
 
-    pass
-
 
 class MidStreamException(Exception):
     """The SSE (Server-sent Event) stream can contain error messages in the middle of the stream,
-    using the “error” event type. This exception is raised when there is such a mid-stream error."""
+    using the “error” event type. This exception is raised when there is such a mid-stream error.
+    """
 
     def __init__(
         self,
@@ -135,7 +134,7 @@ def retry(func: Callable[..., requests.Response]) -> Callable[..., requests.Resp
     return inner
 
 
-def _make_common_request_headers() -> Dict[str, str]:
+def _make_common_request_headers() -> dict[str, str]:
     headers = {
         "Content-Type": "application/json",
         "Accept": "application/json, text/event-stream",
@@ -143,7 +142,7 @@ def _make_common_request_headers() -> Dict[str, str]:
     return headers
 
 
-def _get_request_id(resp: Dict[str, Any]) -> Optional[Any]:
+def _get_request_id(resp: dict[str, Any]) -> Optional[Any]:
     request_id = None
     if "headers" in resp:
         for key, value in resp["headers"].items():
@@ -183,14 +182,14 @@ def _validate_response_format_object(options: CompleteOptions) -> None:
 
 def _make_request_body(
     model: str,
-    prompt: Union[str, List[ConversationMessage]],
+    prompt: Union[str, list[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     data = {
         "model": model,
         "stream": True,
     }
-    if isinstance(prompt, List):
+    if isinstance(prompt, list):
         data["messages"] = prompt
     else:
         data["messages"] = [{"content": prompt}]
@@ -217,7 +216,7 @@ def _make_request_body(
 
 # XP endpoint returns a dict response which needs to be converted to a format which can
 # be consumed by the SSEClient. This method does that.
-def _xp_dict_to_response(raw_resp: Dict[str, Any]) -> requests.Response:
+def _xp_dict_to_response(raw_resp: dict[str, Any]) -> requests.Response:
 
     response = requests.Response()
     response.status_code = int(raw_resp["status"])
@@ -251,9 +250,9 @@ def _xp_dict_to_response(raw_resp: Dict[str, Any]) -> requests.Response:
 
 @retry
 def _call_complete_xp(
-    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
+    snow_api_xp_request_handler: Optional[Callable[..., dict[str, Any]]],
     model: str,
-    prompt: Union[str, List[ConversationMessage]],
+    prompt: Union[str, list[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
     deadline: Optional[float] = None,
 ) -> requests.Response:
@@ -267,7 +266,7 @@ def _call_complete_xp(
 @retry
 def _call_complete_rest(
     model: str,
-    prompt: Union[str, List[ConversationMessage]],
+    prompt: Union[str, list[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,
 ) -> requests.Response:
@@ -340,9 +339,9 @@ def _complete_call_sql_function_snowpark(
 
 
 def _complete_non_streaming_immediate(
-    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
+    snow_api_xp_request_handler: Optional[Callable[..., dict[str, Any]]],
     model: str,
-    prompt: Union[str, List[ConversationMessage]],
+    prompt: Union[str, list[ConversationMessage]],
     options: Optional[CompleteOptions],
     session: Optional[snowpark.Session] = None,
     deadline: Optional[float] = None,
@@ -359,10 +358,10 @@ def _complete_non_streaming_immediate(
 
 
 def _complete_non_streaming_impl(
-    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
+    snow_api_xp_request_handler: Optional[Callable[..., dict[str, Any]]],
     function: str,
     model: Union[str, snowpark.Column],
-    prompt: Union[str, List[ConversationMessage], snowpark.Column],
+    prompt: Union[str, list[ConversationMessage], snowpark.Column],
     options: Optional[Union[CompleteOptions, snowpark.Column]],
     session: Optional[snowpark.Session] = None,
     deadline: Optional[float] = None,
@@ -389,9 +388,9 @@ def _complete_non_streaming_impl(
 
 
 def _complete_rest(
-    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
+    snow_api_xp_request_handler: Optional[Callable[..., dict[str, Any]]],
     model: str,
-    prompt: Union[str, List[ConversationMessage]],
+    prompt: Union[str, list[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,
     deadline: Optional[float] = None,
@@ -414,8 +413,8 @@ def _complete_rest(
 
 def _complete_impl(
     model: Union[str, snowpark.Column],
-    prompt: Union[str, List[ConversationMessage], snowpark.Column],
-    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]] = None,
+    prompt: Union[str, list[ConversationMessage], snowpark.Column],
+    snow_api_xp_request_handler: Optional[Callable[..., dict[str, Any]]] = None,
     function: str = "snowflake.cortex.complete",
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,
@@ -430,7 +429,7 @@ def _complete_impl(
     if stream:
         if not isinstance(model, str):
             raise ValueError("in REST mode, 'model' must be a string")
-        if not isinstance(prompt, str) and not isinstance(prompt, List):
+        if not isinstance(prompt, str) and not isinstance(prompt, list):
             raise ValueError("in REST mode, 'prompt' must be a string or a list of ConversationMessage")
         return _complete_rest(
             snow_api_xp_request_handler=snow_api_xp_request_handler,
@@ -456,7 +455,7 @@ def _complete_impl(
 )
 def complete(
     model: Union[str, snowpark.Column],
-    prompt: Union[str, List[ConversationMessage], snowpark.Column],
+    prompt: Union[str, list[ConversationMessage], snowpark.Column],
     *,
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,

snowflake/cortex/_embed_text_1024.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union, cast
+from typing import Optional, Union, cast
 
 from typing_extensions import deprecated
 
@@ -14,7 +14,7 @@ def embed_text_1024(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
-) -> Union[List[float], snowpark.Column]:
+) -> Union[list[float], snowpark.Column]:
     """Calls into the LLM inference service to embed the text.
 
     Args:
@@ -35,8 +35,8 @@ def _embed_text_1024_impl(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
-) -> Union[List[float], snowpark.Column]:
-    return cast(Union[List[float], snowpark.Column], call_sql_function(function, session, model, text))
+) -> Union[list[float], snowpark.Column]:
+    return cast(Union[list[float], snowpark.Column], call_sql_function(function, session, model, text))
 
 
 EmbedText1024 = deprecated(

snowflake/cortex/_embed_text_768.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union, cast
+from typing import Optional, Union, cast
 
 from typing_extensions import deprecated
 
@@ -14,7 +14,7 @@ def embed_text_768(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
-) -> Union[List[float], snowpark.Column]:
+) -> Union[list[float], snowpark.Column]:
     """Calls into the LLM inference service to embed the text.
 
     Args:
@@ -35,8 +35,8 @@ def _embed_text_768_impl(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
-) -> Union[List[float], snowpark.Column]:
-    return cast(Union[List[float], snowpark.Column], call_sql_function(function, session, model, text))
+) -> Union[list[float], snowpark.Column]:
+    return cast(Union[list[float], snowpark.Column], call_sql_function(function, session, model, text))
 
 
 EmbedText768 = deprecated(

snowflake/cortex/_finetune.py

@@ -1,6 +1,6 @@
 import json
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 from snowflake import snowpark
 from snowflake.cortex._util import (
@@ -53,7 +53,7 @@ class FinetuneStatus:
     created_on: Optional[int] = None
     """Creation timestamp of the Fine-tuning job in milliseconds."""
 
-    error: Optional[Dict[str, Any]] = None
+    error: Optional[dict[str, Any]] = None
     """Error message propagated from the job."""
 
     finished_on: Optional[int] = None
@@ -62,7 +62,7 @@ class FinetuneStatus:
     progress: Optional[float] = None
     """Progress made as a fraction of total [0.0,1.0]."""
 
-    training_result: Optional[List[Dict[str, Any]]] = None
+    training_result: Optional[list[dict[str, Any]]] = None
     """Detailed metrics report for a completed training."""
 
     trained_tokens: Optional[int] = None
@@ -135,7 +135,7 @@ class FinetuneJob:
         """
         result_string = _finetune_impl(operation="DESCRIBE", session=self._session, function_args=[self.status.id])
 
-        result = FinetuneStatus(**cast(Dict[str, Any], _try_load_json(result_string)))
+        result = FinetuneStatus(**cast(dict[str, Any], _try_load_json(result_string)))
         return result
 
 
@@ -167,7 +167,7 @@ class Finetune:
         base_model: str,
         training_data: Union[str, snowpark.DataFrame],
         validation_data: Optional[Union[str, snowpark.DataFrame]] = None,
-        options: Optional[Dict[str, Any]] = None,
+        options: Optional[dict[str, Any]] = None,
     ) -> FinetuneJob:
         """Create a new fine-tuning runs.
 
@@ -240,7 +240,7 @@ class Finetune:
         project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
         subproject=CORTEX_FINETUNE_TELEMETRY_SUBPROJECT,
     )
-    def list_jobs(self) -> List["FinetuneJob"]:
+    def list_jobs(self) -> list["FinetuneJob"]:
         """Show current and past fine-tuning runs.
 
         Returns:
@@ -253,7 +253,7 @@ class Finetune:
         return [FinetuneJob(session=self._session, status=FinetuneStatus(**run_status)) for run_status in result]
 
 
-def _try_load_json(json_string: str) -> Union[Dict[Any, Any], List[Any]]:
+def _try_load_json(json_string: str) -> Union[dict[Any, Any], list[Any]]:
     try:
         result = json.loads(str(json_string))
     except json.JSONDecodeError as e:
@@ -269,5 +269,5 @@ def _try_load_json(json_string: str) -> Union[Dict[Any, Any], List[Any]]:
     return result
 
 
-def _finetune_impl(operation: str, session: Optional[snowpark.Session], function_args: List[Any]) -> str:
+def _finetune_impl(operation: str, session: Optional[snowpark.Session], function_args: list[Any]) -> str:
     return call_sql_function_literals(_CORTEX_FINETUNE_SYSTEM_FUNCTION_NAME, session, operation, *function_args)

snowflake/cortex/_util.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 from snowflake import snowpark
 from snowflake.ml._internal.exceptions import error_codes, exceptions
@@ -11,22 +11,18 @@ CORTEX_FUNCTIONS_TELEMETRY_PROJECT = "CortexFunctions"
 class SnowflakeAuthenticationException(Exception):
     """This exception is raised when there is an issue with Snowflake's configuration."""
 
-    pass
-
 
 class SnowflakeConfigurationException(Exception):
     """This exception is raised when there is an issue with Snowflake's configuration."""
 
-    pass
-
 
 # Calls a sql function, handling both immediate (e.g. python types) and batch
 # (e.g. snowpark column and literal type modes).
 def call_sql_function(
     function: str,
     session: Optional[snowpark.Session],
-    *args: Union[str, List[str], snowpark.Column, Dict[str, Union[int, float]]],
-) -> Union[str, List[float], snowpark.Column]:
+    *args: Union[str, list[str], snowpark.Column, dict[str, Union[int, float]]],
+) -> Union[str, list[float], snowpark.Column]:
     handle_as_column = False
 
     for arg in args:
@@ -34,15 +30,15 @@ def call_sql_function(
             handle_as_column = True
 
     if handle_as_column:
-        return cast(Union[str, List[float], snowpark.Column], _call_sql_function_column(function, *args))
+        return cast(Union[str, list[float], snowpark.Column], _call_sql_function_column(function, *args))
     return cast(
-        Union[str, List[float], snowpark.Column],
+        Union[str, list[float], snowpark.Column],
         _call_sql_function_immediate(function, session, *args),
     )
 
 
 def _call_sql_function_column(
-    function: str, *args: Union[str, List[str], snowpark.Column, Dict[str, Union[int, float]]]
+    function: str, *args: Union[str, list[str], snowpark.Column, dict[str, Union[int, float]]]
 ) -> snowpark.Column:
     return cast(snowpark.Column, functions.builtin(function)(*args))
 
@@ -50,8 +46,8 @@ def _call_sql_function_column(
 def _call_sql_function_immediate(
     function: str,
     session: Optional[snowpark.Session],
-    *args: Union[str, List[str], snowpark.Column, Dict[str, Union[int, float]]],
-) -> Union[str, List[float]]:
+    *args: Union[str, list[str], snowpark.Column, dict[str, Union[int, float]]],
+) -> Union[str, list[float]]:
     session = session or context.get_active_session()
     if session is None:
         raise SnowflakeAuthenticationException(

snowflake/ml/_internal/env.py

@@ -1,8 +1,9 @@
+import os
 import platform
 
-from snowflake.ml import version
-
 SOURCE = "SnowML"
-VERSION = version.VERSION
 PYTHON_VERSION = platform.python_version()
 OS = platform.system()
+IN_ML_RUNTIME_ENV_VAR = "IN_SPCS_ML_RUNTIME"
+IN_ML_RUNTIME = os.getenv(IN_ML_RUNTIME_ENV_VAR)
+USE_OPTIMIZED_DATA_INGESTOR = "USE_OPTIMIZED_DATA_INGESTOR"

snowflake/ml/_internal/env_utils.py

@@ -6,12 +6,13 @@ import textwrap
 import warnings
 from enum import Enum
 from importlib import metadata as importlib_metadata
-from typing import Any, DefaultDict, Dict, List, Optional, Tuple
+from typing import Any, DefaultDict, Optional
 
 import yaml
 from packaging import requirements, specifiers, version
 
 import snowflake.connector
+from snowflake.ml import version as snowml_version
 from snowflake.ml._internal import env as snowml_env, relax_version_strategy
 from snowflake.ml._internal.utils import query_result_checker
 from snowflake.snowpark import context, exceptions, session
@@ -27,8 +28,8 @@ class CONDA_OS(Enum):
 
 
 _NODEFAULTS = "nodefaults"
-_SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE: Dict[str, List[version.Version]] = {}
-_SNOWFLAKE_CONDA_PACKAGE_CACHE: Dict[str, List[version.Version]] = {}
+_SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE: dict[str, list[version.Version]] = {}
+_SNOWFLAKE_CONDA_PACKAGE_CACHE: dict[str, list[version.Version]] = {}
 _SUPPORTED_PACKAGE_SPEC_OPS = ["==", ">=", "<=", ">", "<"]
 
 DEFAULT_CHANNEL_NAME = ""
@@ -64,7 +65,7 @@ def _validate_pip_requirement_string(req_str: str) -> requirements.Requirement:
     return r
 
 
-def _validate_conda_dependency_string(dep_str: str) -> Tuple[str, requirements.Requirement]:
+def _validate_conda_dependency_string(dep_str: str) -> tuple[str, requirements.Requirement]:
     """Validate conda dependency string like `pytorch == 1.12.1` or `conda-forge::transformer` and split the channel
         name before the double colon and requirement specification after that.
 
@@ -115,7 +116,7 @@ class DuplicateDependencyInMultipleChannelsError(Exception):
     ...
 
 
-def append_requirement_list(req_list: List[requirements.Requirement], p_req: requirements.Requirement) -> None:
+def append_requirement_list(req_list: list[requirements.Requirement], p_req: requirements.Requirement) -> None:
     """Append a requirement to an existing requirement list. If need and able to merge, merge it, otherwise, append it.
 
     Args:
@@ -134,7 +135,7 @@ def append_requirement_list(req_list: List[requirements.Requirement], p_req: req
 
 
 def append_conda_dependency(
-    conda_chan_deps: DefaultDict[str, List[requirements.Requirement]], p_chan_dep: Tuple[str, requirements.Requirement]
+    conda_chan_deps: DefaultDict[str, list[requirements.Requirement]], p_chan_dep: tuple[str, requirements.Requirement]
 ) -> None:
     """Append a conda dependency to an existing conda dependencies dict, if not existed in any channel.
         To avoid making unnecessary modification to dict, we check the existence first, then try to merge, then append,
@@ -164,45 +165,73 @@ def append_conda_dependency(
     conda_chan_deps[p_channel].append(p_req)
 
 
-def validate_pip_requirement_string_list(req_str_list: List[str]) -> List[requirements.Requirement]:
-    """Validate the a list of pip requirement string according to PEP 508.
+def validate_pip_requirement_string_list(
+    req_str_list: list[str], add_local_version_specifier: bool = False
+) -> list[requirements.Requirement]:
+    """Validate the list of pip requirement strings according to PEP 508.
 
     Args:
-        req_str_list: The list of string contains the pip requirement specification.
+        req_str_list: The list of strings containing the pip requirement specification.
+        add_local_version_specifier: if True, add the version specifier of the locally installed package version to
+            requirements without version specifiers.
 
     Returns:
         A requirements.Requirement list containing the requirement information.
     """
-    seen_pip_requirement_list: List[requirements.Requirement] = []
+    seen_pip_requirement_list: list[requirements.Requirement] = []
     for req_str in req_str_list:
         append_requirement_list(seen_pip_requirement_list, _validate_pip_requirement_string(req_str=req_str))
 
+    if add_local_version_specifier:
+        # For any requirement string that does not contain a specifier, add the specifier of a locally installed version
+        # if it exists.
+        seen_pip_requirement_list = list(
+            map(
+                lambda req: req if req.specifier else get_local_installed_version_of_pip_package(req),
+                seen_pip_requirement_list,
+            )
+        )
+
     return seen_pip_requirement_list
 
 
-def validate_conda_dependency_string_list(dep_str_list: List[str]) -> DefaultDict[str, List[requirements.Requirement]]:
+def validate_conda_dependency_string_list(
+    dep_str_list: list[str], add_local_version_specifier: bool = False
+) -> DefaultDict[str, list[requirements.Requirement]]:
     """Validate a list of conda dependency string, find any duplicate package across different channel and create a dict
         to represent the whole dependencies.
 
     Args:
         dep_str_list: The list of string contains the conda dependency specification.
+        add_local_version_specifier: if True, add the version specifier of the locally installed package version to
+            requirements without version specifiers.
 
     Returns:
         A dict mapping from the channel name to the list of requirements from that channel.
     """
     validated_conda_dependency_list = list(map(_validate_conda_dependency_string, dep_str_list))
-    ret_conda_dependency_dict: DefaultDict[str, List[requirements.Requirement]] = collections.defaultdict(list)
+    ret_conda_dependency_dict: DefaultDict[str, list[requirements.Requirement]] = collections.defaultdict(list)
     for p_channel, p_req in validated_conda_dependency_list:
         append_conda_dependency(ret_conda_dependency_dict, (p_channel, p_req))
 
+    if add_local_version_specifier:
+        # For any conda dependency string that does not contain a specifier, add the specifier of a locally installed
+        # version if it exists. This is best-effort: if the conda package does not have the same name as the pip
+        # package, it won't be found in the local environment.
+        for channel_str, reqs in ret_conda_dependency_dict.items():
+            reqs = list(
+                map(lambda req: req if req.specifier else get_local_installed_version_of_pip_package(req), reqs)
+            )
+            ret_conda_dependency_dict[channel_str] = reqs
+
     return ret_conda_dependency_dict
 
 
 def get_local_installed_version_of_pip_package(pip_req: requirements.Requirement) -> requirements.Requirement:
     """Get the local installed version of a given pip package requirement.
-        If the package is locally installed, and the local version meet the specifier of the requirements, return a new
+        If the package is locally installed, and the local version meets the specifier of the requirements, return a new
         requirement specifier that pins the version.
-        If the local version does not meet the specifier of the requirements, a warn will be omitted and returns
+        If the local version does not meet the specifier of the requirements, a warning will be emitted and returns
         the original package requirement.
         If the package is not locally installed or not found, the original package requirement is returned.
 
@@ -217,7 +246,7 @@ def get_local_installed_version_of_pip_package(pip_req: requirements.Requirement
         local_dist_version = local_dist.version
     except importlib_metadata.PackageNotFoundError:
         if pip_req.name == SNOWPARK_ML_PKG_NAME:
-            local_dist_version = snowml_env.VERSION
+            local_dist_version = snowml_version.VERSION
         else:
             return pip_req
     new_pip_req = copy.deepcopy(pip_req)
@@ -372,8 +401,8 @@ def relax_requirement_version(req: requirements.Requirement) -> requirements.Req
 
 
 def get_matched_package_versions_in_information_schema_with_active_session(
-    reqs: List[requirements.Requirement], python_version: str
-) -> Dict[str, List[version.Version]]:
+    reqs: list[requirements.Requirement], python_version: str
+) -> dict[str, list[version.Version]]:
     try:
         session = context.get_active_session()
     except exceptions.SnowparkSessionException:
@@ -383,10 +412,10 @@ def get_matched_package_versions_in_information_schema_with_active_session(
 
 def get_matched_package_versions_in_information_schema(
     session: session.Session,
-    reqs: List[requirements.Requirement],
+    reqs: list[requirements.Requirement],
     python_version: str,
-    statement_params: Optional[Dict[str, Any]] = None,
-) -> Dict[str, List[version.Version]]:
+    statement_params: Optional[dict[str, Any]] = None,
+) -> dict[str, list[version.Version]]:
     """Look up the information_schema table to check if a package with the specified specifier exists in the Snowflake
     Conda channel. Note that this is not the source of truth due to the potential delay caused by a package that might
     exist in the information_schema table but has not yet become available in the Snowflake Conda channel.
@@ -400,8 +429,8 @@ def get_matched_package_versions_in_information_schema(
     Returns:
         A Dict, whose key is the package name, and value is a list of versions match the requirements.
     """
-    ret_dict: Dict[str, List[version.Version]] = {}
-    reqs_to_request: List[requirements.Requirement] = []
+    ret_dict: dict[str, list[version.Version]] = {}
+    reqs_to_request: list[requirements.Requirement] = []
     for req in reqs:
         if req.name in _SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE:
             available_versions = list(
@@ -457,7 +486,7 @@ def get_matched_package_versions_in_information_schema(
 
 def save_conda_env_file(
     path: pathlib.Path,
-    conda_chan_deps: DefaultDict[str, List[requirements.Requirement]],
+    conda_chan_deps: DefaultDict[str, list[requirements.Requirement]],
     python_version: str,
     cuda_version: Optional[str] = None,
     default_channel_override: str = SNOWFLAKE_CONDA_CHANNEL_URL,
@@ -478,7 +507,7 @@ def save_conda_env_file(
     """
     assert path.suffix in [".yml", ".yaml"], "Conda environment file should have extension of yml or yaml."
     path.parent.mkdir(parents=True, exist_ok=True)
-    env: Dict[str, Any] = dict()
+    env: dict[str, Any] = dict()
     env["name"] = "snow-env"
     # Get all channels in the dependencies, ordered by the number of the packages which belongs to and put into
     # channels section.
@@ -505,7 +534,7 @@ def save_conda_env_file(
         yaml.safe_dump(env, stream=f, default_flow_style=False)
 
 
-def save_requirements_file(path: pathlib.Path, pip_deps: List[requirements.Requirement]) -> None:
+def save_requirements_file(path: pathlib.Path, pip_deps: list[requirements.Requirement]) -> None:
     """Generate Python requirements.txt file in the given directory path.
 
     Args:
@@ -521,9 +550,9 @@ def save_requirements_file(path: pathlib.Path, pip_deps: List[requirements.Requi
 
 def load_conda_env_file(
     path: pathlib.Path,
-) -> Tuple[
-    DefaultDict[str, List[requirements.Requirement]],
-    Optional[List[requirements.Requirement]],
+) -> tuple[
+    DefaultDict[str, list[requirements.Requirement]],
+    Optional[list[requirements.Requirement]],
     Optional[str],
     Optional[str],
 ]:
@@ -601,7 +630,7 @@ def load_conda_env_file(
     return conda_dep_dict, pip_deps_list if pip_deps_list else None, python_version, cuda_version
 
 
-def load_requirements_file(path: pathlib.Path) -> List[requirements.Requirement]:
+def load_requirements_file(path: pathlib.Path) -> list[requirements.Requirement]:
     """Load Python requirements.txt file from the given directory path.
 
     Args:
@@ -641,8 +670,8 @@ def parse_python_version_string(dep: str) -> Optional[str]:
 
 
 def _find_conda_dep_spec(
-    conda_chan_deps: DefaultDict[str, List[requirements.Requirement]], pkg_name: str
-) -> Optional[Tuple[str, requirements.Requirement]]:
+    conda_chan_deps: DefaultDict[str, list[requirements.Requirement]], pkg_name: str
+) -> Optional[tuple[str, requirements.Requirement]]:
     for channel in conda_chan_deps:
         spec = next(filter(lambda req: req.name == pkg_name, conda_chan_deps[channel]), None)
         if spec:
@@ -650,14 +679,14 @@ def _find_conda_dep_spec(
     return None
 
 
-def _find_pip_req_spec(pip_reqs: List[requirements.Requirement], pkg_name: str) -> Optional[requirements.Requirement]:
+def _find_pip_req_spec(pip_reqs: list[requirements.Requirement], pkg_name: str) -> Optional[requirements.Requirement]:
     spec = next(filter(lambda req: req.name == pkg_name, pip_reqs), None)
     return spec
 
 
 def find_dep_spec(
-    conda_chan_deps: DefaultDict[str, List[requirements.Requirement]],
-    pip_reqs: List[requirements.Requirement],
+    conda_chan_deps: DefaultDict[str, list[requirements.Requirement]],
+    pip_reqs: list[requirements.Requirement],
     conda_pkg_name: str,
     pip_pkg_name: Optional[str] = None,
     remove_spec: bool = False,