oracle-ads 2.12.10rc0__py3-none-any.whl → 2.13.0__py3-none-any.whl

ads/aqua/model/constants.py

@@ -1,5 +1,5 @@
 #!/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/
 
 """
@@ -9,10 +9,10 @@ aqua.model.constants
 This module contains constants/enums used in Aqua Model.
 """
 
-from ads.common.extended_enum import ExtendedEnumMeta
+from ads.common.extended_enum import ExtendedEnum
 
 
-class ModelCustomMetadataFields(str, metaclass=ExtendedEnumMeta):
+class ModelCustomMetadataFields(ExtendedEnum):
     ARTIFACT_LOCATION = "artifact_location"
     DEPLOYMENT_CONTAINER = "deployment-container"
     EVALUATION_CONTAINER = "evaluation-container"
@@ -20,24 +20,24 @@ class ModelCustomMetadataFields(str, metaclass=ExtendedEnumMeta):
     DEPLOYMENT_CONTAINER_URI = "deployment-container-uri"
 
 
-class ModelTask(str, metaclass=ExtendedEnumMeta):
+class ModelTask(ExtendedEnum):
     TEXT_GENERATION = "text-generation"
     IMAGE_TEXT_TO_TEXT = "image-text-to-text"
     IMAGE_TO_TEXT = "image-to-text"
 
 
-class FineTuningMetricCategories(str, metaclass=ExtendedEnumMeta):
+class FineTuningMetricCategories(ExtendedEnum):
     VALIDATION = "validation"
     TRAINING = "training"
 
 
-class ModelType(str, metaclass=ExtendedEnumMeta):
+class ModelType(ExtendedEnum):
     FT = "FT"  # Fine Tuned Model
     BASE = "BASE"  # Base model
 
 
 # TODO: merge metadata key used in create FT
-class FineTuningCustomMetadata(str, metaclass=ExtendedEnumMeta):
+class FineTuningCustomMetadata(ExtendedEnum):
     FT_SOURCE = "fine_tune_source"
     FT_SOURCE_NAME = "fine_tune_source_name"
     FT_OUTPUT_PATH = "fine_tune_output_path"

ads/aqua/model/entities.py

@@ -283,7 +283,7 @@ class ImportModelDetails(CLIBuilderMixin):
     os_path: str
     download_from_hf: Optional[bool] = True
     local_dir: Optional[str] = None
-    cleanup_model_cache: Optional[bool] = True
+    cleanup_model_cache: Optional[bool] = False
     inference_container: Optional[str] = None
     finetuning_container: Optional[str] = None
     compartment_id: Optional[str] = None
@@ -294,6 +294,7 @@ class ImportModelDetails(CLIBuilderMixin):
     ignore_patterns: Optional[List[str]] = None
     freeform_tags: Optional[dict] = None
     defined_tags: Optional[dict] = None
+    ignore_model_artifact_check: Optional[bool] = None
 
     def __post_init__(self):
         self._command = "model register"

ads/aqua/model/enums.py

@@ -1,18 +1,17 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# 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 ads.common.extended_enum import ExtendedEnumMeta
+from ads.common.extended_enum import ExtendedEnum
 
 
-class FineTuningDefinedMetadata(str, metaclass=ExtendedEnumMeta):
+class FineTuningDefinedMetadata(ExtendedEnum):
     """Represents the defined metadata keys used in Fine Tuning."""
 
     VAL_SET_SIZE = "val_set_size"
     TRAINING_DATA = "training_data"
 
 
-class FineTuningCustomMetadata(str, metaclass=ExtendedEnumMeta):
+class FineTuningCustomMetadata(ExtendedEnum):
     """Represents the custom metadata keys used in Fine Tuning."""
 
     FT_SOURCE = "fine_tune_source"

ads/aqua/model/model.py

@@ -15,17 +15,21 @@ from oci.data_science.models import JobRun, Metadata, Model, UpdateModelDetails
 from ads.aqua import ODSC_MODEL_COMPARTMENT_OCID, logger
 from ads.aqua.app import AquaApp
 from ads.aqua.common.enums import (
+    ConfigFolder,
     CustomInferenceContainerTypeFamily,
     FineTuningContainerTypeFamily,
     InferenceContainerTypeFamily,
     Tags,
 )
-from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
+from ads.aqua.common.errors import (
+    AquaFileNotFoundError,
+    AquaRuntimeError,
+    AquaValueError,
+)
 from ads.aqua.common.utils import (
     LifecycleStatus,
     _build_resource_identifier,
     cleanup_local_hf_model_artifact,
-    copy_model_config,
     create_word_icon,
     generate_tei_cmd_var,
     get_artifact_path,
@@ -41,6 +45,7 @@ from ads.aqua.constants import (
     AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME,
     AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE,
     AQUA_MODEL_ARTIFACT_FILE,
+    AQUA_MODEL_TOKENIZER_CONFIG,
     AQUA_MODEL_TYPE_CUSTOM,
     HF_METADATA_FOLDER,
     LICENSE_TXT,
@@ -162,7 +167,7 @@ class AquaModelApp(AquaApp):
         target_compartment = compartment_id or COMPARTMENT_OCID
 
         if service_model.compartment_id != ODSC_MODEL_COMPARTMENT_OCID:
-            logger.debug(
+            logger.info(
                 f"Aqua Model {model_id} already exists in user's compartment."
                 "Skipped copying."
             )
@@ -193,8 +198,8 @@ class AquaModelApp(AquaApp):
             # TODO: decide what kwargs will be needed.
             .create(model_by_reference=True, **kwargs)
         )
-        logger.debug(
-            f"Aqua Model {custom_model.id} created with the service model {model_id}"
+        logger.info(
+            f"Aqua Model {custom_model.id} created with the service model {model_id}."
         )
 
         # tracks unique models that were created in the user compartment
@@ -225,11 +230,16 @@ class AquaModelApp(AquaApp):
 
         cached_item = self._service_model_details_cache.get(model_id)
         if cached_item:
+            logger.info(f"Fetching model details for model {model_id} from cache.")
             return cached_item
 
+        logger.info(f"Fetching model details for model {model_id}.")
         ds_model = DataScienceModel.from_id(model_id)
         if not self._if_show(ds_model):
-            raise AquaRuntimeError(f"Target model `{ds_model.id} `is not Aqua model.")
+            raise AquaRuntimeError(
+                f"Target model `{ds_model.id} `is not an Aqua model as it does not contain "
+                f"{Tags.AQUA_TAG} tag."
+            )
 
         is_fine_tuned_model = bool(
             ds_model.freeform_tags
@@ -248,16 +258,21 @@ class AquaModelApp(AquaApp):
                 ds_model.custom_metadata_list._to_oci_metadata()
             )
             if artifact_path != UNKNOWN:
+                model_card_path = (
+                    f"{artifact_path.rstrip('/')}/config/{README}"
+                    if is_verified_type
+                    else f"{artifact_path.rstrip('/')}/{README}"
+                )
                 model_card = str(
                     read_file(
-                        file_path=(
-                            f"{artifact_path.rstrip('/')}/config/{README}"
-                            if is_verified_type
-                            else f"{artifact_path.rstrip('/')}/{README}"
-                        ),
+                        file_path=model_card_path,
                         auth=default_signer(),
                     )
                 )
+                if not model_card:
+                    logger.warn(
+                        f"Model card for {model_id} is empty or could not be loaded from {model_card_path}."
+                    )
 
         inference_container = ds_model.custom_metadata_list.get(
             ModelCustomMetadataFields.DEPLOYMENT_CONTAINER,
@@ -303,9 +318,10 @@ class AquaModelApp(AquaApp):
             try:
                 jobrun_ocid = ds_model.provenance_metadata.training_id
                 jobrun = self.ds_client.get_job_run(jobrun_ocid).data
-            except Exception:
+            except Exception as e:
                 logger.debug(
                     f"Missing jobrun information in the provenance metadata of the given model {model_id}."
+                    f"\nError: {str(e)}"
                 )
                 jobrun = None
 
@@ -314,7 +330,10 @@ class AquaModelApp(AquaApp):
                     FineTuningCustomMetadata.FT_SOURCE
                 ).value
             except ValueError as e:
-                logger.debug(str(e))
+                logger.debug(
+                    f"Custom metadata is missing {FineTuningCustomMetadata.FT_SOURCE} key for "
+                    f"model {model_id}.\nError: {str(e)}"
+                )
                 source_id = UNKNOWN
 
             try:
@@ -322,7 +341,10 @@ class AquaModelApp(AquaApp):
                     FineTuningCustomMetadata.FT_SOURCE_NAME
                 ).value
             except ValueError as e:
-                logger.debug(str(e))
+                logger.debug(
+                    f"Custom metadata is missing {FineTuningCustomMetadata.FT_SOURCE_NAME} key for "
+                    f"model {model_id}.\nError: {str(e)}"
+                )
                 source_name = UNKNOWN
 
             source_identifier = _build_resource_identifier(
@@ -372,6 +394,7 @@ class AquaModelApp(AquaApp):
             Tags.AQUA_FINE_TUNED_MODEL_TAG, None
         )
         if is_registered_model or is_fine_tuned_model:
+            logger.info(f"Deleting model {model_id}.")
             return ds_model.delete()
         else:
             raise AquaRuntimeError(
@@ -478,6 +501,7 @@ class AquaModelApp(AquaApp):
                     freeform_tags=freeform_tags,
                 )
                 AquaApp().update_model(id, update_model_details)
+                logger.info(f"Updated model details for the model {id}.")
         else:
             raise AquaRuntimeError("Only registered unverified models can be edited.")
 
@@ -546,6 +570,26 @@ class AquaModelApp(AquaApp):
             training_final,
         ]
 
+    def get_hf_tokenizer_config(self, model_id):
+        """Gets the default chat template for the given Aqua model.
+
+        Parameters
+        ----------
+        model_id: str
+            The OCID of the Aqua model.
+
+        Returns
+        -------
+        str:
+            Chat template string.
+        """
+        config = self.get_config(
+            model_id, AQUA_MODEL_TOKENIZER_CONFIG, ConfigFolder.ARTIFACT
+        )
+        if not config:
+            logger.debug(f"Tokenizer config for model: {model_id} is not available.")
+        return config
+
     @staticmethod
     def to_aqua_model(
         model: Union[
@@ -735,7 +779,7 @@ class AquaModelApp(AquaApp):
             )
 
         logger.info(
-            f"Fetch {len(models)} model in compartment_id={compartment_id or ODSC_MODEL_COMPARTMENT_OCID}."
+            f"Fetched {len(models)} model in compartment_id={compartment_id or ODSC_MODEL_COMPARTMENT_OCID}."
         )
 
         aqua_models = []
@@ -765,10 +809,12 @@ class AquaModelApp(AquaApp):
             dict with the key used, and True if cache has the key that needs to be deleted.
         """
         res = {}
-        logger.info("Clearing _service_models_cache")
         with self._cache_lock:
             if ODSC_MODEL_COMPARTMENT_OCID in self._service_models_cache:
                 self._service_models_cache.pop(key=ODSC_MODEL_COMPARTMENT_OCID)
+                logger.info(
+                    f"Cleared models cache for service compartment {ODSC_MODEL_COMPARTMENT_OCID}."
+                )
                 res = {
                     "key": {
                         "compartment_id": ODSC_MODEL_COMPARTMENT_OCID,
@@ -785,10 +831,10 @@ class AquaModelApp(AquaApp):
             dict with the key used, and True if cache has the key that needs to be deleted.
         """
         res = {}
-        logger.info(f"Clearing _service_model_details_cache for {model_id}")
         with self._cache_lock:
             if model_id in self._service_model_details_cache:
                 self._service_model_details_cache.pop(key=model_id)
+                logger.info(f"Clearing model details cache for model {model_id}.")
                 res = {"key": {"model_id": model_id}, "cache_deleted": True}
 
         return res
@@ -873,7 +919,8 @@ class AquaModelApp(AquaApp):
             metadata = ModelCustomMetadata()
             if not inference_container:
                 raise AquaRuntimeError(
-                    f"Require Inference container information. Model: {model_name} does not have associated inference container defaults. Check docs for more information on how to pass inference container."
+                    f"Require Inference container information. Model: {model_name} does not have associated inference "
+                    f"container defaults. Check docs for more information on how to pass inference container."
                 )
             metadata.add(
                 key=AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
@@ -943,24 +990,6 @@ class AquaModelApp(AquaApp):
                 )
                 tags[Tags.LICENSE] = validation_result.tags.get(Tags.LICENSE, UNKNOWN)
 
-        try:
-            # If verified model already has a artifact json, use that.
-            artifact_path = metadata.get(MODEL_BY_REFERENCE_OSS_PATH_KEY).value
-            logger.info(
-                f"Found model artifact in the service bucket. "
-                f"Using artifact from service bucket instead of {os_path}"
-            )
-
-            # todo: implement generic copy_folder method
-            # copy model config from artifact path to user bucket
-            copy_model_config(
-                artifact_path=artifact_path, os_path=os_path, auth=default_signer()
-            )
-        except Exception:
-            logger.debug(
-                f"Proceeding with model registration without copying model config files at {os_path}. "
-                f"Default configuration will be used for deployment and fine-tuning."
-            )
         # Set artifact location to user bucket, and replace existing key if present.
         metadata.add(
             key=MODEL_BY_REFERENCE_OSS_PATH_KEY,
@@ -980,7 +1009,7 @@ class AquaModelApp(AquaApp):
             .with_freeform_tags(**tags)
             .with_defined_tags(**(defined_tags or {}))
         ).create(model_by_reference=True)
-        logger.debug(model)
+        logger.debug(f"Created model catalog entry for the model:\n{model}")
         return model
 
     @staticmethod
@@ -1000,13 +1029,23 @@ class AquaModelApp(AquaApp):
         # todo: revisit this logic to account for .bin files. In the current state, .bin and .safetensor models
         #   are grouped in one category and validation checks for config.json files only.
         if model_format == ModelFormat.SAFETENSORS:
+            model_files.extend(
+                list_os_files_with_extension(oss_path=os_path, extension=".safetensors")
+            )
             try:
                 load_config(
                     file_path=os_path,
                     config_file_name=AQUA_MODEL_ARTIFACT_CONFIG,
                 )
-            except Exception:
-                pass
+            except Exception as ex:
+                message = (
+                    f"The model path {os_path} does not contain the file config.json. "
+                    f"Please check if the path is correct or the model artifacts are available at this location."
+                )
+                logger.warning(
+                    f"{message}\n"
+                    f"Details: {ex.reason if isinstance(ex, AquaFileNotFoundError) else str(ex)}\n"
+                )
             else:
                 model_files.append(AQUA_MODEL_ARTIFACT_CONFIG)
 
@@ -1014,6 +1053,9 @@ class AquaModelApp(AquaApp):
             model_files.extend(
                 list_os_files_with_extension(oss_path=os_path, extension=".gguf")
             )
+        logger.debug(
+            f"Fetched {len(model_files)} model files from {os_path} for model format {model_format}."
+        )
         return model_files
 
     @staticmethod
@@ -1050,12 +1092,17 @@ class AquaModelApp(AquaApp):
 
         for model_sibling in model_siblings:
             extension = pathlib.Path(model_sibling.rfilename).suffix[1:].upper()
-            if model_format == ModelFormat.SAFETENSORS:
-                if model_sibling.rfilename == AQUA_MODEL_ARTIFACT_CONFIG:
-                    model_files.append(model_sibling.rfilename)
-            elif extension == model_format.value:
+            if (
+                model_format == ModelFormat.SAFETENSORS
+                and model_sibling.rfilename == AQUA_MODEL_ARTIFACT_CONFIG
+            ):
+                model_files.append(model_sibling.rfilename)
+            if extension == model_format.value:
                 model_files.append(model_sibling.rfilename)
 
+        logger.debug(
+            f"Fetched {len(model_files)} model files for the model {model_name} for model format {model_format}."
+        )
         return model_files
 
     def _validate_model(
@@ -1089,7 +1136,10 @@ class AquaModelApp(AquaApp):
             safetensors_model_files = self.get_hf_model_files(
                 model_name, ModelFormat.SAFETENSORS
             )
-            if safetensors_model_files:
+            if (
+                safetensors_model_files
+                and AQUA_MODEL_ARTIFACT_CONFIG in safetensors_model_files
+            ):
                 hf_download_config_present = True
             gguf_model_files = self.get_hf_model_files(model_name, ModelFormat.GGUF)
         else:
@@ -1145,8 +1195,11 @@ class AquaModelApp(AquaApp):
                         Tags.LICENSE: license_value,
                     }
                     validation_result.tags = hf_tags
-                except Exception:
-                    pass
+                except Exception as ex:
+                    logger.debug(
+                        f"An error occurred while getting tag information for model {model_name}. "
+                        f"Error: {str(ex)}"
+                    )
 
         validation_result.model_formats = model_formats
 
@@ -1201,40 +1254,55 @@ class AquaModelApp(AquaApp):
         model_name: str = None,
     ):
         if import_model_details.download_from_hf:
-            # validates config.json exists for safetensors model from hugginface
-            if not hf_download_config_present:
+            # validates config.json exists for safetensors model from huggingface
+            if not (
+                hf_download_config_present
+                or import_model_details.ignore_model_artifact_check
+            ):
                 raise AquaRuntimeError(
                     f"The model {model_name} does not contain {AQUA_MODEL_ARTIFACT_CONFIG} file as required "
                     f"by {ModelFormat.SAFETENSORS.value} format model."
                     f" Please check if the model name is correct in Hugging Face repository."
                 )
+            validation_result.telemetry_model_name = model_name
         else:
+            # validate if config.json is available from object storage, and get model name for telemetry
+            model_config = None
             try:
                 model_config = load_config(
                     file_path=import_model_details.os_path,
                     config_file_name=AQUA_MODEL_ARTIFACT_CONFIG,
                 )
             except Exception as ex:
-                logger.error(
-                    f"Exception occurred while loading config file from {import_model_details.os_path}"
-                    f"Exception message: {ex}"
-                )
-                raise AquaRuntimeError(
+                message = (
                     f"The model path {import_model_details.os_path} does not contain the file config.json. "
                     f"Please check if the path is correct or the model artifacts are available at this location."
-                ) from ex
-            else:
+                )
+                if not import_model_details.ignore_model_artifact_check:
+                    logger.error(
+                        f"{message}\n"
+                        f"Details: {ex.reason if isinstance(ex, AquaFileNotFoundError) else str(ex)}"
+                    )
+                    raise AquaRuntimeError(message) from ex
+                else:
+                    logger.warning(
+                        f"{message}\n"
+                        f"Proceeding with model registration as ignore_model_artifact_check field is set."
+                    )
+
+            if verified_model:
+                # model_type validation, log message if metadata field doesn't match.
                 try:
                     metadata_model_type = verified_model.custom_metadata_list.get(
                         AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE
                     ).value
-                    if metadata_model_type:
+                    if metadata_model_type and model_config is not None:
                         if AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE in model_config:
                             if (
                                 model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE]
                                 != metadata_model_type
                             ):
-                                raise AquaRuntimeError(
+                                logger.debug(
                                     f"The {AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE} attribute in {AQUA_MODEL_ARTIFACT_CONFIG}"
                                     f" at {import_model_details.os_path} is invalid, expected {metadata_model_type} for "
                                     f"the model {model_name}. Please check if the path is correct or "
@@ -1246,22 +1314,26 @@ class AquaModelApp(AquaApp):
                                 f"Could not find {AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE} attribute in "
                                 f"{AQUA_MODEL_ARTIFACT_CONFIG}. Proceeding with model registration."
                             )
-                except Exception:
-                    pass
-                if verified_model:
-                    validation_result.telemetry_model_name = verified_model.display_name
-                elif (
-                    model_config is not None
-                    and AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME in model_config
-                ):
-                    validation_result.telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME]}"
-                elif (
-                    model_config is not None
-                    and AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE in model_config
-                ):
-                    validation_result.telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE]}"
-                else:
-                    validation_result.telemetry_model_name = AQUA_MODEL_TYPE_CUSTOM
+                except Exception as ex:
+                    # todo: raise exception if model_type doesn't match. Currently log message and pass since service
+                    #   models do not have this metadata.
+                    logger.debug(
+                        f"Error occurred while processing metadata for model {model_name}. "
+                        f"Exception: {str(ex)}"
+                    )
+                validation_result.telemetry_model_name = verified_model.display_name
+            elif (
+                model_config is not None
+                and AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME in model_config
+            ):
+                validation_result.telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME]}"
+            elif (
+                model_config is not None
+                and AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE in model_config
+            ):
+                validation_result.telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE]}"
+            else:
+                validation_result.telemetry_model_name = AQUA_MODEL_TYPE_CUSTOM
 
     @staticmethod
     def _validate_gguf_format(
@@ -1363,6 +1435,10 @@ class AquaModelApp(AquaApp):
             allow_patterns=allow_patterns,
             ignore_patterns=ignore_patterns,
         )
+        # Upload to object storage and skip .cache/huggingface/ folder
+        logger.debug(
+            f"Uploading local artifacts from local directory {local_dir} to {os_path}."
+        )
         # Upload to object storage
         model_artifact_path = upload_folder(
             os_path=os_path,
@@ -1409,6 +1485,7 @@ class AquaModelApp(AquaApp):
             import_model_details.model.startswith("ocid")
             and "datasciencemodel" in import_model_details.model
         ):
+            logger.info(f"Fetching details for model {import_model_details.model}.")
             verified_model = DataScienceModel.from_id(import_model_details.model)
         else:
             # If users passes model name, check if there is model with the same name in the service model catalog. If it is there, then use that model
@@ -1446,7 +1523,6 @@ class AquaModelApp(AquaApp):
             ).rstrip("/")
         else:
             artifact_path = import_model_details.os_path.rstrip("/")
-
         # Create Model catalog entry with pass by reference
         ds_model = self._create_model_catalog_entry(
             os_path=artifact_path,
@@ -1539,7 +1615,7 @@ class AquaModelApp(AquaApp):
         elif model_type == ModelType.BASE:
             filter_tag = Tags.BASE_MODEL_CUSTOM
         else:
-            raise ValueError(
+            raise AquaValueError(
                 f"Model of type {model_type} is unknown. The values should be in {ModelType.values()}"
             )
 
@@ -1579,7 +1655,10 @@ class AquaModelApp(AquaApp):
         oci_model = self.ds_client.get_model(model_id).data
         artifact_path = get_artifact_path(oci_model.custom_metadata_list)
         if not artifact_path:
-            raise AquaRuntimeError("Failed to get artifact path from custom metadata.")
+            raise AquaRuntimeError(
+                f"License could not be loaded. Failed to get artifact path from custom metadata for"
+                f"the model {model_id}."
+            )
 
         content = str(
             read_file(
@@ -1610,6 +1689,9 @@ class AquaModelApp(AquaApp):
 
         for aqua_model_summary in aqua_model_list:
             if aqua_model_summary.name.lower() == model_id_lower:
+                logger.info(
+                    f"Found matching verified model id {aqua_model_summary.id} for the model {model_id}"
+                )
                 return aqua_model_summary.id
 
         return None