oracle-ads 2.11.14__py3-none-any.whl → 2.11.16__py3-none-any.whl

ads/aqua/ui.py

@@ -1,12 +1,12 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright (c) 2024 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
+from dataclasses import dataclass, field, fields
 from datetime import datetime, timedelta
+from enum import Enum
 from threading import Lock
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from cachetools import TTLCache
 from oci.exceptions import ServiceError
@@ -14,6 +14,7 @@ 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, load_config, sanitize_response
@@ -31,14 +32,84 @@ from ads.config import (
 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
+    evaluation_configuration: AquaContainerEvaluationConfig = field(
+        default_factory=AquaContainerEvaluationConfig
+    )
+
+
 @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)
@@ -47,12 +118,23 @@ class AquaContainerConfig(DataClassSerializable):
     Represents a configuration with AQUA containers to be returned to the client.
     """
 
-    inference: List[AquaContainerConfigItem] = field(default_factory=list)
-    finetune: List[AquaContainerConfigItem] = field(default_factory=list)
-    evaluate: List[AquaContainerConfigItem] = field(default_factory=list)
+    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: Dict) -> "AquaContainerConfig":
+    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.
 
@@ -60,21 +142,39 @@ class AquaContainerConfig(DataClassSerializable):
         ----------
         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.
         """
-        config = config or {}
-        inference_items = []
-        finetune_items = []
-        evaluate_items = []
+        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", ""),
@@ -82,13 +182,35 @@ class AquaContainerConfig(DataClassSerializable):
                             "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, []
+                            ),
+                            evaluation_configuration=AquaContainerEvaluationConfig.from_config(
+                                container_spec.get(
+                                    ContainerSpec.EVALUATION_CONFIGURATION, {}
+                                )
+                            ),
+                        )
+                        if container_spec
+                        else None,
                     )
                     if container.get("type") == "inference":
-                        inference_items.append(container_item)
+                        inference_items[container_type] = container_item
                     elif container_type == "odsc-llm-fine-tuning":
-                        finetune_items.append(container_item)
+                        finetune_items[container_type] = container_item
                     elif container_type == "odsc-llm-evaluate":
-                        evaluate_items.append(container_item)
+                        evaluate_items[container_type] = container_item
 
         return AquaContainerConfig(
             inference=inference_items, finetune=finetune_items, evaluate=evaluate_items
@@ -175,11 +297,11 @@ class AquaUIApp(AquaApp):
         try:
             if not TENANCY_OCID:
                 raise AquaValueError(
-                    f"TENANCY_OCID must be available in environment"
+                    "TENANCY_OCID must be available in environment"
                     " variables to list the sub compartments."
                 )
 
-            if TENANCY_OCID in self._compartments_cache.keys():
+            if TENANCY_OCID in self._compartments_cache:
                 logger.info(
                     f"Returning compartments list in {TENANCY_OCID} from cache."
                 )
@@ -196,7 +318,7 @@ class AquaUIApp(AquaApp):
                         access_level="ANY",
                     )
                 )
-            except ServiceError as se:
+            except ServiceError:
                 logger.error(
                     f"ERROR: Unable to list all sub compartment in tenancy {TENANCY_OCID}."
                 )
@@ -207,7 +329,7 @@ class AquaUIApp(AquaApp):
                             compartment_id=TENANCY_OCID,
                         )
                     )
-                except ServiceError as se:
+                except ServiceError:
                     logger.error(
                         f"ERROR: Unable to list all child compartment in tenancy {TENANCY_OCID}."
                     )
@@ -216,7 +338,7 @@ class AquaUIApp(AquaApp):
                     TENANCY_OCID
                 ).data
                 compartments.insert(0, root_compartment)
-            except ServiceError as se:
+            except ServiceError:
                 logger.error(
                     f"ERROR: Unable to get details of the root compartment {TENANCY_OCID}."
                 )
@@ -248,7 +370,7 @@ class AquaUIApp(AquaApp):
         """
         if not COMPARTMENT_OCID:
             logger.error("No compartment id found from environment variables.")
-        return dict(compartment_id=COMPARTMENT_OCID)
+        return {"compartment_id": COMPARTMENT_OCID}
 
     def clear_compartments_list_cache(self) -> dict:
         """Allows caller to clear compartments list cache
@@ -257,9 +379,9 @@ class AquaUIApp(AquaApp):
             dict with the key used, and True if cache has the key that needs to be deleted.
         """
         res = {}
-        logger.info(f"Clearing list_compartments cache")
+        logger.info("Clearing list_compartments cache")
         with self._cache_lock:
-            if TENANCY_OCID in self._compartments_cache.keys():
+            if TENANCY_OCID in self._compartments_cache:
                 self._compartments_cache.pop(key=TENANCY_OCID)
                 res = {
                     "key": {
@@ -332,6 +454,7 @@ class AquaUIApp(AquaApp):
         response = os_client.list_buckets(
             namespace_name=namespace_name,
             compartment_id=compartment_id,
+            limit=1000,
             **kwargs,
         ).data
 
@@ -474,16 +597,16 @@ class AquaUIApp(AquaApp):
             raise AquaResourceAccessError(
                 f"Could not check limits availability for the shape {instance_shape}. Make sure you have the necessary policy to check limits availability.",
                 service_payload=se.args[0] if se.args else None,
-            )
+            ) from None
 
         available = res.available
 
         try:
             cards = int(instance_shape.split(".")[-1])
-        except:
+        except Exception:
             cards = 1
 
-        response = dict(available_count=available)
+        response = {"available_count": available}
 
         if available < cards:
             raise AquaValueError(
@@ -516,7 +639,7 @@ class AquaUIApp(AquaApp):
             is_versioned = False
             message = f"Model artifact bucket {bucket_uri} is not versioned. Check if the path exists and enable versioning on the bucket to proceed with model creation."
 
-        return dict(is_versioned=is_versioned, message=message)
+        return {"is_versioned": is_versioned, "message": message}
 
     @telemetry(entry_point="plugin=ui&action=list_containers", name="aqua")
     def list_containers(self) -> AquaContainerConfig:
@@ -526,8 +649,9 @@ class AquaUIApp(AquaApp):
         Returns
         -------
         AquaContainerConfig
-            The AQUA containers configuration.
+            The AQUA containers configurations.
         """
         return AquaContainerConfig.from_container_index_json(
-            config=get_container_config()
+            config=get_container_config(),
+            enable_spec=True,
         )

ads/common/object_storage_details.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2021, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
@@ -7,16 +6,15 @@
 import json
 import os
 import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from typing import Dict, List
 from urllib.parse import urlparse
 
-
 import oci
 from ads.common import auth as authutil
 from ads.common import oci_client
 from ads.dataset.progress import TqdmProgressBar
-from concurrent.futures import ThreadPoolExecutor, as_completed
 
 THREAD_POOL_MAX_WORKERS = 10
 
@@ -169,8 +167,7 @@ class ObjectStorageDetails:
 
     def list_objects(self, **kwargs):
         """Lists objects in a given oss path
-
-        Parameters
+            Parameters
         -------
         **kwargs:
             namespace, bucket, filepath are set by the class. By default, fields gets all values. For other supported

ads/common/serializer.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8; -*-
 
 # Copyright (c) 2021, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
@@ -25,10 +24,8 @@ from ads.common import logger
 from ads.common.auth import default_signer
 
 try:
-    from yaml import CSafeDumper as dumper
     from yaml import CSafeLoader as loader
 except:
-    from yaml import SafeDumper as dumper
     from yaml import SafeLoader as loader
 
 
@@ -99,6 +96,8 @@ class Serializable(ABC):
         """JSON serializer for objects not serializable by default json code."""
         if isinstance(obj, datetime):
             return obj.isoformat()
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
         raise TypeError(f"Type {type(obj)} not serializable.")
 
     @staticmethod

ads/jobs/builders/infrastructure/dsc_job.py

@@ -30,6 +30,7 @@ from ads.common.oci_logging import OCILog
 from ads.common.oci_resource import ResourceNotFoundError
 from ads.jobs.builders.infrastructure.base import Infrastructure, RunInstance
 from ads.jobs.builders.infrastructure.dsc_job_runtime import (
+    ContainerRuntimeHandler,
     DataScienceJobRuntimeManager,
 )
 from ads.jobs.builders.infrastructure.utils import get_value
@@ -458,7 +459,7 @@ class DSCJob(OCIDataScienceMixin, oci.data_science.models.Job):
         ----------
         **kwargs :
             Keyword arguments for initializing a Data Science Job Run.
-            The keys can be any keys in supported by OCI JobConfigurationDetails and JobRun, including:
+            The keys can be any keys in supported by OCI JobConfigurationDetails, OcirContainerJobEnvironmentConfigurationDetails and JobRun, including:
             * hyperparameter_values: dict(str, str)
             * environment_variables: dict(str, str)
             * command_line_arguments: str
@@ -466,6 +467,11 @@ class DSCJob(OCIDataScienceMixin, oci.data_science.models.Job):
             * display_name: str
             * freeform_tags: dict(str, str)
             * defined_tags: dict(str, dict(str, object))
+            * image: str
+            * cmd: list[str]
+            * entrypoint: list[str]
+            * image_digest: str
+            * image_signature_id: str
 
         If display_name is not specified, it will be generated as "<JOB_NAME>-run-<TIMESTAMP>".
 
@@ -478,14 +484,28 @@ class DSCJob(OCIDataScienceMixin, oci.data_science.models.Job):
         if not self.id:
             self.create()
 
-        swagger_types = (
+        config_swagger_types = (
             oci.data_science.models.DefaultJobConfigurationDetails().swagger_types.keys()
         )
+        env_config_swagger_types = {}
+        if hasattr(oci.data_science.models, "OcirContainerJobEnvironmentConfigurationDetails"):
+            env_config_swagger_types = (
+                oci.data_science.models.OcirContainerJobEnvironmentConfigurationDetails().swagger_types.keys()
+            )
         config_kwargs = {}
+        env_config_kwargs = {}
         keys = list(kwargs.keys())
         for key in keys:
-            if key in swagger_types:
+            if key in config_swagger_types:
                 config_kwargs[key] = kwargs.pop(key)
+            elif key in env_config_swagger_types:
+                value = kwargs.pop(key)
+                if key in [
+                    ContainerRuntime.CONST_CMD,
+                    ContainerRuntime.CONST_ENTRYPOINT
+                ] and isinstance(value, str):
+                    value = ContainerRuntimeHandler.split_args(value)
+                env_config_kwargs[key] = value
 
         # remove timestamp from the job name (added in default names, when display_name not specified by user)
         if self.display_name:
@@ -514,6 +534,12 @@ class DSCJob(OCIDataScienceMixin, oci.data_science.models.Job):
             config_override.update(config_kwargs)
             kwargs["job_configuration_override_details"] = config_override
 
+        if env_config_kwargs:
+            env_config_kwargs["jobEnvironmentType"] = "OCIR_CONTAINER"
+            env_config_override = kwargs.get("job_environment_configuration_override_details", {})
+            env_config_override.update(env_config_kwargs)
+            kwargs["job_environment_configuration_override_details"] = env_config_override
+
         wait = kwargs.pop("wait", False)
         run = DataScienceJobRun(**kwargs, **self.auth).create()
         if wait:

ads/jobs/builders/infrastructure/dsc_job_runtime.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8; -*-
 
-# Copyright (c) 2021, 2023 Oracle and/or its affiliates.
+# Copyright (c) 2021, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 """Contains classes for conversion between ADS runtime and OCI Data Science Job implementation.
 This module is for ADS developers only.
@@ -305,10 +305,29 @@ class RuntimeHandler:
             self._extract_envs,
             self._extract_artifact,
             self._extract_runtime_minutes,
+            self._extract_properties,
         ]
         for extraction in extractions:
             runtime_spec.update(extraction(dsc_job))
         return self.RUNTIME_CLASS(self._format_env_var(runtime_spec))
+    
+    def _extract_properties(self, dsc_job) -> dict:
+        """Extract the job runtime properties from data science job.
+
+        This is the base method which does not extract the job runtime properties.
+        Sub-class should implement the extraction if needed.
+
+        Parameters
+        ----------
+        dsc_job : DSCJob or oci.datascience.models.Job
+            The data science job containing runtime information.
+
+        Returns
+        -------
+        dict
+            A runtime specification dictionary for initializing a runtime.
+        """
+        return {}
 
     def _extract_args(self, dsc_job) -> dict:
         """Extracts the command line arguments from data science job.
@@ -942,9 +961,12 @@ class GitPythonRuntimeHandler(CondaRuntimeHandler):
 class ContainerRuntimeHandler(RuntimeHandler):
     RUNTIME_CLASS = ContainerRuntime
     CMD_DELIMITER = ","
-    CONST_CONTAINER_IMAGE = "CONTAINER_CUSTOM_IMAGE"
-    CONST_CONTAINER_ENTRYPOINT = "CONTAINER_ENTRYPOINT"
-    CONST_CONTAINER_CMD = "CONTAINER_CMD"
+
+    def translate(self, runtime: Runtime) -> dict:
+        payload = super().translate(runtime)
+        job_env_config = self._translate_env_config(runtime)
+        payload["job_environment_configuration_details"] = job_env_config
+        return payload
 
     def _translate_artifact(self, runtime: Runtime):
         """Specifies a dummy script as the job artifact.
@@ -964,29 +986,34 @@ class ContainerRuntimeHandler(RuntimeHandler):
             os.path.dirname(__file__), "../../templates", "container.py"
         )
 
-    def _translate_env(self, runtime: ContainerRuntime) -> dict:
-        """Translate the environment variable.
+    def _translate_env_config(self, runtime: Runtime) -> dict:
+        """Converts runtime properties to ``OcirContainerJobEnvironmentConfigurationDetails`` payload required by OCI Data Science job.
 
         Parameters
         ----------
-        runtime : GitPythonRuntime
-            An instance of GitPythonRuntime
+        runtime : Runtime
+            The runtime containing the properties to be converted.
 
         Returns
         -------
         dict
-            A dictionary containing environment variables for OCI data science job.
+            A dictionary storing the ``OcirContainerJobEnvironmentConfigurationDetails`` payload for OCI data science job.
         """
-        if not runtime.image:
-            raise ValueError("Specify container image for ContainerRuntime.")
-        envs = super()._translate_env(runtime)
-        spec_mappings = {
-            ContainerRuntime.CONST_IMAGE: self.CONST_CONTAINER_IMAGE,
-            ContainerRuntime.CONST_ENTRYPOINT: self.CONST_CONTAINER_ENTRYPOINT,
-            ContainerRuntime.CONST_CMD: self.CONST_CONTAINER_CMD,
+        job_environment_configuration_details = {
+            "job_environment_type": runtime.job_env_type
         }
-        envs.update(self._translate_specs(runtime, spec_mappings, self.CMD_DELIMITER))
-        return envs
+
+        for key, value in ContainerRuntime.attribute_map.items():
+            property = runtime.get_spec(key, None)
+            if key in [
+                ContainerRuntime.CONST_CMD,
+                ContainerRuntime.CONST_ENTRYPOINT
+            ] and isinstance(property, str):
+                property = self.split_args(property)
+            if property is not None:
+                job_environment_configuration_details[value] = property
+
+        return job_environment_configuration_details
 
     @staticmethod
     def split_args(args: str) -> list:
@@ -1031,17 +1058,37 @@ class ContainerRuntimeHandler(RuntimeHandler):
         """
         spec = super()._extract_envs(dsc_job)
         envs = spec.pop(ContainerRuntime.CONST_ENV_VAR, {})
-        if self.CONST_CONTAINER_IMAGE not in envs:
-            raise IncompatibleRuntime()
-        spec[ContainerRuntime.CONST_IMAGE] = envs.pop(self.CONST_CONTAINER_IMAGE)
-        cmd = self.split_args(envs.pop(self.CONST_CONTAINER_CMD, ""))
-        if cmd:
-            spec[ContainerRuntime.CONST_CMD] = cmd
-        entrypoint = self.split_args(envs.pop(self.CONST_CONTAINER_ENTRYPOINT, ""))
-        if entrypoint:
-            spec[ContainerRuntime.CONST_ENTRYPOINT] = entrypoint
+
         if envs:
             spec[ContainerRuntime.CONST_ENV_VAR] = envs
+
+        return spec
+    
+    def _extract_properties(self, dsc_job) -> dict:
+        """Extract the runtime properties from data science job.
+
+        Parameters
+        ----------
+        dsc_job : DSCJob or oci.datascience.models.Job
+            The data science job containing runtime information.
+
+        Returns
+        -------
+        dict
+            A runtime specification dictionary for initializing a runtime.
+        """
+        spec = super()._extract_envs(dsc_job)
+        
+        job_env_config = getattr(dsc_job, "job_environment_configuration_details", None)
+        job_env_type = getattr(job_env_config, "job_environment_type", None)
+        
+        if not (job_env_config and job_env_type == "OCIR_CONTAINER"):
+            raise IncompatibleRuntime()
+
+        for key, value in ContainerRuntime.attribute_map.items():
+            property = getattr(job_env_config, value, None)
+            if property is not None:
+                spec[key] = property
         return spec