oracle-ads 2.13.1rc0__py3-none-any.whl → 2.13.2rc1__py3-none-any.whl

ads/aqua/__init__.py

@@ -7,7 +7,13 @@ import os
 from logging import getLogger
 
 from ads import logger, set_auth
-from ads.aqua.client.client import AsyncClient, Client
+from ads.aqua.client.client import (
+    AsyncClient,
+    Client,
+    HttpxOCIAuth,
+    get_async_httpx_client,
+    get_httpx_client,
+)
 from ads.aqua.common.utils import fetch_service_compartment
 from ads.config import OCI_RESOURCE_PRINCIPAL_VERSION
 

ads/aqua/app.py

@@ -6,13 +6,14 @@ import json
 import os
 import traceback
 from dataclasses import fields
-from typing import Dict, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 import oci
 from oci.data_science.models import UpdateModelDetails, UpdateModelProvenanceDetails
 
 from ads import set_auth
 from ads.aqua import logger
+from ads.aqua.common.entities import ModelConfigResult
 from ads.aqua.common.enums import ConfigFolder, Tags
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
 from ads.aqua.common.utils import (
@@ -21,10 +22,9 @@ from ads.aqua.common.utils import (
     is_valid_ocid,
     load_config,
 )
-from ads.aqua.constants import UNKNOWN
 from ads.common import oci_client as oc
 from ads.common.auth import default_signer
-from ads.common.utils import extract_region, is_path_exists
+from ads.common.utils import UNKNOWN, extract_region, is_path_exists
 from ads.config import (
     AQUA_TELEMETRY_BUCKET,
     AQUA_TELEMETRY_BUCKET_NS,
@@ -273,24 +273,24 @@ class AquaApp:
         model_id: str,
         config_file_name: str,
         config_folder: Optional[str] = ConfigFolder.CONFIG,
-    ) -> Dict:
-        """Gets the config for the given Aqua model.
+    ) -> ModelConfigResult:
+        """
+        Gets the configuration for the given Aqua model along with the model details.
 
         Parameters
         ----------
-        model_id: str
+        model_id : str
             The OCID of the Aqua model.
-        config_file_name: str
-            name of the config file
-        config_folder: (str, optional):
-            subfolder path where config_file_name needs to be searched
-             Defaults to `ConfigFolder.CONFIG`.
-             When searching inside model artifact directory , the value is ConfigFolder.ARTIFACT`
+        config_file_name : str
+            The name of the configuration file.
+        config_folder : Optional[str]
+            The subfolder path where config_file_name is searched.
+            Defaults to ConfigFolder.CONFIG. For model artifact directories, use ConfigFolder.ARTIFACT.
 
         Returns
         -------
-        Dict:
-            A dict of allowed configs.
+        ModelConfigResult
+            A Pydantic model containing the model_details (extracted from OCI) and the config dictionary.
         """
         config_folder = config_folder or ConfigFolder.CONFIG
         oci_model = self.ds_client.get_model(model_id).data
@@ -302,11 +302,11 @@ class AquaApp:
             if oci_model.freeform_tags
             else False
         )
-
         if not oci_aqua:
-            raise AquaRuntimeError(f"Target model {oci_model.id} is not Aqua model.")
+            raise AquaRuntimeError(f"Target model {oci_model.id} is not an Aqua model.")
+
+        config: Dict[str, Any] = {}
 
-        config = {}
         # 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]
@@ -326,7 +326,7 @@ class AquaApp:
             logger.debug(
                 f"Failed to get artifact path from custom metadata for the model: {model_id}"
             )
-            return config
+            return ModelConfigResult(config=config, model_details=oci_model)
 
         config_path = os.path.join(os.path.dirname(artifact_path), config_folder)
         if not is_path_exists(config_path):
@@ -351,9 +351,8 @@ class AquaApp:
                 f"{config_file_name} is not available for the model: {model_id}. "
                 f"Check if the custom metadata has the artifact path set."
             )
-            return config
 
-        return config
+        return ModelConfigResult(config=config, model_details=oci_model)
 
     @property
     def telemetry(self):
@@ -375,9 +374,11 @@ class CLIBuilderMixin:
         """
         cmd = f"ads aqua {self._command}"
         params = [
-            f"--{field.name} {json.dumps(getattr(self, field.name))}"
-            if isinstance(getattr(self, field.name), dict)
-            else f"--{field.name} {getattr(self, field.name)}"
+            (
+                f"--{field.name} {json.dumps(getattr(self, field.name))}"
+                if isinstance(getattr(self, field.name), dict)
+                else f"--{field.name} {getattr(self, field.name)}"
+            )
             for field in fields(self.__class__)
             if getattr(self, field.name) is not None
         ]

ads/aqua/client/client.py

@@ -51,7 +51,7 @@ _T = TypeVar("_T", bound="BaseClient")
 logger = logging.getLogger(__name__)
 
 
-class OCIAuth(httpx.Auth):
+class HttpxOCIAuth(httpx.Auth):
     """
     Custom HTTPX authentication class that uses the OCI Signer for request signing.
 
@@ -59,14 +59,15 @@ class OCIAuth(httpx.Auth):
         signer (oci.signer.Signer): The OCI signer used to sign requests.
     """
 
-    def __init__(self, signer: oci.signer.Signer):
+    def __init__(self, signer: Optional[oci.signer.Signer] = None):
         """
-        Initialize the OCIAuth instance.
+        Initialize the HttpxOCIAuth instance.
 
         Args:
             signer (oci.signer.Signer): The OCI signer to use for signing requests.
         """
-        self.signer = signer
+
+        self.signer = signer or authutil.default_signer().get("signer")
 
     def auth_flow(self, request: httpx.Request) -> Iterator[httpx.Request]:
         """
@@ -256,7 +257,7 @@ class BaseClient:
         auth = auth or authutil.default_signer()
         if not callable(auth.get("signer")):
             raise ValueError("Auth object must have a 'signer' callable attribute.")
-        self.auth = OCIAuth(auth["signer"])
+        self.auth = HttpxOCIAuth(auth["signer"])
 
         logger.debug(
             f"Initialized {self.__class__.__name__} with endpoint={self.endpoint}, "
@@ -352,7 +353,7 @@ class Client(BaseClient):
             **kwargs: Keyword arguments forwarded to BaseClient.
         """
         super().__init__(*args, **kwargs)
-        self._client = httpx.Client(timeout=self.timeout)
+        self._client = httpx.Client(timeout=self.timeout, auth=self.auth)
 
     def is_closed(self) -> bool:
         return self._client.is_closed
@@ -400,7 +401,6 @@ class Client(BaseClient):
             response = self._client.post(
                 self.endpoint,
                 headers=self._prepare_headers(stream=False, headers=headers),
-                auth=self.auth,
                 json=payload,
             )
             logger.debug(f"Received response with status code: {response.status_code}")
@@ -447,7 +447,6 @@ class Client(BaseClient):
                     "POST",
                     self.endpoint,
                     headers=self._prepare_headers(stream=True, headers=headers),
-                    auth=self.auth,
                     json={**payload, "stream": True},
                 ) as response:
                     try:
@@ -581,7 +580,7 @@ class AsyncClient(BaseClient):
             **kwargs: Keyword arguments forwarded to BaseClient.
         """
         super().__init__(*args, **kwargs)
-        self._client = httpx.AsyncClient(timeout=self.timeout)
+        self._client = httpx.AsyncClient(timeout=self.timeout, auth=self.auth)
 
     def is_closed(self) -> bool:
         return self._client.is_closed
@@ -637,7 +636,6 @@ class AsyncClient(BaseClient):
             response = await self._client.post(
                 self.endpoint,
                 headers=self._prepare_headers(stream=False, headers=headers),
-                auth=self.auth,
                 json=payload,
             )
             logger.debug(f"Received response with status code: {response.status_code}")
@@ -683,7 +681,6 @@ class AsyncClient(BaseClient):
                     "POST",
                     self.endpoint,
                     headers=self._prepare_headers(stream=True, headers=headers),
-                    auth=self.auth,
                     json={**payload, "stream": True},
                 ) as response:
                     try:
@@ -797,3 +794,43 @@ class AsyncClient(BaseClient):
         logger.debug(f"Generating embeddings with input: {input}, payload: {payload}")
         payload = {**(payload or {}), "input": input}
         return await self._request(payload=payload, headers=headers)
+
+
+def get_httpx_client(**kwargs: Any) -> httpx.Client:
+    """
+    Creates and returns a synchronous httpx Client configured with OCI authentication signer based
+    the authentication type setup using ads.set_auth method or env variable OCI_IAM_TYPE.
+    More information - https://accelerated-data-science.readthedocs.io/en/stable/user_guide/cli/authentication.html
+
+    Parameters
+    ----------
+    **kwargs : Any
+        Keyword arguments supported by httpx.Client
+
+    Returns
+    -------
+    Client
+        A configured synchronous httpx Client instance.
+    """
+    kwargs["auth"] = kwargs.get("auth") or HttpxOCIAuth()
+    return httpx.Client(**kwargs)
+
+
+def get_async_httpx_client(**kwargs: Any) -> httpx.AsyncClient:
+    """
+    Creates and returns a synchronous httpx Client configured with OCI authentication signer based
+    the authentication type setup using ads.set_auth method or env variable OCI_IAM_TYPE.
+    More information - https://accelerated-data-science.readthedocs.io/en/stable/user_guide/cli/authentication.html
+
+    Parameters
+    ----------
+    **kwargs : Any
+        Keyword arguments supported by httpx.Client
+
+    Returns
+    -------
+    AsyncClient
+        A configured asynchronous httpx AsyncClient instance.
+    """
+    kwargs["auth"] = kwargs.get("auth") or HttpxOCIAuth()
+    return httpx.AsyncClient(**kwargs)

ads/aqua/common/entities.py

@@ -1,7 +1,12 @@
 #!/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 typing import Any, Dict, Optional
+
+from oci.data_science.models import Model
+from pydantic import BaseModel, Field
+
 
 class ContainerSpec:
     """
@@ -15,3 +20,25 @@ class ContainerSpec:
     ENV_VARS = "envVars"
     RESTRICTED_PARAMS = "restrictedParams"
     EVALUATION_CONFIGURATION = "evaluationConfiguration"
+
+
+class ModelConfigResult(BaseModel):
+    """
+    Represents the result of getting the AQUA model configuration.
+
+    Attributes:
+        model_details (Dict[str, Any]): A dictionary containing model details extracted from OCI.
+        config (Dict[str, Any]): A dictionary of the loaded configuration.
+    """
+
+    config: Optional[Dict[str, Any]] = Field(
+        None, description="Loaded configuration dictionary."
+    )
+    model_details: Optional[Model] = Field(
+        None, description="Details of the model from OCI."
+    )
+
+    class Config:
+        extra = "ignore"
+        arbitrary_types_allowed = True
+        protected_namespaces = ()

ads/aqua/common/enums.py

@@ -2,12 +2,6 @@
 # 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.common.enums
-~~~~~~~~~~~~~~
-This module contains the set of enums used in AQUA.
-"""
-
 from ads.common.extended_enum import ExtendedEnum
 
 
@@ -88,7 +82,8 @@ class RqsAdditionalDetails(ExtendedEnum):
 
 class TextEmbeddingInferenceContainerParams(ExtendedEnum):
     """Contains a subset of params that are required for enabling model deployment in OCI Data Science. More options
-    are available at https://huggingface.co/docs/text-embeddings-inference/en/cli_arguments"""
+    are available at https://huggingface.co/docs/text-embeddings-inference/en/cli_arguments
+    """
 
     MODEL_ID = "model-id"
     PORT = "port"
@@ -97,3 +92,14 @@ class TextEmbeddingInferenceContainerParams(ExtendedEnum):
 class ConfigFolder(ExtendedEnum):
     CONFIG = "config"
     ARTIFACT = "artifact"
+
+
+class ModelFormat(ExtendedEnum):
+    GGUF = "GGUF"
+    SAFETENSORS = "SAFETENSORS"
+    UNKNOWN = "UNKNOWN"
+
+
+class Platform(ExtendedEnum):
+    ARM_CPU = "ARM_CPU"
+    NVIDIA_GPU = "NVIDIA_GPU"

ads/aqua/common/utils.py

@@ -19,7 +19,6 @@ from pathlib import Path
 from string import Template
 from typing import List, Union
 
-import fsspec
 import oci
 from cachetools import TTLCache, cached
 from huggingface_hub.constants import HF_HUB_CACHE
@@ -58,7 +57,6 @@ from ads.aqua.constants import (
     SUPPORTED_FILE_FORMATS,
     TEI_CONTAINER_DEFAULT_HOST,
     TGI_INFERENCE_RESTRICTED_PARAMS,
-    UNKNOWN,
     UNKNOWN_JSON_STR,
     VLLM_INFERENCE_RESTRICTED_PARAMS,
 )
@@ -68,7 +66,13 @@ from ads.common.decorator.threaded import threaded
 from ads.common.extended_enum import ExtendedEnum
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.common.oci_resource import SEARCH_TYPE, OCIResource
-from ads.common.utils import copy_file, get_console_link, upload_to_os
+from ads.common.utils import (
+    UNKNOWN,
+    copy_file,
+    get_console_link,
+    read_file,
+    upload_to_os,
+)
 from ads.config import (
     AQUA_MODEL_DEPLOYMENT_FOLDER,
     AQUA_SERVICE_MODELS_BUCKET,
@@ -228,15 +232,6 @@ def get_artifact_path(custom_metadata_list: List) -> str:
     return UNKNOWN
 
 
-def read_file(file_path: str, **kwargs) -> str:
-    try:
-        with fsspec.open(file_path, "r", **kwargs.get("auth", {})) as f:
-            return f.read()
-    except Exception as e:
-        logger.debug(f"Failed to read file {file_path}. {e}")
-        return UNKNOWN
-
-
 @threaded()
 def load_config(file_path: str, config_file_name: str, **kwargs) -> dict:
     artifact_path = f"{file_path.rstrip('/')}/{config_file_name}"
@@ -553,7 +548,7 @@ def service_config_path():
     return f"oci://{AQUA_SERVICE_MODELS_BUCKET}@{CONDA_BUCKET_NS}/service_models/config"
 
 
-@cached(cache=TTLCache(maxsize=1, ttl=timedelta(hours=5), timer=datetime.now))
+@cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=10), timer=datetime.now))
 def get_container_config():
     config = load_config(
         file_path=service_config_path(),

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
+        )