snowflake-ml-python 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

snowflake/cortex/__init__.py

@@ -1,24 +1,32 @@
-from snowflake.cortex._classify_text import ClassifyText
-from snowflake.cortex._complete import Complete, CompleteOptions
-from snowflake.cortex._embed_text_768 import EmbedText768
-from snowflake.cortex._embed_text_1024 import EmbedText1024
-from snowflake.cortex._extract_answer import ExtractAnswer
+from snowflake.cortex._classify_text import ClassifyText, classify_text
+from snowflake.cortex._complete import Complete, CompleteOptions, 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
 from snowflake.cortex._finetune import Finetune, FinetuneJob, FinetuneStatus
-from snowflake.cortex._sentiment import Sentiment
-from snowflake.cortex._summarize import Summarize
-from snowflake.cortex._translate import Translate
+from snowflake.cortex._sentiment import Sentiment, sentiment
+from snowflake.cortex._summarize import Summarize, summarize
+from snowflake.cortex._translate import Translate, translate
 
 __all__ = [
     "ClassifyText",
+    "classify_text",
     "Complete",
+    "complete",
     "CompleteOptions",
     "EmbedText768",
+    "embed_text_768",
     "EmbedText1024",
+    "embed_text_1024",
     "ExtractAnswer",
+    "extract_answer",
     "Finetune",
     "FinetuneJob",
     "FinetuneStatus",
     "Sentiment",
+    "sentiment",
     "Summarize",
+    "summarize",
     "Translate",
+    "translate",
 ]

snowflake/cortex/_classify_text.py

@@ -1,5 +1,7 @@
 from typing import List, Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,7 +10,7 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def ClassifyText(
+def classify_text(
     str_input: Union[str, snowpark.Column],
     categories: Union[List[str], snowpark.Column],
     session: Optional[snowpark.Session] = None,
@@ -34,3 +36,12 @@ def _classify_text_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     return cast(Union[str, snowpark.Column], call_sql_function(function, session, str_input, categories))
+
+
+ClassifyText = deprecated(
+    "ClassifyText() is deprecated and will be removed in a future release. Please use classify_text() instead."
+)(
+    telemetry.send_api_usage_telemetry(
+        project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
+    )(classify_text)
+)

snowflake/cortex/_complete.py

@@ -6,7 +6,7 @@ from typing import Any, Callable, Dict, Iterator, List, Optional, TypedDict, Uni
 from urllib.parse import urlunparse
 
 import requests
-from typing_extensions import NotRequired
+from typing_extensions import NotRequired, deprecated
 
 from snowflake import snowpark
 from snowflake.cortex._sse_client import SSEClient
@@ -49,6 +49,10 @@ class CompleteOptions(TypedDict):
     generally used as an alternative to temperature. The difference is that top_p restricts the set of possible tokens
     that the model outputs, while temperature influences which tokens are chosen at each step. """
 
+    guardrails: NotRequired[bool]
+    """ A boolean value that controls whether Cortex Guard filters unsafe or harmful responses
+    from the language model. """
+
 
 class ResponseParseException(Exception):
     """This exception is raised when the server response cannot be parsed."""
@@ -56,6 +60,15 @@ class ResponseParseException(Exception):
     pass
 
 
+class GuardrailsOptions(TypedDict):
+    enabled: bool
+    """A boolean value that controls whether Cortex Guard filters unsafe or harmful responses
+    from the language model."""
+
+    response_when_unsafe: str
+    """The response to return when the language model generates unsafe or harmful content."""
+
+
 _MAX_RETRY_SECONDS = 30
 
 
@@ -117,6 +130,12 @@ def _make_request_body(
             data["temperature"] = options["temperature"]
         if "top_p" in options:
             data["top_p"] = options["top_p"]
+        if "guardrails" in options and options["guardrails"]:
+            guardrails_options: GuardrailsOptions = {
+                "enabled": True,
+                "response_when_unsafe": "Response filtered by Cortex Guard",
+            }
+            data["guardrails"] = guardrails_options
     return data
 
 
@@ -127,8 +146,26 @@ def _xp_dict_to_response(raw_resp: Dict[str, Any]) -> requests.Response:
     response.status_code = int(raw_resp["status"])
     response.headers = raw_resp["headers"]
 
+    request_id = None
+    for key, value in raw_resp["headers"].items():
+        # Note: there is some whitespace in the headers making it not possible
+        # to directly index the header reliably.
+        if key.strip().lower() == "x-snowflake-request-id":
+            request_id = value
+            break
+
     data = raw_resp["content"]
-    data = json.loads(data)
+    try:
+        data = json.loads(data)
+    except json.JSONDecodeError:
+        raise ValueError(f"Request failed (request id: {request_id})")
+
+    if response.status_code < 200 or response.status_code >= 300:
+        if "message" not in data:
+            raise ValueError(f"Request failed (request id: {request_id})")
+        message = data["message"]
+        raise ValueError(f"Request failed: {message} (request id: {request_id})")
+
     # Convert the dictionary to a string format that resembles the SSE event format
     # For example, if the dict is {'event': 'message', 'data': 'your data'}, it should be formatted like this:
     sse_format_data = ""
@@ -144,6 +181,7 @@ 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]]],
     model: str,
     prompt: Union[str, List[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
@@ -151,9 +189,8 @@ def _call_complete_xp(
 ) -> requests.Response:
     headers = _make_common_request_headers()
     body = _make_request_body(model, prompt, options)
-    import _snowflake
-
-    raw_resp = _snowflake.send_snow_api_request("POST", _REST_COMPLETE_URL, {}, headers, body, {}, deadline)
+    assert snow_api_xp_request_handler is not None
+    raw_resp = snow_api_xp_request_handler("POST", _REST_COMPLETE_URL, {}, headers, body, {}, deadline)
     return _xp_dict_to_response(raw_resp)
 
 
@@ -218,17 +255,26 @@ def _complete_call_sql_function_snowpark(
 
 
 def _complete_non_streaming_immediate(
+    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
     model: str,
     prompt: Union[str, List[ConversationMessage]],
     options: Optional[CompleteOptions],
     session: Optional[snowpark.Session] = None,
     deadline: Optional[float] = None,
 ) -> str:
-    response = _complete_rest(model=model, prompt=prompt, options=options, session=session, deadline=deadline)
+    response = _complete_rest(
+        snow_api_xp_request_handler=snow_api_xp_request_handler,
+        model=model,
+        prompt=prompt,
+        options=options,
+        session=session,
+        deadline=deadline,
+    )
     return "".join(response)
 
 
 def _complete_non_streaming_impl(
+    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
     function: str,
     model: Union[str, snowpark.Column],
     prompt: Union[str, List[ConversationMessage], snowpark.Column],
@@ -246,19 +292,31 @@ def _complete_non_streaming_impl(
     if isinstance(options, snowpark.Column):
         raise ValueError("'options' cannot be a snowpark.Column when 'prompt' is a string.")
     return _complete_non_streaming_immediate(
-        model=model, prompt=prompt, options=options, session=session, deadline=deadline
+        snow_api_xp_request_handler=snow_api_xp_request_handler,
+        model=model,
+        prompt=prompt,
+        options=options,
+        session=session,
+        deadline=deadline,
     )
 
 
 def _complete_rest(
+    snow_api_xp_request_handler: Optional[Callable[..., Dict[str, Any]]],
     model: str,
     prompt: Union[str, List[ConversationMessage]],
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,
     deadline: Optional[float] = None,
 ) -> Iterator[str]:
-    if is_in_stored_procedure():  # type: ignore[no-untyped-call]
-        response = _call_complete_xp(model=model, prompt=prompt, options=options, deadline=deadline)
+    if snow_api_xp_request_handler is not None:
+        response = _call_complete_xp(
+            snow_api_xp_request_handler=snow_api_xp_request_handler,
+            model=model,
+            prompt=prompt,
+            options=options,
+            deadline=deadline,
+        )
     else:
         response = _call_complete_rest(model=model, prompt=prompt, options=options, session=session, deadline=deadline)
     assert response.status_code >= 200 and response.status_code < 300
@@ -268,10 +326,11 @@ 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,
+    function: str = "snowflake.cortex.complete",
     options: Optional[CompleteOptions] = None,
     session: Optional[snowpark.Session] = None,
     stream: bool = False,
-    function: str = "snowflake.cortex.complete",
     timeout: Optional[float] = None,
     deadline: Optional[float] = None,
 ) -> Union[str, Iterator[str], snowpark.Column]:
@@ -284,14 +343,29 @@ def _complete_impl(
             raise ValueError("in REST mode, 'model' must be a string")
         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(model=model, prompt=prompt, options=options, session=session, deadline=deadline)
-    return _complete_non_streaming_impl(function, model, prompt, options, session, deadline)
+        return _complete_rest(
+            snow_api_xp_request_handler=snow_api_xp_request_handler,
+            model=model,
+            prompt=prompt,
+            options=options,
+            session=session,
+            deadline=deadline,
+        )
+    return _complete_non_streaming_impl(
+        snow_api_xp_request_handler=snow_api_xp_request_handler,
+        function=function,
+        model=model,
+        prompt=prompt,
+        options=options,
+        session=session,
+        deadline=deadline,
+    )
 
 
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def Complete(
+def complete(
     model: Union[str, snowpark.Column],
     prompt: Union[str, List[ConversationMessage], snowpark.Column],
     *,
@@ -319,10 +393,19 @@ def Complete(
     Returns:
         A column of string responses.
     """
+
+    # Set the XP snow api function, if available.
+    snow_api_xp_request_handler = None
+    if is_in_stored_procedure():  # type: ignore[no-untyped-call]
+        import _snowflake
+
+        snow_api_xp_request_handler = _snowflake.send_snow_api_request
+
     try:
         return _complete_impl(
             model,
             prompt,
+            snow_api_xp_request_handler=snow_api_xp_request_handler,
             options=options,
             session=session,
             stream=stream,
@@ -331,3 +414,8 @@ def Complete(
         )
     except ValueError as err:
         raise err
+
+
+Complete = deprecated("Complete() is deprecated and will be removed in a future release. Use complete() instead")(
+    telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(complete)
+)

snowflake/cortex/_embed_text_1024.py

@@ -1,5 +1,7 @@
 from typing import List, Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,12 +10,12 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def EmbedText1024(
+def embed_text_1024(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[List[float], snowpark.Column]:
-    """TextEmbed calls into the LLM inference service to embed the text.
+    """Calls into the LLM inference service to embed the text.
 
     Args:
         model: A Column of strings representing the model to use for embedding. The value
@@ -35,3 +37,8 @@ def _embed_text_1024_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[List[float], snowpark.Column]:
     return cast(Union[List[float], snowpark.Column], call_sql_function(function, session, model, text))
+
+
+EmbedText1024 = deprecated(
+    "EmbedText1024() is deprecated and will be removed in a future release. Use embed_text_1024() instead"
+)(telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(embed_text_1024))

snowflake/cortex/_embed_text_768.py

@@ -1,5 +1,7 @@
 from typing import List, Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,12 +10,12 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def EmbedText768(
+def embed_text_768(
     model: Union[str, snowpark.Column],
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[List[float], snowpark.Column]:
-    """TextEmbed calls into the LLM inference service to embed the text.
+    """Calls into the LLM inference service to embed the text.
 
     Args:
         model: A Column of strings representing the model to use for embedding. The value
@@ -35,3 +37,8 @@ def _embed_text_768_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[List[float], snowpark.Column]:
     return cast(Union[List[float], snowpark.Column], call_sql_function(function, session, model, text))
+
+
+EmbedText768 = deprecated(
+    "EmbedText768() is deprecated and will be removed in a future release. Use embed_text_768() instead"
+)(telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(embed_text_768))

snowflake/cortex/_extract_answer.py

@@ -1,5 +1,7 @@
 from typing import Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,12 +10,12 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def ExtractAnswer(
+def extract_answer(
     from_text: Union[str, snowpark.Column],
     question: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
-    """ExtractAnswer calls into the LLM inference service to extract an answer from within specified text.
+    """Calls into the LLM inference service to extract an answer from within specified text.
 
     Args:
         from_text: A Column of strings representing input text.
@@ -34,3 +36,8 @@ def _extract_answer_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     return cast(Union[str, snowpark.Column], call_sql_function(function, session, from_text, question))
+
+
+ExtractAnswer = deprecated(
+    "ExtractAnswer() is deprecated and will be removed in a future release. Use extract_answer() instead"
+)(telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(extract_answer))

snowflake/cortex/_sentiment.py

@@ -1,5 +1,7 @@
 from typing import Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,10 +10,10 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def Sentiment(
+def sentiment(
     text: Union[str, snowpark.Column], session: Optional[snowpark.Session] = None
 ) -> Union[float, snowpark.Column]:
-    """Sentiment calls into the LLM inference service to perform sentiment analysis on the input text.
+    """Calls into the LLM inference service to perform sentiment analysis on the input text.
 
     Args:
         text: A Column of text strings to send to the LLM.
@@ -31,3 +33,8 @@ def _sentiment_impl(
     if isinstance(output, snowpark.Column):
         return output
     return float(cast(str, output))
+
+
+Sentiment = deprecated("Sentiment() is deprecated and will be removed in a future release. Use sentiment() instead")(
+    telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(sentiment)
+)

snowflake/cortex/_summarize.py

@@ -1,5 +1,7 @@
 from typing import Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,11 +10,11 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def Summarize(
+def summarize(
     text: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
-    """Summarize calls into the LLM inference service to summarize the input text.
+    """Calls into the LLM inference service to summarize the input text.
 
     Args:
         text: A Column of strings to summarize.
@@ -31,3 +33,8 @@ def _summarize_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     return cast(Union[str, snowpark.Column], call_sql_function(function, session, text))
+
+
+Summarize = deprecated("Summarize() is deprecated and will be removed in a future release. Use summarize() instead")(
+    telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(summarize)
+)

snowflake/cortex/_translate.py

@@ -1,5 +1,7 @@
 from typing import Optional, Union, cast
 
+from typing_extensions import deprecated
+
 from snowflake import snowpark
 from snowflake.cortex._util import CORTEX_FUNCTIONS_TELEMETRY_PROJECT, call_sql_function
 from snowflake.ml._internal import telemetry
@@ -8,13 +10,13 @@ from snowflake.ml._internal import telemetry
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
-def Translate(
+def translate(
     text: Union[str, snowpark.Column],
     from_language: Union[str, snowpark.Column],
     to_language: Union[str, snowpark.Column],
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
-    """Translate calls into the LLM inference service to perform translation.
+    """Calls into the LLM inference service to perform translation.
 
     Args:
         text: A Column of strings to translate.
@@ -37,3 +39,8 @@ def _translate_impl(
     session: Optional[snowpark.Session] = None,
 ) -> Union[str, snowpark.Column]:
     return cast(Union[str, snowpark.Column], call_sql_function(function, session, text, from_language, to_language))
+
+
+Translate = deprecated("Translate() is deprecated and will be removed in a future release. Use translate() instead")(
+    telemetry.send_api_usage_telemetry(project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT)(translate)
+)

snowflake/ml/_internal/env_utils.py

@@ -15,7 +15,6 @@ import snowflake.connector
 from snowflake.ml._internal import env as snowml_env
 from snowflake.ml._internal.utils import query_result_checker
 from snowflake.snowpark import context, exceptions, session
-from snowflake.snowpark._internal import utils as snowpark_utils
 
 
 class CONDA_OS(Enum):
@@ -344,55 +343,6 @@ def relax_requirement_version(req: requirements.Requirement) -> requirements.Req
     return new_req
 
 
-def get_matched_package_versions_in_snowflake_conda_channel(
-    req: requirements.Requirement,
-    python_version: str = snowml_env.PYTHON_VERSION,
-    conda_os: CONDA_OS = CONDA_OS.LINUX_64,
-) -> List[version.Version]:
-    """Search the snowflake anaconda channel for packages that matches the specifier. Note that this will be the
-    source of truth for checking whether a package indeed exists in Snowflake conda channel.
-
-    Given that a package comes in different architectures, we only check for the Linux x86_64 architecture and assume
-    the package exists in other architectures. If such an assumption does not hold true for a certain package, the
-    caller should specify the architecture to search for.
-
-    Args:
-        req: Requirement specifier.
-        python_version: A string of python version where model is run.
-        conda_os: Specified platform to search availability of the package.
-
-    Returns:
-        List of package versions that meet the requirement specifier.
-    """
-    # Move the retryable_http import here as when UDF import this file, it won't have the "requests" dependency.
-    from snowflake.ml._internal.utils import retryable_http
-
-    assert not snowpark_utils.is_in_stored_procedure()  # type: ignore[no-untyped-call]
-
-    url = f"{SNOWFLAKE_CONDA_CHANNEL_URL}/{conda_os.value}/repodata.json"
-
-    if req.name not in _SNOWFLAKE_CONDA_PACKAGE_CACHE:
-        try:
-            http_client = retryable_http.get_http_client()
-            parsed_python_version = version.Version(python_version)
-            python_version_build_str = f"py{parsed_python_version.major}{parsed_python_version.minor}"
-            repodata = http_client.get(url).json()
-            assert isinstance(repodata, dict)
-            packages_info = repodata["packages"]
-            assert isinstance(packages_info, dict)
-            version_list = [
-                version.parse(package_info["version"])
-                for package_info in packages_info.values()
-                if package_info["name"] == req.name and python_version_build_str in package_info["build"]
-            ]
-            _SNOWFLAKE_CONDA_PACKAGE_CACHE[req.name] = version_list
-        except Exception:
-            pass
-
-    matched_versions = list(req.specifier.filter(set(_SNOWFLAKE_CONDA_PACKAGE_CACHE.get(req.name, []))))
-    return matched_versions
-
-
 def get_matched_package_versions_in_information_schema_with_active_session(
     reqs: List[requirements.Requirement], python_version: str
 ) -> Dict[str, List[version.Version]]:
@@ -404,7 +354,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], python_version: str
+    session: session.Session,
+    reqs: List[requirements.Requirement],
+    python_version: str,
+    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
@@ -414,6 +367,7 @@ def get_matched_package_versions_in_information_schema(
         session: Snowflake connection session.
         reqs: List of requirement specifiers.
         python_version: A string of python version where model is run.
+        statement_params: Optional statement parameters.
 
     Returns:
         A Dict, whose key is the package name, and value is a list of versions match the requirements.
@@ -451,8 +405,9 @@ def get_matched_package_versions_in_information_schema(
                 query_result_checker.SqlResultValidator(
                     session=session,
                     query=sql,
+                    statement_params=statement_params,
                 )
-                .has_column("VERSION")
+                .has_column("VERSION", allow_empty=True)
                 .has_dimensions(expected_rows=None, expected_cols=2)
                 .validate()
             )

snowflake/ml/_internal/platform_capabilities.py

@@ -0,0 +1,87 @@
+import json
+from typing import Any, Dict, Optional
+
+from absl import logging
+
+from snowflake.ml._internal.exceptions import error_codes, exceptions
+from snowflake.ml._internal.utils import query_result_checker
+from snowflake.snowpark import (
+    exceptions as snowpark_exceptions,
+    session as snowpark_session,
+)
+
+
+class PlatformCapabilities:
+    """Class that retrieves platform feature values for the currently running server.
+
+    Example usage:
+    ```
+    pc = PlatformCapabilities.get_instance(session)
+    if pc.is_nested_function_enabled():
+        # Nested functions are enabled.
+        print("Nested functions are enabled.")
+    else:
+        # Nested functions are disabled.
+        print("Nested functions are disabled or not supported.")
+    ```
+    """
+
+    _instance: Optional["PlatformCapabilities"] = None
+
+    @classmethod
+    def get_instance(cls, session: Optional[snowpark_session.Session] = None) -> "PlatformCapabilities":
+        if not cls._instance:
+            cls._instance = cls(session)
+        return cls._instance
+
+    def is_nested_function_enabled(self) -> bool:
+        return self._get_bool_feature("SPCS_MODEL_ENABLE_EMBEDDED_SERVICE_FUNCTIONS", False)
+
+    @staticmethod
+    def _get_features(session: snowpark_session.Session) -> Dict[str, Any]:
+        try:
+            result = (
+                query_result_checker.SqlResultValidator(
+                    session=session,
+                    query="SELECT SYSTEM$ML_PLATFORM_CAPABILITIES() AS FEATURES;",
+                )
+                .has_dimensions(expected_rows=1, expected_cols=1)
+                .has_column("FEATURES")
+                .validate()[0]
+            )
+            if "FEATURES" in result:
+                capabilities_json: str = result["FEATURES"]
+                try:
+                    parsed_json = json.loads(capabilities_json)
+                    assert isinstance(parsed_json, dict), f"Expected JSON object, got {type(parsed_json)}"
+                    return parsed_json
+                except json.JSONDecodeError as e:
+                    message = f"""Unable to parse JSON from: "{capabilities_json}"; Error="{e}"."""
+                    raise exceptions.SnowflakeMLException(
+                        error_code=error_codes.INTERNAL_SNOWML_ERROR, original_exception=RuntimeError(message)
+                    )
+        except snowpark_exceptions.SnowparkSQLException as e:
+            logging.debug(f"Failed to retrieve platform capabilities: {e}")
+            # This can happen is server side is older than 9.2. That is fine.
+        return {}
+
+    def __init__(self, session: Optional[snowpark_session.Session] = None) -> None:
+        if not session:
+            session = next(iter(snowpark_session._get_active_sessions()))
+            assert session, "Missing active session object"
+        self.features: Dict[str, Any] = PlatformCapabilities._get_features(session)
+
+    def _get_bool_feature(self, feature_name: str, default_value: bool) -> bool:
+        value = self.features.get(feature_name, default_value)
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, int) and value in [0, 1]:
+            return value == 1
+        if isinstance(value, str):
+            if value.lower() in ["true", "1"]:
+                return True
+            elif value.lower() in ["false", "0"]:
+                return False
+            else:
+                raise ValueError(f"Invalid boolean string: {value} for feature {feature_name}")
+        raise ValueError(f"Invalid boolean feature value: {value} for feature {feature_name}")