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

snowflake/ml/jobs/manager.py

@@ -1,6 +1,16 @@
 import pathlib
 import textwrap
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
 from uuid import uuid4
 
 import yaml
@@ -16,6 +26,8 @@ from snowflake.snowpark.exceptions import SnowparkSQLException
 _PROJECT = "MLJob"
 JOB_ID_PREFIX = "MLJOB_"
 
+T = TypeVar("T")
+
 
 @snowpark._internal.utils.private_preview(version="1.7.4")
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["limit", "scope"])
@@ -59,7 +71,7 @@ def list_jobs(
 
 @snowpark._internal.utils.private_preview(version="1.7.4")
 @telemetry.send_api_usage_telemetry(project=_PROJECT)
-def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob:
+def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob[Any]:
     """Retrieve a job service from the backend."""
     session = session or get_active_session()
 
@@ -71,7 +83,8 @@ def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob
 
     try:
         # Validate that job exists by doing a status check
-        job = jb.MLJob(job_id, session=session)
+        # FIXME: Retrieve return path
+        job = jb.MLJob[Any](job_id, session=session)
         _ = job.status
         return job
     except SnowparkSQLException as e:
@@ -82,7 +95,7 @@ def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob
 
 @snowpark._internal.utils.private_preview(version="1.7.4")
 @telemetry.send_api_usage_telemetry(project=_PROJECT)
-def delete_job(job: Union[str, jb.MLJob], session: Optional[snowpark.Session] = None) -> None:
+def delete_job(job: Union[str, jb.MLJob[Any]], session: Optional[snowpark.Session] = None) -> None:
     """Delete a job service from the backend. Status and logs will be lost."""
     if isinstance(job, jb.MLJob):
         job_id = job.id
@@ -106,8 +119,10 @@ def submit_file(
     external_access_integrations: Optional[List[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[Dict[str, Any]] = None,
+    num_instances: Optional[int] = None,
+    enable_metrics: bool = False,
     session: Optional[snowpark.Session] = None,
-) -> jb.MLJob:
+) -> jb.MLJob[None]:
     """
     Submit a Python file as a job to the compute pool.
 
@@ -121,6 +136,8 @@ def submit_file(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
+        num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        enable_metrics: Whether to enable metrics publishing for the job.
         session: The Snowpark session to use. If none specified, uses active session.
 
     Returns:
@@ -136,6 +153,8 @@ def submit_file(
         external_access_integrations=external_access_integrations,
         query_warehouse=query_warehouse,
         spec_overrides=spec_overrides,
+        num_instances=num_instances,
+        enable_metrics=enable_metrics,
         session=session,
     )
 
@@ -154,8 +173,10 @@ def submit_directory(
     external_access_integrations: Optional[List[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[Dict[str, Any]] = None,
+    num_instances: Optional[int] = None,
+    enable_metrics: bool = False,
     session: Optional[snowpark.Session] = None,
-) -> jb.MLJob:
+) -> jb.MLJob[None]:
     """
     Submit a directory containing Python script(s) as a job to the compute pool.
 
@@ -170,6 +191,8 @@ def submit_directory(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
+        num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        enable_metrics: Whether to enable metrics publishing for the job.
         session: The Snowpark session to use. If none specified, uses active session.
 
     Returns:
@@ -186,10 +209,52 @@ def submit_directory(
         external_access_integrations=external_access_integrations,
         query_warehouse=query_warehouse,
         spec_overrides=spec_overrides,
+        num_instances=num_instances,
+        enable_metrics=enable_metrics,
         session=session,
     )
 
 
+@overload
+def _submit_job(
+    source: str,
+    compute_pool: str,
+    *,
+    stage_name: str,
+    entrypoint: Optional[str] = None,
+    args: Optional[List[str]] = None,
+    env_vars: Optional[Dict[str, str]] = None,
+    pip_requirements: Optional[List[str]] = None,
+    external_access_integrations: Optional[List[str]] = None,
+    query_warehouse: Optional[str] = None,
+    spec_overrides: Optional[Dict[str, Any]] = None,
+    num_instances: Optional[int] = None,
+    enable_metrics: bool = False,
+    session: Optional[snowpark.Session] = None,
+) -> jb.MLJob[None]:
+    ...
+
+
+@overload
+def _submit_job(
+    source: Callable[..., T],
+    compute_pool: str,
+    *,
+    stage_name: str,
+    entrypoint: Optional[str] = None,
+    args: Optional[List[str]] = None,
+    env_vars: Optional[Dict[str, str]] = None,
+    pip_requirements: Optional[List[str]] = None,
+    external_access_integrations: Optional[List[str]] = None,
+    query_warehouse: Optional[str] = None,
+    spec_overrides: Optional[Dict[str, Any]] = None,
+    num_instances: Optional[int] = None,
+    enable_metrics: bool = False,
+    session: Optional[snowpark.Session] = None,
+) -> jb.MLJob[T]:
+    ...
+
+
 @telemetry.send_api_usage_telemetry(
     project=_PROJECT,
     func_params_to_log=[
@@ -201,7 +266,7 @@ def submit_directory(
     ],
 )
 def _submit_job(
-    source: Union[str, Callable[..., Any]],
+    source: Union[str, Callable[..., T]],
     compute_pool: str,
     *,
     stage_name: str,
@@ -212,9 +277,10 @@ def _submit_job(
     external_access_integrations: Optional[List[str]] = None,
     query_warehouse: Optional[str] = None,
     spec_overrides: Optional[Dict[str, Any]] = None,
-    session: Optional[snowpark.Session] = None,
     num_instances: Optional[int] = None,
-) -> jb.MLJob:
+    enable_metrics: bool = False,
+    session: Optional[snowpark.Session] = None,
+) -> jb.MLJob[T]:
     """
     Submit a job to the compute pool.
 
@@ -229,8 +295,9 @@ def _submit_job(
         external_access_integrations: A list of external access integrations.
         query_warehouse: The query warehouse to use. Defaults to session warehouse.
         spec_overrides: Custom service specification overrides to apply.
-        session: The Snowpark session to use. If none specified, uses active session.
         num_instances: The number of instances to use for the job. If none specified, single node job is created.
+        enable_metrics: Whether to enable metrics publishing for the job.
+        session: The Snowpark session to use. If none specified, uses active session.
 
     Returns:
         An object representing the submitted job.
@@ -257,6 +324,7 @@ def _submit_job(
         payload=uploaded_payload,
         args=args,
         num_instances=num_instances,
+        enable_metrics=enable_metrics,
     )
     spec_overrides = spec_utils.generate_spec_overrides(
         environment_vars=env_vars,
@@ -299,5 +367,4 @@ def _submit_job(
             ) from e
         raise
 
-    # TODO: Wrap snowflake.core.service.JobService object
-    return jb.MLJob(job_id, session=session)
+    return jb.MLJob(job_id, service_spec=spec, session=session)

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

@@ -789,14 +789,17 @@ class ModelOperator:
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> type_hints.Task:
-        model_spec = self._fetch_model_spec(
+        model_version = self._model_client.show_versions(
             database_name=database_name,
             schema_name=schema_name,
             model_name=model_name,
             version_name=version_name,
+            validate_result=True,
             statement_params=statement_params,
-        )
-        task_val = model_spec.get("task", type_hints.Task.UNKNOWN.value)
+        )[0]
+
+        model_attributes = json.loads(model_version.model_attributes)
+        task_val = model_attributes.get("task", type_hints.Task.UNKNOWN.value)
         return type_hints.Task(task_val)
 
     def get_functions(

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

@@ -9,7 +9,7 @@ import time
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
 from snowflake import snowpark
-from snowflake.ml._internal import file_utils
+from snowflake.ml._internal import file_utils, platform_capabilities as pc
 from snowflake.ml._internal.utils import service_logger, sql_identifier
 from snowflake.ml.model._client.service import model_deployment_spec
 from snowflake.ml.model._client.sql import service as service_sql, stage as stage_sql
@@ -57,30 +57,30 @@ class ServiceOperator:
         self._session = session
         self._database_name = database_name
         self._schema_name = schema_name
-        self._workspace = tempfile.TemporaryDirectory()
         self._service_client = service_sql.ServiceSQLClient(
             session,
             database_name=database_name,
             schema_name=schema_name,
         )
-        self._stage_client = stage_sql.StageSQLClient(
-            session,
-            database_name=database_name,
-            schema_name=schema_name,
-        )
-        self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec(
-            workspace_path=pathlib.Path(self._workspace.name)
-        )
+        if pc.PlatformCapabilities.get_instance().is_inlined_deployment_spec_enabled():
+            self._workspace = None
+            self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec()
+        else:
+            self._workspace = tempfile.TemporaryDirectory()
+            self._stage_client = stage_sql.StageSQLClient(
+                session,
+                database_name=database_name,
+                schema_name=schema_name,
+            )
+            self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec(
+                workspace_path=pathlib.Path(self._workspace.name)
+            )
 
     def __eq__(self, __value: object) -> bool:
         if not isinstance(__value, ServiceOperator):
             return False
         return self._service_client == __value._service_client
 
-    @property
-    def workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._workspace.name)
-
     def create_service(
         self,
         *,
@@ -119,19 +119,21 @@ class ServiceOperator:
 
         image_repo_database_name = image_repo_database_name or database_name or self._database_name
         image_repo_schema_name = image_repo_schema_name or schema_name or self._schema_name
-        # create a temp stage
-        stage_name = sql_identifier.SqlIdentifier(
-            snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
-        )
-        self._stage_client.create_tmp_stage(
-            database_name=database_name,
-            schema_name=schema_name,
-            stage_name=stage_name,
-            statement_params=statement_params,
-        )
-        stage_path = self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)
-
-        self._model_deployment_spec.save(
+        if self._workspace:
+            # create a temp stage
+            stage_name = sql_identifier.SqlIdentifier(
+                snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
+            )
+            self._stage_client.create_tmp_stage(
+                database_name=database_name,
+                schema_name=schema_name,
+                stage_name=stage_name,
+                statement_params=statement_params,
+            )
+            stage_path = self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)
+        else:
+            stage_path = None
+        spec_yaml_str_or_path = self._model_deployment_spec.save(
             database_name=database_name,
             schema_name=schema_name,
             model_name=model_name,
@@ -154,26 +156,35 @@ class ServiceOperator:
             force_rebuild=force_rebuild,
             external_access_integrations=build_external_access_integrations,
         )
-        file_utils.upload_directory_to_stage(
-            self._session,
-            local_path=self.workspace_path,
-            stage_path=pathlib.PurePosixPath(stage_path),
-            statement_params=statement_params,
-        )
+        if self._workspace:
+            assert stage_path is not None
+            file_utils.upload_directory_to_stage(
+                self._session,
+                local_path=pathlib.Path(self._workspace.name),
+                stage_path=pathlib.PurePosixPath(stage_path),
+                statement_params=statement_params,
+            )
 
-        # check if the inference service is already running
+        # check if the inference service is already running/suspended
         model_inference_service_exists = self._check_if_service_exists(
             database_name=service_database_name,
             schema_name=service_schema_name,
             service_name=service_name,
-            service_status_list_if_exists=[service_sql.ServiceStatus.READY],
+            service_status_list_if_exists=[
+                service_sql.ServiceStatus.READY,
+                service_sql.ServiceStatus.SUSPENDING,
+                service_sql.ServiceStatus.SUSPENDED,
+            ],
             statement_params=statement_params,
         )
 
         # deploy the model service
         query_id, async_job = self._service_client.deploy_model(
-            stage_path=stage_path,
-            model_deployment_spec_file_rel_path=model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH,
+            stage_path=stage_path if self._workspace else None,
+            model_deployment_spec_file_rel_path=(
+                model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH if self._workspace else None
+            ),
+            model_deployment_spec_yaml_str=None if self._workspace else spec_yaml_str_or_path,
             statement_params=statement_params,
         )
 
@@ -309,7 +320,10 @@ class ServiceOperator:
                         set_service_log_metadata_to_model_inference(
                             service_log_meta,
                             model_inference_service,
-                            "Model Inference image build is not rebuilding the image and using previously built image.",
+                            (
+                                "Model Inference image build is not rebuilding the image, but using a previously built "
+                                "image."
+                            ),
                         )
                         continue
 
@@ -366,7 +380,9 @@ class ServiceOperator:
             time.sleep(5)
 
         if model_inference_service_exists:
-            module_logger.info(f"Inference service {model_inference_service.display_service_name} is already RUNNING.")
+            module_logger.info(
+                f"Inference service {model_inference_service.display_service_name} has already been deployed."
+            )
         else:
             self._finalize_logs(
                 service_log_meta.service_logger, service_log_meta.service, service_log_meta.log_offset, statement_params
@@ -416,6 +432,8 @@ class ServiceOperator:
             service_status_list_if_exists = [
                 service_sql.ServiceStatus.PENDING,
                 service_sql.ServiceStatus.READY,
+                service_sql.ServiceStatus.SUSPENDING,
+                service_sql.ServiceStatus.SUSPENDED,
                 service_sql.ServiceStatus.DONE,
                 service_sql.ServiceStatus.FAILED,
             ]

snowflake/ml/model/_client/service/model_deployment_spec.py

@@ -16,7 +16,7 @@ class ModelDeploymentSpec:
 
     DEPLOY_SPEC_FILE_REL_PATH = "deploy.yml"
 
-    def __init__(self, workspace_path: pathlib.Path) -> None:
+    def __init__(self, workspace_path: Optional[pathlib.Path] = None) -> None:
         self.workspace_path = workspace_path
 
     def save(
@@ -43,7 +43,7 @@ class ModelDeploymentSpec:
         max_batch_rows: Optional[int],
         force_rebuild: bool,
         external_access_integrations: Optional[List[sql_identifier.SqlIdentifier]],
-    ) -> None:
+    ) -> str:
         # create the deployment spec
         # models spec
         fq_model_name = identifier.get_schema_level_object_identifier(
@@ -105,9 +105,12 @@ class ModelDeploymentSpec:
             service=service_dict,
         )
 
+        # Anchors are not supported in the server, avoid that.
+        yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
+        if self.workspace_path is None:
+            return yaml.safe_dump(model_deployment_spec_dict)
         # save the yaml
         file_path = self.workspace_path / self.DEPLOY_SPEC_FILE_REL_PATH
         with file_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(model_deployment_spec_dict, f)
+        return str(file_path.resolve())

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

@@ -20,6 +20,8 @@ class ServiceStatus(enum.Enum):
     UNKNOWN = "UNKNOWN"  # status is unknown because we have not received enough data from K8s yet.
     PENDING = "PENDING"  # resource set is being created, can't be used yet
     READY = "READY"  # resource set has been deployed.
+    SUSPENDING = "SUSPENDING"  # the service is set to suspended but the resource set is still in deleting state
+    SUSPENDED = "SUSPENDED"  # the service is suspended and the resource set is deleted
     DELETING = "DELETING"  # resource set is being deleted
     FAILED = "FAILED"  # resource set has failed and cannot be used anymore
     DONE = "DONE"  # resource set has finished running
@@ -71,13 +73,17 @@ class ServiceSQLClient(_base._BaseSQLClient):
     def deploy_model(
         self,
         *,
-        stage_path: str,
-        model_deployment_spec_file_rel_path: str,
+        stage_path: Optional[str] = None,
+        model_deployment_spec_yaml_str: Optional[str] = None,
+        model_deployment_spec_file_rel_path: Optional[str] = None,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> Tuple[str, snowpark.AsyncJob]:
-        async_job = self._session.sql(
-            f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
-        ).collect(block=False, statement_params=statement_params)
+        assert model_deployment_spec_yaml_str or model_deployment_spec_file_rel_path
+        if model_deployment_spec_yaml_str:
+            sql_str = f"CALL SYSTEM$DEPLOY_MODEL('{model_deployment_spec_yaml_str}')"
+        else:
+            sql_str = f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
+        async_job = self._session.sql(sql_str).collect(block=False, statement_params=statement_params)
         assert isinstance(async_job, snowpark.AsyncJob)
         return async_job.query_id, async_job
 

snowflake/ml/model/_model_composer/model_composer.py

@@ -44,6 +44,7 @@ class ModelComposer:
         stage_path: str,
         *,
         statement_params: Optional[Dict[str, Any]] = None,
+        save_location: Optional[str] = None,
     ) -> None:
         self.session = session
         self.stage_path: Union[pathlib.PurePosixPath, parse.ParseResult] = None  # type: ignore[assignment]
@@ -54,10 +55,29 @@ class ModelComposer:
             # The stage path is a user stage path
             self.stage_path = pathlib.PurePosixPath(stage_path)
 
-        self._workspace = tempfile.TemporaryDirectory()
-        self._packager_workspace = tempfile.TemporaryDirectory()
+        # Set up workspace based on save_location if provided, otherwise use temporary directory
+        self.save_location = save_location
+        if save_location:
+            # Use the save_location directory directly
+            self._workspace_path = pathlib.Path(save_location)
+            self._workspace_path.mkdir(exist_ok=True)
+            # ensure that the directory is empty
+            if any(self._workspace_path.iterdir()):
+                raise ValueError(f"The directory {self._workspace_path} is not empty.")
+            self._workspace = None
+
+            self._packager_workspace_path = self._workspace_path / ModelComposer.MODEL_DIR_REL_PATH
+            self._packager_workspace_path.mkdir(exist_ok=True)
+            self._packager_workspace = None
+        else:
+            # Use a temporary directory
+            self._workspace = tempfile.TemporaryDirectory()
+            self._workspace_path = pathlib.Path(self._workspace.name)
+
+            self._packager_workspace_path = self._workspace_path / ModelComposer.MODEL_DIR_REL_PATH
+            self._packager_workspace_path.mkdir(exist_ok=True)
 
-        self.packager = model_packager.ModelPackager(local_dir_path=str(self._packager_workspace_path))
+        self.packager = model_packager.ModelPackager(local_dir_path=str(self.packager_workspace_path))
         self.manifest = model_manifest.ModelManifest(workspace_path=self.workspace_path)
 
         self.model_file_rel_path = f"model-{uuid.uuid4().hex}.zip"
@@ -65,16 +85,16 @@ class ModelComposer:
         self._statement_params = statement_params
 
     def __del__(self) -> None:
-        self._workspace.cleanup()
-        self._packager_workspace.cleanup()
+        if self._workspace:
+            self._workspace.cleanup()
 
     @property
     def workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._workspace.name)
+        return self._workspace_path
 
     @property
-    def _packager_workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._packager_workspace.name)
+    def packager_workspace_path(self) -> pathlib.Path:
+        return self._packager_workspace_path
 
     @property
     def model_stage_path(self) -> str:
@@ -167,6 +187,7 @@ class ModelComposer:
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
             artifact_repository_map=artifact_repository_map,
+            target_platforms=target_platforms,
             python_version=python_version,
             ext_modules=ext_modules,
             code_paths=code_paths,
@@ -175,9 +196,6 @@ class ModelComposer:
         )
         assert self.packager.meta is not None
 
-        file_utils.copytree(
-            str(self._packager_workspace_path), str(self.workspace_path / ModelComposer.MODEL_DIR_REL_PATH)
-        )
         self.manifest.save(
             model_meta=self.packager.meta,
             model_rel_path=pathlib.PurePosixPath(ModelComposer.MODEL_DIR_REL_PATH),

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

@@ -36,7 +36,6 @@ class ModelManifest:
     """
 
     MANIFEST_FILE_REL_PATH = "MANIFEST.yml"
-    _ENABLE_USER_FILES = False
     _DEFAULT_RUNTIME_NAME = "python_runtime"
 
     def __init__(self, workspace_path: pathlib.Path) -> None:
@@ -149,7 +148,7 @@ class ModelManifest:
             ],
         )
 
-        if self._ENABLE_USER_FILES:
+        if self.user_files:
             manifest_dict["user_files"] = [user_file.save(self.workspace_path) for user_file in self.user_files]
 
         lineage_sources = self._extract_lineage_info(data_sources)

snowflake/ml/model/_packager/model_env/model_env.py

@@ -29,11 +29,13 @@ class ModelEnv:
         self,
         conda_env_rel_path: Optional[str] = None,
         pip_requirements_rel_path: Optional[str] = None,
+        prefer_pip: bool = False,
     ) -> None:
         if conda_env_rel_path is None:
             conda_env_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_CONDA_ENV_FILENAME)
         if pip_requirements_rel_path is None:
             pip_requirements_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_PIP_REQUIREMENTS_FILENAME)
+        self.prefer_pip: bool = prefer_pip
         self.conda_env_rel_path = pathlib.PurePosixPath(pathlib.Path(conda_env_rel_path).as_posix())
         self.pip_requirements_rel_path = pathlib.PurePosixPath(pathlib.Path(pip_requirements_rel_path).as_posix())
         self.artifact_repository_map: Optional[Dict[str, str]] = None
@@ -113,7 +115,11 @@ class ModelEnv:
         if snowpark_ml_version:
             self._snowpark_ml_version = version.parse(snowpark_ml_version)
 
-    def include_if_absent(self, pkgs: List[ModelDependency], check_local_version: bool = False) -> None:
+    def include_if_absent(
+        self,
+        pkgs: List[ModelDependency],
+        check_local_version: bool = False,
+    ) -> None:
         """Append requirements into model env if absent. Depending on the environment, requirements may be added
         to either the pip requirements or conda dependencies.
 
@@ -121,7 +127,7 @@ class ModelEnv:
             pkgs: A list of ModelDependency namedtuple to be appended.
             check_local_version: Flag to indicate if it is required to pin to local version. Defaults to False.
         """
-        if self.pip_requirements and not self.conda_dependencies and pkgs:
+        if (self.pip_requirements or self.prefer_pip) and not self.conda_dependencies and pkgs:
             pip_pkg_reqs: List[str] = []
             warnings.warn(
                 (

snowflake/ml/model/_packager/model_handlers/sklearn.py

@@ -57,6 +57,7 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
         "predict_proba",
         "predict_log_proba",
         "decision_function",
+        "score_samples",
     ]
     EXPLAIN_TARGET_METHODS = ["predict", "predict_proba", "predict_log_proba"]
 
@@ -74,10 +75,6 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
             and (
                 not type_utils.LazyType("lightgbm.LGBMModel").isinstance(model)
             )  # LGBMModel is actually a BaseEstimator
-            and any(
-                (hasattr(model, method) and callable(getattr(model, method, None)))
-                for method in cls.DEFAULT_TARGET_METHODS
-            )
         )
 
     @classmethod

snowflake/ml/model/_packager/model_meta/_packaging_requirements.py

@@ -1 +1 @@
-REQUIREMENTS = ['cloudpickle>=2.0.0']
+REQUIREMENTS = ['cloudpickle>=2.0.0,<3']

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -49,6 +49,7 @@ def create_model_metadata(
     conda_dependencies: Optional[List[str]] = None,
     pip_requirements: Optional[List[str]] = None,
     artifact_repository_map: Optional[Dict[str, str]] = None,
+    target_platforms: Optional[List[model_types.TargetPlatform]] = None,
     python_version: Optional[str] = None,
     task: model_types.Task = model_types.Task.UNKNOWN,
     **kwargs: Any,
@@ -69,6 +70,7 @@ def create_model_metadata(
         conda_dependencies: List of conda requirements for running the model. Defaults to None.
         pip_requirements: List of pip Python packages requirements for running the model. Defaults to None.
         artifact_repository_map: A dict mapping from package channel to artifact repository name.
+        target_platforms: List of target platforms to run the model.
         python_version: A string of python version where model is run. Used for user override. If specified as None,
             current version would be captured. Defaults to None.
         task: The task of the Model Version. It is an enum class Task with values TABULAR_REGRESSION,
@@ -101,12 +103,14 @@ def create_model_metadata(
         else:
             raise ValueError("`snowflake.ml` is imported via a way that embedding local ML library is not supported.")
 
+    prefer_pip = target_platforms == [model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
     env = _create_env_for_model_metadata(
         conda_dependencies=conda_dependencies,
         pip_requirements=pip_requirements,
         artifact_repository_map=artifact_repository_map,
         python_version=python_version,
         embed_local_ml_library=embed_local_ml_library,
+        prefer_pip=prefer_pip,
     )
 
     if embed_local_ml_library:
@@ -157,8 +161,9 @@ def _create_env_for_model_metadata(
     artifact_repository_map: Optional[Dict[str, str]] = None,
     python_version: Optional[str] = None,
     embed_local_ml_library: bool = False,
+    prefer_pip: bool = False,
 ) -> model_env.ModelEnv:
-    env = model_env.ModelEnv()
+    env = model_env.ModelEnv(prefer_pip=prefer_pip)
 
     # Mypy doesn't like getter and setter have different types. See python/mypy #3004
     env.conda_dependencies = conda_dependencies  # type: ignore[assignment]

snowflake/ml/model/_packager/model_meta/model_meta_schema.py

@@ -82,6 +82,7 @@ class SentenceTransformersModelBlobOptions(BaseModelBlobOptions):
 
 ModelBlobOptions = Union[
     BaseModelBlobOptions,
+    CatBoostModelBlobOptions,
     HuggingFacePipelineModelBlobOptions,
     MLFlowModelBlobOptions,
     XgboostModelBlobOptions,