oracle-ads 2.13.8__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

ads/aqua/modeldeployment/deployment.py

@@ -1,1324 +0,0 @@
-#!/usr/bin/env python
-# 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
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Union
-
-from cachetools import TTLCache, cached
-from oci.data_science.models import ModelDeploymentShapeSummary
-from pydantic import ValidationError
-
-from ads.aqua.app import AquaApp, logger
-from ads.aqua.common.entities import (
-    AquaMultiModelRef,
-    ComputeShapeSummary,
-    ContainerPath,
-)
-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,
-    get_combined_params,
-    get_container_params_type,
-    get_model_by_reference_paths,
-    get_ocid_substring,
-    get_params_dict,
-    get_params_list,
-    get_resource_name,
-    get_restricted_params_by_container,
-    load_gpu_shapes_index,
-    validate_cmd_var,
-)
-from ads.aqua.config.container_config import AquaContainerConfig, Usage
-from ads.aqua.constants import (
-    AQUA_MODEL_ARTIFACT_FILE,
-    AQUA_MODEL_TYPE_CUSTOM,
-    AQUA_MODEL_TYPE_MULTI,
-    AQUA_MODEL_TYPE_SERVICE,
-    AQUA_MULTI_MODEL_CONFIG,
-    MODEL_BY_REFERENCE_OSS_PATH_KEY,
-    MODEL_NAME_DELIMITER,
-    UNKNOWN_DICT,
-)
-from ads.aqua.data import AquaResourceIdentifier
-from ads.aqua.finetuning.finetuning import FineTuneCustomMetadata
-from ads.aqua.model import AquaModelApp
-from ads.aqua.model.constants import AquaModelMetadataKeys, ModelCustomMetadataFields
-from ads.aqua.modeldeployment.entities import (
-    AquaDeployment,
-    AquaDeploymentConfig,
-    AquaDeploymentDetail,
-    ConfigurationItem,
-    ConfigValidationError,
-    CreateModelDeploymentDetails,
-    ModelDeploymentConfigSummary,
-)
-from ads.aqua.modeldeployment.utils import MultiModelDeploymentConfigLoader
-from ads.common.object_storage_details import ObjectStorageDetails
-from ads.common.utils import UNKNOWN, get_log_links
-from ads.config import (
-    AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME,
-    AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
-    AQUA_DEPLOYMENT_CONTAINER_URI_METADATA_NAME,
-    COMPARTMENT_OCID,
-    PROJECT_OCID,
-)
-from ads.model.datascience_model import DataScienceModel
-from ads.model.deployment import (
-    ModelDeployment,
-    ModelDeploymentContainerRuntime,
-    ModelDeploymentInfrastructure,
-    ModelDeploymentMode,
-)
-from ads.model.model_metadata import ModelCustomMetadataItem
-from ads.telemetry import telemetry
-
-
-class AquaDeploymentApp(AquaApp):
-    """Provides a suite of APIs to interact with Aqua model deployments within the Oracle
-    Cloud Infrastructure Data Science service, serving as an interface for deploying
-    machine learning models.
-
-
-    Methods
-    -------
-    create(model_id: str, instance_shape: str, display_name: str,...) -> AquaDeployment
-        Creates a model deployment for Aqua Model.
-    get(model_deployment_id: str) -> AquaDeployment:
-        Retrieves details of an Aqua model deployment by its unique identifier.
-    list(**kwargs) -> List[AquaModelSummary]:
-        Lists all Aqua deployments within a specified compartment and/or project.
-    get_deployment_config(self, model_id: str) -> AquaDeploymentConfig:
-        Gets the deployment config of given Aqua model.
-    get_multimodel_deployment_config(self, model_ids: List[str],...) -> ModelDeploymentConfigSummary:
-        Retrieves the deployment configuration for multiple Aqua models and calculates
-        the GPU allocations for all compatible shapes.
-    list_shapes(self, **kwargs) -> List[Dict]:
-        Lists the valid model deployment shapes.
-
-    Note:
-        Use `ads aqua deployment <method_name> --help` to get more details on the parameters available.
-        This class is designed to work within the Oracle Cloud Infrastructure
-        and requires proper configuration and authentication set up to interact
-        with OCI services.
-    """
-
-    @telemetry(entry_point="plugin=deployment&action=create", name="aqua")
-    def create(
-        self,
-        create_deployment_details: Optional[CreateModelDeploymentDetails] = None,
-        **kwargs,
-    ) -> "AquaDeployment":
-        """
-        Creates a new Aqua model deployment.\n
-        For detailed information about CLI flags see: https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/ai-quick-actions/cli-tips.md#create-model-deployment
-
-        Args:
-            create_deployment_details : CreateModelDeploymentDetails, optional
-                An instance of CreateModelDeploymentDetails containing all required and optional
-                fields for creating a model deployment via Aqua.
-            kwargs:
-                instance_shape (str): The instance shape used for deployment.
-                display_name (str): The name of the model deployment.
-                compartment_id (Optional[str]): The compartment OCID.
-                project_id (Optional[str]): The project OCID.
-                description (Optional[str]): The description of the deployment.
-                model_id (Optional[str]): The model OCID to deploy.
-                models (Optional[List[AquaMultiModelRef]]): List of models for multimodel deployment.
-                instance_count (int): Number of instances used for deployment.
-                log_group_id (Optional[str]): OCI logging group ID for logs.
-                access_log_id (Optional[str]): OCID for access logs.
-                predict_log_id (Optional[str]): OCID for prediction logs.
-                bandwidth_mbps (Optional[int]): Bandwidth limit on the load balancer in Mbps.
-                web_concurrency (Optional[int]): Number of worker processes/threads for handling requests.
-                server_port (Optional[int]): Server port for the Docker container image.
-                health_check_port (Optional[int]): Health check port for the Docker container image.
-                env_var (Optional[Dict[str, str]]): Environment variables for deployment.
-                container_family (Optional[str]): Image family of the model deployment container runtime.
-                memory_in_gbs (Optional[float]): Memory (in GB) for the selected shape.
-                ocpus (Optional[float]): OCPU count for the selected shape.
-                model_file (Optional[str]): File used for model deployment.
-                private_endpoint_id (Optional[str]): Private endpoint ID for model deployment.
-                container_image_uri (Optional[str]): Image URI for model deployment container runtime.
-                cmd_var (Optional[List[str]]): Command variables for the container runtime.
-                freeform_tags (Optional[Dict]): Freeform tags for model deployment.
-                defined_tags (Optional[Dict]): Defined tags for model deployment.
-
-        Returns
-        -------
-        AquaDeployment
-            An Aqua deployment instance.
-        """
-        # Build deployment details from kwargs if not explicitly provided.
-        if create_deployment_details is None:
-            try:
-                create_deployment_details = CreateModelDeploymentDetails(**kwargs)
-            except ValidationError as ex:
-                custom_errors = build_pydantic_error_message(ex)
-                raise AquaValueError(
-                    f"Invalid parameters for creating a model deployment. Error details: {custom_errors}."
-                ) from ex
-
-        if not (create_deployment_details.model_id or create_deployment_details.models):
-            raise AquaValueError(
-                "Invalid parameters for creating a model deployment. Either `model_id` or `models` must be provided."
-            )
-
-        # Set defaults for compartment and project if not provided.
-        compartment_id = create_deployment_details.compartment_id or COMPARTMENT_OCID
-        project_id = create_deployment_details.project_id or PROJECT_OCID
-        freeform_tags = create_deployment_details.freeform_tags
-        defined_tags = create_deployment_details.defined_tags
-
-        # validate instance shape availability in compartment
-        available_shapes = [
-            shape.name.lower()
-            for shape in self.list_shapes(
-                compartment_id=compartment_id
-            )
-        ]
-
-        if create_deployment_details.instance_shape.lower() not in available_shapes:
-            raise AquaValueError(
-                f"Invalid Instance Shape. The selected shape '{create_deployment_details.instance_shape}' "
-                f"is not available in the {self.region} region. Please choose another shape to deploy the model."
-            )
-
-        # Get container config
-        container_config = self.get_container_config()
-
-        # Create an AquaModelApp instance once to perform the deployment creation.
-        model_app = AquaModelApp()
-        if create_deployment_details.model_id:
-            logger.debug(
-                f"Single model ({create_deployment_details.model_id}) provided. "
-                "Delegating to single model creation method."
-            )
-            aqua_model = model_app.create(
-                model_id=create_deployment_details.model_id,
-                compartment_id=compartment_id,
-                project_id=project_id,
-                freeform_tags=freeform_tags,
-                defined_tags=defined_tags,
-            )
-            return self._create(
-                aqua_model=aqua_model,
-                create_deployment_details=create_deployment_details,
-                container_config=container_config,
-            )
-        else:
-            model_ids = [model.model_id for model in create_deployment_details.models]
-            try:
-                model_config_summary = self.get_multimodel_deployment_config(
-                    model_ids=model_ids, compartment_id=compartment_id
-                )
-                if not model_config_summary.gpu_allocation:
-                    raise AquaValueError(model_config_summary.error_message)
-                create_deployment_details.validate_multimodel_deployment_feasibility(
-                    models_config_summary=model_config_summary
-                )
-            except ConfigValidationError as err:
-                raise AquaValueError(f"{err}") from err
-
-            service_inference_containers = container_config.inference.values()
-
-            supported_container_families = [
-                container_config_item.family
-                for container_config_item in service_inference_containers
-                if any(
-                    usage.upper() in container_config_item.usages
-                    for usage in [Usage.MULTI_MODEL, Usage.OTHER]
-                )
-            ]
-
-            if not supported_container_families:
-                raise AquaValueError(
-                    "Currently, there are no containers that support multi-model deployment."
-                )
-
-            # Check if provided container family supports multi-model deployment
-            if (
-                create_deployment_details.container_family
-                and create_deployment_details.container_family
-                not in supported_container_families
-            ):
-                raise AquaValueError(
-                    f"Unsupported deployment container '{create_deployment_details.container_family}'. "
-                    f"Only {supported_container_families} families are supported for multi-model deployments."
-                )
-
-            # Verify if it matches one of the registered containers and attempt to
-            # extract the container family from there.
-            # If the container is not recognized, we can only issue a warning that
-            # the provided container may not support multi-model deployment.
-            if create_deployment_details.container_image_uri:
-                selected_container_name = ContainerPath(
-                    full_path=create_deployment_details.container_image_uri
-                ).name
-
-                container_config_item = next(
-                    (
-                        container_config_item
-                        for container_config_item in service_inference_containers
-                        if ContainerPath(
-                            full_path=f"{container_config_item.name}:{container_config_item.version}"
-                        ).name.upper()
-                        == selected_container_name.upper()
-                    ),
-                    None,
-                )
-
-                if (
-                    container_config_item
-                    and container_config_item.family not in supported_container_families
-                ):
-                    raise AquaValueError(
-                        f"Unsupported deployment container '{create_deployment_details.container_image_uri}'. "
-                        f"Only {supported_container_families} families are supported for multi-model deployments."
-                    )
-
-                if not container_config_item:
-                    logger.warning(
-                        f"The provided container `{create_deployment_details.container_image_uri}` may not support multi-model deployment. "
-                        f"Only the following container families are supported: {supported_container_families}."
-                    )
-
-            logger.debug(
-                f"Multi models ({model_ids}) provided. Delegating to multi model creation method."
-            )
-
-            aqua_model = model_app.create_multi(
-                models=create_deployment_details.models,
-                compartment_id=compartment_id,
-                project_id=project_id,
-                freeform_tags=freeform_tags,
-                defined_tags=defined_tags,
-            )
-            return self._create_multi(
-                aqua_model=aqua_model,
-                model_config_summary=model_config_summary,
-                create_deployment_details=create_deployment_details,
-                container_config=container_config,
-            )
-
-    def _create(
-        self,
-        aqua_model: DataScienceModel,
-        create_deployment_details: CreateModelDeploymentDetails,
-        container_config: Dict,
-    ) -> AquaDeployment:
-        """Builds the configurations required by single model deployment and creates the deployment.
-
-        Parameters
-        ----------
-        aqua_model : DataScienceModel
-            An instance of Aqua data science model.
-        create_deployment_details : CreateModelDeploymentDetails
-            An instance of CreateModelDeploymentDetails containing all required and optional
-            fields for creating a model deployment via Aqua.
-        container_config: Dict
-            Container config dictionary.
-
-        Returns
-        -------
-        AquaDeployment
-            An Aqua deployment instance.
-        """
-        tags = {}
-        for tag in [
-            Tags.AQUA_SERVICE_MODEL_TAG,
-            Tags.AQUA_FINE_TUNED_MODEL_TAG,
-            Tags.AQUA_TAG,
-        ]:
-            if tag in aqua_model.freeform_tags:
-                tags[tag] = aqua_model.freeform_tags[tag]
-
-        tags.update({Tags.AQUA_MODEL_NAME_TAG: aqua_model.display_name})
-        tags.update({Tags.TASK: aqua_model.freeform_tags.get(Tags.TASK, UNKNOWN)})
-
-        # Set up info to get deployment config
-        config_source_id = create_deployment_details.model_id
-        model_name = aqua_model.display_name
-
-        is_fine_tuned_model = Tags.AQUA_FINE_TUNED_MODEL_TAG in aqua_model.freeform_tags
-
-        if is_fine_tuned_model:
-            try:
-                config_source_id = aqua_model.custom_metadata_list.get(
-                    FineTuneCustomMetadata.FINE_TUNE_SOURCE
-                ).value
-                model_name = aqua_model.custom_metadata_list.get(
-                    FineTuneCustomMetadata.FINE_TUNE_SOURCE_NAME
-                ).value
-            except ValueError as err:
-                raise AquaValueError(
-                    f"Either {FineTuneCustomMetadata.FINE_TUNE_SOURCE} or {FineTuneCustomMetadata.FINE_TUNE_SOURCE_NAME} is missing "
-                    f"from custom metadata for the model {config_source_id}"
-                ) from err
-
-        # set up env and cmd var
-        env_var = create_deployment_details.env_var or {}
-        cmd_var = create_deployment_details.cmd_var or []
-
-        try:
-            model_path_prefix = aqua_model.custom_metadata_list.get(
-                MODEL_BY_REFERENCE_OSS_PATH_KEY
-            ).value.rstrip("/")
-        except ValueError as err:
-            raise AquaValueError(
-                f"{MODEL_BY_REFERENCE_OSS_PATH_KEY} key is not available in the custom metadata field."
-            ) from err
-
-        if ObjectStorageDetails.is_oci_path(model_path_prefix):
-            os_path = ObjectStorageDetails.from_path(model_path_prefix)
-            model_path_prefix = os_path.filepath.rstrip("/")
-
-        env_var.update({"BASE_MODEL": f"{model_path_prefix}"})
-
-        if is_fine_tuned_model:
-            _, fine_tune_output_path = get_model_by_reference_paths(
-                aqua_model.model_file_description
-            )
-
-            if not fine_tune_output_path:
-                raise AquaValueError(
-                    "Fine tuned output path is not available in the model artifact."
-                )
-
-            os_path = ObjectStorageDetails.from_path(fine_tune_output_path)
-            fine_tune_output_path = os_path.filepath.rstrip("/")
-
-            env_var.update({"FT_MODEL": f"{fine_tune_output_path}"})
-
-        container_type_key = self._get_container_type_key(
-            model=aqua_model,
-            container_family=create_deployment_details.container_family,
-        )
-
-        container_image_uri = (
-            create_deployment_details.container_image_uri
-            or self.get_container_image(container_type=container_type_key)
-        )
-        if not container_image_uri:
-            try:
-                container_image_uri = aqua_model.custom_metadata_list.get(
-                    AQUA_DEPLOYMENT_CONTAINER_URI_METADATA_NAME
-                ).value
-            except ValueError as err:
-                raise AquaValueError(
-                    f"{AQUA_DEPLOYMENT_CONTAINER_URI_METADATA_NAME} key is not available in the custom metadata "
-                    f"field. Either re-register the model with custom container URI, or set container_image_uri "
-                    f"parameter when creating this deployment."
-                ) from err
-        logger.info(
-            f"Aqua Image used for deploying {aqua_model.id} : {container_image_uri}"
-        )
-
-        try:
-            cmd_var_string = aqua_model.custom_metadata_list.get(
-                AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME
-            ).value
-            default_cmd_var = shlex.split(cmd_var_string)
-            if default_cmd_var:
-                cmd_var = validate_cmd_var(default_cmd_var, cmd_var)
-            logger.info(f"CMD used for deploying {aqua_model.id} :{cmd_var}")
-        except ValueError:
-            logger.debug(
-                f"CMD will be ignored for this deployment as {AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME} "
-                f"key is not available in the custom metadata field for this model."
-            )
-        except Exception as e:
-            logger.error(
-                f"There was an issue processing CMD arguments. Error: {str(e)}"
-            )
-
-        model_formats_str = aqua_model.freeform_tags.get(
-            Tags.MODEL_FORMAT, ModelFormat.SAFETENSORS
-        ).upper()
-        model_format = model_formats_str.split(",")
-
-        # Figure out a better way to handle this in future release
-        if (
-            ModelFormat.GGUF in model_format
-            and container_type_key.lower()
-            == InferenceContainerTypeFamily.AQUA_LLAMA_CPP_CONTAINER_FAMILY
-        ):
-            model_file = create_deployment_details.model_file
-            if model_file is not None:
-                logger.info(
-                    f"Overriding {model_file} as model_file for model {aqua_model.id}."
-                )
-            else:
-                try:
-                    model_file = aqua_model.custom_metadata_list.get(
-                        AQUA_MODEL_ARTIFACT_FILE
-                    ).value
-                except ValueError as err:
-                    raise AquaValueError(
-                        f"{AQUA_MODEL_ARTIFACT_FILE} key is not available in the custom metadata field "
-                        f"for model {aqua_model.id}. Either register the model with a default model_file or pass "
-                        f"as a parameter when creating a deployment."
-                    ) from err
-
-            env_var.update({"BASE_MODEL_FILE": f"{model_file}"})
-            tags.update({Tags.MODEL_ARTIFACT_FILE: model_file})
-
-        # Fetch the startup cli command for the container
-        # container_index.json will have "containerSpec" section which will provide the cli params for
-        # a given container family
-        container_config = self.get_container_config_item(container_type_key)
-
-        container_spec = container_config.spec if container_config else UNKNOWN
-        # these params cannot be overridden for Aqua deployments
-        params = container_spec.cli_param if container_spec else UNKNOWN
-        server_port = create_deployment_details.server_port or (
-            container_spec.server_port if container_spec else None
-        )
-        # Give precendece to the input parameter
-        health_check_port = create_deployment_details.health_check_port or (
-            container_spec.health_check_port if container_spec else None
-        )
-
-        deployment_config = self.get_deployment_config(model_id=config_source_id)
-
-        config_params = deployment_config.configuration.get(
-            create_deployment_details.instance_shape, ConfigurationItem()
-        ).parameters.get(get_container_params_type(container_type_key), UNKNOWN)
-
-        # validate user provided params
-        user_params = env_var.get("PARAMS", UNKNOWN)
-        if user_params:
-            # todo: remove this check in the future version, logic to be moved to container_index
-            if (
-                container_type_key.lower()
-                == InferenceContainerTypeFamily.AQUA_LLAMA_CPP_CONTAINER_FAMILY
-            ):
-                # AQUA_LLAMA_CPP_CONTAINER_FAMILY container uses uvicorn that required model/server params
-                # to be set as env vars
-                raise AquaValueError(
-                    f"Currently, parameters cannot be overridden for the container: {container_image_uri}. Please proceed "
-                    f"with deployment without parameter overrides."
-                )
-
-            restricted_params = self._find_restricted_params(
-                params, user_params, container_type_key
-            )
-            if restricted_params:
-                raise AquaValueError(
-                    f"Parameters {restricted_params} are set by Aqua "
-                    f"and cannot be overridden or are invalid."
-                )
-
-        deployment_params = get_combined_params(config_params, user_params)
-
-        params = f"{params} {deployment_params}".strip()
-        if params:
-            env_var.update({"PARAMS": params})
-        env_vars = container_spec.env_vars if container_spec else []
-        for env in env_vars:
-            if isinstance(env, dict):
-                env = {k: v for k, v in env.items() if v}
-                for key, _ in env.items():
-                    if key not in env_var:
-                        env_var.update(env)
-
-        logger.info(f"Env vars used for deploying {aqua_model.id} :{env_var}")
-
-        tags = {**tags, **(create_deployment_details.freeform_tags or {})}
-        model_type = (
-            AQUA_MODEL_TYPE_CUSTOM if is_fine_tuned_model else AQUA_MODEL_TYPE_SERVICE
-        )
-
-        return self._create_deployment(
-            create_deployment_details=create_deployment_details,
-            aqua_model_id=aqua_model.id,
-            model_name=model_name,
-            model_type=model_type,
-            container_image_uri=container_image_uri,
-            server_port=server_port,
-            health_check_port=health_check_port,
-            env_var=env_var,
-            tags=tags,
-            cmd_var=cmd_var,
-        )
-
-    def _create_multi(
-        self,
-        aqua_model: DataScienceModel,
-        model_config_summary: ModelDeploymentConfigSummary,
-        create_deployment_details: CreateModelDeploymentDetails,
-        container_config: AquaContainerConfig,
-    ) -> AquaDeployment:
-        """Builds the environment variables required by multi deployment container and creates the deployment.
-
-        Parameters
-        ----------
-        model_config_summary : model_config_summary
-            Summary Model Deployment configuration for the group of models.
-        aqua_model : DataScienceModel
-            An instance of Aqua data science model.
-        create_deployment_details : CreateModelDeploymentDetails
-            An instance of CreateModelDeploymentDetails containing all required and optional
-            fields for creating a model deployment via Aqua.
-        container_config: Dict
-            Container config dictionary.
-        Returns
-        -------
-        AquaDeployment
-            An Aqua deployment instance.
-        """
-        model_config = []
-        model_name_list = []
-        env_var = {**(create_deployment_details.env_var or UNKNOWN_DICT)}
-
-        container_type_key = self._get_container_type_key(
-            model=aqua_model,
-            container_family=create_deployment_details.container_family,
-        )
-        container_config = self.get_container_config_item(container_type_key)
-        container_spec = container_config.spec if container_config else UNKNOWN
-
-        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("/")
-
-            model_config.append({"params": params, "model_path": artifact_path_prefix})
-            model_name_list.append(model.model_name)
-
-        env_var.update({AQUA_MULTI_MODEL_CONFIG: json.dumps({"models": model_config})})
-
-        env_vars = container_spec.env_vars if container_spec else []
-        for env in env_vars:
-            if isinstance(env, dict):
-                env = {k: v for k, v in env.items() if v}
-                for key, _ in env.items():
-                    if key not in env_var:
-                        env_var.update(env)
-
-        logger.info(f"Env vars used for deploying {aqua_model.id} : {env_var}.")
-
-        container_image_uri = (
-            create_deployment_details.container_image_uri
-            or self.get_container_image(container_type=container_type_key)
-        )
-        server_port = create_deployment_details.server_port or (
-            container_spec.server_port if container_spec else None
-        )
-        health_check_port = create_deployment_details.health_check_port or (
-            container_spec.health_check_port if container_spec else None
-        )
-        tags = {
-            Tags.AQUA_MODEL_ID_TAG: aqua_model.id,
-            Tags.MULTIMODEL_TYPE_TAG: "true",
-            Tags.AQUA_TAG: "active",
-            **(create_deployment_details.freeform_tags or UNKNOWN_DICT),
-        }
-
-        model_name = f"{MODEL_NAME_DELIMITER} ".join(model_name_list)
-
-        aqua_deployment = self._create_deployment(
-            create_deployment_details=create_deployment_details,
-            aqua_model_id=aqua_model.id,
-            model_name=model_name,
-            model_type=AQUA_MODEL_TYPE_MULTI,
-            container_image_uri=container_image_uri,
-            server_port=server_port,
-            health_check_port=health_check_port,
-            env_var=env_var,
-            tags=tags,
-        )
-        aqua_deployment.models = create_deployment_details.models
-        return aqua_deployment
-
-    def _create_deployment(
-        self,
-        create_deployment_details: CreateModelDeploymentDetails,
-        aqua_model_id: str,
-        model_name: str,
-        model_type: str,
-        container_image_uri: str,
-        server_port: str,
-        health_check_port: str,
-        env_var: dict,
-        tags: dict,
-        cmd_var: Optional[dict] = None,
-    ):
-        """Creates data science model deployment.
-
-        Parameters
-        ----------
-        create_deployment_details : CreateModelDeploymentDetails
-            An instance of CreateModelDeploymentDetails containing all required and optional
-            fields for creating a model deployment via Aqua.
-        aqua_model_id: str
-            The id of the aqua model to be deployed.
-        model_name: str
-            The name of the aqua model to be deployed. If it's multi model deployment, it is a list of model names.
-        model_type: str
-            The type of aqua model to be deployed. Allowed values are: `custom`, `service` and `multi_model`.
-        container_image_uri: str
-            The container image uri to deploy the model.
-        server_port: str
-            The service port of the container image.
-        health_check_port: str
-            The health check port of the container image.
-        env_var: dict
-            The environment variables input for the deployment.
-        tags: dict
-            The tags input for the deployment.
-        cmd_var: dict, optional
-            The cmd arguments input for the deployment.
-
-        Returns
-        -------
-        AquaDeployment
-            An Aqua deployment instance.
-        """
-        # Start model deployment
-        # configure model deployment infrastructure
-        infrastructure = (
-            ModelDeploymentInfrastructure()
-            .with_project_id(create_deployment_details.project_id or PROJECT_OCID)
-            .with_compartment_id(
-                create_deployment_details.compartment_id or COMPARTMENT_OCID
-            )
-            .with_shape_name(create_deployment_details.instance_shape)
-            .with_bandwidth_mbps(create_deployment_details.bandwidth_mbps)
-            .with_replica(create_deployment_details.instance_count)
-            .with_web_concurrency(create_deployment_details.web_concurrency)
-            .with_private_endpoint_id(create_deployment_details.private_endpoint_id)
-            .with_access_log(
-                log_group_id=create_deployment_details.log_group_id,
-                log_id=create_deployment_details.access_log_id,
-            )
-            .with_predict_log(
-                log_group_id=create_deployment_details.log_group_id,
-                log_id=create_deployment_details.predict_log_id,
-            )
-        )
-        if (
-            create_deployment_details.memory_in_gbs
-            and create_deployment_details.ocpus
-            and infrastructure.shape_name.endswith("Flex")
-        ):
-            infrastructure.with_shape_config_details(
-                ocpus=create_deployment_details.ocpus,
-                memory_in_gbs=create_deployment_details.memory_in_gbs,
-            )
-        # configure model deployment runtime
-        container_runtime = (
-            ModelDeploymentContainerRuntime()
-            .with_image(container_image_uri)
-            .with_server_port(server_port)
-            .with_health_check_port(health_check_port)
-            .with_env(env_var)
-            .with_deployment_mode(ModelDeploymentMode.HTTPS)
-            .with_model_uri(aqua_model_id)
-            .with_region(self.region)
-            .with_overwrite_existing_artifact(True)
-            .with_remove_existing_artifact(True)
-        )
-        if cmd_var:
-            container_runtime.with_cmd(cmd_var)
-
-        # configure model deployment and deploy model on container runtime
-        deployment = (
-            ModelDeployment()
-            .with_display_name(create_deployment_details.display_name)
-            .with_description(create_deployment_details.description)
-            .with_freeform_tags(**tags)
-            .with_defined_tags(**(create_deployment_details.defined_tags or {}))
-            .with_infrastructure(infrastructure)
-            .with_runtime(container_runtime)
-        ).deploy(wait_for_completion=False)
-
-        deployment_id = deployment.id
-        logger.info(
-            f"Aqua model deployment {deployment_id} created for model {aqua_model_id}."
-        )
-
-        # we arbitrarily choose last 8 characters of OCID to identify MD in telemetry
-        telemetry_kwargs = {"ocid": get_ocid_substring(deployment_id, key_len=8)}
-
-        # tracks unique deployments that were created in the user compartment
-        self.telemetry.record_event_async(
-            category=f"aqua/{model_type}/deployment",
-            action="create",
-            detail=model_name,
-            **telemetry_kwargs,
-        )
-        # tracks the shape used for deploying the custom or service models by name
-        self.telemetry.record_event_async(
-            category=f"aqua/{model_type}/deployment/create",
-            action="shape",
-            detail=create_deployment_details.instance_shape,
-            value=model_name,
-        )
-
-        return AquaDeployment.from_oci_model_deployment(
-            deployment.dsc_model_deployment, self.region
-        )
-
-    @staticmethod
-    def _get_container_type_key(model: DataScienceModel, container_family: str) -> str:
-        container_type_key = UNKNOWN
-        if container_family:
-            container_type_key = container_family
-        else:
-            try:
-                container_type_key = model.custom_metadata_list.get(
-                    AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME
-                ).value
-            except ValueError as err:
-                raise AquaValueError(
-                    f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field "
-                    f"for model {model.id}. For unverified Aqua models, {AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} should be"
-                    f"set and value can be one of {', '.join(InferenceContainerTypeFamily.values())}."
-                ) from err
-
-        return container_type_key
-
-    @telemetry(entry_point="plugin=deployment&action=list", name="aqua")
-    def list(self, **kwargs) -> List["AquaDeployment"]:
-        """List Aqua model deployments in a given compartment and under certain project.
-
-        Parameters
-        ----------
-        kwargs
-            Keyword arguments, such as compartment_id and project_id,
-            for `list_call_get_all_results <https://docs.oracle.com/en-us/iaas/tools/python/2.118.1/api/pagination.html#oci.pagination.list_call_get_all_results>`_
-
-        Returns
-        -------
-        List[AquaDeployment]:
-            The list of the Aqua model deployments.
-        """
-        compartment_id = kwargs.pop("compartment_id", COMPARTMENT_OCID)
-
-        model_deployments = self.list_resource(
-            self.ds_client.list_model_deployments,
-            compartment_id=compartment_id,
-            **kwargs,
-        )
-
-        results = []
-        for model_deployment in model_deployments:
-            oci_aqua = (
-                (
-                    Tags.AQUA_TAG in model_deployment.freeform_tags
-                    or Tags.AQUA_TAG.lower() in model_deployment.freeform_tags
-                )
-                if model_deployment.freeform_tags
-                else False
-            )
-
-            if oci_aqua:
-                results.append(
-                    AquaDeployment.from_oci_model_deployment(
-                        model_deployment, self.region
-                    )
-                )
-
-                # log telemetry if MD is in active or failed state
-                deployment_id = model_deployment.id
-                state = model_deployment.lifecycle_state.upper()
-                if state in ["ACTIVE", "FAILED"]:
-                    # tracks unique deployments that were listed in the user compartment
-                    # we arbitrarily choose last 8 characters of OCID to identify MD in telemetry
-                    self.telemetry.record_event_async(
-                        category="aqua/deployment",
-                        action="list",
-                        detail=get_ocid_substring(deployment_id, key_len=8),
-                        value=state,
-                    )
-
-        logger.info(
-            f"Fetched {len(results)} model deployments from compartment_id={compartment_id}."
-        )
-        # tracks number of times deployment listing was called
-        self.telemetry.record_event_async(category="aqua/deployment", action="list")
-
-        return results
-
-    @telemetry(entry_point="plugin=deployment&action=delete", name="aqua")
-    def delete(self, model_deployment_id: str):
-        logger.info(f"Deleting model deployment {model_deployment_id}.")
-        return self.ds_client.delete_model_deployment(
-            model_deployment_id=model_deployment_id
-        ).data
-
-    @telemetry(entry_point="plugin=deployment&action=deactivate", name="aqua")
-    def deactivate(self, model_deployment_id: str):
-        logger.info(f"Deactivating model deployment {model_deployment_id}.")
-        return self.ds_client.deactivate_model_deployment(
-            model_deployment_id=model_deployment_id
-        ).data
-
-    @telemetry(entry_point="plugin=deployment&action=activate", name="aqua")
-    def activate(self, model_deployment_id: str):
-        logger.info(f"Activating model deployment {model_deployment_id}.")
-        return self.ds_client.activate_model_deployment(
-            model_deployment_id=model_deployment_id
-        ).data
-
-    @telemetry(entry_point="plugin=deployment&action=get", name="aqua")
-    def get(self, model_deployment_id: str, **kwargs) -> "AquaDeploymentDetail":
-        """Gets the information of Aqua model deployment.
-
-        Parameters
-        ----------
-        model_deployment_id: str
-            The OCID of the Aqua model deployment.
-        kwargs
-            Keyword arguments, for `get_model_deployment
-            <https://docs.oracle.com/en-us/iaas/tools/python/2.119.1/api/data_science/client/oci.data_science.DataScienceClient.html#oci.data_science.DataScienceClient.get_model_deployment>`_
-
-        Returns
-        -------
-        AquaDeploymentDetail:
-            The instance of the Aqua model deployment details.
-        """
-        logger.info(f"Fetching model deployment details for {model_deployment_id}.")
-
-        model_deployment = self.ds_client.get_model_deployment(
-            model_deployment_id=model_deployment_id, **kwargs
-        ).data
-
-        oci_aqua = (
-            (
-                Tags.AQUA_TAG in model_deployment.freeform_tags
-                or Tags.AQUA_TAG.lower() in model_deployment.freeform_tags
-            )
-            if model_deployment.freeform_tags
-            else False
-        )
-
-        if not oci_aqua:
-            raise AquaRuntimeError(
-                f"Target deployment {model_deployment_id} is not Aqua deployment as it does not contain "
-                f"{Tags.AQUA_TAG} tag."
-            )
-
-        log_id = ""
-        log_group_id = ""
-        log_name = ""
-        log_group_name = ""
-
-        logs = (
-            model_deployment.category_log_details.access
-            or model_deployment.category_log_details.predict
-        )
-        if logs:
-            log_id = logs.log_id
-            log_group_id = logs.log_group_id
-        if log_id:
-            log_name = get_resource_name(log_id)
-        if log_group_id:
-            log_group_name = get_resource_name(log_group_id)
-
-        log_group_url = get_log_links(region=self.region, log_group_id=log_group_id)
-        log_url = get_log_links(
-            region=self.region,
-            log_group_id=log_group_id,
-            log_id=log_id,
-            compartment_id=model_deployment.compartment_id,
-            source_id=model_deployment.id,
-        )
-
-        aqua_deployment = AquaDeployment.from_oci_model_deployment(
-            model_deployment, self.region
-        )
-
-        if Tags.MULTIMODEL_TYPE_TAG in model_deployment.freeform_tags:
-            aqua_model_id = model_deployment.freeform_tags.get(
-                Tags.AQUA_MODEL_ID_TAG, UNKNOWN
-            )
-            if not aqua_model_id:
-                raise AquaRuntimeError(
-                    f"Invalid multi model deployment {model_deployment_id}."
-                    f"Make sure the {Tags.AQUA_MODEL_ID_TAG} tag is added to the deployment."
-                )
-            aqua_model = DataScienceModel.from_id(aqua_model_id)
-            custom_metadata_list = aqua_model.custom_metadata_list
-            multi_model_metadata_value = custom_metadata_list.get(
-                ModelCustomMetadataFields.MULTIMODEL_METADATA,
-                ModelCustomMetadataItem(
-                    key=ModelCustomMetadataFields.MULTIMODEL_METADATA
-                ),
-            ).value
-            if not multi_model_metadata_value:
-                raise AquaRuntimeError(
-                    f"Invalid multi-model deployment: {model_deployment_id}. "
-                    f"Ensure that the required custom metadata `{ModelCustomMetadataFields.MULTIMODEL_METADATA}` is added to the AQUA multi-model `{aqua_model.display_name}` ({aqua_model.id})."
-                )
-            multi_model_metadata = json.loads(
-                aqua_model.dsc_model.get_custom_metadata_artifact(
-                    metadata_key_name=ModelCustomMetadataFields.MULTIMODEL_METADATA
-                ).decode("utf-8")
-            )
-            aqua_deployment.models = [
-                AquaMultiModelRef(**metadata) for metadata in multi_model_metadata
-            ]
-
-        return AquaDeploymentDetail(
-            **vars(aqua_deployment),
-            log_group=AquaResourceIdentifier(
-                log_group_id, log_group_name, log_group_url
-            ),
-            log=AquaResourceIdentifier(log_id, log_name, log_url),
-        )
-
-    @telemetry(
-        entry_point="plugin=deployment&action=get_deployment_config", name="aqua"
-    )
-    def get_deployment_config(self, model_id: str) -> AquaDeploymentConfig:
-        """Gets the deployment config of given Aqua model.
-
-        Parameters
-        ----------
-        model_id: str
-            The OCID of the Aqua model.
-
-        Returns
-        -------
-        AquaDeploymentConfig:
-            An instance of AquaDeploymentConfig.
-        """
-        config = self.get_config_from_metadata(
-            model_id, AquaModelMetadataKeys.DEPLOYMENT_CONFIGURATION
-        ).config
-        if config:
-            logger.info(
-                f"Fetched {AquaModelMetadataKeys.DEPLOYMENT_CONFIGURATION} from defined metadata for model: {model_id}."
-            )
-            return AquaDeploymentConfig(**(config or UNKNOWN_DICT))
-        config = self.get_config(
-            model_id,
-            DEFINED_METADATA_TO_FILE_MAP.get(
-                AquaModelMetadataKeys.DEPLOYMENT_CONFIGURATION.lower()
-            ),
-        ).config
-        if not config:
-            logger.debug(
-                f"Deployment config for custom model: {model_id} is not available. Use defaults."
-            )
-        return AquaDeploymentConfig(**(config or UNKNOWN_DICT))
-
-    @telemetry(
-        entry_point="plugin=deployment&action=get_multimodel_deployment_config",
-        name="aqua",
-    )
-    def get_multimodel_deployment_config(
-        self,
-        model_ids: List[str],
-        primary_model_id: Optional[str] = None,
-        **kwargs: Dict,
-    ) -> ModelDeploymentConfigSummary:
-        """
-        Retrieves the deployment configuration for multiple models and calculates
-        GPU allocations across all compatible shapes.
-
-        More details:
-        https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/ai-quick-actions/multimodel-deployment-tips.md#get_multimodel_deployment_config
-
-        CLI example:
-        ads aqua deployment get_multimodel_deployment_config --model_ids '["md_ocid1","md_ocid2"]'
-
-        If a primary model ID is provided, GPU allocation will prioritize that model
-        when selecting compatible shapes.
-
-        Example:
-        Assume all three models: A, B, and C, support the same shape: "BM.GPU.H100.8" and each supports the following GPU counts for that shape: 1, 2, 4, 8.
-        If `no` primary model is specified, valid allocations could be: [2, 4, 2], [2, 2, 4], or [4, 2, 2]
-        If `B` is set as the primary model, the allocation will be: [2, 4, 2], where B receives the maximum available GPU count
-
-        Parameters
-        ----------
-        model_ids : List[str]
-            A list of OCIDs for the Aqua models.
-        primary_model_id : Optional[str]
-            The OCID of the primary Aqua model. If provided, GPU allocation will prioritize
-            this model. Otherwise, GPUs will be evenly allocated.
-        **kwargs: Dict
-            - compartment_id: str
-                The compartment OCID to retrieve the model deployment shapes.
-
-        Returns
-        -------
-        ModelDeploymentConfigSummary
-            A summary of the model deployment configurations and GPU allocations.
-        """
-        if not model_ids:
-            raise AquaValueError(
-                "Model IDs were not provided. Please provide a valid list of model IDs to retrieve the multi-model deployment configuration."
-            )
-
-        compartment_id = kwargs.pop("compartment_id", COMPARTMENT_OCID)
-
-        # Get the all model deployment available shapes in a given compartment
-        available_shapes = self.list_shapes(compartment_id=compartment_id)
-
-        return MultiModelDeploymentConfigLoader(
-            deployment_app=self,
-        ).load(
-            shapes=available_shapes,
-            model_ids=model_ids,
-            primary_model_id=primary_model_id,
-        )
-
-    def get_deployment_default_params(
-        self,
-        model_id: str,
-        instance_shape: str,
-        gpu_count: int = None,
-    ) -> List[str]:
-        """Gets the default params set in the deployment configs for the given model and instance shape.
-
-        Parameters
-        ----------
-        model_id: str
-            The OCID of the Aqua model.
-
-        instance_shape: (str).
-            The shape of the instance used for deployment.
-
-        gpu_count: (int, optional).
-            The number of GPUs used by the Aqua model. Defaults to None.
-
-        Returns
-        -------
-        List[str]:
-            List of parameters from the loaded from deployment config json file. If not available, then an empty list
-            is returned.
-
-        """
-        default_params = []
-        config_params = {}
-        model = DataScienceModel.from_id(model_id)
-        try:
-            container_type_key = model.custom_metadata_list.get(
-                AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME
-            ).value
-        except ValueError:
-            container_type_key = UNKNOWN
-            logger.debug(
-                f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field for model {model_id}."
-            )
-
-        if (
-            container_type_key
-            and container_type_key in InferenceContainerTypeFamily.values()
-        ):
-            deployment_config = self.get_deployment_config(model_id)
-
-            instance_shape_config = deployment_config.configuration.get(
-                instance_shape, ConfigurationItem()
-            )
-
-            if instance_shape_config.multi_model_deployment and gpu_count:
-                gpu_params = instance_shape_config.multi_model_deployment
-
-                for gpu_config in gpu_params:
-                    if gpu_config.gpu_count == gpu_count:
-                        config_params = gpu_config.parameters.get(
-                            get_container_params_type(container_type_key), UNKNOWN
-                        )
-                        break
-
-            else:
-                config_params = instance_shape_config.parameters.get(
-                    get_container_params_type(container_type_key), UNKNOWN
-                )
-
-            if config_params:
-                params_list = get_params_list(config_params)
-                restricted_params_set = get_restricted_params_by_container(
-                    container_type_key
-                )
-
-                # remove restricted params from the list as user cannot override them during deployment
-                for params in params_list:
-                    if params.split()[0] not in restricted_params_set:
-                        default_params.append(params)
-
-        return default_params
-
-    def validate_deployment_params(
-        self,
-        model_id: str,
-        params: List[str] = None,
-        container_family: str = None,
-    ) -> Dict:
-        """Validate if the deployment parameters passed by the user can be overridden. Parameter values are not
-        validated, only param keys are validated.
-
-        Parameters
-        ----------
-        model_id: str
-            The OCID of the Aqua model.
-        params : List[str], optional
-            Params passed by the user.
-        container_family: str
-            The image family of model deployment container runtime. Required for unverified Aqua models.
-
-        Returns
-        -------
-            Return a list of restricted params.
-
-        """
-        restricted_params = []
-        if params:
-            model = DataScienceModel.from_id(model_id)
-            container_type_key = self._get_container_type_key(
-                model=model, container_family=container_family
-            )
-
-            container_config = self.get_container_config_item(container_type_key)
-            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(
-                cli_params, params, container_type_key
-            )
-
-        if restricted_params:
-            raise AquaValueError(
-                f"Parameters {restricted_params} are set by Aqua "
-                f"and cannot be overridden or are invalid."
-            )
-        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]:
-        """Lists the valid model deployment shapes.
-
-        Parameters
-        ----------
-        kwargs
-            Keyword arguments, such as compartment_id
-            for `list_call_get_all_results <https://docs.oracle.com/en-us/iaas/tools/python/2.118.1/api/pagination.html#oci.pagination.list_call_get_all_results>`_
-
-        Returns
-        -------
-        List[ComputeShapeSummary]:
-            The list of the model deployment shapes.
-        """
-        compartment_id = kwargs.pop("compartment_id", COMPARTMENT_OCID)
-        oci_shapes: list[ModelDeploymentShapeSummary] = self.list_resource(
-            self.ds_client.list_model_deployment_shapes,
-            compartment_id=compartment_id,
-            **kwargs,
-        )
-
-        gpu_specs = load_gpu_shapes_index()
-
-        return [
-            ComputeShapeSummary(
-                core_count=oci_shape.core_count,
-                memory_in_gbs=oci_shape.memory_in_gbs,
-                shape_series=oci_shape.shape_series,
-                name=oci_shape.name,
-                gpu_specs=gpu_specs.shapes.get(oci_shape.name)
-                or gpu_specs.shapes.get(oci_shape.name.upper()),
-            )
-            for oci_shape in oci_shapes
-        ]