snowflake-ml-python 1.3.1__py3-none-any.whl → 1.4.1__py3-none-any.whl

snowflake/ml/fileset/sfcfs.py

@@ -60,6 +60,8 @@ class SFFileSystem(fsspec.AbstractFileSystem):
     b'2014-02-05 14:35:00.00000054,13,2014-02-05 14:35:00 UTC,-74.00688,40.73049,-74.00563,40.70676,2\n'
     """
 
+    protocol = PROTOCOL_NAME
+
     def __init__(
         self,
         sf_connection: Optional[connection.SnowflakeConnection] = None,
@@ -204,7 +206,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
         >>> sffs.ls("@MYDB.public.FOO/nytrain/")
         ['@MYDB.public.FOO/nytrain/data_0_0_0.csv', '@MYDB.public.FOO/nytrain/data_0_0_1.csv']
         """
-        file_path = _parse_sfc_file_path(path)
+        file_path = self._parse_file_path(path)
         stage_fs = self._get_stage_fs(file_path)
         stage_path_list = stage_fs.ls(file_path.filepath, detail=True, **kwargs)
         stage_path_list = cast(List[Dict[str, Any]], stage_path_list)
@@ -226,13 +228,15 @@ class SFFileSystem(fsspec.AbstractFileSystem):
         """
         if not files:
             return
-        stage_file_paths: Dict[Tuple[str, str, str], List[str]] = collections.defaultdict(list)
+        stage_fs_dict: Dict[str, stage_fs.SFStageFileSystem] = {}
+        stage_file_paths: Dict[str, List[str]] = collections.defaultdict(list)
         for file in files:
-            file_path = _parse_sfc_file_path(file)
-            stage_file_paths[(file_path.database, file_path.schema, file_path.stage)].append(file_path.filepath)
+            path_info = self._parse_file_path(file)
+            fs = self._get_stage_fs(path_info)
+            stage_fs_dict[fs.stage_name] = fs
+            stage_file_paths[fs.stage_name].append(path_info.filepath)
         for k, v in stage_file_paths.items():
-            stage_fs = self._get_stage_fs(_SFFilePath(k[0], k[1], k[2], "*"))
-            stage_fs.optimize_read(v)
+            stage_fs_dict[k].optimize_read(v)
 
     @telemetry.send_api_usage_telemetry(
         project=_PROJECT,
@@ -256,7 +260,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
         Returns:
             A fsspec AbstractBufferedFile which supports python file operations.
         """
-        file_path = _parse_sfc_file_path(path)
+        file_path = self._parse_file_path(path)
         stage_fs = self._get_stage_fs(file_path)
         return stage_fs._open(file_path.filepath, **kwargs)
 
@@ -267,7 +271,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
     @snowpark._internal.utils.private_preview(version="0.2.0")
     def info(self, path: str, **kwargs: Any) -> Dict[str, Any]:
         """Override fsspec `info` method. Give details of entry at path."""
-        file_path = _parse_sfc_file_path(path)
+        file_path = self._parse_file_path(path)
         stage_fs = self._get_stage_fs(file_path)
         res: Dict[str, Any] = stage_fs.info(file_path.filepath, **kwargs)
         if res:
@@ -292,52 +296,54 @@ class SFFileSystem(fsspec.AbstractFileSystem):
         """Convert the relative path in a stage to an absolute path starts with the location of the stage."""
         return stage_fs.stage_name + "/" + path
 
+    @classmethod
+    def _parse_file_path(cls, path: str) -> _SFFilePath:
+        """Parse a snowflake location path.
 
-fsspec.register_implementation(PROTOCOL_NAME, SFFileSystem)
-
+        The following propertis will be extracted from the path input:
+        - database
+        - schema
+        - stage
+        - path (optional)
 
-def _parse_sfc_file_path(path: str) -> _SFFilePath:
-    """Parse a snowflake location path.
+        Args:
+            path: A string in the format of "@{database}.{schema}.{stage}/{path}".
 
-    The following propertis will be extracted from the path input:
-    - database
-    - schema
-    - stage
-    - path (optional)
+                Example:
+                    "@my_db.my_schema.my_stage/"
+                    "@my_db.my_schema.my_stage/file1"
+                    "@my_db.my_schema.my_stage/dir1/"
+                    "@my_db.my_schema.my_stage/dir1/file2"
 
-    Args:
-        path: A string in the format of "@{database}.{schema}.{stage}/{path}".
+        Returns:
+            A namedtuple consists of database name, schema name, stage name and path.
 
-            Example:
-                "@my_db.my_schema.my_stage/"
-                "@my_db.my_schema.my_stage/file1"
-                "@my_db.my_schema.my_stage/dir1/"
-                "@my_db.my_schema.my_stage/dir1/file2"
+        Raises:
+            SnowflakeMLException: An error occurred when invalid path is given.
+        """
+        sfc_prefix = f"{PROTOCOL_NAME}://"
+        if path.startswith(sfc_prefix):
+            path = path[len(sfc_prefix) :]
+        if not path.startswith("@"):
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.SNOWML_INVALID_STAGE,
+                original_exception=ValueError(
+                    'Invalid path. Expected path to start with "@". Example: @database.schema.stage/optional_path.'
+                ),
+            )
+        try:
+            res = identifier.parse_schema_level_object_identifier(path[1:])
+            if res[1] is None or res[0] is None or (res[3] and not res[3].startswith("/")):
+                raise ValueError("Invalid path. Missing database or schema identifier.")
+            logging.debug(f"Parsed path: {res}")
+            return _SFFilePath(res[0], res[1], res[2], res[3][1:])
+        except ValueError:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.SNOWML_INVALID_STAGE,
+                original_exception=ValueError(
+                    f"Invalid path. Expected format: @database.schema.stage/optional_path. Getting {path}"
+                ),
+            )
 
-    Returns:
-        A namedtuple consists of database name, schema name, stage name and path.
 
-    Raises:
-        SnowflakeMLException: An error occurred when invalid path is given.
-    """
-    sfc_prefix = f"{PROTOCOL_NAME}://"
-    if path.startswith(sfc_prefix):
-        path = path[len(sfc_prefix) :]
-    if not path.startswith("@"):
-        raise snowml_exceptions.SnowflakeMLException(
-            error_code=error_codes.SNOWML_INVALID_STAGE,
-            original_exception=ValueError(
-                'Invalid path. Expected path to start with "@". Example: @database.schema.stage/optional_path.'
-            ),
-        )
-    try:
-        res = identifier.parse_schema_level_object_identifier(path[1:])
-        logging.debug(f"Parsed path: {res}")
-        return _SFFilePath(res[0], res[1], res[2], res[3][1:])
-    except ValueError:
-        raise snowml_exceptions.SnowflakeMLException(
-            error_code=error_codes.SNOWML_INVALID_STAGE,
-            original_exception=ValueError(
-                f"Invalid path. Expected format: @database.schema.stage/optional_path. Getting {path}"
-            ),
-        )
+fsspec.register_implementation(PROTOCOL_NAME, SFFileSystem)

snowflake/ml/fileset/stage_fs.py

@@ -8,7 +8,7 @@ import fsspec
 from fsspec.implementations import http as httpfs
 
 from snowflake import snowpark
-from snowflake.connector import connection
+from snowflake.connector import connection, errorcode
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.exceptions import (
     error_codes,
@@ -17,6 +17,7 @@ from snowflake.ml._internal.exceptions import (
     fileset_errors,
 )
 from snowflake.snowpark import exceptions as snowpark_exceptions
+from snowflake.snowpark._internal import utils as snowpark_utils
 
 # The default length of how long a presigned url stays active in seconds.
 # Presigned url here is used to fetch file objects from Snowflake when SFStageFileSystem.open() is called.
@@ -79,7 +80,9 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
     #   None -> Try pre-signed URL access, fall back to file download
     #   True -> Use file download path without trying pre-signed URL access
     #   False -> Use pre-signed URL access, skip download fallback on failure
-    _USE_FALLBACK_FILE_ACCESS = None
+    _USE_FALLBACK_FILE_ACCESS = (
+        True if snowpark_utils.is_in_stored_procedure() else None  # type: ignore[no-untyped-call]
+    )
 
     def __init__(
         self,
@@ -164,6 +167,7 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
         """
         try:
             loc = self.stage_name
+            path = path.lstrip("/")
             objects = self._session.sql(f"LIST {loc}/{path}").collect()
         except snowpark_exceptions.SnowparkClientException as e:
             if e.message.startswith(fileset_errors.ERRNO_DOMAIN_NOT_EXIST):
@@ -234,7 +238,7 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
         """
         path = path.lstrip("/")
         if self._USE_FALLBACK_FILE_ACCESS:
-            return self._session.file.get_stream(f"{self.stage_name}/{path}")
+            return self._open_with_snowpark(path)
         cached_presigned_url = self._url_cache.get(path, None)
         if not cached_presigned_url:
             res = self._fetch_presigned_urls([path])
@@ -252,19 +256,42 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
         except FileNotFoundError:
             # Enable fallback if _USE_FALLBACK_FILE_ACCESS is True or None; set to False to disable
             if self._USE_FALLBACK_FILE_ACCESS != False:  # noqa: E712
-                try:
-                    # Try falling back to Snowpark file read if presigned URL access failed
-                    # If fallback is successful, most likely in sproc without External Access Integration
-                    content = self._session.file.get_stream(f"{self.stage_name}/{path}")
-                    self._USE_FALLBACK_FILE_ACCESS = True
-                    return content
-                except Exception:
-                    pass
+                content = self._open_with_snowpark(path)
+                self._USE_FALLBACK_FILE_ACCESS = True
+                return content
             raise snowml_exceptions.SnowflakeMLException(
                 error_code=error_codes.SNOWML_NOT_FOUND,
                 original_exception=fileset_errors.StageFileNotFoundError(f"Stage file {path} doesn't exist."),
             )
 
+    def _open_with_snowpark(self, path: str, **kwargs: Dict[str, Any]) -> fsspec.spec.AbstractBufferedFile:
+        """Open the a file for reading using snowflake.snowpark.file_operation
+
+        Args:
+            path: Path of file in Snowflake stage.
+            **kwargs: Extra options to pass to snowflake.snowpark.file_operation.get_stream
+
+        Returns:
+            A fsspec file-like object.
+
+        Raises:
+            SnowflakeMLException: An error occurred when the given path points to a file that cannot be found.
+            SnowflakeMLException: An unknown Snowpark error occurred during file read.
+        """
+        try:
+            return self._session.file.get_stream(f"{self.stage_name}/{path}", **kwargs)
+        except snowpark_exceptions.SnowparkSQLException as e:
+            if _match_error_code(e, errorcode.ER_FILE_NOT_EXISTS):
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.SNOWML_NOT_FOUND,
+                    original_exception=fileset_errors.StageFileNotFoundError(f"Stage file {path} doesn't exist."),
+                )
+            else:
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.INTERNAL_SNOWPARK_ERROR,
+                    original_exception=e,
+                )
+
     def _parse_list_result(
         self, list_result: List[Tuple[str, int, str, str]], search_path: str
     ) -> List[Dict[str, Any]]:
@@ -352,7 +379,7 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
         file_df = self._session.create_dataframe(files).to_df("name")
         try:
             presigned_urls: List[Tuple[str, str]] = file_df.select_expr(
-                f"name, get_presigned_url({self.stage_name}, name, {url_lifetime}) as url"
+                f"name, get_presigned_url('{self.stage_name}', name, {url_lifetime}) as url"
             ).collect(
                 statement_params=telemetry.get_function_usage_statement_params(
                     project=_PROJECT,
@@ -363,7 +390,9 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
                 ),
             )
         except snowpark_exceptions.SnowparkClientException as e:
-            if e.message.startswith(fileset_errors.ERRNO_STAGE_NOT_EXIST):
+            if e.message.startswith(fileset_errors.ERRNO_DOMAIN_NOT_EXIST) or e.message.startswith(
+                fileset_errors.ERRNO_STAGE_NOT_EXIST
+            ):
                 raise snowml_exceptions.SnowflakeMLException(
                     error_code=error_codes.SNOWML_NOT_FOUND,
                     original_exception=fileset_errors.StageNotFoundError(
@@ -376,3 +405,9 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
                     original_exception=fileset_errors.FileSetError(str(e)),
                 )
         return presigned_urls
+
+
+def _match_error_code(ex: snowpark_exceptions.SnowparkSQLException, error_code: int) -> bool:
+    # Snowpark writes error code to message instead of populating e.error_code
+    error_code_str = str(error_code)
+    return ex.error_code == error_code_str or error_code_str in ex.message

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

@@ -1,12 +1,9 @@
-import re
 from typing import Any, Callable, Dict, List, Optional, Union
 
 import pandas as pd
 
-from snowflake import connector
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.model import model_signature
 from snowflake.ml.model._client.ops import metadata_ops, model_ops
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
 from snowflake.snowpark import dataframe
@@ -21,6 +18,7 @@ class ModelVersion:
     _model_ops: model_ops.ModelOperator
     _model_name: sql_identifier.SqlIdentifier
     _version_name: sql_identifier.SqlIdentifier
+    _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.")
@@ -37,6 +35,7 @@ class ModelVersion:
         self._model_ops = model_ops
         self._model_name = model_name
         self._version_name = version_name
+        self._functions = self._get_functions()
         return self
 
     def __eq__(self, __value: object) -> bool:
@@ -205,39 +204,16 @@ class ModelVersion:
             statement_params=statement_params,
         )
 
-    # Only used when the model does not contains user_data with client SDK information.
-    def _legacy_show_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,
         )
-        manifest = self._model_ops.get_model_version_manifest(
+        return self._model_ops.get_functions(
             model_name=self._model_name,
             version_name=self._version_name,
             statement_params=statement_params,
         )
-        model_meta = self._model_ops.get_model_version_native_packing_meta(
-            model_name=self._model_name,
-            version_name=self._version_name,
-            statement_params=statement_params,
-        )
-        return_functions_info: List[model_manifest_schema.ModelFunctionInfo] = []
-        for method in manifest["methods"]:
-            # Method's name is resolved so we need to use case_sensitive as True to get the user-facing identifier.
-            method_name = sql_identifier.SqlIdentifier(method["name"], case_sensitive=True).identifier()
-            # Method's handler is `functions.<target_method>.infer`
-            assert re.match(
-                r"^functions\.([^\d\W]\w*)\.infer$", method["handler"]
-            ), f"Get unexpected handler name {method['handler']}"
-            target_method = method["handler"].split(".")[1]
-            signature_dict = model_meta["signatures"][target_method]
-            fi = model_manifest_schema.ModelFunctionInfo(
-                name=method_name,
-                target_method=target_method,
-                signature=model_signature.ModelSignature.from_dict(signature_dict),
-            )
-            return_functions_info.append(fi)
-        return return_functions_info
 
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -253,26 +229,7 @@ class ModelVersion:
             - target_method: The original method name in the logged Python object.
             - signature: Python signature of the original method.
         """
-        statement_params = telemetry.get_statement_params(
-            project=_TELEMETRY_PROJECT,
-            subproject=_TELEMETRY_SUBPROJECT,
-        )
-        try:
-            client_data = self._model_ops.get_client_data_in_user_data(
-                model_name=self._model_name,
-                version_name=self._version_name,
-                statement_params=statement_params,
-            )
-            return [
-                model_manifest_schema.ModelFunctionInfo(
-                    name=fi["name"],
-                    target_method=fi["target_method"],
-                    signature=model_signature.ModelSignature.from_dict(fi["signature"]),
-                )
-                for fi in client_data["functions"]
-            ]
-        except (NotImplementedError, ValueError, connector.DataError):
-            return self._legacy_show_functions()
+        return self._functions
 
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -306,7 +263,7 @@ class ModelVersion:
             subproject=_TELEMETRY_SUBPROJECT,
         )
 
-        functions: List[model_manifest_schema.ModelFunctionInfo] = self.show_functions()
+        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] = (

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

@@ -1,7 +1,7 @@
-import json
 import pathlib
 import tempfile
-from typing import Any, Dict, List, Optional, Union, cast
+from contextlib import contextmanager
+from typing import Any, Dict, Generator, List, Optional, Union, cast
 
 import yaml
 
@@ -19,7 +19,7 @@ from snowflake.ml.model._model_composer.model_manifest import (
     model_manifest,
     model_manifest_schema,
 )
-from snowflake.ml.model._packager.model_meta import model_meta, model_meta_schema
+from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.ml.model._signatures import snowpark_handler
 from snowflake.snowpark import dataframe, row, session
 from snowflake.snowpark._internal import utils as snowpark_utils
@@ -337,42 +337,91 @@ class ModelOperator:
             mm = model_manifest.ModelManifest(pathlib.Path(tmpdir))
             return mm.load()
 
-    def get_model_version_native_packing_meta(
+    @contextmanager
+    def _enable_model_details(
+        self,
+        *,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> Generator[None, None, None]:
+        self._model_client.config_model_details(enable=True, statement_params=statement_params)
+        yield
+        self._model_client.config_model_details(enable=False, statement_params=statement_params)
+
+    @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 = {}
+        for target_method in target_methods:
+            # Here we need to find the SQL function corresponding to the Python function.
+            # If the python function name is `abc`, then SQL function name can be `ABC` or `"abc"`.
+            # We will try to match`"abc"` first, then `ABC`.
+            # The reason why is because, if we have two python methods whose names are `abc` and `aBc`.
+            # At most 1 of them can be `ABC`, so if we check `"abc"` or `"aBc"` first we could resolve them correctly.
+            function_name = sql_identifier.SqlIdentifier(target_method, case_sensitive=True)
+            if function_name not in sql_functions_names:
+                function_name = sql_identifier.SqlIdentifier(target_method)
+                assert (
+                    function_name in sql_functions_names
+                ), f"Unable to match {target_method} in {sql_functions_names}."
+            res[function_name] = target_method
+        return res
+
+    def get_functions(
         self,
         *,
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
-    ) -> model_meta_schema.ModelMetadataDict:
-        with tempfile.TemporaryDirectory() as tmpdir:
-            model_meta_file_path = self._model_version_client.get_file(
+    ) -> List[model_manifest_schema.ModelFunctionInfo]:
+        with self._enable_model_details(statement_params=statement_params):
+            raw_model_spec_res = self._model_client.show_versions(
                 model_name=model_name,
                 version_name=version_name,
-                file_path=pathlib.PurePosixPath(
-                    model_composer.ModelComposer.MODEL_DIR_REL_PATH, model_meta.MODEL_METADATA_FILE
-                ),
-                target_path=pathlib.Path(tmpdir),
+                check_model_details=True,
                 statement_params=statement_params,
+            )[0][self._model_client.MODEL_VERSION_MODEL_SPEC_COL_NAME]
+            model_spec_dict = yaml.safe_load(raw_model_spec_res)
+            model_spec = model_meta.ModelMetadata._validate_model_metadata(model_spec_dict)
+            show_functions_res = self._model_version_client.show_functions(
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+            function_names_and_types = []
+            for r in show_functions_res:
+                function_name = sql_identifier.SqlIdentifier(
+                    r[self._model_version_client.FUNCTION_NAME_COL_NAME], case_sensitive=True
+                )
+
+                function_type = model_manifest_schema.ModelMethodFunctionTypes.FUNCTION.value
+                try:
+                    return_type = r[self._model_version_client.FUNCTION_RETURN_TYPE_COL_NAME]
+                except KeyError:
+                    pass
+                else:
+                    if "TABLE" in return_type:
+                        function_type = model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value
+
+                function_names_and_types.append((function_name, function_type))
+
+            signatures = model_spec["signatures"]
+            function_names = [name for name, _ in function_names_and_types]
+            function_name_mapping = ModelOperator._match_model_spec_with_sql_functions(
+                function_names, list(signatures.keys())
             )
-            with open(model_meta_file_path, encoding="utf-8") as f:
-                raw_model_meta = yaml.safe_load(f)
-            return model_meta.ModelMetadata._validate_model_metadata(raw_model_meta)
 
-    def get_client_data_in_user_data(
-        self,
-        *,
-        model_name: sql_identifier.SqlIdentifier,
-        version_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> model_manifest_schema.SnowparkMLDataDict:
-        raw_user_data_json_string = self._model_client.show_versions(
-            model_name=model_name,
-            version_name=version_name,
-            statement_params=statement_params,
-        )[0][self._model_client.MODEL_VERSION_USER_DATA_COL_NAME]
-        raw_user_data = json.loads(raw_user_data_json_string)
-        assert isinstance(raw_user_data, dict), "user data should be a dictionary"
-        return model_manifest.ModelManifest.parse_client_data_from_user_data(raw_user_data)
+            return [
+                model_manifest_schema.ModelFunctionInfo(
+                    name=function_name.identifier(),
+                    target_method=function_name_mapping[function_name],
+                    target_method_function_type=function_type,
+                    signature=model_signature.ModelSignature.from_dict(
+                        signatures[function_name_mapping[function_name]]
+                    ),
+                )
+                for function_name, function_type in function_names_and_types
+            ]
 
     def invoke_method(
         self,

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

@@ -16,7 +16,7 @@ class ModelSQLClient:
     MODEL_VERSION_NAME_COL_NAME = "name"
     MODEL_VERSION_COMMENT_COL_NAME = "comment"
     MODEL_VERSION_METADATA_COL_NAME = "metadata"
-    MODEL_VERSION_USER_DATA_COL_NAME = "user_data"
+    MODEL_VERSION_MODEL_SPEC_COL_NAME = "model_spec"
 
     def __init__(
         self,
@@ -72,6 +72,7 @@ class ModelSQLClient:
         model_name: sql_identifier.SqlIdentifier,
         version_name: Optional[sql_identifier.SqlIdentifier] = None,
         validate_result: bool = True,
+        check_model_details: bool = False,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> List[row.Row]:
         like_sql = ""
@@ -87,10 +88,11 @@ class ModelSQLClient:
             .has_column(ModelSQLClient.MODEL_VERSION_NAME_COL_NAME, allow_empty=True)
             .has_column(ModelSQLClient.MODEL_VERSION_COMMENT_COL_NAME, allow_empty=True)
             .has_column(ModelSQLClient.MODEL_VERSION_METADATA_COL_NAME, allow_empty=True)
-            .has_column(ModelSQLClient.MODEL_VERSION_USER_DATA_COL_NAME, allow_empty=True)
         )
         if validate_result and version_name:
             res = res.has_dimensions(expected_rows=1)
+        if check_model_details:
+            res = res.has_column(ModelSQLClient.MODEL_VERSION_MODEL_SPEC_COL_NAME, allow_empty=True)
 
         return res.validate()
 
@@ -118,3 +120,22 @@ class ModelSQLClient:
             f"DROP MODEL {self.fully_qualified_model_name(model_name)}",
             statement_params=statement_params,
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def config_model_details(
+        self,
+        *,
+        enable: bool,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        if enable:
+            query_result_checker.SqlResultValidator(
+                self._session,
+                "ALTER SESSION SET SHOW_MODEL_DETAILS_IN_SHOW_VERSIONS_IN_MODEL=true",
+                statement_params=statement_params,
+            ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+        else:
+            query_result_checker.SqlResultValidator(
+                self._session,
+                "ALTER SESSION UNSET SHOW_MODEL_DETAILS_IN_SHOW_VERSIONS_IN_MODEL",
+                statement_params=statement_params,
+            ).has_dimensions(expected_rows=1, expected_cols=1).validate()

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

@@ -9,7 +9,7 @@ from snowflake.ml._internal.utils import (
     query_result_checker,
     sql_identifier,
 )
-from snowflake.snowpark import dataframe, functions as F, session, types as spt
+from snowflake.snowpark import dataframe, functions as F, row, session, types as spt
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 
@@ -21,6 +21,9 @@ def _normalize_url_for_sql(url: str) -> str:
 
 
 class ModelVersionSQLClient:
+    FUNCTION_NAME_COL_NAME = "name"
+    FUNCTION_RETURN_TYPE_COL_NAME = "return_type"
+
     def __init__(
         self,
         session: session.Session,
@@ -124,6 +127,24 @@ class ModelVersionSQLClient:
             ).has_dimensions(expected_rows=1).validate()
         return target_path / file_path.name
 
+    def show_functions(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[row.Row]:
+        res = query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"SHOW FUNCTIONS IN MODEL {self.fully_qualified_model_name(model_name)}"
+                f" VERSION {version_name.identifier()}"
+            ),
+            statement_params=statement_params,
+        ).has_column(ModelVersionSQLClient.FUNCTION_NAME_COL_NAME, allow_empty=True)
+
+        return res.validate()
+
     def set_comment(
         self,
         *,

snowflake/ml/model/_deploy_client/image_builds/server_image_builder.py

@@ -174,9 +174,7 @@ class ServerImageBuilder(base_image_builder.ImageBuilder):
             .read_text("utf-8")
         )
 
-        spec_file_path = os.path.join(
-            os.path.dirname(self.context_dir), f"{constants.IMAGE_BUILD_JOB_SPEC_TEMPLATE}.yaml"
-        )
+        spec_file_path = os.path.join(self.context_dir, f"{constants.IMAGE_BUILD_JOB_SPEC_TEMPLATE}.yaml")
 
         with file_utils.open_file(spec_file_path, "w+") as spec_file:
             assert self.artifact_stage_location.startswith("@")

snowflake/ml/model/_deploy_client/snowservice/deploy.py

@@ -239,14 +239,17 @@ def _validate_compute_pool(session: Session, *, options: deploy_options.SnowServ
                 ),
             )
 
-    elif state not in ["ACTIVE", "IDLE"]:
+    elif state not in ["STARTING", "ACTIVE", "IDLE"]:
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.INVALID_SNOWPARK_COMPUTE_POOL,
             original_exception=RuntimeError(
-                "The compute pool you are requesting to use is not in the ACTIVE/IDLE status."
+                "The compute pool you are requesting to use is not in the ACTIVE/IDLE/STARTING status."
             ),
         )
 
+    if state in ["SUSPENDED", "STARTING"]:
+        logger.warning(f"The compute pool you are requesting is in {state} state. We are waiting it to be ready.")
+
     if options.use_gpu:
         assert options.num_gpus is not None
         request_gpus = options.num_gpus