oracle-ads 2.13.11__py3-none-any.whl → 2.13.13__py3-none-any.whl

ads/aqua/extension/common_handler.py

@@ -1,8 +1,8 @@
 #!/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/
-
-
+import json
+import os
 from importlib import metadata
 
 import huggingface_hub
@@ -18,6 +18,10 @@ from ads.aqua.common.utils import (
 )
 from ads.aqua.extension.base_handler import AquaAPIhandler
 from ads.aqua.extension.errors import Errors
+from ads.common.object_storage_details import ObjectStorageDetails
+from ads.common.utils import read_file
+from ads.config import CONDA_BUCKET_NAME, CONDA_BUCKET_NS
+from ads.opctl.operator.common.utils import default_signer
 
 
 class ADSVersionHandler(AquaAPIhandler):
@@ -28,6 +32,46 @@ class ADSVersionHandler(AquaAPIhandler):
         self.finish({"data": metadata.version("oracle_ads")})
 
 
+class AquaVersionHandler(AquaAPIhandler):
+    @handle_exceptions
+    def get(self):
+        """
+        Returns the current and latest deployed version of AQUA
+
+        {
+          "installed": {
+            "aqua": "0.1.3.0",
+            "ads": "2.14.2"
+          },
+          "latest": {
+            "aqua": "0.1.4.0",
+            "ads": "2.14.4"
+          }
+        }
+
+        """
+
+        current_aqua_version_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "..", "version.json"
+        )
+        current_aqua_version = json.loads(read_file(current_aqua_version_path))
+        current_ads_version = {"ads": metadata.version("oracle_ads")}
+        current_version = {"installed": {**current_aqua_version, **current_ads_version}}
+        try:
+            latest_version_artifact_path = ObjectStorageDetails(
+                CONDA_BUCKET_NAME,
+                CONDA_BUCKET_NS,
+                "service_pack/aqua_latest_version.json",
+            ).path
+            latest_version = json.loads(
+                read_file(latest_version_artifact_path, auth=default_signer())
+            )
+        except Exception:
+            latest_version = {"latest": current_version["installed"]}
+        response = {**current_version, **latest_version}
+        return self.finish(response)
+
+
 class CompatibilityCheckHandler(AquaAPIhandler):
     """The handler to check if the extension is compatible."""
 
@@ -118,4 +162,5 @@ __handlers__ = [
     ("network_status", NetworkStatusHandler),
     ("hf_login", HFLoginHandler),
     ("hf_logged_in", HFUserStatusHandler),
+    ("aqua_version", AquaVersionHandler),
 ]

ads/aqua/extension/model_handler.py

@@ -11,12 +11,15 @@ from ads.aqua.common.decorator import handle_exceptions
 from ads.aqua.common.enums import CustomInferenceContainerTypeFamily
 from ads.aqua.common.errors import AquaRuntimeError
 from ads.aqua.common.utils import get_hf_model_info, is_valid_ocid, list_hf_models
+from ads.aqua.constants import AQUA_CHAT_TEMPLATE_METADATA_KEY
 from ads.aqua.extension.base_handler import AquaAPIhandler
 from ads.aqua.extension.errors import Errors
 from ads.aqua.model import AquaModelApp
 from ads.aqua.model.entities import AquaModelSummary, HFModelSummary
 from ads.config import SERVICE
+from ads.model import DataScienceModel
 from ads.model.common.utils import MetadataArtifactPathType
+from ads.model.service.oci_datascience_model import OCIDataScienceModel
 
 
 class AquaModelHandler(AquaAPIhandler):
@@ -241,7 +244,7 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         aqua_model_app = AquaModelApp()
         model_ocid = aqua_model_app._find_matching_aqua_model(model_id=model_id_lower)
         if model_ocid:
-            return aqua_model_app.get(model_ocid, load_model_card=False)
+            return aqua_model_app.get(model_ocid)
 
         return None
 
@@ -320,26 +323,65 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         )
 
 
-class AquaModelTokenizerConfigHandler(AquaAPIhandler):
+class AquaModelChatTemplateHandler(AquaAPIhandler):
     def get(self, model_id):
         """
-        Handles requests for retrieving the Hugging Face tokenizer configuration of a specified model.
-        Expected request format: GET /aqua/models/<model-ocid>/tokenizer
+        Handles requests for retrieving the chat template from custom metadata of a specified model.
+        Expected request format: GET /aqua/models/<model-ocid>/chat-template
 
         """
 
         path_list = urlparse(self.request.path).path.strip("/").split("/")
-        # Path should be /aqua/models/ocid1.iad.ahdxxx/tokenizer
-        # path_list=['aqua','models','<model-ocid>','tokenizer']
+        # Path should be /aqua/models/ocid1.iad.ahdxxx/chat-template
+        # path_list=['aqua','models','<model-ocid>','chat-template']
         if (
             len(path_list) == 4
             and is_valid_ocid(path_list[2])
-            and path_list[3] == "tokenizer"
+            and path_list[3] == "chat-template"
         ):
-            return self.finish(AquaModelApp().get_hf_tokenizer_config(model_id))
+            try:
+                oci_data_science_model = OCIDataScienceModel.from_id(model_id)
+            except Exception as e:
+                raise HTTPError(404, f"Model not found for id: {model_id}. Details: {str(e)}")
+            return self.finish(oci_data_science_model.get_custom_metadata_artifact("chat_template"))
 
         raise HTTPError(400, f"The request {self.request.path} is invalid.")
 
+    @handle_exceptions
+    def post(self, model_id: str):
+        """
+        Handles POST requests to add a custom chat_template metadata artifact to a model.
+
+        Expected request format:
+        POST /aqua/models/<model-ocid>/chat-template
+        Body: { "chat_template": "<your_template_string>" }
+
+        """
+        try:
+            input_body = self.get_json_body()
+        except Exception as e:
+            raise HTTPError(400, f"Invalid JSON body: {str(e)}")
+
+        chat_template = input_body.get("chat_template")
+        if not chat_template:
+            raise HTTPError(400, "Missing required field: 'chat_template'")
+
+        try:
+            data_science_model = DataScienceModel.from_id(model_id)
+        except Exception as e:
+            raise HTTPError(404, f"Model not found for id: {model_id}. Details: {str(e)}")
+
+        try:
+            result = data_science_model.create_custom_metadata_artifact(
+                metadata_key_name=AQUA_CHAT_TEMPLATE_METADATA_KEY,
+                path_type=MetadataArtifactPathType.CONTENT,
+                artifact_path_or_content=chat_template.encode()
+            )
+        except Exception as e:
+            raise HTTPError(500, f"Failed to create metadata artifact: {str(e)}")
+
+        return self.finish(result)
+
 
 class AquaModelDefinedMetadataArtifactHandler(AquaAPIhandler):
     """
@@ -381,7 +423,7 @@ __handlers__ = [
     ("model/?([^/]*)", AquaModelHandler),
     ("model/?([^/]*)/license", AquaModelLicenseHandler),
     ("model/?([^/]*)/readme", AquaModelReadmeHandler),
-    ("model/?([^/]*)/tokenizer", AquaModelTokenizerConfigHandler),
+    ("model/?([^/]*)/chat-template", AquaModelChatTemplateHandler),
     ("model/hf/search/?([^/]*)", AquaHuggingFaceHandler),
     (
         "model/?([^/]*)/definedMetadata/?([^/]*)",

ads/aqua/model/constants.py

@@ -26,6 +26,7 @@ class ModelTask(ExtendedEnum):
     TEXT_GENERATION = "text-generation"
     IMAGE_TEXT_TO_TEXT = "image-text-to-text"
     IMAGE_TO_TEXT = "image-to-text"
+    TIME_SERIES_FORECASTING = "time-series-forecasting"
 
 
 class FineTuningMetricCategories(ExtendedEnum):

ads/aqua/model/enums.py

@@ -27,6 +27,24 @@ class FineTuningCustomMetadata(ExtendedEnum):
 
 class MultiModelSupportedTaskType(ExtendedEnum):
     TEXT_GENERATION = "text_generation"
+    TEXT_GENERATION_INFERENCE = "text_generation_inference"
+    TEXT2TEXT_GENERATION = "text2text_generation"
+    SUMMARIZATION = "summarization"
+    TRANSLATION = "translation"
+    CONVERSATIONAL = "conversational"
+    FEATURE_EXTRACTION = "feature_extraction"
+    SENTENCE_SIMILARITY = "sentence_similarity"
+    AUTOMATIC_SPEECH_RECOGNITION = "automatic_speech_recognition"
+    TEXT_TO_SPEECH = "text_to_speech"
+    TEXT_TO_IMAGE = "text_to_image"
+    TEXT_EMBEDDING = "text_embedding"
     IMAGE_TEXT_TO_TEXT = "image_text_to_text"
     CODE_SYNTHESIS = "code_synthesis"
-    EMBEDDING = "text_embedding"
+    QUESTION_ANSWERING = "question_answering"
+    AUDIO_CLASSIFICATION = "audio_classification"
+    AUDIO_TO_AUDIO = "audio_to_audio"
+    IMAGE_CLASSIFICATION = "image_classification"
+    IMAGE_TO_TEXT = "image_to_text"
+    IMAGE_TO_IMAGE = "image_to_image"
+    VIDEO_CLASSIFICATION = "video_classification"
+    TIME_SERIES_FORECASTING = "time_series_forecasting"

ads/aqua/model/model.py

@@ -83,18 +83,10 @@ from ads.aqua.model.entities import (
     ModelValidationResult,
 )
 from ads.aqua.model.enums import MultiModelSupportedTaskType
-from ads.aqua.model.utils import (
-    extract_base_model_from_ft,
-    extract_fine_tune_artifacts_path,
-)
+from ads.aqua.model.utils import extract_fine_tune_artifacts_path
 from ads.common.auth import default_signer
 from ads.common.oci_resource import SEARCH_TYPE, OCIResource
-from ads.common.utils import (
-    UNKNOWN,
-    get_console_link,
-    is_path_exists,
-    read_file,
-)
+from ads.common.utils import UNKNOWN, get_console_link, is_path_exists, read_file
 from ads.config import (
     AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME,
     AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
@@ -247,6 +239,7 @@ class AquaModelApp(AquaApp):
         compartment_id: Optional[str] = None,
         freeform_tags: Optional[Dict] = None,
         defined_tags: Optional[Dict] = None,
+        source_models: Optional[Dict[str, DataScienceModel]] = None,
         **kwargs,  # noqa: ARG002
     ) -> DataScienceModel:
         """
@@ -264,6 +257,10 @@ class AquaModelApp(AquaApp):
             Freeform tags for the model.
         defined_tags : Optional[Dict]
             Defined tags for the model.
+        source_models: Optional[Dict[str, DataScienceModel]]
+            A mapping of model OCIDs to their corresponding `DataScienceModel` objects.
+            This dictionary contains metadata for all models involved in the multi-model deployment,
+            including both base models and fine-tuned weights.
 
         Returns
         -------
@@ -300,60 +297,127 @@ class AquaModelApp(AquaApp):
 
         selected_models_deployment_containers = set()
 
-        # Process each model
+        if not source_models:
+            # Collect all unique model IDs (including fine-tuned models)
+            source_model_ids = list(
+                {model_id for model in models for model_id in model.all_model_ids()}
+            )
+            logger.debug(
+                "Fetching source model metadata for model IDs: %s", source_model_ids
+            )
+
+            # Fetch source model metadata
+            source_models = self.get_multi_source(source_model_ids) or {}
+
+        # Process each model in the input list
         for model in models:
-            source_model = DataScienceModel.from_id(model.model_id)
-            display_name = source_model.display_name
+            # Retrieve base model metadata
+            source_model: DataScienceModel = source_models.get(model.model_id)
+            if not source_model:
+                logger.error(
+                    "Failed to fetch metadata for base model ID: %s", model.model_id
+                )
+                raise AquaValueError(
+                    f"Unable to retrieve metadata for base model ID: {model.model_id}."
+                )
+
+            # Use display name as fallback if model name not provided
+            model.model_name = model.model_name or source_model.display_name
+
+            # Validate model file description
             model_file_description = source_model.model_file_description
-            # Update model name in user's input model
-            model.model_name = model.model_name or display_name
-
-            # TODO Uncomment the section below, if only service models should be allowed for multi-model deployment
-            # if not source_model.freeform_tags.get(Tags.AQUA_SERVICE_MODEL_TAG, UNKNOWN):
-            #     raise AquaValueError(
-            #         f"Invalid selected model {display_name}. "
-            #         "Currently only service models are supported for multi model deployment."
-            #     )
-
-            # check if model is a fine-tuned model and if so, add the fine tuned weights path to the fine_tune_weights_location pydantic field
-            is_fine_tuned_model = (
-                Tags.AQUA_FINE_TUNED_MODEL_TAG in source_model.freeform_tags
+            if not model_file_description:
+                logger.error(
+                    "Model '%s' (%s) has no file description.",
+                    source_model.display_name,
+                    model.model_id,
+                )
+                raise AquaValueError(
+                    f"Model '{source_model.display_name}' (ID: {model.model_id}) has no file description. "
+                    "Please register the model with a file description."
+                )
+
+            # Track model file description in a validated structure
+            model_file_description_list.append(
+                ModelFileDescription(**model_file_description)
             )
 
-            if is_fine_tuned_model:
-                model.model_id, model.model_name = extract_base_model_from_ft(
-                    source_model
+            # Ensure base model has a valid artifact
+            if not source_model.artifact:
+                logger.error(
+                    "Base model '%s' (%s) has no artifact.",
+                    model.model_name,
+                    model.model_id,
                 )
-                model_artifact_path, model.fine_tune_weights_location = (
-                    extract_fine_tune_artifacts_path(source_model)
+                raise AquaValueError(
+                    f"Model '{model.model_name}' (ID: {model.model_id}) has no registered artifacts. "
+                    "Please register the model before deployment."
                 )
 
-            else:
-                # Retrieve model artifact for base models
-                model_artifact_path = source_model.artifact
+            # Set base model artifact path
+            model.artifact_location = source_model.artifact
+            logger.debug(
+                "Model '%s' artifact path set to: %s",
+                model.model_name,
+                model.artifact_location,
+            )
 
-            display_name_list.append(display_name)
+            display_name_list.append(model.model_name)
 
+            # Extract model task metadata from source model
             self._extract_model_task(model, source_model)
 
-            if not model_artifact_path:
-                raise AquaValueError(
-                    f"Model '{display_name}' (ID: {model.model_id}) has no artifacts. "
-                    "Please register the model first."
+            # Process fine-tuned weights if provided
+            for ft_model in model.fine_tune_weights or []:
+                fine_tune_source_model: DataScienceModel = source_models.get(
+                    ft_model.model_id
                 )
+                if not fine_tune_source_model:
+                    logger.error(
+                        "Failed to fetch metadata for fine-tuned model ID: %s",
+                        ft_model.model_id,
+                    )
+                    raise AquaValueError(
+                        f"Unable to retrieve metadata for fine-tuned model ID: {ft_model.model_id}."
+                    )
 
-            # Update model artifact location in user's input model
-            model.artifact_location = model_artifact_path
+                # Validate model file description
+                ft_model_file_description = (
+                    fine_tune_source_model.model_file_description
+                )
+                if not ft_model_file_description:
+                    logger.error(
+                        "Model '%s' (%s) has no file description.",
+                        fine_tune_source_model.display_name,
+                        ft_model.model_id,
+                    )
+                    raise AquaValueError(
+                        f"Model '{fine_tune_source_model.display_name}' (ID: {ft_model.model_id}) has no file description. "
+                        "Please register the model with a file description."
+                    )
 
-            if not model_file_description:
-                raise AquaValueError(
-                    f"Model '{display_name}' (ID: {model.model_id}) has no file description. "
-                    "Please register the model first."
+                # Track model file description in a validated structure
+                model_file_description_list.append(
+                    ModelFileDescription(**ft_model_file_description)
                 )
 
-            model_file_description_list.append(
-                ModelFileDescription(**model_file_description)
-            )
+                # Extract fine-tuned model path
+                _, fine_tune_path = extract_fine_tune_artifacts_path(
+                    fine_tune_source_model
+                )
+                logger.debug(
+                    "Resolved fine-tuned model path for '%s': %s",
+                    ft_model.model_id,
+                    fine_tune_path,
+                )
+                ft_model.model_path = fine_tune_path
+
+                # Use fallback name if needed
+                ft_model.model_name = (
+                    ft_model.model_name or fine_tune_source_model.display_name
+                )
+
+                display_name_list.append(ft_model.model_name)
 
             # Validate deployment container consistency
             deployment_container = source_model.custom_metadata_list.get(
@@ -364,9 +428,15 @@ class AquaModelApp(AquaApp):
             ).value
 
             if deployment_container not in supported_container_families:
+                logger.error(
+                    "Unsupported deployment container '%s' for model '%s'. Supported: %s",
+                    deployment_container,
+                    source_model.id,
+                    supported_container_families,
+                )
                 raise AquaValueError(
                     f"Unsupported deployment container '{deployment_container}' for model '{source_model.id}'. "
-                    f"Only '{supported_container_families}' are supported for multi-model deployments."
+                    f"Only {supported_container_families} are supported for multi-model deployments."
                 )
 
             selected_models_deployment_containers.add(deployment_container)
@@ -480,8 +550,6 @@ class AquaModelApp(AquaApp):
         ----------
         model_id: str
             The model OCID.
-        load_model_card: (bool, optional). Defaults to `True`.
-            Whether to load model card from artifacts or not.
 
         Returns
         -------

ads/aqua/model/utils.py

@@ -3,9 +3,8 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 """AQUA model utils"""
 
-from typing import Dict, Optional, Tuple
+from typing import Tuple
 
-from ads.aqua.common.entities import AquaMultiModelRef
 from ads.aqua.common.errors import AquaValueError
 from ads.aqua.common.utils import get_model_by_reference_paths
 from ads.aqua.finetuning.constants import FineTuneCustomMetadata