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

ads/aqua/ui.py

@@ -1,12 +1,9 @@
 #!/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/
 import concurrent.futures
-from dataclasses import dataclass, field, fields
 from datetime import datetime, timedelta
-from enum import Enum
 from threading import Lock
-from typing import Dict, List, Optional
 
 from cachetools import TTLCache
 from oci.exceptions import ServiceError
@@ -14,210 +11,18 @@ from oci.identity.models import Compartment
 
 from ads.aqua import logger
 from ads.aqua.app import AquaApp
-from ads.aqua.common.entities import ContainerSpec
 from ads.aqua.common.enums import Tags
 from ads.aqua.common.errors import AquaResourceAccessError, AquaValueError
 from ads.aqua.common.utils import get_container_config, sanitize_response
+from ads.aqua.config.container_config import AquaContainerConfig
 from ads.aqua.constants import PRIVATE_ENDPOINT_TYPE
 from ads.common import oci_client as oc
 from ads.common.auth import default_signer
 from ads.common.object_storage_details import ObjectStorageDetails
-from ads.common.serializer import DataClassSerializable
-from ads.config import (
-    COMPARTMENT_OCID,
-    DATA_SCIENCE_SERVICE_NAME,
-    TENANCY_OCID,
-)
+from ads.config import COMPARTMENT_OCID, DATA_SCIENCE_SERVICE_NAME, TENANCY_OCID
 from ads.telemetry import telemetry
 
 
-class ModelFormat(Enum):
-    GGUF = "GGUF"
-    SAFETENSORS = "SAFETENSORS"
-    UNKNOWN = "UNKNOWN"
-
-    def to_dict(self):
-        return self.value
-
-
-# todo: the container config spec information is shared across ui and deployment modules, move them
-#   within ads.aqua.common.entities. In that case, check for circular imports due to usage of get_container_config.
-
-
-@dataclass(repr=False)
-class AquaContainerEvaluationConfig(DataClassSerializable):
-    """
-    Represents the evaluation configuration for the container.
-    """
-
-    inference_max_threads: Optional[int] = None
-    inference_rps: Optional[int] = None
-    inference_timeout: Optional[int] = None
-    inference_retries: Optional[int] = None
-    inference_backoff_factor: Optional[int] = None
-    inference_delay: Optional[int] = None
-
-    @classmethod
-    def from_config(cls, config: dict) -> "AquaContainerEvaluationConfig":
-        return cls(
-            inference_max_threads=config.get("inference_max_threads"),
-            inference_rps=config.get("inference_rps"),
-            inference_timeout=config.get("inference_timeout"),
-            inference_retries=config.get("inference_retries"),
-            inference_backoff_factor=config.get("inference_backoff_factor"),
-            inference_delay=config.get("inference_delay"),
-        )
-
-    def to_filtered_dict(self):
-        return {
-            field.name: getattr(self, field.name)
-            for field in fields(self)
-            if getattr(self, field.name) is not None
-        }
-
-
-@dataclass(repr=False)
-class AquaContainerConfigSpec(DataClassSerializable):
-    cli_param: str = None
-    server_port: str = None
-    health_check_port: str = None
-    env_vars: List[dict] = None
-    restricted_params: List[str] = None
-
-
-@dataclass(repr=False)
-class AquaContainerConfigItem(DataClassSerializable):
-    """Represents an item of the AQUA container configuration."""
-
-    class Platform(Enum):
-        ARM_CPU = "ARM_CPU"
-        NVIDIA_GPU = "NVIDIA_GPU"
-
-        def to_dict(self):
-            return self.value
-
-        def __repr__(self):
-            return repr(self.value)
-
-    name: str = None
-    version: str = None
-    display_name: str = None
-    family: str = None
-    platforms: List[Platform] = None
-    model_formats: List[ModelFormat] = None
-    spec: AquaContainerConfigSpec = field(default_factory=AquaContainerConfigSpec)
-
-
-@dataclass(repr=False)
-class AquaContainerConfig(DataClassSerializable):
-    """
-    Represents a configuration with AQUA containers to be returned to the client.
-    """
-
-    inference: Dict[str, AquaContainerConfigItem] = field(default_factory=dict)
-    finetune: Dict[str, AquaContainerConfigItem] = field(default_factory=dict)
-    evaluate: Dict[str, AquaContainerConfigItem] = field(default_factory=dict)
-
-    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: Optional[Dict] = None,
-        enable_spec: Optional[bool] = False,
-    ) -> "AquaContainerConfig":
-        """
-        Create an AquaContainerConfig instance from a container index JSON.
-
-        Parameters
-        ----------
-        config : Dict
-            The container index JSON.
-        enable_spec: bool
-            flag to check if container specification details should be fetched.
-
-        Returns
-        -------
-        AquaContainerConfig
-            The container configuration instance.
-        """
-        if not config:
-            config = get_container_config()
-        inference_items = {}
-        finetune_items = {}
-        evaluate_items = {}
-
-        # extract inference containers
-        for container_type, containers in config.items():
-            if isinstance(containers, list):
-                for container in containers:
-                    platforms = [
-                        AquaContainerConfigItem.Platform[platform]
-                        for platform in container.get("platforms", [])
-                    ]
-                    model_formats = [
-                        ModelFormat[model_format]
-                        for model_format in container.get("modelFormats", [])
-                    ]
-                    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,
-                        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 AquaContainerConfig(
-            inference=inference_items, finetune=finetune_items, evaluate=evaluate_items
-        )
-
-
 class AquaUIApp(AquaApp):
     """Contains APIs for supporting Aqua UI.
 
@@ -512,7 +317,8 @@ class AquaUIApp(AquaApp):
 
         Returns
         -------
-            str has json representation of `oci.data_science.models.ModelDeploymentShapeSummary`."""
+        str has json representation of `oci.data_science.models.ModelDeploymentShapeSummary`.
+        """
         compartment_id = kwargs.pop("compartment_id", COMPARTMENT_OCID)
         logger.info(
             f"Loading model deployment shape summary from compartment: {compartment_id}"

ads/common/auth.py

@@ -1,23 +1,25 @@
 #!/usr/bin/env python
-# -*- coding: utf-8; -*-
 
-# Copyright (c) 2021, 2023 Oracle and/or its affiliates.
+# Copyright (c) 2021, 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 copy
-from datetime import datetime
 import os
-from dataclasses import dataclass
 import time
+from dataclasses import dataclass
+from datetime import datetime
 from typing import Any, Callable, Dict, Optional, Union
 
-import ads.telemetry
 import oci
+from oci.config import (
+    DEFAULT_LOCATION,  # "~/.oci/config"
+    DEFAULT_PROFILE,  # "DEFAULT"
+)
+
+import ads.telemetry
 from ads.common import logger
 from ads.common.decorator.deprecate import deprecated
-from ads.common.extended_enum import ExtendedEnumMeta
-from oci.config import DEFAULT_LOCATION  # "~/.oci/config"
-from oci.config import DEFAULT_PROFILE  # "DEFAULT"
+from ads.common.extended_enum import ExtendedEnum
 
 SECURITY_TOKEN_LEFT_TIME = 600
 
@@ -26,7 +28,7 @@ class SecurityTokenError(Exception):  # pragma: no cover
     pass
 
 
-class AuthType(str, metaclass=ExtendedEnumMeta):
+class AuthType(ExtendedEnum):
     API_KEY = "api_key"
     RESOURCE_PRINCIPAL = "resource_principal"
     INSTANCE_PRINCIPAL = "instance_principal"
@@ -73,7 +75,11 @@ class AuthState(metaclass=SingletonMeta):
         self.oci_key_profile = self.oci_key_profile or os.environ.get(
             "OCI_CONFIG_PROFILE", DEFAULT_PROFILE
         )
-        self.oci_config = self.oci_config or {"region": os.environ["OCI_RESOURCE_REGION"]} if os.environ.get("OCI_RESOURCE_REGION") else {}
+        self.oci_config = (
+            self.oci_config or {"region": os.environ["OCI_RESOURCE_REGION"]}
+            if os.environ.get("OCI_RESOURCE_REGION")
+            else {}
+        )
         self.oci_signer_kwargs = self.oci_signer_kwargs or {}
         self.oci_client_kwargs = self.oci_client_kwargs or {}
 
@@ -82,11 +88,15 @@ def set_auth(
     auth: Optional[str] = AuthType.API_KEY,
     oci_config_location: Optional[str] = DEFAULT_LOCATION,
     profile: Optional[str] = DEFAULT_PROFILE,
-    config: Optional[Dict] = {"region": os.environ["OCI_RESOURCE_REGION"]} if os.environ.get("OCI_RESOURCE_REGION") else {},
+    config: Optional[Dict] = (
+        {"region": os.environ["OCI_RESOURCE_REGION"]}
+        if os.environ.get("OCI_RESOURCE_REGION")
+        else {}
+    ),
     signer: Optional[Any] = None,
     signer_callable: Optional[Callable] = None,
-    signer_kwargs: Optional[Dict] = {},
-    client_kwargs: Optional[Dict] = {},
+    signer_kwargs: Optional[Dict] = None,
+    client_kwargs: Optional[Dict] = None,
 ) -> None:
     """
     Sets the default authentication type.
@@ -187,6 +197,9 @@ def set_auth(
     >>> # instance principals authentication dictionary created based on callable with kwargs parameters:
     >>> ads.set_auth(signer_callable=signer_callable, signer_kwargs=signer_kwargs)
     """
+    signer_kwargs = signer_kwargs or {}
+    client_kwargs = client_kwargs or {}
+
     auth_state = AuthState()
 
     valid_auth_keys = AuthFactory.classes.keys()
@@ -202,8 +215,8 @@ def set_auth(
         oci_config_location != DEFAULT_LOCATION or profile != DEFAULT_PROFILE
     ):
         raise ValueError(
-            f"'config' and 'oci_config_location', 'profile' pair are mutually exclusive."
-            f"Please specify 'config' OR 'oci_config_location', 'profile' pair."
+            "'config' and 'oci_config_location', 'profile' pair are mutually exclusive."
+            "Please specify 'config' OR 'oci_config_location', 'profile' pair."
         )
 
     auth_state.oci_config = config
@@ -250,9 +263,11 @@ def api_keys(
     """
     signer_args = dict(
         oci_config=oci_config if isinstance(oci_config, Dict) else {},
-        oci_config_location=oci_config
-        if isinstance(oci_config, str)
-        else os.path.expanduser(DEFAULT_LOCATION),
+        oci_config_location=(
+            oci_config
+            if isinstance(oci_config, str)
+            else os.path.expanduser(DEFAULT_LOCATION)
+        ),
         oci_key_profile=profile,
         client_kwargs=client_kwargs,
     )
@@ -326,9 +341,11 @@ def security_token(
     """
     signer_args = dict(
         oci_config=oci_config if isinstance(oci_config, Dict) else {},
-        oci_config_location=oci_config
-        if isinstance(oci_config, str)
-        else os.path.expanduser(DEFAULT_LOCATION),
+        oci_config_location=(
+            oci_config
+            if isinstance(oci_config, str)
+            else os.path.expanduser(DEFAULT_LOCATION)
+        ),
         oci_key_profile=profile,
         client_kwargs=client_kwargs,
     )
@@ -621,7 +638,7 @@ class APIKey(AuthSignerGenerator):
             )
 
         oci.config.validate_config(configuration)
-        logger.debug(f"Using 'api_key' authentication.")
+        logger.debug("Using 'api_key' authentication.")
         return {
             "config": configuration,
             "signer": oci.signer.Signer(
@@ -684,14 +701,19 @@ class ResourcePrincipal(AuthSignerGenerator):
             "signer": oci.auth.signers.get_resource_principals_signer(),
             "client_kwargs": self.client_kwargs,
         }
-        logger.debug(f"Using 'resource_principal' authentication.")
+        logger.debug("Using 'resource_principal' authentication.")
         return signer_dict
 
     @staticmethod
     def supported():
         return any(
             os.environ.get(var)
-            for var in ['JOB_RUN_OCID', 'NB_SESSION_OCID', 'DATAFLOW_RUN_ID', 'PIPELINE_RUN_OCID']
+            for var in [
+                "JOB_RUN_OCID",
+                "NB_SESSION_OCID",
+                "DATAFLOW_RUN_ID",
+                "PIPELINE_RUN_OCID",
+            ]
         )
 
 
@@ -747,7 +769,7 @@ class InstancePrincipal(AuthSignerGenerator):
             ),
             "client_kwargs": self.client_kwargs,
         }
-        logger.debug(f"Using 'instance_principal' authentication.")
+        logger.debug("Using 'instance_principal' authentication.")
         return signer_dict
 
 
@@ -814,7 +836,7 @@ class SecurityToken(AuthSignerGenerator):
                 oci.config.from_file(self.oci_config_location, self.oci_key_profile)
             )
 
-        logger.debug(f"Using 'security_token' authentication.")
+        logger.debug("Using 'security_token' authentication.")
 
         for parameter in self.SECURITY_TOKEN_REQUIRED:
             if parameter not in configuration:
@@ -903,7 +925,7 @@ class SecurityToken(AuthSignerGenerator):
             raise ValueError("Invalid `security_token_file`. Specify a valid path.")
         try:
             token = None
-            with open(expanded_path, "r") as f:
+            with open(expanded_path) as f:
                 token = f.read()
             return token
         except:
@@ -1023,7 +1045,7 @@ class OCIAuthContext:
             logger.debug(f"OCI profile set to {self.profile}")
         else:
             ads.set_auth(auth=AuthType.RESOURCE_PRINCIPAL)
-            logger.debug(f"OCI auth set to resource principal")
+            logger.debug("OCI auth set to resource principal")
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

ads/common/extended_enum.py

@@ -1,73 +1,81 @@
 #!/usr/bin/env python
-# -*- coding: utf-8; -*-
 
-# Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+# Copyright (c) 2022, 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 abc import ABCMeta
-from enum import Enum
 
 
 class ExtendedEnumMeta(ABCMeta):
-    """The helper metaclass to extend functionality of a generic Enum.
+    """
+    A helper metaclass to extend functionality of a generic "Enum-like" class.
 
     Methods
     -------
-    values(cls) -> list:
-        Gets the list of class attributes.
-
-    Examples
-    --------
-    >>> class TestEnum(str, metaclass=ExtendedEnumMeta):
-    ...    KEY1 = "value1"
-    ...    KEY2 = "value2"
-    >>> print(TestEnum.KEY1) # "value1"
+    __contains__(cls, item) -> bool:
+        Checks if `item` is among the attribute values of the class.
+        Case-insensitive if `item` is a string.
+    values(cls) -> tuple:
+        Returns the tuple of class attribute values.
+    keys(cls) -> tuple:
+        Returns the tuple of class attribute names.
     """
 
-    def __contains__(cls, value):
-        return value and value.lower() in tuple(value.lower() for value in cls.values())
-
-    def values(cls) -> list:
-        """Gets the list of class attributes values.
+    def __contains__(cls, item: object) -> bool:
+        """
+        Checks if `item` is a member of the class's values.
 
-        Returns
-        -------
-        list
-            The list of class values.
+        - If `item` is a string, does a case-insensitive match against any string
+          values stored in the class.
+        - Otherwise, does a direct membership test.
+        """
+        # Gather the attribute values
+        attr_values = cls.values()
+
+        # If item is a string, compare case-insensitively to any str-type values
+        if isinstance(item, str):
+            return any(
+                isinstance(val, str) and val.lower() == item.lower()
+                for val in attr_values
+            )
+        else:
+            # For non-string items (e.g., int), do a direct membership check
+            return item in attr_values
+
+    def __iter__(cls):
+        # Make the class iterable by returning an iterator over its values
+        return iter(cls.values())
+
+    def values(cls) -> tuple:
+        """
+        Gets the tuple of class attribute values, excluding private or special
+        attributes and any callables (methods, etc.).
         """
         return tuple(
-            value for key, value in cls.__dict__.items() if not key.startswith("_")
+            value
+            for key, value in cls.__dict__.items()
+            if not key.startswith("_") and not callable(value)
         )
 
-    def keys(cls) -> list:
-        """Gets the list of class attributes names.
-
-        Returns
-        -------
-        list
-            The list of class attributes names.
+    def keys(cls) -> tuple:
+        """
+        Gets the tuple of class attribute names, excluding private or special
+        attributes and any callables (methods, etc.).
         """
         return tuple(
-            key for key, value in cls.__dict__.items() if not key.startswith("_")
+            key
+            for key, value in cls.__dict__.items()
+            if not key.startswith("_") and not callable(value)
         )
 
 
-class ExtendedEnum(Enum):
+class ExtendedEnum(metaclass=ExtendedEnumMeta):
     """The base class to extend functionality of a generic Enum.
 
     Examples
     --------
-    >>> class TestEnum(ExtendedEnumMeta):
-    ...    KEY1 = "value1"
-    ...    KEY2 = "value2"
-    >>> print(TestEnum.KEY1.value) # "value1"
+    >>> class TestEnum(ExtendedEnum):
+    ...    KEY1 = "v1"
+    ...    KEY2 = "v2"
     """
-
-    @classmethod
-    def values(cls):
-        return sorted(map(lambda c: c.value, cls))
-
-    @classmethod
-    def keys(cls):
-        return sorted(map(lambda c: c.name, cls))