oracle-ads 2.13.5__py3-none-any.whl → 2.13.7__py3-none-any.whl

ads/aqua/__init__.py

@@ -14,7 +14,6 @@ from ads.aqua.client.client import (
     get_async_httpx_client,
     get_httpx_client,
 )
-from ads.aqua.common.utils import fetch_service_compartment
 from ads.config import OCI_RESOURCE_PRINCIPAL_VERSION
 
 ENV_VAR_LOG_LEVEL = "ADS_AQUA_LOG_LEVEL"
@@ -39,7 +38,3 @@ def set_log_level(log_level: str):
 
 if OCI_RESOURCE_PRINCIPAL_VERSION:
     set_auth("resource_principal")
-
-ODSC_MODEL_COMPARTMENT_OCID = (
-    os.environ.get("ODSC_MODEL_COMPARTMENT_OCID") or fetch_service_compartment()
-)

ads/aqua/app.py

@@ -7,11 +7,16 @@ import os
 import traceback
 from dataclasses import fields
 from datetime import datetime, timedelta
-from typing import Any, Dict, Optional, Union
+from itertools import chain
+from typing import Any, Dict, List, Optional, Union
 
 import oci
 from cachetools import TTLCache, cached
-from oci.data_science.models import UpdateModelDetails, UpdateModelProvenanceDetails
+from oci.data_science.models import (
+    ContainerSummary,
+    UpdateModelDetails,
+    UpdateModelProvenanceDetails,
+)
 
 from ads import set_auth
 from ads.aqua import logger
@@ -24,6 +29,11 @@ from ads.aqua.common.utils import (
     is_valid_ocid,
     load_config,
 )
+from ads.aqua.config.container_config import (
+    AquaContainerConfig,
+    AquaContainerConfigItem,
+)
+from ads.aqua.constants import SERVICE_MANAGED_CONTAINER_URI_SCHEME
 from ads.common import oci_client as oc
 from ads.common.auth import default_signer
 from ads.common.utils import UNKNOWN, extract_region, is_path_exists
@@ -240,7 +250,9 @@ class AquaApp:
             .with_custom_metadata_list(model_custom_metadata)
             .with_defined_metadata_list(model_taxonomy_metadata)
             .with_provenance_metadata(ModelProvenanceMetadata(training_id=UNKNOWN))
-            .with_defined_tags(**(defined_tags or {})) # Create defined tags when a model is created.
+            .with_defined_tags(
+                **(defined_tags or {})
+            )  # Create defined tags when a model is created.
             .create(
                 **kwargs,
             )
@@ -271,6 +283,43 @@ class AquaApp:
                 logger.info(f"Artifact not found in model {model_id}.")
                 return False
 
+    def get_config_from_metadata(
+        self, model_id: str, metadata_key: str
+    ) -> ModelConfigResult:
+        """Gets the config for the given Aqua model from model catalog metadata content.
+
+        Parameters
+        ----------
+        model_id: str
+            The OCID of the Aqua model.
+        metadata_key: str
+            The metadata key name where artifact content is stored
+        Returns
+        -------
+        ModelConfigResult
+            A Pydantic model containing the model_details (extracted from OCI) and the config dictionary.
+        """
+        config = {}
+        oci_model = self.ds_client.get_model(model_id).data
+        try:
+            config = self.ds_client.get_model_defined_metadatum_artifact_content(
+                model_id, metadata_key
+            ).data.content.decode("utf-8")
+            return ModelConfigResult(config=json.loads(config), model_details=oci_model)
+        except UnicodeDecodeError as ex:
+            logger.error(
+                f"Failed to decode content for '{metadata_key}' in defined metadata for model '{model_id}' : {ex}"
+            )
+        except json.JSONDecodeError as ex:
+            logger.error(
+                f"Invalid JSON format for '{metadata_key}' in defined metadata for model '{model_id}' : {ex}"
+            )
+        except Exception as ex:
+            logger.error(
+                f"Failed to retrieve defined metadata key '{metadata_key}' for model '{model_id}': {ex}"
+            )
+        return ModelConfigResult(config=config, model_details=oci_model)
+
     @cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=1), timer=datetime.now))
     def get_config(
         self,
@@ -310,22 +359,7 @@ class AquaApp:
             raise AquaRuntimeError(f"Target model {oci_model.id} is not an Aqua model.")
 
         config: Dict[str, Any] = {}
-
-        # if the current model has a service model tag, then
-        if Tags.AQUA_SERVICE_MODEL_TAG in oci_model.freeform_tags:
-            base_model_ocid = oci_model.freeform_tags[Tags.AQUA_SERVICE_MODEL_TAG]
-            logger.info(
-                f"Base model found for the model: {oci_model.id}. "
-                f"Loading {config_file_name} for base model {base_model_ocid}."
-            )
-            if config_folder == ConfigFolder.ARTIFACT:
-                artifact_path = get_artifact_path(oci_model.custom_metadata_list)
-            else:
-                base_model = self.ds_client.get_model(base_model_ocid).data
-                artifact_path = get_artifact_path(base_model.custom_metadata_list)
-        else:
-            logger.info(f"Loading {config_file_name} for model {oci_model.id}...")
-            artifact_path = get_artifact_path(oci_model.custom_metadata_list)
+        artifact_path = get_artifact_path(oci_model.custom_metadata_list)
         if not artifact_path:
             logger.debug(
                 f"Failed to get artifact path from custom metadata for the model: {model_id}"
@@ -340,7 +374,7 @@ class AquaApp:
         config_file_path = os.path.join(config_path, config_file_name)
         if is_path_exists(config_file_path):
             try:
-                logger.debug(
+                logger.info(
                     f"Loading config: `{config_file_name}` from `{config_path}`"
                 )
                 config = load_config(
@@ -361,6 +395,85 @@ class AquaApp:
 
         return ModelConfigResult(config=config, model_details=oci_model)
 
+    def get_container_image(self, container_type: str = None) -> str:
+        """
+        Gets the latest smc container complete image name from the given container type.
+
+        Parameters
+        ----------
+        container_type: str
+            type of container, can be either odsc-vllm-serving, odsc-llm-fine-tuning, odsc-llm-evaluate
+
+        Returns
+        -------
+        str:
+            A complete container name along with version. ex: dsmc://odsc-vllm-serving:0.7.4.1
+        """
+
+        containers = self.list_service_containers()
+        container = next(
+            (c for c in containers if c.is_latest and c.family_name == container_type),
+            None,
+        )
+        if not container:
+            raise AquaValueError(f"Invalid container type : {container_type}")
+        container_image = (
+            SERVICE_MANAGED_CONTAINER_URI_SCHEME
+            + container.container_name
+            + ":"
+            + container.tag
+        )
+        return container_image
+
+    @cached(cache=TTLCache(maxsize=20, ttl=timedelta(minutes=30), timer=datetime.now))
+    def list_service_containers(self) -> List[ContainerSummary]:
+        """
+        List containers from containers.conf in OCI Datascience control plane
+        """
+        containers = self.ds_client.list_containers().data
+        return containers
+
+    def get_container_config(self) -> AquaContainerConfig:
+        """
+        Fetches latest containers from containers.conf in OCI Datascience control plane
+
+        Returns
+        -------
+        AquaContainerConfig
+            An Object that contains latest container info for the given container family
+
+        """
+        return AquaContainerConfig.from_service_config(
+            service_containers=self.list_service_containers()
+        )
+
+    def get_container_config_item(
+        self, container_family: str
+    ) -> AquaContainerConfigItem:
+        """
+        Fetches latest container for given container_family_name from containers.conf in OCI Datascience control plane
+
+        Returns
+        -------
+        AquaContainerConfigItem
+            An Object that contains latest container info for the given container family
+
+        """
+
+        aqua_container_config = self.get_container_config()
+        inference_config = aqua_container_config.inference.values()
+        ft_config = aqua_container_config.finetune.values()
+        eval_config = aqua_container_config.evaluate.values()
+        container = next(
+            (
+                container
+                for container in chain(inference_config, ft_config, eval_config)
+                if container.family.lower() == container_family.lower()
+            ),
+            None,
+        )
+        return container
+
     @property
     def telemetry(self):
         if not self._telemetry:

ads/aqua/cli.py

@@ -1,23 +1,20 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# 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/
 import os
 
 from ads.aqua import (
     ENV_VAR_LOG_LEVEL,
-    ODSC_MODEL_COMPARTMENT_OCID,
     logger,
     set_log_level,
 )
-from ads.aqua.common.errors import AquaCLIError, AquaConfigError
+from ads.aqua.common.errors import AquaCLIError
 from ads.aqua.evaluation import AquaEvaluationApp
 from ads.aqua.finetuning import AquaFineTuningApp
 from ads.aqua.model import AquaModelApp
 from ads.aqua.modeldeployment import AquaDeploymentApp
 from ads.common.utils import LOG_LEVELS
-from ads.config import NB_SESSION_OCID
 
 
 class AquaCommand:
@@ -82,16 +79,6 @@ class AquaCommand:
 
         set_log_level(aqua_log_level)
 
-        if not ODSC_MODEL_COMPARTMENT_OCID:
-            if NB_SESSION_OCID:
-                raise AquaConfigError(
-                    f"Aqua is not available for the notebook session {NB_SESSION_OCID}. For more information, "
-                    f"please refer to the documentation."
-                )
-            raise AquaConfigError(
-                "ODSC_MODEL_COMPARTMENT_OCID environment variable is not set for Aqua."
-            )
-
     @staticmethod
     def _validate_value(flag, value):
         """Check if the given value for bool flag is valid.

ads/aqua/common/enums.py

@@ -2,6 +2,8 @@
 # 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/
 
+from typing import Dict, List
+
 from ads.common.extended_enum import ExtendedEnum
 
 
@@ -106,3 +108,15 @@ class ModelFormat(ExtendedEnum):
 class Platform(ExtendedEnum):
     ARM_CPU = "ARM_CPU"
     NVIDIA_GPU = "NVIDIA_GPU"
+
+
+# This dictionary defines compatibility groups for container families.
+# The structure is:
+#   - Key: The preferred container family to use when multiple compatible families are selected.
+#   - Value: A list of all compatible families (including the preferred one).
+CONTAINER_FAMILY_COMPATIBILITY: Dict[str, List[str]] = {
+    InferenceContainerTypeFamily.AQUA_VLLM_V1_CONTAINER_FAMILY: [
+        InferenceContainerTypeFamily.AQUA_VLLM_V1_CONTAINER_FAMILY,
+        InferenceContainerTypeFamily.AQUA_VLLM_CONTAINER_FAMILY,
+    ],
+}

ads/aqua/common/utils.py

@@ -37,6 +37,7 @@ from pydantic import BaseModel, ValidationError
 
 from ads.aqua.common.entities import GPUShapesIndex
 from ads.aqua.common.enums import (
+    CONTAINER_FAMILY_COMPATIBILITY,
     InferenceContainerParamType,
     InferenceContainerType,
     RqsAdditionalDetails,
@@ -49,12 +50,14 @@ from ads.aqua.common.errors import (
 )
 from ads.aqua.constants import (
     AQUA_GA_LIST,
-    COMPARTMENT_MAPPING_KEY,
     CONSOLE_LINK_RESOURCE_TYPE_MAPPING,
-    CONTAINER_INDEX,
+    DEPLOYMENT_CONFIG,
+    FINE_TUNING_CONFIG,
     HF_LOGIN_DEFAULT_TIMEOUT,
+    LICENSE,
     MAXIMUM_ALLOWED_DATASET_IN_BYTE,
     MODEL_BY_REFERENCE_OSS_PATH_KEY,
+    README,
     SERVICE_MANAGED_CONTAINER_URI_SCHEME,
     SUPPORTED_FILE_FORMATS,
     TEI_CONTAINER_DEFAULT_HOST,
@@ -88,6 +91,14 @@ from ads.model import DataScienceModel, ModelVersionSet
 logger = logging.getLogger("ads.aqua")
 
 
+DEFINED_METADATA_TO_FILE_MAP = {
+    "readme": README,
+    "license": LICENSE,
+    "finetuneconfiguration": FINE_TUNING_CONFIG,
+    "deploymentconfiguration": DEPLOYMENT_CONFIG,
+}
+
+
 class LifecycleStatus(ExtendedEnum):
     UNKNOWN = ""
 
@@ -548,87 +559,6 @@ def _build_job_identifier(
         return AquaResourceIdentifier()
 
 
-def service_config_path():
-    return f"oci://{AQUA_SERVICE_MODELS_BUCKET}@{CONDA_BUCKET_NS}/service_models/config"
-
-
-@cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=10), timer=datetime.now))
-def get_container_config():
-    config = load_config(
-        file_path=service_config_path(),
-        config_file_name=CONTAINER_INDEX,
-    )
-
-    return config
-
-
-def get_container_image(
-    config_file_name: str = None, container_type: str = None
-) -> str:
-    """Gets the image name from the given model and container type.
-    Parameters
-    ----------
-    config_file_name: str
-        name of the config file
-    container_type: str
-        type of container, can be either deployment-container, finetune-container, evaluation-container
-
-    Returns
-    -------
-    Dict:
-        A dict of allowed configs.
-    """
-
-    container_image = UNKNOWN
-    config = config_file_name or get_container_config()
-    config_file_name = service_config_path()
-
-    if container_type not in config:
-        return UNKNOWN
-
-    mapping = config[container_type]
-    versions = [obj["version"] for obj in mapping]
-    # assumes numbered versions, update if `latest` is used
-    latest = get_max_version(versions)
-    for obj in mapping:
-        if obj["version"] == str(latest):
-            container_image = f"{obj['name']}:{obj['version']}"
-            break
-
-    if not container_image:
-        raise AquaValueError(
-            f"{config_file_name} is missing name and/or version details."
-        )
-
-    return container_image
-
-
-def fetch_service_compartment() -> Union[str, None]:
-    """
-    Loads the compartment mapping json from service bucket.
-    This json file has a service-model-compartment key which contains a dictionary of namespaces
-    and the compartment OCID of the service models in that namespace.
-    """
-    config_file_name = (
-        f"oci://{AQUA_SERVICE_MODELS_BUCKET}@{CONDA_BUCKET_NS}/service_models/config"
-    )
-
-    try:
-        config = load_config(
-            file_path=config_file_name,
-            config_file_name=CONTAINER_INDEX,
-        )
-    except Exception as e:
-        logger.debug(
-            f"Config file {config_file_name}/{CONTAINER_INDEX} to fetch service compartment OCID "
-            f"could not be found. \n{str(e)}."
-        )
-        return
-    compartment_mapping = config.get(COMPARTMENT_MAPPING_KEY)
-    if compartment_mapping:
-        return compartment_mapping.get(CONDA_BUCKET_NS)
-
-
 def get_max_version(versions):
     """Takes in a list of versions and returns the higher version."""
     if not versions:
@@ -1316,3 +1246,40 @@ def load_gpu_shapes_index(
             )
 
     return GPUShapesIndex(**data)
+
+
+def get_preferred_compatible_family(selected_families: set[str]) -> str:
+    """
+    Determines the preferred container family from a given set of container families.
+
+    This method is used in the context of multi-model deployment to handle cases
+    where models selected for deployment use different, but compatible, container families.
+
+    It checks the input `families` set against the `CONTAINER_FAMILY_COMPATIBILITY` map.
+    If a compatibility group exists that fully includes all the families in the input,
+    the corresponding key (i.e., the preferred family) is returned.
+
+    Parameters
+    ----------
+    families : set[str]
+        A set of container family identifiers.
+
+    Returns
+    -------
+    Optional[str]
+        The preferred container family if all families are compatible within one group;
+        otherwise, returns `None` indicating that no compatible family group was found.
+
+    Example
+    -------
+    >>> get_preferred_compatible_family({"odsc-vllm-serving", "odsc-vllm-serving-v1"})
+    'odsc-vllm-serving-v1'
+
+    >>> get_preferred_compatible_family({"odsc-vllm-serving", "odsc-tgi-serving"})
+    None  # Incompatible families
+    """
+    for preferred, compatible_list in CONTAINER_FAMILY_COMPATIBILITY.items():
+        if selected_families.issubset(set(compatible_list)):
+            return preferred
+
+    return None

ads/aqua/config/container_config.py

@@ -1,14 +1,20 @@
 #!/usr/bin/env python
 # Copyright (c) 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
 from typing import Dict, List, Optional
 
+from oci.data_science.models import ContainerSummary
 from pydantic import Field
 
-from ads.aqua.common.entities import ContainerSpec
 from ads.aqua.config.utils.serializer import Serializable
+from ads.aqua.constants import (
+    SERVICE_MANAGED_CONTAINER_URI_SCHEME,
+    UNKNOWN_JSON_LIST,
+    UNKNOWN_JSON_STR,
+)
 from ads.common.extended_enum import ExtendedEnum
+from ads.common.utils import UNKNOWN
 
 
 class Usage(ExtendedEnum):
@@ -46,6 +52,9 @@ class AquaContainerConfigSpec(Serializable):
     restricted_params: Optional[List[str]] = Field(
         default_factory=list, description="List of restricted parameters."
     )
+    evaluation_configuration: Optional[Dict] = Field(
+        default_factory=dict, description="Dict of evaluation configuration."
+    )
 
     class Config:
         extra = "allow"
@@ -126,87 +135,114 @@ class AquaContainerConfig(Serializable):
         }
 
     @classmethod
-    def from_container_index_json(
-        cls,
-        config: Dict,
-        enable_spec: Optional[bool] = False,
+    def from_service_config(
+        cls, service_containers: List[ContainerSummary]
     ) -> "AquaContainerConfig":
         """
-        Creates an AquaContainerConfig instance from a container index JSON.
+        Creates an AquaContainerConfig instance from a service containers.conf.
 
         Parameters
         ----------
-        config (Optional[Dict]): The container index JSON.
-        enable_spec (Optional[bool]): If True, fetch container specification details.
-
+        service_containers (List[Any]):  List of containers specified in containers.conf
         Returns
         -------
         AquaContainerConfig: The constructed container configuration.
         """
-        # TODO: Return this logic back if necessary in the next iteraion.
-        # if not config:
-        #     config = get_container_config()
 
         inference_items: Dict[str, AquaContainerConfigItem] = {}
         finetune_items: Dict[str, AquaContainerConfigItem] = {}
         evaluate_items: Dict[str, AquaContainerConfigItem] = {}
-
-        for container_type, containers in config.items():
-            if isinstance(containers, list):
-                for container in containers:
-                    platforms = container.get("platforms", [])
-                    model_formats = container.get("modelFormats", [])
-                    usages = container.get("usages", [])
-                    container_spec = (
-                        config.get(ContainerSpec.CONTAINER_SPEC, {}).get(
-                            container_type, {}
+        for container in service_containers:
+            if not container.is_latest:
+                continue
+            container_item = AquaContainerConfigItem(
+                name=SERVICE_MANAGED_CONTAINER_URI_SCHEME + container.container_name,
+                version=container.tag,
+                display_name=container.display_name,
+                family=container.family_name,
+                usages=container.usages,
+                platforms=[],
+                model_formats=[],
+                spec=None,
+            )
+            container_type = container.family_name
+            usages = [x.upper() for x in container.usages]
+            if "INFERENCE" in usages or "MULTI_MODEL" in usages:
+                container_item.platforms.append(
+                    container.workload_configuration_details_list[
+                        0
+                    ].additional_configurations.get("platforms")
+                )
+                container_item.model_formats.append(
+                    container.workload_configuration_details_list[
+                        0
+                    ].additional_configurations.get("modelFormats")
+                )
+                env_vars = [
+                    {
+                        "MODEL_DEPLOY_PREDICT_ENDPOINT": container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get(
+                            "MODEL_DEPLOY_PREDICT_ENDPOINT", UNKNOWN
                         )
-                        if enable_spec
-                        else None
-                    )
-                    container_item = AquaContainerConfigItem(
-                        name=container.get("name", ""),
-                        version=container.get("version", ""),
-                        display_name=container.get(
-                            "displayName", container.get("version", "")
-                        ),
-                        family=container_type,
-                        platforms=platforms,
-                        model_formats=model_formats,
-                        usages=usages,
-                        spec=(
-                            AquaContainerConfigSpec(
-                                cli_param=container_spec.get(
-                                    ContainerSpec.CLI_PARM, ""
-                                ),
-                                server_port=container_spec.get(
-                                    ContainerSpec.SERVER_PORT, ""
-                                ),
-                                health_check_port=container_spec.get(
-                                    ContainerSpec.HEALTH_CHECK_PORT, ""
-                                ),
-                                env_vars=container_spec.get(ContainerSpec.ENV_VARS, []),
-                                restricted_params=container_spec.get(
-                                    ContainerSpec.RESTRICTED_PARAMS, []
-                                ),
-                            )
-                            if container_spec
-                            else None
-                        ),
-                    )
-                    if container.get("type") == "inference":
-                        inference_items[container_type] = container_item
-                    elif (
-                        container.get("type") == "fine-tune"
-                        or container_type == "odsc-llm-fine-tuning"
-                    ):
-                        finetune_items[container_type] = container_item
-                    elif (
-                        container.get("type") == "evaluate"
-                        or container_type == "odsc-llm-evaluate"
-                    ):
-                        evaluate_items[container_type] = container_item
-
+                    },
+                    {
+                        "MODEL_DEPLOY_HEALTH_ENDPOINT": container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get(
+                            "MODEL_DEPLOY_HEALTH_ENDPOINT", UNKNOWN
+                        )
+                    },
+                    {
+                        "MODEL_DEPLOY_ENABLE_STREAMING": container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get(
+                            "MODEL_DEPLOY_ENABLE_STREAMING", UNKNOWN
+                        )
+                    },
+                    {
+                        "PORT": container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get("PORT", "")
+                    },
+                    {
+                        "HEALTH_CHECK_PORT": container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get("HEALTH_CHECK_PORT", UNKNOWN),
+                    },
+                ]
+                container_spec = AquaContainerConfigSpec(
+                    cli_param=container.workload_configuration_details_list[0].cmd,
+                    server_port=str(
+                        container.workload_configuration_details_list[0].server_port
+                    ),
+                    health_check_port=str(
+                        container.workload_configuration_details_list[
+                            0
+                        ].health_check_port
+                    ),
+                    env_vars=env_vars,
+                    restricted_params=json.loads(
+                        container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get("restrictedParams")
+                        or UNKNOWN_JSON_LIST
+                    ),
+                    evaluation_configuration=json.loads(
+                        container.workload_configuration_details_list[
+                            0
+                        ].additional_configurations.get(
+                            "evaluationConfiguration", UNKNOWN_JSON_STR
+                        )
+                    ),
+                )
+                container_item.spec = container_spec
+            if "INFERENCE" in usages or "MULTI_MODEL" in usages:
+                inference_items[container_type] = container_item
+            if "FINE_TUNE" in usages:
+                finetune_items[container_type] = container_item
+            if "EVALUATION" in usages:
+                evaluate_items[container_type] = container_item
         return cls(
             inference=inference_items, finetune=finetune_items, evaluate=evaluate_items
         )