oracle-ads 2.12.11__py3-none-any.whl → 2.13.1__py3-none-any.whl

ads/aqua/config/container_config.py

@@ -0,0 +1,203 @@
+#!/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/
+
+from typing import Dict, List, Optional
+
+from pydantic import Field
+
+from ads.aqua.common.entities import ContainerSpec
+from ads.aqua.config.utils.serializer import Serializable
+
+
+class AquaContainerConfigSpec(Serializable):
+    """
+    Represents container specification details.
+
+    Attributes
+    ----------
+    cli_param (Optional[str]): CLI parameter for container configuration.
+    server_port (Optional[str]): The server port for the container.
+    health_check_port (Optional[str]): The health check port for the container.
+    env_vars (Optional[List[Dict]]): Environment variables for the container.
+    restricted_params (Optional[List[str]]): Restricted parameters for container configuration.
+    """
+
+    cli_param: Optional[str] = Field(
+        default=None, description="CLI parameter for container configuration."
+    )
+    server_port: Optional[str] = Field(
+        default=None, description="Server port for the container."
+    )
+    health_check_port: Optional[str] = Field(
+        default=None, description="Health check port for the container."
+    )
+    env_vars: Optional[List[Dict]] = Field(
+        default_factory=list, description="List of environment variables."
+    )
+    restricted_params: Optional[List[str]] = Field(
+        default_factory=list, description="List of restricted parameters."
+    )
+
+    class Config:
+        extra = "allow"
+
+
+class AquaContainerConfigItem(Serializable):
+    """
+    Represents an item of the AQUA container configuration.
+
+    Attributes
+    ----------
+    name (Optional[str]): Name of the container configuration item.
+    version (Optional[str]): Version of the container.
+    display_name (Optional[str]): Display name for UI.
+    family (Optional[str]): Container family or category.
+    platforms (Optional[List[str]]): Supported platforms.
+    model_formats (Optional[List[str]]): Supported model formats.
+    spec (Optional[AquaContainerConfigSpec]): Container specification details.
+    """
+
+    name: Optional[str] = Field(
+        default=None, description="Name of the container configuration item."
+    )
+    version: Optional[str] = Field(
+        default=None, description="Version of the container."
+    )
+    display_name: Optional[str] = Field(
+        default=None, description="Display name of the container."
+    )
+    family: Optional[str] = Field(
+        default=None, description="Container family or category."
+    )
+    platforms: Optional[List[str]] = Field(
+        default_factory=list, description="Supported platforms."
+    )
+    model_formats: Optional[List[str]] = Field(
+        default_factory=list, description="Supported model formats."
+    )
+    spec: Optional[AquaContainerConfigSpec] = Field(
+        default_factory=AquaContainerConfigSpec,
+        description="Detailed container specification.",
+    )
+    usages: Optional[List[str]] = Field(
+        default_factory=list, description="Supported usages."
+    )
+
+    class Config:
+        extra = "allow"
+
+
+class AquaContainerConfig(Serializable):
+    """
+    Represents a configuration of AQUA containers to be returned to the client.
+
+    Attributes
+    ----------
+    inference (Dict[str, AquaContainerConfigItem]): Inference container configuration items.
+    finetune (Dict[str, AquaContainerConfigItem]): Fine-tuning container configuration items.
+    evaluate (Dict[str, AquaContainerConfigItem]): Evaluation container configuration items.
+    """
+
+    inference: Dict[str, AquaContainerConfigItem] = Field(
+        default_factory=dict, description="Inference container configuration items."
+    )
+    finetune: Dict[str, AquaContainerConfigItem] = Field(
+        default_factory=dict, description="Fine-tuning container configuration items."
+    )
+    evaluate: Dict[str, AquaContainerConfigItem] = Field(
+        default_factory=dict, description="Evaluation container configuration items."
+    )
+
+    def to_dict(self):
+        return {
+            "inference": list(self.inference.values()),
+            "finetune": list(self.finetune.values()),
+            "evaluate": list(self.evaluate.values()),
+        }
+
+    @classmethod
+    def from_container_index_json(
+        cls,
+        config: Dict,
+        enable_spec: Optional[bool] = False,
+    ) -> "AquaContainerConfig":
+        """
+        Creates an AquaContainerConfig instance from a container index JSON.
+
+        Parameters
+        ----------
+        config (Optional[Dict]): The container index JSON.
+        enable_spec (Optional[bool]): If True, fetch container specification details.
+
+        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, {}
+                        )
+                        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
+
+        return cls(
+            inference=inference_items, finetune=finetune_items, evaluate=evaluate_items
+        )

ads/aqua/config/evaluation/evaluation_service_config.py

@@ -1,9 +1,8 @@
 #!/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/
 
-from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 from pydantic import Field
@@ -11,139 +10,6 @@ from pydantic import Field
 from ads.aqua.config.utils.serializer import Serializable
 
 
-class ModelParamsOverrides(Serializable):
-    """Defines overrides for model parameters, including exclusions and additional inclusions."""
-
-    exclude: Optional[List[str]] = Field(default_factory=list)
-    include: Optional[Dict[str, Any]] = Field(default_factory=dict)
-
-    class Config:
-        extra = "ignore"
-
-
-class ModelParamsVersion(Serializable):
-    """Handles version-specific model parameter overrides."""
-
-    overrides: Optional[ModelParamsOverrides] = Field(
-        default_factory=ModelParamsOverrides
-    )
-
-    class Config:
-        extra = "ignore"
-
-
-class ModelParamsContainer(Serializable):
-    """Represents a container's model configuration, including tasks, defaults, and versions."""
-
-    name: Optional[str] = None
-    default: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    versions: Optional[Dict[str, ModelParamsVersion]] = Field(default_factory=dict)
-
-    class Config:
-        extra = "ignore"
-
-
-class InferenceParams(Serializable):
-    """Contains inference-related parameters with defaults."""
-
-    class Config:
-        extra = "allow"
-
-
-class InferenceContainer(Serializable):
-    """Represents the inference parameters specific to a container."""
-
-    name: Optional[str] = None
-    params: Optional[Dict[str, Any]] = Field(default_factory=dict)
-
-    class Config:
-        extra = "ignore"
-
-
-class ReportParams(Serializable):
-    """Handles the report-related parameters."""
-
-    default: Optional[Dict[str, Any]] = Field(default_factory=dict)
-
-    class Config:
-        extra = "ignore"
-
-
-class InferenceParamsConfig(Serializable):
-    """Combines default inference parameters with container-specific configurations."""
-
-    default: Optional[InferenceParams] = Field(default_factory=InferenceParams)
-    containers: Optional[List[InferenceContainer]] = Field(default_factory=list)
-
-    def get_merged_params(self, container_name: str) -> InferenceParams:
-        """
-        Merges default inference params with those specific to the given container.
-
-        Parameters
-        ----------
-        container_name (str): The name of the container.
-
-        Returns
-        -------
-        InferenceParams: The merged inference parameters.
-        """
-        merged_params = self.default.to_dict()
-        for containers in self.containers:
-            if containers.name.lower() == container_name.lower():
-                merged_params.update(containers.params or {})
-                break
-        return InferenceParams(**merged_params)
-
-    class Config:
-        extra = "ignore"
-
-
-class InferenceModelParamsConfig(Serializable):
-    """Encapsulates the model parameters for different containers."""
-
-    default: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    containers: Optional[List[ModelParamsContainer]] = Field(default_factory=list)
-
-    def get_merged_model_params(
-        self,
-        container_name: str,
-        version: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        Gets the model parameters for a given container, version,
-        merged with the defaults.
-
-        Parameters
-        ----------
-        container_name (str): The name of the container.
-        version (Optional[str]): The specific version of the container.
-
-        Returns
-        -------
-        Dict[str, Any]: The merged model parameters.
-        """
-        params = deepcopy(self.default)
-
-        for container in self.containers:
-            if container.name.lower() == container_name.lower():
-                params.update(container.default)
-
-                if version and version in container.versions:
-                    version_overrides = container.versions[version].overrides
-                    if version_overrides:
-                        if version_overrides.include:
-                            params.update(version_overrides.include)
-                        if version_overrides.exclude:
-                            for key in version_overrides.exclude:
-                                params.pop(key, None)
-                break
-
-        return params
-
-    class Config:
-        extra = "ignore"
-
-
 class ShapeFilterConfig(Serializable):
     """Represents the filtering options for a specific shape."""
 
@@ -151,7 +17,7 @@ class ShapeFilterConfig(Serializable):
     evaluation_target: Optional[List[str]] = Field(default_factory=list)
 
     class Config:
-        extra = "ignore"
+        extra = "allow"
 
 
 class ShapeConfig(Serializable):
@@ -178,7 +44,7 @@ class MetricConfig(Serializable):
     tags: Optional[List[str]] = Field(default_factory=list)
 
     class Config:
-        extra = "ignore"
+        extra = "allow"
 
 
 class ModelParamsConfig(Serializable):
@@ -223,7 +89,7 @@ class UIConfig(Serializable):
         ]
 
     class Config:
-        extra = "ignore"
+        extra = "allow"
         protected_namespaces = ()
 
 
@@ -235,49 +101,7 @@ class EvaluationServiceConfig(Serializable):
 
     version: Optional[str] = "1.0"
     kind: Optional[str] = "evaluation_service_config"
-    report_params: Optional[ReportParams] = Field(default_factory=ReportParams)
-    inference_params: Optional[InferenceParamsConfig] = Field(
-        default_factory=InferenceParamsConfig
-    )
-    inference_model_params: Optional[InferenceModelParamsConfig] = Field(
-        default_factory=InferenceModelParamsConfig
-    )
     ui_config: Optional[UIConfig] = Field(default_factory=UIConfig)
 
-    def get_merged_inference_params(self, container_name: str) -> InferenceParams:
-        """
-        Merges default inference params with those specific to the given container.
-
-        Params
-        ------
-        container_name (str): The name of the container.
-
-        Returns
-        -------
-        InferenceParams: The merged inference parameters.
-        """
-        return self.inference_params.get_merged_params(container_name=container_name)
-
-    def get_merged_inference_model_params(
-        self,
-        container_name: str,
-        version: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        Gets the model parameters for a given container, version, and task, merged with the defaults.
-
-        Parameters
-        ----------
-        container_name (str): The name of the container.
-        version (Optional[str]): The specific version of the container.
-
-        Returns
-        -------
-        Dict[str, Any]: The merged model parameters.
-        """
-        return self.inference_model_params.get_merged_model_params(
-            container_name=container_name, version=version
-        )
-
     class Config:
-        extra = "ignore"
+        extra = "allow"

ads/aqua/constants.py

@@ -3,13 +3,13 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 """This module defines constants used in ads.aqua module."""
 
-UNKNOWN = ""
 UNKNOWN_VALUE = ""
 READY_TO_IMPORT_STATUS = "TRUE"
 UNKNOWN_DICT = {}
 README = "README.md"
 LICENSE_TXT = "config/LICENSE.txt"
 DEPLOYMENT_CONFIG = "deployment_config.json"
+AQUA_MODEL_TOKENIZER_CONFIG = "tokenizer_config.json"
 COMPARTMENT_MAPPING_KEY = "service-model-compartment"
 CONTAINER_INDEX = "container_index.json"
 EVALUATION_REPORT_JSON = "report.json"

ads/aqua/evaluation/constants.py

@@ -1,6 +1,5 @@
 #!/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/
 
 """
@@ -9,9 +8,10 @@ aqua.evaluation.const
 
 This module contains constants/enums used in Aqua Evaluation.
 """
+
 from oci.data_science.models import JobRun
 
-from ads.common.extended_enum import ExtendedEnumMeta
+from ads.common.extended_enum import ExtendedEnum
 
 EVAL_TERMINATION_STATE = [
     JobRun.LIFECYCLE_STATE_SUCCEEDED,
@@ -19,7 +19,7 @@ EVAL_TERMINATION_STATE = [
 ]
 
 
-class EvaluationCustomMetadata(str, metaclass=ExtendedEnumMeta):
+class EvaluationCustomMetadata(ExtendedEnum):
     EVALUATION_SOURCE = "evaluation_source"
     EVALUATION_JOB_ID = "evaluation_job_id"
     EVALUATION_JOB_RUN_ID = "evaluation_job_run_id"
@@ -28,11 +28,11 @@ class EvaluationCustomMetadata(str, metaclass=ExtendedEnumMeta):
     EVALUATION_ERROR = "aqua_evaluate_error"
 
 
-class EvaluationConfig(str, metaclass=ExtendedEnumMeta):
+class EvaluationConfig(ExtendedEnum):
     PARAMS = "model_params"
 
 
-class EvaluationReportJson(str, metaclass=ExtendedEnumMeta):
+class EvaluationReportJson(ExtendedEnum):
     """Contains evaluation report.json fields name."""
 
     METRIC_SUMMARY_RESULT = "metric_summary_result"
@@ -43,7 +43,7 @@ class EvaluationReportJson(str, metaclass=ExtendedEnumMeta):
     DATASET = "dataset"
 
 
-class EvaluationMetricResult(str, metaclass=ExtendedEnumMeta):
+class EvaluationMetricResult(ExtendedEnum):
     """Contains metric result's fields name in report.json."""
 
     SHORT_NAME = "key"

ads/aqua/evaluation/errors.py

@@ -1,6 +1,5 @@
 #!/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/
 """
 aqua.evaluation.errors
@@ -9,10 +8,10 @@ aqua.evaluation.errors
 This module contains errors in Aqua Evaluation.
 """
 
-from ads.common.extended_enum import ExtendedEnumMeta
+from ads.common.extended_enum import ExtendedEnum
 
 
-class EvaluationJobExitCode(str, metaclass=ExtendedEnumMeta):
+class EvaluationJobExitCode(ExtendedEnum):
     SUCCESS = 0
     COMMON_ERROR = 1
 

ads/aqua/evaluation/evaluation.py

@@ -40,11 +40,13 @@ from ads.aqua.common.errors import (
 from ads.aqua.common.utils import (
     extract_id_and_name_from_tag,
     fire_and_forget,
+    get_container_config,
     get_container_image,
     is_valid_ocid,
     upload_local_to_os,
 )
 from ads.aqua.config.config import get_evaluation_service_config
+from ads.aqua.config.container_config import AquaContainerConfig
 from ads.aqua.constants import (
     CONSOLE_LINK_RESOURCE_TYPE_MAPPING,
     EVALUATION_REPORT,
@@ -53,7 +55,6 @@ from ads.aqua.constants import (
     JOB_INFRASTRUCTURE_TYPE_DEFAULT_NETWORKING,
     LIFECYCLE_DETAILS_MISSING_JOBRUN,
     NB_SESSION_IDENTIFIER,
-    UNKNOWN,
 )
 from ads.aqua.evaluation.constants import (
     EVAL_TERMINATION_STATE,
@@ -75,10 +76,9 @@ from ads.aqua.evaluation.entities import (
     CreateAquaEvaluationDetails,
 )
 from ads.aqua.evaluation.errors import EVALUATION_JOB_EXIT_CODE_MESSAGE
-from ads.aqua.ui import AquaContainerConfig
 from ads.common.auth import default_signer
 from ads.common.object_storage_details import ObjectStorageDetails
-from ads.common.utils import get_console_link, get_files, get_log_links
+from ads.common.utils import UNKNOWN, get_console_link, get_files, get_log_links
 from ads.config import (
     AQUA_JOB_SUBNET_ID,
     COMPARTMENT_OCID,
@@ -192,7 +192,7 @@ class AquaEvaluationApp(AquaApp):
                         evaluation_source.runtime.to_dict()
                     )
                     inference_config = AquaContainerConfig.from_container_index_json(
-                        enable_spec=True
+                        config=get_container_config(), enable_spec=True
                     ).inference
                     for container in inference_config.values():
                         if container.name == runtime.image[: runtime.image.rfind(":")]:

ads/aqua/extension/base_handler.py

@@ -37,6 +37,10 @@ class AquaAPIhandler(APIHandler):
         except Exception:
             pass
 
+    def prepare(self, *args, **kwargs):
+        """The base class prepare is not required for Aqua"""
+        pass
+        
     @staticmethod
     def serialize(obj: Any):
         """Serialize the object.

ads/aqua/extension/model_handler.py

@@ -8,19 +8,13 @@ from urllib.parse import urlparse
 from tornado.web import HTTPError
 
 from ads.aqua.common.decorator import handle_exceptions
-from ads.aqua.common.enums import (
-    CustomInferenceContainerTypeFamily,
-)
+from ads.aqua.common.enums import CustomInferenceContainerTypeFamily
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
-from ads.aqua.common.utils import (
-    get_hf_model_info,
-    list_hf_models,
-)
+from ads.aqua.common.utils import get_hf_model_info, is_valid_ocid, list_hf_models
 from ads.aqua.extension.base_handler import AquaAPIhandler
 from ads.aqua.extension.errors import Errors
 from ads.aqua.model import AquaModelApp
 from ads.aqua.model.entities import AquaModelSummary, HFModelSummary
-from ads.aqua.ui import ModelFormat
 
 
 class AquaModelHandler(AquaAPIhandler):
@@ -43,26 +37,24 @@ class AquaModelHandler(AquaAPIhandler):
                 raise HTTPError(
                     400, Errors.MISSING_REQUIRED_PARAMETER.format("model_format")
                 )
-            try:
-                model_format = ModelFormat(model_format.upper())
-            except ValueError as err:
-                raise AquaValueError(f"Invalid model format: {model_format}") from err
+            
+            model_format = model_format.upper()
+            
+            if os_path:
+                return self.finish(
+                    AquaModelApp.get_model_files(os_path, model_format)
+                )
+            elif model_name:
+                return self.finish(
+                    AquaModelApp.get_hf_model_files(model_name, model_format)
+                )
             else:
-                if os_path:
-                    return self.finish(
-                        AquaModelApp.get_model_files(os_path, model_format)
-                    )
-                elif model_name:
-                    return self.finish(
-                        AquaModelApp.get_hf_model_files(model_name, model_format)
-                    )
-                else:
-                    raise HTTPError(
-                        400,
-                        Errors.MISSING_ONEOF_REQUIRED_PARAMETER.format(
-                            "os_path", "model_name"
-                        ),
-                    )
+                raise HTTPError(
+                    400,
+                    Errors.MISSING_ONEOF_REQUIRED_PARAMETER.format(
+                        "os_path", "model_name"
+                    ),
+                )
         elif not model_id:
             return self.list()
 
@@ -316,8 +308,30 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         )
 
 
+class AquaModelTokenizerConfigHandler(AquaAPIhandler):
+    def get(self, model_id):
+        """
+        Handles requests for retrieving the Hugging Face tokenizer configuration of a specified model.
+        Expected request format: GET /aqua/models/<model-ocid>/tokenizer
+
+        """
+
+        path_list = urlparse(self.request.path).path.strip("/").split("/")
+        # Path should be /aqua/models/ocid1.iad.ahdxxx/tokenizer
+        # path_list=['aqua','models','<model-ocid>','tokenizer']
+        if (
+            len(path_list) == 4
+            and is_valid_ocid(path_list[2])
+            and path_list[3] == "tokenizer"
+        ):
+            return self.finish(AquaModelApp().get_hf_tokenizer_config(model_id))
+
+        raise HTTPError(400, f"The request {self.request.path} is invalid.")
+
+
 __handlers__ = [
     ("model/?([^/]*)", AquaModelHandler),
     ("model/?([^/]*)/license", AquaModelLicenseHandler),
+    ("model/?([^/]*)/tokenizer", AquaModelTokenizerConfigHandler),
     ("model/hf/search/?([^/]*)", AquaHuggingFaceHandler),
 ]