oracle-ads 2.12.6__tar.gz → 2.12.8__tar.gz

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oracle_ads
-Version: 2.12.6
+Version: 2.12.8
 Summary: Oracle Accelerated Data Science SDK
 Keywords: Oracle Cloud Infrastructure,OCI,Machine Learning,ML,Artificial Intelligence,AI,Data Science,Cloud,Oracle
 Author: Oracle Data Science
@@ -109,7 +109,7 @@ Requires-Dist: py-cpuinfo ; extra == "opctl"
 Requires-Dist: rich ; extra == "opctl"
 Requires-Dist: fire ; extra == "opctl"
 Requires-Dist: cachetools ; extra == "opctl"
-Requires-Dist: huggingface_hub==0.23.4 ; extra == "opctl"
+Requires-Dist: huggingface_hub==0.26.2 ; extra == "opctl"
 Requires-Dist: optuna==2.9.0 ; extra == "optuna"
 Requires-Dist: oracle_ads[viz] ; extra == "optuna"
 Requires-Dist: aiohttp ; extra == "pii"
@@ -130,6 +130,7 @@ Requires-Dist: pyspark>=3.0.0 ; extra == "spark"
 Requires-Dist: oracle_ads[viz] ; extra == "tensorflow"
 Requires-Dist: tensorflow<=2.15.1 ; extra == "tensorflow"
 Requires-Dist: arff ; extra == "testsuite"
+Requires-Dist: autogen-agentchat~=0.2 ; extra == "testsuite"
 Requires-Dist: category_encoders==2.6.3 ; extra == "testsuite"
 Requires-Dist: cohere==4.53 ; extra == "testsuite"
 Requires-Dist: faiss-cpu ; extra == "testsuite"

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/THIRD_PARTY_LICENSES.txt

@@ -24,6 +24,12 @@ autots
 * Source code: https://github.com/winedarksea/AutoTS
 * Project home: https://winedarksea.github.io/AutoTS/build/html/index.html
 
+autogen
+* Copyright (c) 2024 Microsoft Corporation.
+* License: MIT License
+* Source code: https://github.com/microsoft/autogen
+* Project home: microsoft.github.io/autogen/
+
 bokeh
 * Copyright Copyright (c) 2012 - 2021, Anaconda, Inc., and Bokeh Contributors
 * License: BSD 3-Clause "New" or "Revised" License

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/common/utils.py

@@ -788,13 +788,14 @@ def get_ocid_substring(ocid: str, key_len: int) -> str:
     return ocid[-key_len:] if ocid and len(ocid) > key_len else ""
 
 
-def upload_folder(os_path: str, local_dir: str, model_name: str) -> str:
+def upload_folder(os_path: str, local_dir: str, model_name: str, exclude_pattern: str = None) -> str:
     """Upload the local folder to the object storage
 
     Args:
         os_path (str): object storage URI with prefix. This is the path to upload
         local_dir (str): Local directory where the object is downloaded
         model_name (str): Name of the huggingface model
+        exclude_pattern (optional, str): The matching pattern of files to be excluded from uploading.
     Retuns:
         str: Object name inside the bucket
     """
@@ -804,6 +805,8 @@ def upload_folder(os_path: str, local_dir: str, model_name: str) -> str:
     auth_state = AuthState()
     object_path = os_details.filepath.rstrip("/") + "/" + model_name + "/"
     command = f"oci os object bulk-upload --src-dir {local_dir} --prefix {object_path} -bn {os_details.bucket} -ns {os_details.namespace} --auth {auth_state.oci_iam_type} --profile {auth_state.oci_key_profile} --no-overwrite"
+    if exclude_pattern:
+        command += f" --exclude {exclude_pattern}"
     try:
         logger.info(f"Running: {command}")
         subprocess.check_call(shlex.split(command))

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/constants.py

@@ -35,6 +35,7 @@ AQUA_MODEL_ARTIFACT_CONFIG = "config.json"
 AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME = "_name_or_path"
 AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE = "model_type"
 AQUA_MODEL_ARTIFACT_FILE = "model_file"
+HF_METADATA_FOLDER = ".cache/"
 HF_LOGIN_DEFAULT_TIMEOUT = 2
 
 TRAINING_METRICS_FINAL = "training_metrics_final"

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/evaluation/entities.py

@@ -83,7 +83,7 @@ class CreateAquaEvaluationDetails(Serializable):
     ocpus: Optional[float] = None
     log_group_id: Optional[str] = None
     log_id: Optional[str] = None
-    metrics: Optional[List[str]] = None
+    metrics: Optional[List[Dict[str, Any]]] = None
     force_overwrite: Optional[bool] = False
 
     class Config:
@@ -140,7 +140,7 @@ class AquaEvaluationCommands(Serializable):
     evaluation_id: str
     evaluation_target_id: str
     input_data: Dict[str, Any]
-    metrics: List[str]
+    metrics: List[Dict[str, Any]]
     output_dir: str
     params: Dict[str, Any]
 

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/evaluation/evaluation.py

@@ -159,7 +159,8 @@ class AquaEvaluationApp(AquaApp):
                 create_aqua_evaluation_details = CreateAquaEvaluationDetails(**kwargs)
             except Exception as ex:
                 custom_errors = {
-                    ".".join(map(str, e["loc"])): e["msg"] for e in json.loads(ex.json())
+                    ".".join(map(str, e["loc"])): e["msg"]
+                    for e in json.loads(ex.json())
                 }
                 raise AquaValueError(
                     f"Invalid create evaluation parameters. Error details: {custom_errors}."
@@ -619,11 +620,6 @@ class AquaEvaluationApp(AquaApp):
             evaluation_id=evaluation_id,
             evaluation_target_id=evaluation_source_id,
             input_data={
-                "columns": {
-                    "prompt": "prompt",
-                    "completion": "completion",
-                    "category": "category",
-                },
                 "format": Path(dataset_path).suffix,
                 "url": dataset_path,
             },

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/extension/model_handler.py

@@ -129,6 +129,8 @@ class AquaModelHandler(AquaAPIhandler):
             str(input_data.get("download_from_hf", "false")).lower() == "true"
         )
         inference_container_uri = input_data.get("inference_container_uri")
+        allow_patterns = input_data.get("allow_patterns")
+        ignore_patterns = input_data.get("ignore_patterns")
 
         return self.finish(
             AquaModelApp().register(
@@ -141,6 +143,8 @@ class AquaModelHandler(AquaAPIhandler):
                 project_id=project_id,
                 model_file=model_file,
                 inference_container_uri=inference_container_uri,
+                allow_patterns=allow_patterns,
+                ignore_patterns=ignore_patterns,
             )
         )
 

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/model/entities.py

@@ -289,6 +289,8 @@ class ImportModelDetails(CLIBuilderMixin):
     project_id: Optional[str] = None
     model_file: Optional[str] = None
     inference_container_uri: Optional[str] = None
+    allow_patterns: Optional[List[str]] = None
+    ignore_patterns: Optional[List[str]] = None
 
     def __post_init__(self):
         self._command = "model register"

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/model/model.py

@@ -40,6 +40,7 @@ from ads.aqua.constants import (
     AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE,
     AQUA_MODEL_ARTIFACT_FILE,
     AQUA_MODEL_TYPE_CUSTOM,
+    HF_METADATA_FOLDER,
     LICENSE_TXT,
     MODEL_BY_REFERENCE_OSS_PATH_KEY,
     README,
@@ -1274,6 +1275,8 @@ class AquaModelApp(AquaApp):
         model_name: str,
         os_path: str,
         local_dir: str = None,
+        allow_patterns: List[str] = None,
+        ignore_patterns: List[str] = None,
     ) -> str:
         """This helper function downloads the model artifact from Hugging Face to a local folder, then uploads
         to object storage location.
@@ -1283,6 +1286,12 @@ class AquaModelApp(AquaApp):
         model_name (str): The huggingface model name.
         os_path (str): The OS path where the model files are located.
         local_dir (str): The local temp dir to store the huggingface model.
+        allow_patterns (list): Model files matching at least one pattern are downloaded.
+            Example: ["*.json"] will download all .json files. ["folder/*"] will download all files under `folder`.
+            Patterns are Standard Wildcards (globbing patterns) and rules can be found here: https://docs.python.org/3/library/fnmatch.html
+        ignore_patterns (list): Model files matching any of the patterns are not downloaded.
+            Example: ["*.json"] will ignore all .json files. ["folder/*"] will ignore all files under `folder`.
+            Patterns are Standard Wildcards (globbing patterns) and rules can be found here: https://docs.python.org/3/library/fnmatch.html
 
         Returns
         -------
@@ -1293,30 +1302,19 @@ class AquaModelApp(AquaApp):
         if not local_dir:
             local_dir = os.path.join(os.path.expanduser("~"), "cached-model")
         local_dir = os.path.join(local_dir, model_name)
-        retry = 10
-        i = 0
-        huggingface_download_err_message = None
-        while i < retry:
-            try:
-                # Download to cache folder. The while loop retries when there is a network failure
-                snapshot_download(repo_id=model_name)
-            except Exception as e:
-                huggingface_download_err_message = str(e)
-                i += 1
-            else:
-                break
-        if i == retry:
-            raise Exception(
-                f"Could not download the model {model_name} from https://huggingface.co with message {huggingface_download_err_message}"
-            )
         os.makedirs(local_dir, exist_ok=True)
-        # Copy the model from the cache to destination
-        snapshot_download(repo_id=model_name, local_dir=local_dir)
-        # Upload to object storage
+        snapshot_download(
+            repo_id=model_name,
+            local_dir=local_dir,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+        )
+        # Upload to object storage and skip .cache/huggingface/ folder
         model_artifact_path = upload_folder(
             os_path=os_path,
             local_dir=local_dir,
             model_name=model_name,
+            exclude_pattern=f"{HF_METADATA_FOLDER}*"
         )
 
         return model_artifact_path
@@ -1335,6 +1333,12 @@ class AquaModelApp(AquaApp):
                 os_path (str): Object storage destination URI to store the downloaded model. Format: oci://bucket-name@namespace/prefix
                 inference_container (str): selects service defaults
                 finetuning_container (str): selects service defaults
+                allow_patterns (list): Model files matching at least one pattern are downloaded.
+                    Example: ["*.json"] will download all .json files. ["folder/*"] will download all files under `folder`.
+                    Patterns are Standard Wildcards (globbing patterns) and rules can be found here: https://docs.python.org/3/library/fnmatch.html
+                ignore_patterns (list): Model files matching any of the patterns are not downloaded.
+                    Example: ["*.json"] will ignore all .json files. ["folder/*"] will ignore all files under `folder`.
+                    Patterns are Standard Wildcards (globbing patterns) and rules can be found here: https://docs.python.org/3/library/fnmatch.html
 
         Returns:
             AquaModel:
@@ -1381,6 +1385,8 @@ class AquaModelApp(AquaApp):
                 model_name=model_name,
                 os_path=import_model_details.os_path,
                 local_dir=import_model_details.local_dir,
+                allow_patterns=import_model_details.allow_patterns,
+                ignore_patterns=import_model_details.ignore_patterns,
             ).rstrip("/")
         else:
             artifact_path = import_model_details.os_path.rstrip("/")

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/aqua/modeldeployment/deployment.py

@@ -185,7 +185,7 @@ class AquaDeploymentApp(AquaApp):
                 tags[tag] = aqua_model.freeform_tags[tag]
 
         tags.update({Tags.AQUA_MODEL_NAME_TAG: aqua_model.display_name})
-        tags.update({Tags.TASK: aqua_model.freeform_tags.get(Tags.TASK, None)})
+        tags.update({Tags.TASK: aqua_model.freeform_tags.get(Tags.TASK, UNKNOWN)})
 
         # Set up info to get deployment config
         config_source_id = model_id
@@ -533,16 +533,22 @@ class AquaDeploymentApp(AquaApp):
         return results
 
     @telemetry(entry_point="plugin=deployment&action=delete", name="aqua")
-    def delete(self,model_deployment_id:str):
-        return self.ds_client.delete_model_deployment(model_deployment_id=model_deployment_id).data
+    def delete(self, model_deployment_id: str):
+        return self.ds_client.delete_model_deployment(
+            model_deployment_id=model_deployment_id
+        ).data
 
-    @telemetry(entry_point="plugin=deployment&action=deactivate",name="aqua")
-    def deactivate(self,model_deployment_id:str):
-        return self.ds_client.deactivate_model_deployment(model_deployment_id=model_deployment_id).data
+    @telemetry(entry_point="plugin=deployment&action=deactivate", name="aqua")
+    def deactivate(self, model_deployment_id: str):
+        return self.ds_client.deactivate_model_deployment(
+            model_deployment_id=model_deployment_id
+        ).data
 
-    @telemetry(entry_point="plugin=deployment&action=activate",name="aqua")
-    def activate(self,model_deployment_id:str):
-        return self.ds_client.activate_model_deployment(model_deployment_id=model_deployment_id).data
+    @telemetry(entry_point="plugin=deployment&action=activate", name="aqua")
+    def activate(self, model_deployment_id: str):
+        return self.ds_client.activate_model_deployment(
+            model_deployment_id=model_deployment_id
+        ).data
 
     @telemetry(entry_point="plugin=deployment&action=get", name="aqua")
     def get(self, model_deployment_id: str, **kwargs) -> "AquaDeploymentDetail":

oracle_ads-2.12.8/ads/llm/autogen/client_v02.py

@@ -0,0 +1,282 @@
+# coding: utf-8
+# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+"""This module contains the custom LLM client for AutoGen v0.2 to use LangChain chat models.
+https://microsoft.github.io/autogen/0.2/blog/2024/01/26/Custom-Models/
+
+To use the custom client:
+1. Prepare the LLM config, including the parameters for initializing the LangChain client.
+2. Register the custom LLM
+
+The LLM config should config the following keys:
+* model_client_cls: Required by AutoGen to identify the custom client. It should be "LangChainModelClient"
+* langchain_cls: LangChain class including the full import path.
+* model: Name of the model to be used by AutoGen
+* client_params: A dictionary containing the parameters to initialize the LangChain chat model.
+
+Although the `LangChainModelClient` is designed to be generic and can potentially support any LangChain chat model,
+the invocation depends on the server API spec and it may not be compatible with some implementations.
+
+Following is an example config for OCI Generative AI service:
+{
+    "model_client_cls": "LangChainModelClient",
+    "langchain_cls": "langchain_community.chat_models.oci_generative_ai.ChatOCIGenAI",
+    "model": "cohere.command-r-plus",
+    # client_params will be used to initialize the LangChain ChatOCIGenAI class.
+    "client_params": {
+        "model_id": "cohere.command-r-plus",
+        "compartment_id": COMPARTMENT_OCID,
+        "model_kwargs": {"temperature": 0, "max_tokens": 2048},
+        # Update the authentication method as needed
+        "auth_type": "SECURITY_TOKEN",
+        "auth_profile": "DEFAULT",
+        # You may need to specify `service_endpoint` if the service is in a different region.
+    },
+}
+
+Following is an example config for OCI Data Science Model Deployment:
+{
+    "model_client_cls": "LangChainModelClient",
+    "langchain_cls": "ads.llm.ChatOCIModelDeploymentVLLM",
+    "model": "odsc-llm",
+    "endpoint": "https://MODEL_DEPLOYMENT_URL/predict",
+    "model_kwargs": {"temperature": 0.1, "max_tokens": 2048},
+    # function_call_params will only be added to the API call when function/tools are added.
+    "function_call_params": {
+        "tool_choice": "auto",
+        "chat_template": ChatTemplates.mistral(),
+    },
+}
+
+Note that if `client_params` is not specified in the config, all arguments from the config except
+`model_client_cls` and `langchain_cls`, and `function_call_params`, will be used to initialize
+the LangChain chat model.
+
+The `function_call_params` will only be used for function/tool calling when tools are specified.
+
+To register the custom client:
+
+from ads.llm.autogen.client_v02 import LangChainModelClient, register_custom_client
+register_custom_client(LangChainModelClient)
+
+Once registered with ADS, the custom LLM class will be auto-registered for all new agents.
+There is no need to call `register_model_client()` on each agent.
+
+References:
+https://microsoft.github.io/autogen/0.2/docs/notebooks/agentchat_huggingface_langchain/
+https://github.com/microsoft/autogen/blob/0.2/notebook/agentchat_custom_model.ipynb
+
+"""
+import copy
+import importlib
+import json
+import logging
+from typing import Any, Dict, List, Union
+from types import SimpleNamespace
+
+from autogen import ModelClient
+from autogen.oai.client import OpenAIWrapper, PlaceHolderClient
+from langchain_core.messages import AIMessage
+
+
+logger = logging.getLogger(__name__)
+
+# custom_clients is a dictionary mapping the name of the class to the actual class
+custom_clients = {}
+
+# There is a bug in GroupChat when using custom client:
+# https://github.com/microsoft/autogen/issues/2956
+# Here we will be patching the OpenAIWrapper to fix the issue.
+# With this patch, you only need to register the client once with ADS.
+# For example:
+#
+# from ads.llm.autogen.client_v02 import LangChainModelClient, register_custom_client
+# register_custom_client(LangChainModelClient)
+#
+# This patch will auto-register the custom LLM to all new agents.
+# So there is no need to call `register_model_client()` on each agent.
+OpenAIWrapper._original_register_default_client = OpenAIWrapper._register_default_client
+
+
+def _new_register_default_client(
+    self: OpenAIWrapper, config: Dict[str, Any], openai_config: Dict[str, Any]
+) -> None:
+    """This is a patched version of the _register_default_client() method
+    to automatically register custom client for agents.
+    """
+    model_client_cls_name = config.get("model_client_cls")
+    if model_client_cls_name in custom_clients:
+        self._clients.append(PlaceHolderClient(config))
+        self.register_model_client(custom_clients[model_client_cls_name])
+    else:
+        self._original_register_default_client(
+            config=config, openai_config=openai_config
+        )
+
+
+# Patch the _register_default_client() method
+OpenAIWrapper._register_default_client = _new_register_default_client
+
+
+def register_custom_client(client_class):
+    """Registers custom client for AutoGen."""
+    if client_class.__name__ not in custom_clients:
+        custom_clients[client_class.__name__] = client_class
+
+
+def _convert_to_langchain_tool(tool):
+    """Converts the OpenAI tool spec to LangChain tool spec."""
+    if tool["type"] == "function":
+        tool = tool["function"]
+        required = tool["parameters"].get("required", [])
+        properties = copy.deepcopy(tool["parameters"]["properties"])
+        for key in properties.keys():
+            val = properties[key]
+            val["default"] = key in required
+        return {
+            "title": tool["name"],
+            "description": tool["description"],
+            "properties": properties,
+        }
+    raise NotImplementedError(f"Type {tool['type']} is not supported.")
+
+
+def _convert_to_openai_tool_call(tool_call):
+    """Converts the LangChain tool call in AI message to OpenAI tool call."""
+    return {
+        "id": tool_call.get("id"),
+        "function": {
+            "name": tool_call.get("name"),
+            "arguments": (
+                ""
+                if tool_call.get("args") is None
+                else json.dumps(tool_call.get("args"))
+            ),
+        },
+        "type": "function",
+    }
+
+
+class Message(AIMessage):
+    """Represents message returned from the LLM."""
+
+    @classmethod
+    def from_message(cls, message: AIMessage):
+        """Converts from LangChain AIMessage."""
+        message = copy.deepcopy(message)
+        message.__class__ = cls
+        message.tool_calls = [
+            _convert_to_openai_tool_call(tool) for tool in message.tool_calls
+        ]
+        return message
+
+    @property
+    def function_call(self):
+        """Function calls."""
+        return self.tool_calls
+
+
+class LangChainModelClient(ModelClient):
+    """Represents a model client wrapping a LangChain chat model."""
+
+    def __init__(self, config: dict, **kwargs) -> None:
+        super().__init__()
+        logger.info("LangChain model client config: %s", str(config))
+        # Make a copy of the config since we are popping some keys
+        config = copy.deepcopy(config)
+        # model_client_cls will always be LangChainModelClient
+        self.client_class = config.pop("model_client_cls")
+
+        # model_name is used in constructing the response.
+        self.model_name = config.get("model", "")
+
+        # If the config specified function_call_params,
+        # Pop the params and use them only for tool calling.
+        self.function_call_params = config.pop("function_call_params", {})
+
+        # If the config specified invoke_params,
+        # Pop the params and use them only for invoking.
+        self.invoke_params = config.pop("invoke_params", {})
+
+        # Import the LangChain class
+        if "langchain_cls" not in config:
+            raise ValueError("Missing langchain_cls in LangChain Model Client config.")
+        module_cls = config.pop("langchain_cls")
+        module_name, cls_name = str(module_cls).rsplit(".", 1)
+        langchain_module = importlib.import_module(module_name)
+        langchain_cls = getattr(langchain_module, cls_name)
+
+        # If the config specified client_params,
+        # Only use the client_params to initialize the LangChain model.
+        # Otherwise, use the config
+        self.client_params = config.get("client_params", config)
+
+        # Initialize the LangChain client
+        self.model = langchain_cls(**self.client_params)
+
+    def create(self, params) -> ModelClient.ModelClientResponseProtocol:
+        """Creates a LLM completion for a given config.
+
+        Parameters
+        ----------
+        params : dict
+            OpenAI API compatible parameters, including all the keys from llm_config.
+
+        Returns
+        -------
+        ModelClientResponseProtocol
+            Response from LLM
+
+        """
+        streaming = params.get("stream", False)
+        # TODO: num_of_responses
+        num_of_responses = params.get("n", 1)
+        messages = params.pop("messages", [])
+
+        invoke_params = copy.deepcopy(self.invoke_params)
+
+        tools = params.get("tools")
+        if tools:
+            model = self.model.bind_tools(
+                [_convert_to_langchain_tool(tool) for tool in tools]
+            )
+            # invoke_params["tools"] = tools
+            invoke_params.update(self.function_call_params)
+        else:
+            model = self.model
+
+        response = SimpleNamespace()
+        response.choices = []
+        response.model = self.model_name
+
+        if streaming and messages:
+            # If streaming is enabled and has messages, then iterate over the chunks of the response.
+            raise NotImplementedError()
+        else:
+            # If streaming is not enabled, send a regular chat completion request
+            ai_message = model.invoke(messages, **invoke_params)
+            choice = SimpleNamespace()
+            choice.message = Message.from_message(ai_message)
+            response.choices.append(choice)
+        return response
+
+    def message_retrieval(
+        self, response: ModelClient.ModelClientResponseProtocol
+    ) -> Union[List[str], List[ModelClient.ModelClientResponseProtocol.Choice.Message]]:
+        """
+        Retrieve and return a list of strings or a list of Choice.Message from the response.
+
+        NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,
+        since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.
+        """
+        return [choice.message for choice in response.choices]
+
+    def cost(self, response: ModelClient.ModelClientResponseProtocol) -> float:
+        response.cost = 0
+        return 0
+
+    @staticmethod
+    def get_usage(response: ModelClient.ModelClientResponseProtocol) -> Dict:
+        """Return usage summary of the response using RESPONSE_USAGE_KEYS."""
+        return {}

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/opctl/operator/common/utils.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # Copyright (c) 2023, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
@@ -18,7 +17,6 @@ import yaml
 from cerberus import Validator
 
 from ads.opctl import logger, utils
-from ads.opctl.operator import __operators__
 
 CONTAINER_NETWORK = "CONTAINER_NETWORK"
 
@@ -26,7 +24,11 @@ CONTAINER_NETWORK = "CONTAINER_NETWORK"
 class OperatorValidator(Validator):
     """The custom validator class."""
 
-    pass
+    def validate(self, obj_dict, **kwargs):
+        # Model should be case insensitive
+        if "model" in obj_dict["spec"]:
+            obj_dict["spec"]["model"] = str(obj_dict["spec"]["model"]).lower()
+        return super().validate(obj_dict, **kwargs)
 
 
 def create_output_folder(name):
@@ -34,7 +36,7 @@ def create_output_folder(name):
     protocol = fsspec.utils.get_protocol(output_folder)
     storage_options = {}
     if protocol != "file":
-        storage_options = auth or default_signer()
+        storage_options = default_signer()
 
     fs = fsspec.filesystem(protocol, **storage_options)
     name_suffix = 1

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/opctl/operator/lowcode/anomaly/model/base_model.py

@@ -166,9 +166,8 @@ class AnomalyOperatorBaseModel(ABC):
         yaml_appendix = rc.Yaml(self.config.to_dict())
         summary = rc.Block(
             rc.Group(
-                rc.Text(
-                    f"You selected the **`{self.spec.model}`** model.\n{model_description.text}\n"
-                ),
+                rc.Text(f"You selected the **`{self.spec.model}`** model.\n"),
+                model_description,
                 rc.Text(
                     "Based on your dataset, you could have also selected "
                     f"any of the models: `{'`, `'.join(SupportedModels.keys() if self.spec.datetime_column else NonTimeADSupportedModels.keys())}`."

{oracle_ads-2.12.6 → oracle_ads-2.12.8}/ads/opctl/operator/lowcode/anomaly/model/factory.py

@@ -26,9 +26,9 @@ class UnSupportedModelError(Exception):
 
     def __init__(self, operator_config: AnomalyOperatorConfig, model_type: str):
         supported_models = (
-            SupportedModels.values
+            SupportedModels.values()
             if operator_config.spec.datetime_column
-            else NonTimeADSupportedModels.values
+            else NonTimeADSupportedModels.values()
         )
         message = (
             f"Model: `{model_type}` is not supported. "