oracle-ads 2.13.11__py3-none-any.whl → 2.13.12__py3-none-any.whl

ads/aqua/modeldeployment/constants.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 """
@@ -8,3 +8,6 @@ aqua.modeldeployment.constants
 
 This module contains constants used in Aqua Model Deployment.
 """
+
+DEFAULT_WAIT_TIME = 12000
+DEFAULT_POLL_INTERVAL = 10

ads/aqua/modeldeployment/deployment.py

@@ -2,10 +2,12 @@
 # Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
+
 import json
 import shlex
+import threading
 from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from cachetools import TTLCache, cached
 from oci.data_science.models import ModelDeploymentShapeSummary
@@ -17,20 +19,15 @@ from ads.aqua.common.entities import (
     ComputeShapeSummary,
     ContainerPath,
 )
-from ads.aqua.common.enums import (
-    InferenceContainerTypeFamily,
-    ModelFormat,
-    Tags,
-)
+from ads.aqua.common.enums import InferenceContainerTypeFamily, ModelFormat, Tags
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
 from ads.aqua.common.utils import (
     DEFINED_METADATA_TO_FILE_MAP,
-    build_params_string,
     build_pydantic_error_message,
+    find_restricted_params,
     get_combined_params,
     get_container_params_type,
     get_ocid_substring,
-    get_params_dict,
     get_params_list,
     get_resource_name,
     get_restricted_params_by_container,
@@ -55,22 +52,29 @@ from ads.aqua.model.utils import (
     extract_base_model_from_ft,
     extract_fine_tune_artifacts_path,
 )
+from ads.aqua.modeldeployment.config_loader import (
+    AquaDeploymentConfig,
+    ConfigurationItem,
+    ModelDeploymentConfigSummary,
+    MultiModelDeploymentConfigLoader,
+)
+from ads.aqua.modeldeployment.constants import DEFAULT_POLL_INTERVAL, DEFAULT_WAIT_TIME
 from ads.aqua.modeldeployment.entities import (
     AquaDeployment,
-    AquaDeploymentConfig,
     AquaDeploymentDetail,
-    ConfigurationItem,
     ConfigValidationError,
     CreateModelDeploymentDetails,
-    ModelDeploymentConfigSummary,
 )
-from ads.aqua.modeldeployment.utils import MultiModelDeploymentConfigLoader
+from ads.aqua.modeldeployment.model_group_config import ModelGroupConfig
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.common.utils import UNKNOWN, get_log_links
+from ads.common.work_request import DataScienceWorkRequest
 from ads.config import (
     AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME,
     AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
     AQUA_DEPLOYMENT_CONTAINER_URI_METADATA_NAME,
+    AQUA_TELEMETRY_BUCKET,
+    AQUA_TELEMETRY_BUCKET_NS,
     COMPARTMENT_OCID,
     PROJECT_OCID,
 )
@@ -486,7 +490,7 @@ class AquaDeploymentApp(AquaApp):
                     f"with deployment without parameter overrides."
                 )
 
-            restricted_params = self._find_restricted_params(
+            restricted_params = find_restricted_params(
                 params, user_params, container_type_key
             )
             if restricted_params:
@@ -508,6 +512,9 @@ class AquaDeploymentApp(AquaApp):
                     if key not in env_var:
                         env_var.update(env)
 
+        env_var.update({"AQUA_TELEMETRY_BUCKET_NS": AQUA_TELEMETRY_BUCKET_NS})
+        env_var.update({"AQUA_TELEMETRY_BUCKET": AQUA_TELEMETRY_BUCKET})
+
         logger.info(f"Env vars used for deploying {aqua_model.id} :{env_var}")
 
         tags = {**tags, **(create_deployment_details.freeform_tags or {})}
@@ -553,7 +560,6 @@ class AquaDeploymentApp(AquaApp):
         AquaDeployment
             An Aqua deployment instance.
         """
-        model_config = []
         model_name_list = []
         env_var = {**(create_deployment_details.env_var or UNKNOWN_DICT)}
 
@@ -566,80 +572,14 @@ class AquaDeploymentApp(AquaApp):
 
         container_params = container_spec.cli_param if container_spec else UNKNOWN
 
-        for model in create_deployment_details.models:
-            user_params = build_params_string(model.env_var)
-            if user_params:
-                restricted_params = self._find_restricted_params(
-                    container_params, user_params, container_type_key
-                )
-                if restricted_params:
-                    selected_model = model.model_name or model.model_id
-                    raise AquaValueError(
-                        f"Parameters {restricted_params} are set by Aqua "
-                        f"and cannot be overridden or are invalid."
-                        f"Select other parameters for model {selected_model}."
-                    )
-
-            # replaces `--served-model-name`` with user's model name
-            container_params_dict = get_params_dict(container_params)
-            container_params_dict.update({"--served-model-name": model.model_name})
-            # replaces `--tensor-parallel-size` with model gpu count
-            container_params_dict.update({"--tensor-parallel-size": model.gpu_count})
-            params = build_params_string(container_params_dict)
-
-            deployment_config = model_config_summary.deployment_config.get(
-                model.model_id, AquaDeploymentConfig()
-            ).configuration.get(
-                create_deployment_details.instance_shape, ConfigurationItem()
-            )
-
-            # finds the corresponding deployment parameters based on the gpu count
-            # and combines them with user's parameters. Existing deployment parameters
-            # will be overriden by user's parameters.
-            params_found = False
-            for item in deployment_config.multi_model_deployment:
-                if (
-                    model.gpu_count
-                    and item.gpu_count
-                    and item.gpu_count == model.gpu_count
-                ):
-                    config_parameters = item.parameters.get(
-                        get_container_params_type(container_type_key), UNKNOWN
-                    )
-                    params = f"{params} {get_combined_params(config_parameters, user_params)}".strip()
-                    params_found = True
-                    break
-
-            if not params_found and deployment_config.parameters:
-                config_parameters = deployment_config.parameters.get(
-                    get_container_params_type(container_type_key), UNKNOWN
-                )
-                params = f"{params} {get_combined_params(config_parameters, user_params)}".strip()
-                params_found = True
-
-            # if no config parameters found, append user parameters directly.
-            if not params_found:
-                params = f"{params} {user_params}".strip()
-
-            artifact_path_prefix = model.artifact_location.rstrip("/")
-            if ObjectStorageDetails.is_oci_path(artifact_path_prefix):
-                os_path = ObjectStorageDetails.from_path(artifact_path_prefix)
-                artifact_path_prefix = os_path.filepath.rstrip("/")
-
-            # override by-default completion/ chat endpoint with other endpoint (embedding)
-            config_data = {"params": params, "model_path": artifact_path_prefix}
-            if model.model_task:
-                config_data["model_task"] = model.model_task
-
-            if model.fine_tune_weights_location:
-                config_data["fine_tune_weights_location"] = (
-                    model.fine_tune_weights_location
-                )
-
-            model_config.append(config_data)
-            model_name_list.append(model.model_name)
+        multi_model_config = ModelGroupConfig.from_create_model_deployment_details(
+            create_deployment_details,
+            model_config_summary,
+            container_type_key,
+            container_params,
+        )
 
-        env_var.update({AQUA_MULTI_MODEL_CONFIG: json.dumps({"models": model_config})})
+        env_var.update({AQUA_MULTI_MODEL_CONFIG: multi_model_config.model_dump_json()})
 
         env_vars = container_spec.env_vars if container_spec else []
         for env in env_vars:
@@ -788,9 +728,21 @@ class AquaDeploymentApp(AquaApp):
 
         deployment_id = deployment.id
         logger.info(
-            f"Aqua model deployment {deployment_id} created for model {aqua_model_id}."
+            f"Aqua model deployment {deployment_id} created for model {aqua_model_id}. Work request Id is {deployment.dsc_model_deployment.workflow_req_id}"
         )
 
+        progress_thread = threading.Thread(
+            target=self.get_deployment_status,
+            args=(
+                deployment_id,
+                deployment.dsc_model_deployment.workflow_req_id,
+                model_type,
+                model_name,
+            ),
+            daemon=True,
+        )
+        progress_thread.start()
+
         # we arbitrarily choose last 8 characters of OCID to identify MD in telemetry
         telemetry_kwargs = {"ocid": get_ocid_substring(deployment_id, key_len=8)}
 
@@ -1231,7 +1183,7 @@ class AquaDeploymentApp(AquaApp):
             container_spec = container_config.spec if container_config else UNKNOWN
             cli_params = container_spec.cli_param if container_spec else UNKNOWN
 
-            restricted_params = self._find_restricted_params(
+            restricted_params = find_restricted_params(
                 cli_params, params, container_type_key
             )
 
@@ -1242,41 +1194,6 @@ class AquaDeploymentApp(AquaApp):
             )
         return {"valid": True}
 
-    @staticmethod
-    def _find_restricted_params(
-        default_params: Union[str, List[str]],
-        user_params: Union[str, List[str]],
-        container_family: str,
-    ) -> List[str]:
-        """Returns a list of restricted params that user chooses to override when creating an Aqua deployment.
-        The default parameters coming from the container index json file cannot be overridden.
-
-        Parameters
-        ----------
-        default_params:
-            Inference container parameter string with default values.
-        user_params:
-            Inference container parameter string with user provided values.
-        container_family: str
-            The image family of model deployment container runtime.
-
-        Returns
-        -------
-            A list with params keys common between params1 and params2.
-
-        """
-        restricted_params = []
-        if default_params and user_params:
-            default_params_dict = get_params_dict(default_params)
-            user_params_dict = get_params_dict(user_params)
-
-            restricted_params_set = get_restricted_params_by_container(container_family)
-            for key, _items in user_params_dict.items():
-                if key in default_params_dict or key in restricted_params_set:
-                    restricted_params.append(key.lstrip("-"))
-
-        return restricted_params
-
     @telemetry(entry_point="plugin=deployment&action=list_shapes", name="aqua")
     @cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=5), timer=datetime.now))
     def list_shapes(self, **kwargs) -> List[ComputeShapeSummary]:
@@ -1313,3 +1230,62 @@ class AquaDeploymentApp(AquaApp):
             )
             for oci_shape in oci_shapes
         ]
+
+    def get_deployment_status(
+        self,
+        model_deployment_id: str,
+        work_request_id: str,
+        model_type: str,
+        model_name: str,
+    ) -> None:
+        """Waits for the data science  model deployment to be completed and log its status in telemetry.
+
+        Parameters
+        ----------
+
+        model_deployment_id: str
+            The id of the deployed aqua model.
+        work_request_id: str
+            The work request Id of the model deployment.
+        model_type: str
+            The type of aqua model to be deployed. Allowed values are: `custom`, `service` and `multi_model`.
+
+        Returns
+        -------
+        AquaDeployment
+            An Aqua deployment instance.
+        """
+        ocid = get_ocid_substring(model_deployment_id, key_len=8)
+        telemetry_kwargs = {"ocid": ocid}
+
+        data_science_work_request: DataScienceWorkRequest = DataScienceWorkRequest(
+            work_request_id
+        )
+
+        try:
+            data_science_work_request.wait_work_request(
+                progress_bar_description="Creating model deployment",
+                max_wait_time=DEFAULT_WAIT_TIME,
+                poll_interval=DEFAULT_POLL_INTERVAL,
+            )
+        except Exception:
+            if data_science_work_request._error_message:
+                error_str = ""
+                for error in data_science_work_request._error_message:
+                    error_str = error_str + " " + error.message
+
+            self.telemetry.record_event(
+                category=f"aqua/{model_type}/deployment/status",
+                action="FAILED",
+                detail=error_str,
+                value=model_name,
+                **telemetry_kwargs,
+            )
+
+        else:
+            self.telemetry.record_event_async(
+                category=f"aqua/{model_type}/deployment/status",
+                action="SUCCEEDED",
+                value=model_name,
+                **telemetry_kwargs,
+            )

ads/aqua/modeldeployment/entities.py

@@ -13,6 +13,10 @@ from ads.aqua.common.enums import Tags
 from ads.aqua.config.utils.serializer import Serializable
 from ads.aqua.constants import UNKNOWN_DICT
 from ads.aqua.data import AquaResourceIdentifier
+from ads.aqua.modeldeployment.config_loader import (
+    ConfigurationItem,
+    ModelDeploymentConfigSummary,
+)
 from ads.common.serializer import DataClassSerializable
 from ads.common.utils import UNKNOWN, get_console_link
 
@@ -213,184 +217,6 @@ class AquaDeploymentDetail(AquaDeployment, DataClassSerializable):
         extra = "allow"
 
 
-class ShapeInfoConfig(Serializable):
-    """Describes how many memory and cpu to this model for specific shape.
-
-    Attributes:
-        memory_in_gbs (float, optional): The number of memory in gbs to this model of the shape.
-        ocpu (float, optional): The number of ocpus to this model of the shape.
-    """
-
-    memory_in_gbs: Optional[float] = Field(
-        None,
-        description="The number of memory in gbs to this model of the shape.",
-    )
-    ocpu: Optional[float] = Field(
-        None,
-        description="The number of ocpus to this model of the shape.",
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class DeploymentShapeInfo(Serializable):
-    """Describes the shape information to this model for specific shape.
-
-    Attributes:
-        configs (List[ShapeInfoConfig], optional): A list of memory and cpu number details to this model of the shape.
-        type (str, optional): The type of the shape.
-    """
-
-    configs: Optional[List[ShapeInfoConfig]] = Field(
-        default_factory=list,
-        description="A list of memory and cpu number details to this model of the shape.",
-    )
-    type: Optional[str] = Field(
-        default_factory=str, description="The type of the shape."
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class MultiModelConfig(Serializable):
-    """Describes how many GPUs and the parameters of specific shape for multi model deployment.
-
-    Attributes:
-        gpu_count (int, optional): Number of GPUs count to this model of this shape.
-        parameters (Dict[str, str], optional): A dictionary of parameters (e.g., VLLM_PARAMS) to
-            configure the behavior of a particular GPU shape.
-    """
-
-    gpu_count: Optional[int] = Field(
-        default_factory=int, description="The number of GPUs allocated to the model."
-    )
-    parameters: Optional[Dict[str, str]] = Field(
-        default_factory=dict,
-        description="Key-value pairs for GPU shape parameters (e.g., VLLM_PARAMS).",
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class ConfigurationItem(Serializable):
-    """Holds key-value parameter pairs for a specific GPU or CPU shape.
-
-    Attributes:
-        parameters (Dict[str, str], optional): A dictionary of parameters (e.g., VLLM_PARAMS) to
-            configure the behavior of a particular GPU shape.
-        multi_model_deployment (List[MultiModelConfig], optional): A list of multi model configuration details.
-        shape_info (DeploymentShapeInfo, optional): The shape information to this model for specific CPU shape.
-    """
-
-    parameters: Optional[Dict[str, str]] = Field(
-        default_factory=dict,
-        description="Key-value pairs for shape parameters.",
-    )
-    multi_model_deployment: Optional[List[MultiModelConfig]] = Field(
-        default_factory=list, description="A list of multi model configuration details."
-    )
-    shape_info: Optional[DeploymentShapeInfo] = Field(
-        default_factory=DeploymentShapeInfo,
-        description="The shape information to this model for specific shape",
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class AquaDeploymentConfig(Serializable):
-    """Represents multi model's shape list and detailed configuration.
-
-    Attributes:
-        shape (List[str], optional): A list of shape names (e.g., BM.GPU.A10.4).
-        configuration (Dict[str, ConfigurationItem], optional): Maps each shape to its configuration details.
-    """
-
-    shape: Optional[List[str]] = Field(
-        default_factory=list, description="List of supported shapes for the model."
-    )
-    configuration: Optional[Dict[str, ConfigurationItem]] = Field(
-        default_factory=dict, description="Configuration details keyed by shape."
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class GPUModelAllocation(Serializable):
-    """Describes how many GPUs are allocated to a particular model.
-
-    Attributes:
-        ocid (str, optional): The unique identifier of the model.
-        gpu_count (int, optional): Number of GPUs allocated to this model.
-    """
-
-    ocid: Optional[str] = Field(
-        default_factory=str, description="The unique model OCID."
-    )
-    gpu_count: Optional[int] = Field(
-        default_factory=int, description="The number of GPUs allocated to the model."
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class GPUShapeAllocation(Serializable):
-    """
-    Allocation details for a specific GPU shape.
-
-    Attributes:
-        models (List[GPUModelAllocation], optional): List of model GPU allocations for this shape.
-        total_gpus_available (int, optional): The total number of GPUs available for this shape.
-    """
-
-    models: Optional[List[GPUModelAllocation]] = Field(
-        default_factory=list, description="List of model allocations for this shape."
-    )
-    total_gpus_available: Optional[int] = Field(
-        default_factory=int, description="Total GPUs available for this shape."
-    )
-
-    class Config:
-        extra = "allow"
-
-
-class ModelDeploymentConfigSummary(Serializable):
-    """Top-level configuration model for OCI-based deployments.
-
-    Attributes:
-        deployment_config (Dict[str, AquaDeploymentConfig], optional): Deployment configurations
-            keyed by model OCID.
-        gpu_allocation (Dict[str, GPUShapeAllocation], optional): GPU allocations keyed by GPU shape.
-        error_message (str, optional): Error message if GPU allocation is not possible.
-    """
-
-    deployment_config: Optional[Dict[str, AquaDeploymentConfig]] = Field(
-        default_factory=dict,
-        description=(
-            "Deployment configuration details for each model, including supported shapes "
-            "and shape-specific parameters."
-        ),
-    )
-    gpu_allocation: Optional[Dict[str, GPUShapeAllocation]] = Field(
-        default_factory=dict,
-        description=(
-            "Details on how GPUs are allocated per shape, including the total "
-            "GPUs available for each shape."
-        ),
-    )
-    error_message: Optional[str] = Field(
-        default=None, description="Error message if GPU allocation is not possible."
-    )
-
-    class Config:
-        extra = "allow"
-
-
 class CreateModelDeploymentDetails(BaseModel):
     """Class for creating Aqua model deployments."""