snowflake-ml-python 1.1.2__py3-none-any.whl → 1.2.1__py3-none-any.whl

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

@@ -4,7 +4,11 @@ import textwrap
 from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import ParseResult
 
-from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.ml._internal.utils import (
+    identifier,
+    query_result_checker,
+    sql_identifier,
+)
 from snowflake.snowpark import dataframe, functions as F, session, types as spt
 from snowflake.snowpark._internal import utils as snowpark_utils
 
@@ -46,11 +50,14 @@ class ModelVersionSQLClient:
         stage_path: str,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        self._version_name = version_name
-        self._session.sql(
-            f"CREATE MODEL {self.fully_qualified_model_name(model_name)} WITH VERSION {version_name.identifier()}"
-            f" FROM {stage_path}"
-        ).collect(statement_params=statement_params)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"CREATE MODEL {self.fully_qualified_model_name(model_name)} WITH VERSION {version_name.identifier()}"
+                f" FROM {stage_path}"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
     # TODO(SNOW-987381): Merge with above when we have `create or alter module m [with] version v1 ...`
     def add_version_from_stage(
@@ -61,11 +68,14 @@ class ModelVersionSQLClient:
         stage_path: str,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        self._version_name = version_name
-        self._session.sql(
-            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} ADD VERSION {version_name.identifier()}"
-            f" FROM {stage_path}"
-        ).collect(statement_params=statement_params)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"ALTER MODEL {self.fully_qualified_model_name(model_name)} ADD VERSION {version_name.identifier()}"
+                f" FROM {stage_path}"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
     def set_default_version(
         self,
@@ -74,24 +84,14 @@ class ModelVersionSQLClient:
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        self._session.sql(
-            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
-            f"SET DEFAULT_VERSION = {version_name.identifier()}"
-        ).collect(statement_params=statement_params)
-
-    def get_default_version(
-        self,
-        *,
-        model_name: sql_identifier.SqlIdentifier,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> str:
-        # TODO: Replace SHOW with DESC when available.
-        default_version: str = (
-            self._session.sql(f"SHOW VERSIONS IN MODEL {self.fully_qualified_model_name(model_name)}")
-            .filter('"is_default_version" = TRUE')[['"name"']]
-            .collect(statement_params=statement_params)[0][0]
-        )
-        return default_version
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
+                f"SET DEFAULT_VERSION = {version_name.identifier()}"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
     def get_file(
         self,
@@ -108,14 +108,14 @@ class ModelVersionSQLClient:
         stage_location_url = ParseResult(
             scheme="snow", netloc="model", path=stage_location, params="", query="", fragment=""
         ).geturl()
-        local_location = target_path.absolute().as_posix()
-        local_location_url = ParseResult(
-            scheme="file", netloc="", path=local_location, params="", query="", fragment=""
-        ).geturl()
+        local_location = target_path.resolve().as_posix()
+        local_location_url = f"file://{local_location}"
 
-        self._session.sql(
-            f"GET {_normalize_url_for_sql(stage_location_url)} {_normalize_url_for_sql(local_location_url)}"
-        ).collect(statement_params=statement_params)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"GET {_normalize_url_for_sql(stage_location_url)} {_normalize_url_for_sql(local_location_url)}",
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1).validate()
         return target_path / file_path.name
 
     def set_comment(
@@ -126,11 +126,14 @@ class ModelVersionSQLClient:
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        comment_sql = (
-            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
-            f"MODIFY VERSION {version_name.identifier()} SET COMMENT=$${comment}$$"
-        )
-        self._session.sql(comment_sql).collect(statement_params=statement_params)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
+                f"MODIFY VERSION {version_name.identifier()} SET COMMENT=$${comment}$$"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
     def invoke_method(
         self,
@@ -143,24 +146,29 @@ class ModelVersionSQLClient:
         returns: List[Tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> dataframe.DataFrame:
-        tmp_table_name = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
-        INTERMEDIATE_TABLE_NAME = identifier.get_schema_level_object_identifier(
-            self._database_name.identifier(),
-            self._schema_name.identifier(),
-            tmp_table_name,
-        )
-        input_df.write.save_as_table(  # type: ignore[call-overload]
-            table_name=INTERMEDIATE_TABLE_NAME,
-            mode="errorifexists",
-            table_type="temporary",
-            statement_params=statement_params,
-        )
+        with_statements = []
+        if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
+            INTERMEDIATE_TABLE_NAME = "SNOWPARK_ML_MODEL_INFERENCE_INPUT"
+            with_statements.append(f"{INTERMEDIATE_TABLE_NAME} AS ({input_df.queries['queries'][0]})")
+        else:
+            tmp_table_name = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
+            INTERMEDIATE_TABLE_NAME = identifier.get_schema_level_object_identifier(
+                self._database_name.identifier(),
+                self._schema_name.identifier(),
+                tmp_table_name,
+            )
+            input_df.write.save_as_table(  # type: ignore[call-overload]
+                table_name=INTERMEDIATE_TABLE_NAME,
+                mode="errorifexists",
+                table_type="temporary",
+                statement_params=statement_params,
+            )
 
         INTERMEDIATE_OBJ_NAME = "TMP_RESULT"
 
         module_version_alias = "MODEL_VERSION_ALIAS"
-        model_version_alias_sql = (
-            f"WITH {module_version_alias} AS "
+        with_statements.append(
+            f"{module_version_alias} AS "
             f"MODEL {self.fully_qualified_model_name(model_name)} VERSION {version_name.identifier()}"
         )
 
@@ -171,7 +179,7 @@ class ModelVersionSQLClient:
         args_sql = ", ".join(args_sql_list)
 
         sql = textwrap.dedent(
-            f"""{model_version_alias_sql}
+            f"""WITH {','.join(with_statements)}
                 SELECT *,
                     {module_version_alias}!{method_name.identifier()}({args_sql}) AS {INTERMEDIATE_OBJ_NAME}
                 FROM {INTERMEDIATE_TABLE_NAME}"""
@@ -206,8 +214,11 @@ class ModelVersionSQLClient:
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
         json_metadata = json.dumps(metadata_dict)
-        sql = (
-            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} MODIFY VERSION {version_name.identifier()}"
-            f" SET METADATA=$${json_metadata}$$"
-        )
-        self._session.sql(sql).collect(statement_params=statement_params)
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"ALTER MODEL {self.fully_qualified_model_name(model_name)} MODIFY VERSION {version_name.identifier()}"
+                f" SET METADATA=$${json_metadata}$$"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()

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

@@ -1,6 +1,10 @@
 from typing import Any, Dict, Optional
 
-from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.ml._internal.utils import (
+    identifier,
+    query_result_checker,
+    sql_identifier,
+)
 from snowflake.snowpark import session
 
 
@@ -35,6 +39,8 @@ class StageSQLClient:
         stage_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        self._session.sql(f"CREATE TEMPORARY STAGE {self.fully_qualified_stage_name(stage_name)}").collect(
-            statement_params=statement_params
-        )
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"CREATE TEMPORARY STAGE {self.fully_qualified_stage_name(stage_name)}",
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()

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

@@ -0,0 +1,118 @@
+from typing import Any, Dict, List, Optional
+
+from snowflake.ml._internal.utils import (
+    identifier,
+    query_result_checker,
+    sql_identifier,
+)
+from snowflake.snowpark import row, session
+
+
+class ModuleTagSQLClient:
+    def __init__(
+        self,
+        session: session.Session,
+        *,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+    ) -> None:
+        self._session = session
+        self._database_name = database_name
+        self._schema_name = schema_name
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ModuleTagSQLClient):
+            return False
+        return self._database_name == __value._database_name and self._schema_name == __value._schema_name
+
+    def fully_qualified_module_name(
+        self,
+        module_name: sql_identifier.SqlIdentifier,
+    ) -> str:
+        return identifier.get_schema_level_object_identifier(
+            self._database_name.identifier(), self._schema_name.identifier(), module_name.identifier()
+        )
+
+    def set_tag_on_model(
+        self,
+        model_name: sql_identifier.SqlIdentifier,
+        *,
+        tag_database_name: sql_identifier.SqlIdentifier,
+        tag_schema_name: sql_identifier.SqlIdentifier,
+        tag_name: sql_identifier.SqlIdentifier,
+        tag_value: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        fq_model_name = self.fully_qualified_module_name(model_name)
+        fq_tag_name = identifier.get_schema_level_object_identifier(
+            tag_database_name.identifier(), tag_schema_name.identifier(), tag_name.identifier()
+        )
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"ALTER MODEL {fq_model_name} SET TAG {fq_tag_name} = $${tag_value}$$",
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def unset_tag_on_model(
+        self,
+        model_name: sql_identifier.SqlIdentifier,
+        *,
+        tag_database_name: sql_identifier.SqlIdentifier,
+        tag_schema_name: sql_identifier.SqlIdentifier,
+        tag_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        fq_model_name = self.fully_qualified_module_name(model_name)
+        fq_tag_name = identifier.get_schema_level_object_identifier(
+            tag_database_name.identifier(), tag_schema_name.identifier(), tag_name.identifier()
+        )
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"ALTER MODEL {fq_model_name} UNSET TAG {fq_tag_name}",
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def get_tag_value(
+        self,
+        module_name: sql_identifier.SqlIdentifier,
+        *,
+        tag_database_name: sql_identifier.SqlIdentifier,
+        tag_schema_name: sql_identifier.SqlIdentifier,
+        tag_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> row.Row:
+        fq_module_name = self.fully_qualified_module_name(module_name)
+        fq_tag_name = identifier.get_schema_level_object_identifier(
+            tag_database_name.identifier(), tag_schema_name.identifier(), tag_name.identifier()
+        )
+        return (
+            query_result_checker.SqlResultValidator(
+                self._session,
+                f"SELECT SYSTEM$GET_TAG($${fq_tag_name}$$, $${fq_module_name}$$, 'MODULE') AS TAG_VALUE",
+                statement_params=statement_params,
+            )
+            .has_dimensions(expected_rows=1, expected_cols=1)
+            .has_column("TAG_VALUE")
+            .validate()[0]
+        )
+
+    def get_tag_list(
+        self,
+        module_name: sql_identifier.SqlIdentifier,
+        *,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[row.Row]:
+        fq_module_name = self.fully_qualified_module_name(module_name)
+        return (
+            query_result_checker.SqlResultValidator(
+                self._session,
+                f"""SELECT TAG_DATABASE, TAG_SCHEMA, TAG_NAME, TAG_VALUE
+FROM TABLE({self._database_name.identifier()}.INFORMATION_SCHEMA.TAG_REFERENCES($${fq_module_name}$$, 'MODULE'))""",
+                statement_params=statement_params,
+            )
+            .has_column("TAG_DATABASE", allow_empty=True)
+            .has_column("TAG_SCHEMA", allow_empty=True)
+            .has_column("TAG_NAME", allow_empty=True)
+            .has_column("TAG_VALUE", allow_empty=True)
+            .validate()
+        )

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

@@ -9,11 +9,11 @@ from enum import Enum
 from typing import List
 
 from snowflake import snowpark
+from snowflake.ml._internal.container_services.image_registry import credential
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
 )
-from snowflake.ml._internal.utils import spcs_image_registry
 from snowflake.ml.model._deploy_client.image_builds import base_image_builder
 
 logger = logging.getLogger(__name__)
@@ -106,7 +106,7 @@ class ClientImageBuilder(base_image_builder.ImageBuilder):
                 self._run_docker_commands(commands)
 
         self.validate_docker_client_env()
-        with spcs_image_registry.generate_image_registry_credential(
+        with credential.generate_image_registry_credential(
             self.session
         ) as registry_cred, tempfile.TemporaryDirectory() as docker_config_dir:
             try:

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

@@ -2,7 +2,6 @@ import os
 import posixpath
 import shutil
 import string
-from abc import ABC
 from typing import Optional
 
 import importlib_resources
@@ -15,7 +14,7 @@ from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import FileOperation, Session
 
 
-class DockerContext(ABC):
+class DockerContext:
     """
     Constructs the Docker context directory required for image building.
     """
@@ -53,12 +52,13 @@ class DockerContext(ABC):
 
     def _copy_entrypoint_script_to_docker_context(self) -> None:
         """Copy gunicorn_run.sh entrypoint to docker context directory."""
-        with importlib_resources.as_file(
-            importlib_resources.files(image_builds).joinpath(  # type: ignore[no-untyped-call]
-                constants.ENTRYPOINT_SCRIPT
-            )
-        ) as path:
-            shutil.copy(path, os.path.join(self.context_dir, constants.ENTRYPOINT_SCRIPT))
+        script_path = importlib_resources.files(image_builds).joinpath(  # type: ignore[no-untyped-call]
+            constants.ENTRYPOINT_SCRIPT
+        )
+        target_path = os.path.join(self.context_dir, constants.ENTRYPOINT_SCRIPT)
+
+        with open(script_path, encoding="utf-8") as source_file, file_utils.open_file(target_path, "w") as target_file:
+            target_file.write(source_file.read())
 
     def _copy_model_env_dependency_to_docker_context(self) -> None:
         """

snowflake/ml/model/_deploy_client/image_builds/inference_server/main.py

@@ -105,6 +105,8 @@ def _run_setup() -> None:
 
             # TODO (Server-side Model Rollout):
             # Keep try block only
+            # SPCS spec will convert all environment variables as strings.
+            use_gpu = os.environ.get("SNOWML_USE_GPU", "False").lower() == "true"
             try:
                 from snowflake.ml.model._packager import model_packager
 
@@ -112,9 +114,7 @@ def _run_setup() -> None:
                 pk.load(
                     as_custom_model=True,
                     meta_only=False,
-                    options=model_types.ModelLoadOption(
-                        {"use_gpu": cast(bool, os.environ.get("SNOWML_USE_GPU", False))}
-                    ),
+                    options=model_types.ModelLoadOption({"use_gpu": use_gpu}),
                 )
                 _LOADED_MODEL = pk.model
                 _LOADED_META = pk.meta
@@ -132,9 +132,7 @@ def _run_setup() -> None:
                     _LOADED_MODEL, meta_LOADED_META = model_api._load(
                         local_dir_path=extracted_dir,
                         as_custom_model=True,
-                        options=model_types.ModelLoadOption(
-                            {"use_gpu": cast(bool, os.environ.get("SNOWML_USE_GPU", False))}
-                        ),
+                        options=model_types.ModelLoadOption({"use_gpu": use_gpu}),
                     )
             _MODEL_LOADING_STATE = _ModelLoadingState.SUCCEEDED
             logger.info("Successfully loaded model into memory")

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

@@ -7,6 +7,9 @@ import importlib_resources
 
 from snowflake import snowpark
 from snowflake.ml._internal import file_utils
+from snowflake.ml._internal.container_services.image_registry import (
+    registry_client as image_registry_client,
+)
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
@@ -14,11 +17,7 @@ from snowflake.ml._internal.exceptions import (
 from snowflake.ml._internal.utils import identifier
 from snowflake.ml.model._deploy_client import image_builds
 from snowflake.ml.model._deploy_client.image_builds import base_image_builder
-from snowflake.ml.model._deploy_client.utils import (
-    constants,
-    image_registry_client,
-    snowservice_client,
-)
+from snowflake.ml.model._deploy_client.utils import constants, snowservice_client
 
 logger = logging.getLogger(__name__)
 
@@ -117,7 +116,7 @@ class ServerImageBuilder(base_image_builder.ImageBuilder):
 
         kaniko_shell_file = os.path.join(self.context_dir, constants.KANIKO_SHELL_SCRIPT_NAME)
 
-        with open(kaniko_shell_file, "w+", encoding="utf-8") as script_file:
+        with file_utils.open_file(kaniko_shell_file, "w+") as script_file:
             normed_artifact_stage_path = posixpath.normpath(identifier.remove_prefix(self.artifact_stage_location, "@"))
             params = {
                 # Remove @ in the beginning, append "/" to denote root directory.
@@ -175,7 +174,7 @@ class ServerImageBuilder(base_image_builder.ImageBuilder):
             os.path.dirname(self.context_dir), f"{constants.IMAGE_BUILD_JOB_SPEC_TEMPLATE}.yaml"
         )
 
-        with open(spec_file_path, "w+", encoding="utf-8") as spec_file:
+        with file_utils.open_file(spec_file_path, "w+") as spec_file:
             assert self.artifact_stage_location.startswith("@")
             normed_artifact_stage_path = posixpath.normpath(identifier.remove_prefix(self.artifact_stage_location, "@"))
             (db, schema, stage, path) = identifier.parse_schema_level_object_identifier(normed_artifact_stage_path)

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

@@ -14,6 +14,9 @@ from packaging import requirements
 from typing_extensions import Unpack
 
 from snowflake.ml._internal import env_utils, file_utils
+from snowflake.ml._internal.container_services.image_registry import (
+    registry_client as image_registry_client,
+)
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
@@ -32,11 +35,7 @@ from snowflake.ml.model._deploy_client.image_builds import (
     server_image_builder,
 )
 from snowflake.ml.model._deploy_client.snowservice import deploy_options, instance_types
-from snowflake.ml.model._deploy_client.utils import (
-    constants,
-    image_registry_client,
-    snowservice_client,
-)
+from snowflake.ml.model._deploy_client.utils import constants, snowservice_client
 from snowflake.ml.model._packager.model_meta import model_meta, model_meta_schema
 from snowflake.snowpark import Session
 

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

@@ -1,2 +1,10 @@
 # Snowpark Container Service GPU instance type and corresponding GPU counts.
-INSTANCE_TYPE_TO_GPU_COUNT = {"GPU_3": 1, "GPU_5": 1, "GPU_7": 4, "GPU_10": 8}
+INSTANCE_TYPE_TO_GPU_COUNT = {
+    "GPU_3": 1,
+    "GPU_5": 1,
+    "GPU_7": 4,
+    "GPU_10": 8,
+    "GPU_NV_S": 1,
+    "GPU_NV_M": 4,
+    "GPU_NV_L": 8,
+}

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

@@ -2,6 +2,7 @@ import copy
 import logging
 import posixpath
 import tempfile
+import textwrap
 from types import ModuleType
 from typing import IO, List, Optional, Tuple, TypedDict, Union
 
@@ -154,7 +155,7 @@ def _get_model_final_packages(
     Returns:
         List of final packages string that is accepted by Snowpark register UDF call.
     """
-    final_packages = None
+
     if (
         any(channel.lower() not in [env_utils.DEFAULT_CHANNEL_NAME] for channel in meta.env._conda_dependencies.keys())
         or meta.env.pip_requirements
@@ -173,21 +174,29 @@ def _get_model_final_packages(
     else:
         required_packages = meta.env._conda_dependencies[env_utils.DEFAULT_CHANNEL_NAME]
 
-    final_packages = env_utils.validate_requirements_in_information_schema(
+    package_availability_dict = env_utils.get_matched_package_versions_in_information_schema(
         session, required_packages, python_version=meta.env.python_version
     )
-
-    if final_packages is None:
+    no_version_available_packages = [
+        req_name for req_name, ver_list in package_availability_dict.items() if len(ver_list) < 1
+    ]
+    unavailable_packages = [req.name for req in required_packages if req.name not in package_availability_dict]
+    if no_version_available_packages or unavailable_packages:
         relax_version_info_str = "" if relax_version else "Try to set relax_version as True in the options. "
+        required_package_str = " ".join(map(lambda x: f'"{x}"', required_packages))
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.DEPENDENCY_VERSION_ERROR,
             original_exception=RuntimeError(
-                "The model's dependencies are not available in Snowflake Anaconda Channel. "
-                + relax_version_info_str
-                + "Required packages are:\n"
-                + " ".join(map(lambda x: f'"{x}"', required_packages))
-                + "\n Required Python version is: "
-                + meta.env.python_version
+                textwrap.dedent(
+                    f"""
+                The model's dependencies are not available in Snowflake Anaconda Channel. {relax_version_info_str}
+                Required packages are: {required_package_str}
+                Required Python version is: {meta.env.python_version}
+                Packages that are not available are: {unavailable_packages}
+                Packages that cannot meet your requirements are: {no_version_available_packages}
+                Package availability information of those you requested is: {package_availability_dict}
+                """
+                ),
             ),
         )
-    return final_packages
+    return list(sorted(map(str, required_packages)))

snowflake/ml/model/_model_composer/model_manifest/model_manifest.py

@@ -1,6 +1,6 @@
 import collections
 import pathlib
-from typing import List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 
 import yaml
 
@@ -83,7 +83,11 @@ class ModelManifest:
             ],
         )
 
+        manifest_dict["user_data"] = self.generate_user_data_with_client_data(model_meta)
+
         with (self.workspace_path / ModelManifest.MANIFEST_FILE_REL_PATH).open("w", encoding="utf-8") as f:
+            # Anchors are not supported in the server, avoid that.
+            yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
             yaml.safe_dump(manifest_dict, f)
 
     def load(self) -> model_manifest_schema.ModelManifestDict:
@@ -99,3 +103,43 @@ class ModelManifest:
         res = cast(model_manifest_schema.ModelManifestDict, raw_input)
 
         return res
+
+    def generate_user_data_with_client_data(self, model_meta: model_meta_api.ModelMetadata) -> Dict[str, Any]:
+        client_data = model_manifest_schema.SnowparkMLDataDict(
+            schema_version=model_manifest_schema.MANIFEST_CLIENT_DATA_SCHEMA_VERSION,
+            functions=[
+                model_manifest_schema.ModelFunctionInfoDict(
+                    name=method.method_name.identifier(),
+                    target_method=method.target_method,
+                    signature=model_meta.signatures[method.target_method].to_dict(),
+                )
+                for method in self.methods
+            ],
+        )
+        return {model_manifest_schema.MANIFEST_CLIENT_DATA_KEY_NAME: client_data}
+
+    @staticmethod
+    def parse_client_data_from_user_data(raw_user_data: Dict[str, Any]) -> model_manifest_schema.SnowparkMLDataDict:
+        raw_client_data = raw_user_data.get(model_manifest_schema.MANIFEST_CLIENT_DATA_KEY_NAME, {})
+        if not isinstance(raw_client_data, dict) or "schema_version" not in raw_client_data:
+            raise ValueError(f"Ill-formatted client data {raw_client_data} in user data found.")
+        loaded_client_data_schema_version = raw_client_data["schema_version"]
+        if (
+            not isinstance(loaded_client_data_schema_version, str)
+            or loaded_client_data_schema_version != model_manifest_schema.MANIFEST_CLIENT_DATA_SCHEMA_VERSION
+        ):
+            raise ValueError(f"Unsupported client data schema version {loaded_client_data_schema_version} confronted.")
+
+        return_functions_info: List[model_manifest_schema.ModelFunctionInfoDict] = []
+        loaded_functions_info = raw_client_data.get("functions", [])
+        for func in loaded_functions_info:
+            fi = model_manifest_schema.ModelFunctionInfoDict(
+                name=func["name"],
+                target_method=func["target_method"],
+                signature=func["signature"],
+            )
+            return_functions_info.append(fi)
+
+        return model_manifest_schema.SnowparkMLDataDict(
+            schema_version=loaded_client_data_schema_version, functions=return_functions_info
+        )