oracle-ads 2.11.9__py3-none-any.whl → 2.11.11__py3-none-any.whl

ads/aqua/modeldeployment/entities.py

@@ -0,0 +1,142 @@
+#!/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/
+
+from dataclasses import dataclass, field
+from typing import Union
+
+from oci.data_science.models import ModelDeployment, ModelDeploymentSummary
+
+from ads.aqua.common.enums import Tags
+from ads.aqua.constants import UNKNOWN, UNKNOWN_DICT
+from ads.aqua.data import AquaResourceIdentifier
+from ads.common.serializer import DataClassSerializable
+from ads.common.utils import get_console_link
+
+
+@dataclass
+class ModelParams:
+    max_tokens: int = None
+    temperature: float = None
+    top_k: float = None
+    top_p: float = None
+    model: str = None
+
+
+class ContainerSpec:
+    """
+    Class to hold to hold keys within the container spec.
+    """
+
+    CONTAINER_SPEC = "containerSpec"
+    CLI_PARM = "cliParam"
+    SERVER_PORT = "serverPort"
+    HEALTH_CHECK_PORT = "healthCheckPort"
+    ENV_VARS = "envVars"
+
+
+@dataclass
+class ShapeInfo:
+    instance_shape: str = None
+    instance_count: int = None
+    ocpus: float = None
+    memory_in_gbs: float = None
+
+
+@dataclass(repr=False)
+class AquaDeployment(DataClassSerializable):
+    """Represents an Aqua Model Deployment"""
+
+    id: str = None
+    display_name: str = None
+    aqua_service_model: bool = None
+    aqua_model_name: str = None
+    state: str = None
+    description: str = None
+    created_on: str = None
+    created_by: str = None
+    endpoint: str = None
+    console_link: str = None
+    lifecycle_details: str = None
+    shape_info: field(default_factory=ShapeInfo) = None
+    tags: dict = None
+
+    @classmethod
+    def from_oci_model_deployment(
+        cls,
+        oci_model_deployment: Union[ModelDeploymentSummary, ModelDeployment],
+        region: str,
+    ) -> "AquaDeployment":
+        """Converts oci model deployment response to AquaDeployment instance.
+
+        Parameters
+        ----------
+        oci_model_deployment: Union[ModelDeploymentSummary, ModelDeployment]
+            The instance of either oci.data_science.models.ModelDeployment or
+            oci.data_science.models.ModelDeploymentSummary class.
+        region: str
+            The region of this model deployment.
+
+        Returns
+        -------
+        AquaDeployment:
+            The instance of the Aqua model deployment.
+        """
+        instance_configuration = (
+            oci_model_deployment.model_deployment_configuration_details.model_configuration_details.instance_configuration
+        )
+        instance_shape_config_details = (
+            instance_configuration.model_deployment_instance_shape_config_details
+        )
+        instance_count = (
+            oci_model_deployment.model_deployment_configuration_details.model_configuration_details.scaling_policy.instance_count
+        )
+        shape_info = ShapeInfo(
+            instance_shape=instance_configuration.instance_shape_name,
+            instance_count=instance_count,
+            ocpus=(
+                instance_shape_config_details.ocpus
+                if instance_shape_config_details
+                else None
+            ),
+            memory_in_gbs=(
+                instance_shape_config_details.memory_in_gbs
+                if instance_shape_config_details
+                else None
+            ),
+        )
+
+        freeform_tags = oci_model_deployment.freeform_tags or UNKNOWN_DICT
+        aqua_service_model_tag = freeform_tags.get(Tags.AQUA_SERVICE_MODEL_TAG, None)
+        aqua_model_name = freeform_tags.get(Tags.AQUA_MODEL_NAME_TAG, UNKNOWN)
+
+        return AquaDeployment(
+            id=oci_model_deployment.id,
+            display_name=oci_model_deployment.display_name,
+            aqua_service_model=aqua_service_model_tag is not None,
+            aqua_model_name=aqua_model_name,
+            shape_info=shape_info,
+            state=oci_model_deployment.lifecycle_state,
+            lifecycle_details=getattr(
+                oci_model_deployment, "lifecycle_details", UNKNOWN
+            ),
+            description=oci_model_deployment.description,
+            created_on=str(oci_model_deployment.time_created),
+            created_by=oci_model_deployment.created_by,
+            endpoint=oci_model_deployment.model_deployment_url,
+            console_link=get_console_link(
+                resource="model-deployments",
+                ocid=oci_model_deployment.id,
+                region=region,
+            ),
+            tags=freeform_tags,
+        )
+
+
+@dataclass(repr=False)
+class AquaDeploymentDetail(AquaDeployment, DataClassSerializable):
+    """Represents a details of Aqua deployment."""
+
+    log_group: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
+    log: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)

ads/aqua/modeldeployment/inference.py

@@ -0,0 +1,75 @@
+#!/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 json
+from dataclasses import asdict, dataclass, field
+
+import requests
+
+from ads.aqua.app import AquaApp, logger
+from ads.aqua.modeldeployment.entities import ModelParams
+from ads.common.auth import default_signer
+from ads.telemetry import telemetry
+
+
+@dataclass
+class MDInferenceResponse(AquaApp):
+    """Contains APIs for Aqua Model deployments Inference.
+
+    Attributes
+    ----------
+
+    model_params: Dict
+    prompt: string
+
+    Methods
+    -------
+    get_model_deployment_response(self, **kwargs) -> "String"
+        Creates an instance of model deployment via Aqua
+    """
+
+    prompt: str = None
+    model_params: field(default_factory=ModelParams) = None
+
+    @telemetry(entry_point="plugin=inference&action=get_response", name="aqua")
+    def get_model_deployment_response(self, endpoint):
+        """
+        Returns MD inference response
+
+        Parameters
+        ----------
+        endpoint: str
+            MD predict url
+        prompt: str
+            User prompt.
+
+        model_params: (Dict, optional)
+            Model parameters to be associated with the message.
+            Currently supported VLLM+OpenAI parameters.
+
+            --model-params '{
+                "max_tokens":500,
+                "temperature": 0.5,
+                "top_k": 10,
+                "top_p": 0.5,
+                "model": "/opt/ds/model/deployed_model",
+                ...}'
+
+        Returns
+        -------
+        model_response_content
+        """
+
+        params_dict = asdict(self.model_params)
+        params_dict = {
+            key: value for key, value in params_dict.items() if value is not None
+        }
+        body = {"prompt": self.prompt, **params_dict}
+        request_kwargs = {"json": body, "headers": {"Content-Type": "application/json"}}
+        response = requests.post(
+            endpoint, auth=default_signer()["signer"], **request_kwargs
+        )
+        return json.loads(response.content)

ads/aqua/ui.py

@@ -3,21 +3,24 @@
 # 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 datetime import datetime, timedelta
 from threading import Lock
+from typing import Dict, List
 
 from cachetools import TTLCache
 from oci.exceptions import ServiceError
 from oci.identity.models import Compartment
 
 from ads.aqua import logger
-from ads.aqua.base import AquaApp
-from ads.aqua.data import Tags
-from ads.aqua.exception import AquaValueError, AquaResourceAccessError
-from ads.aqua.utils import load_config, sanitize_response
+from ads.aqua.app import AquaApp
+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
 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 (
     AQUA_CONFIG_FOLDER,
     AQUA_RESOURCE_LIMIT_NAMES_CONFIG,
@@ -28,6 +31,70 @@ from ads.config import (
 from ads.telemetry import telemetry
 
 
+@dataclass(repr=False)
+class AquaContainerConfigItem(DataClassSerializable):
+    """Represents an item of the AQUA container configuration."""
+
+    name: str = None
+    version: str = None
+    display_name: str = None
+    family: str = None
+
+
+@dataclass(repr=False)
+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)
+
+    @classmethod
+    def from_container_index_json(cls, config: Dict) -> "AquaContainerConfig":
+        """
+        Create an AquaContainerConfig instance from a container index JSON.
+
+        Parameters
+        ----------
+        config : Dict
+            The container index JSON.
+
+        Returns
+        -------
+        AquaContainerConfig
+            The container configuration instance.
+        """
+        config = config or {}
+        inference_items = []
+        finetune_items = []
+        evaluate_items = []
+
+        # extract inference containers
+        for container_type, containers in config.items():
+            if isinstance(containers, list):
+                for container in containers:
+                    container_item = AquaContainerConfigItem(
+                        name=container.get("name", ""),
+                        version=container.get("version", ""),
+                        display_name=container.get(
+                            "displayName", container.get("version", "")
+                        ),
+                        family=container_type,
+                    )
+                    if container.get("type") == "inference":
+                        inference_items.append(container_item)
+                    elif container_type == "odsc-llm-fine-tuning":
+                        finetune_items.append(container_item)
+                    elif container_type == "odsc-llm-evaluate":
+                        evaluate_items.append(container_item)
+
+        return AquaContainerConfig(
+            inference=inference_items, finetune=finetune_items, evaluate=evaluate_items
+        )
+
+
 class AquaUIApp(AquaApp):
     """Contains APIs for supporting Aqua UI.
 
@@ -42,7 +109,8 @@ class AquaUIApp(AquaApp):
         Lists the specified log group's log objects.
     list_compartments(self, **kwargs) -> List[Dict]
         Lists the compartments in a specified compartment.
-
+    list_containers(self, **kwargs) -> AquaContainerConfig
+        Containers config to be returned to the client.
     """
 
     _compartments_cache = TTLCache(
@@ -219,9 +287,7 @@ class AquaUIApp(AquaApp):
         """
         compartment_id = kwargs.pop("compartment_id", COMPARTMENT_OCID)
         target_resource = (
-            "experiments"
-            if target_tag == Tags.AQUA_EVALUATION.value
-            else "modelversionsets"
+            "experiments" if target_tag == Tags.AQUA_EVALUATION else "modelversionsets"
         )
         logger.info(f"Loading {target_resource} from compartment: {compartment_id}")
 
@@ -451,3 +517,17 @@ class AquaUIApp(AquaApp):
             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)
+
+    @telemetry(entry_point="plugin=ui&action=list_containers", name="aqua")
+    def list_containers(self) -> AquaContainerConfig:
+        """
+        Lists the AQUA containers.
+
+        Returns
+        -------
+        AquaContainerConfig
+            The AQUA containers configuration.
+        """
+        return AquaContainerConfig.from_container_index_json(
+            config=get_container_config()
+        )

ads/cli.py

@@ -4,19 +4,21 @@
 # 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/
 
-import traceback
 import sys
+import traceback
+from dataclasses import is_dataclass
 
 import fire
-from dataclasses import is_dataclass
+
 from ads.common import logger
 
 try:
     import click
-    import ads.opctl.cli
+
     import ads.jobs.cli
-    import ads.pipeline.cli
+    import ads.opctl.cli
     import ads.opctl.operator.cli
+    import ads.pipeline.cli
 except Exception as ex:
     print(
         "Please run `pip install oracle-ads[opctl]` to install "
@@ -33,6 +35,7 @@ if sys.version_info >= (3, 8):
 else:
     import importlib_metadata as metadata
 
+
 ADS_VERSION = metadata.version("oracle_ads")
 
 
@@ -86,13 +89,58 @@ def serialize(data):
         print(str(data))
 
 
+def exit_program(ex: Exception, logger: "logging.Logger") -> None:
+    """
+    Logs the exception and exits the program with a specific exit code.
+
+    This function logs the full traceback and the exception message, then terminates
+    the program with an exit code. If the exception object has an 'exit_code' attribute,
+    it uses that as the exit code; otherwise, it defaults to 1.
+
+    Parameters
+    ----------
+    ex (Exception):
+        The exception that triggered the program exit. This exception
+        should ideally contain an 'exit_code' attribute, but it is not mandatory.
+    logger (Logger):
+        A logging.Logger instance used to log the traceback and the error message.
+
+    Returns
+    -------
+    None:
+        This function does not return anything because it calls sys.exit,
+        terminating the process.
+
+    Examples
+    --------
+
+    >>> import logging
+    >>> logger = logging.getLogger('ExampleLogger')
+    >>> try:
+    ...     raise ValueError("An error occurred")
+    ... except Exception as e:
+    ...     exit_program(e, logger)
+    """
+
+    logger.debug(traceback.format_exc())
+    logger.error(str(ex))
+
+    exit_code = getattr(ex, "exit_code", 1)
+    logger.error(f"Exit code: {exit_code}")
+    sys.exit(exit_code)
+
+
 def cli():
     if len(sys.argv) > 1 and sys.argv[1] == "aqua":
+        from ads.aqua import logger as aqua_logger
         from ads.aqua.cli import AquaCommand
 
-        fire.Fire(
-            AquaCommand, command=sys.argv[2:], name="ads aqua", serialize=serialize
-        )
+        try:
+            fire.Fire(
+                AquaCommand, command=sys.argv[2:], name="ads aqua", serialize=serialize
+            )
+        except Exception as err:
+            exit_program(err, aqua_logger)
     else:
         click_cli()
 

ads/common/decorator/threaded.py

@@ -0,0 +1,97 @@
+#!/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/
+
+
+import concurrent.futures
+import functools
+import logging
+from typing import Optional
+
+from git import Optional
+
+from ads.config import THREADED_DEFAULT_TIMEOUT
+
+logger = logging.getLogger(__name__)
+
+# Create a global thread pool with a maximum of 10 threads
+thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
+
+
+class TimeoutError(Exception):
+    """
+    Custom exception to be raised when a function times out.
+
+    Attributes
+    ----------
+    message : str
+        The error message describing what went wrong.
+
+    Parameters
+    ----------
+    message : str
+        The error message.
+    """
+
+    def __init__(
+        self,
+        func_name: str,
+        timeout: int,
+        message: Optional[str] = "The operation could not be completed in time.",
+    ):
+        super().__init__(
+            f"{message} The function '{func_name}' exceeded the timeout of {timeout} seconds."
+        )
+
+
+def threaded(timeout: Optional[int] = THREADED_DEFAULT_TIMEOUT):
+    """
+    Decorator to run a function in a separate thread using a global thread pool.
+
+    Parameters
+    ----------
+    timeout (int, optional)
+        The maximum time in seconds to wait for the function to complete.
+        If the function does not complete within this time, "timeout" is returned.
+
+    Returns
+    -------
+    function: The wrapped function that will run in a separate thread with the specified timeout.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            """
+            Wrapper function to submit the decorated function to the thread pool and handle timeout.
+
+            Parameters
+            ----------
+                *args: Positional arguments to pass to the decorated function.
+                **kwargs: Keyword arguments to pass to the decorated function.
+
+            Returns
+            -------
+            Any: The result of the decorated function if it completes within the timeout.
+
+            Raise
+            -----
+            TimeoutError
+                In case of the function exceeded the timeout.
+            """
+            future = thread_pool.submit(func, *args, **kwargs)
+            try:
+                return future.result(timeout=timeout)
+            except concurrent.futures.TimeoutError as ex:
+                logger.debug(
+                    f"The function '{func.__name__}' "
+                    f"exceeded the timeout of {timeout} seconds. "
+                    f"{ex}"
+                )
+                raise TimeoutError(func.__name__, timeout)
+
+        return wrapper
+
+    return decorator

ads/common/serializer.py

@@ -79,7 +79,7 @@ class Serializable(ABC):
 
     @classmethod
     @abstractmethod
-    def from_dict(cls, obj_dict: dict) -> "Serializable":
+    def from_dict(cls, obj_dict: dict, **kwargs) -> "Serializable":
         """Returns an instance of the class instantiated by the dictionary provided.
 
         Parameters
@@ -239,7 +239,7 @@ class Serializable(ABC):
             Returns instance of the class
         """
         if json_string:
-            return cls.from_dict(json.loads(json_string, cls=decoder))
+            return cls.from_dict(json.loads(json_string, cls=decoder), **kwargs)
         if uri:
             json_dict = json.loads(cls._read_from_file(uri, **kwargs), cls=decoder)
             return cls.from_dict(json_dict)

ads/config.py

@@ -8,6 +8,7 @@ import contextlib
 import inspect
 import os
 from typing import Dict, Optional
+
 from ads.common.config import DEFAULT_CONFIG_PATH, DEFAULT_CONFIG_PROFILE, Config, Mode
 
 OCI_ODSC_SERVICE_ENDPOINT = os.environ.get("OCI_ODSC_SERVICE_ENDPOINT")
@@ -41,7 +42,6 @@ COMPARTMENT_OCID = (
 )
 MD_OCID = os.environ.get("MD_OCID")
 DATAFLOW_RUN_OCID = os.environ.get("DATAFLOW_RUN_ID")
-
 RESOURCE_OCID = (
     NB_SESSION_OCID or JOB_RUN_OCID or MD_OCID or PIPELINE_RUN_OCID or DATAFLOW_RUN_OCID
 )
@@ -66,6 +66,8 @@ AQUA_RESOURCE_LIMIT_NAMES_CONFIG = os.environ.get(
 AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME = "deployment-container"
 AQUA_FINETUNING_CONTAINER_METADATA_NAME = "finetune-container"
 AQUA_EVALUATION_CONTAINER_METADATA_NAME = "evaluation-container"
+AQUA_DEPLOYMENT_CONTAINER_OVERRIDE_FLAG_METADATA_NAME = "deployment-container-custom"
+AQUA_FINETUNING_CONTAINER_OVERRIDE_FLAG_METADATA_NAME = "finetune-container-custom"
 AQUA_MODEL_DEPLOYMENT_FOLDER = "/opt/ds/model/deployed_model/"
 AQUA_SERVED_MODEL_NAME = "odsc-llm"
 AQUA_CONFIG_FOLDER = os.path.join(
@@ -84,6 +86,8 @@ DEBUG_TELEMETRY = os.environ.get("DEBUG_TELEMETRY", None)
 AQUA_SERVICE_NAME = "aqua"
 DATA_SCIENCE_SERVICE_NAME = "data-science"
 
+THREADED_DEFAULT_TIMEOUT = os.environ.get("THREADED_DEFAULT_TIMEOUT", 5)
+
 
 def export(
     uri: Optional[str] = DEFAULT_CONFIG_PATH,

ads/jobs/builders/infrastructure/dsc_job.py

@@ -9,6 +9,7 @@ import datetime
 import inspect
 import logging
 import os
+import re
 import time
 import traceback
 import uuid
@@ -375,12 +376,13 @@ class DSCJob(OCIDataScienceMixin, oci.data_science.models.Job):
         """
         runs = self.run_list()
         for run in runs:
-            if run.lifecycle_state in [
-                DataScienceJobRun.LIFECYCLE_STATE_ACCEPTED,
-                DataScienceJobRun.LIFECYCLE_STATE_IN_PROGRESS,
-                DataScienceJobRun.LIFECYCLE_STATE_NEEDS_ATTENTION,
-            ]:
-                run.cancel(wait_for_completion=True)
+            if force_delete:
+                if run.lifecycle_state in [
+                    DataScienceJobRun.LIFECYCLE_STATE_ACCEPTED,
+                    DataScienceJobRun.LIFECYCLE_STATE_IN_PROGRESS,
+                    DataScienceJobRun.LIFECYCLE_STATE_NEEDS_ATTENTION,
+                ]:
+                    run.cancel(wait_for_completion=True)
             run.delete()
         self.client.delete_job(self.id)
         return self
@@ -582,6 +584,25 @@ class DataScienceJobRun(
             id=self.log_id, log_group_id=self.log_details.log_group_id, **auth
         )
 
+    @property
+    def exit_code(self):
+        """The exit code of the job run from the lifecycle details.
+        Note that,
+        None will be returned if the job run is not finished or failed without exit code.
+        0 will be returned if job run succeeded.
+        """
+        if self.lifecycle_state == self.LIFECYCLE_STATE_SUCCEEDED:
+            return 0
+        if not self.lifecycle_details:
+            return None
+        match = re.search(r"exit code (\d+)", self.lifecycle_details)
+        if not match:
+            return None
+        try:
+            return int(match.group(1))
+        except Exception:
+            return None
+
     @staticmethod
     def _format_log(message: str, date_time: datetime.datetime) -> dict:
         """Formats a message as log record with datetime.
@@ -655,6 +676,22 @@ class DataScienceJobRun(
             print(f"{timestamp} - {status}")
         return status
 
+    def wait(self, interval: float = SLEEP_INTERVAL):
+        """Waits for the job run until if finishes.
+
+        Parameters
+        ----------
+        interval : float
+            Time interval in seconds between each request to update the logs.
+            Defaults to 3 (seconds).
+
+        """
+        self.sync()
+        while self.status not in self.TERMINAL_STATES:
+            time.sleep(interval)
+            self.sync()
+        return self
+
     def watch(
         self,
         interval: float = SLEEP_INTERVAL,
@@ -830,6 +867,12 @@ class DataScienceJobRun(
         self.job.download(to_dir)
         return self
 
+    def delete(self, force_delete: bool = False):
+        if force_delete:
+            self.cancel(wait_for_completion=True)
+        super().delete()
+        return
+
 
 # This is for backward compatibility
 DSCJobRun = DataScienceJobRun

ads/model/datascience_model.py

@@ -238,7 +238,7 @@ class DataScienceModel(Builder):
         CONST_MODEL_VERSION_ID: "version_id",
         CONST_TIME_CREATED: "time_created",
         CONST_LIFECYCLE_STATE: "lifecycle_state",
-        CONST_MODEL_FILE_DESCRIPTION: "model_file_description",
+        CONST_MODEL_FILE_DESCRIPTION: "model_description",
     }
 
     def __init__(self, spec: Dict = None, **kwargs) -> None: