oracle-ads 2.12.9__py3-none-any.whl → 2.12.10__py3-none-any.whl

ads/aqua/modeldeployment/deployment.py

@@ -1,8 +1,7 @@
 #!/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/
 
-import logging
 import shlex
 from typing import Dict, List, Optional, Union
 
@@ -271,7 +270,7 @@ class AquaDeploymentApp(AquaApp):
                     f"field. Either re-register the model with custom container URI, or set container_image_uri "
                     f"parameter when creating this deployment."
                 ) from err
-        logging.info(
+        logger.info(
             f"Aqua Image used for deploying {aqua_model.id} : {container_image_uri}"
         )
 
@@ -282,14 +281,14 @@ class AquaDeploymentApp(AquaApp):
             default_cmd_var = shlex.split(cmd_var_string)
             if default_cmd_var:
                 cmd_var = validate_cmd_var(default_cmd_var, cmd_var)
-            logging.info(f"CMD used for deploying {aqua_model.id} :{cmd_var}")
+            logger.info(f"CMD used for deploying {aqua_model.id} :{cmd_var}")
         except ValueError:
-            logging.debug(
+            logger.debug(
                 f"CMD will be ignored for this deployment as {AQUA_DEPLOYMENT_CONTAINER_CMD_VAR_METADATA_NAME} "
                 f"key is not available in the custom metadata field for this model."
             )
         except Exception as e:
-            logging.error(
+            logger.error(
                 f"There was an issue processing CMD arguments. Error: {str(e)}"
             )
 
@@ -385,7 +384,7 @@ class AquaDeploymentApp(AquaApp):
                     if key not in env_var:
                         env_var.update(env)
 
-        logging.info(f"Env vars used for deploying {aqua_model.id} :{env_var}")
+        logger.info(f"Env vars used for deploying {aqua_model.id} :{env_var}")
 
         # Start model deployment
         # configure model deployment infrastructure
@@ -440,10 +439,14 @@ class AquaDeploymentApp(AquaApp):
             .with_runtime(container_runtime)
         ).deploy(wait_for_completion=False)
 
+        deployment_id = deployment.dsc_model_deployment.id
+        logger.info(
+            f"Aqua model deployment {deployment_id} created for model {aqua_model.id}."
+        )
         model_type = (
             AQUA_MODEL_TYPE_CUSTOM if is_fine_tuned_model else AQUA_MODEL_TYPE_SERVICE
         )
-        deployment_id = deployment.dsc_model_deployment.id
+
         # we arbitrarily choose last 8 characters of OCID to identify MD in telemetry
         telemetry_kwargs = {"ocid": get_ocid_substring(deployment_id, key_len=8)}
 
@@ -539,6 +542,9 @@ class AquaDeploymentApp(AquaApp):
                         value=state,
                     )
 
+        logger.info(
+            f"Fetched {len(results)} model deployments from compartment_id={compartment_id}."
+        )
         # tracks number of times deployment listing was called
         self.telemetry.record_event_async(category="aqua/deployment", action="list")
 
@@ -546,18 +552,21 @@ class AquaDeploymentApp(AquaApp):
 
     @telemetry(entry_point="plugin=deployment&action=delete", name="aqua")
     def delete(self, model_deployment_id: str):
+        logger.info(f"Deleting model deployment {model_deployment_id}.")
         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):
+        logger.info(f"Deactivating model deployment {model_deployment_id}.")
         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):
+        logger.info(f"Activating model deployment {model_deployment_id}.")
         return self.ds_client.activate_model_deployment(
             model_deployment_id=model_deployment_id
         ).data
@@ -579,6 +588,8 @@ class AquaDeploymentApp(AquaApp):
         AquaDeploymentDetail:
             The instance of the Aqua model deployment details.
         """
+        logger.info(f"Fetching model deployment details for {model_deployment_id}.")
+
         model_deployment = self.ds_client.get_model_deployment(
             model_deployment_id=model_deployment_id, **kwargs
         ).data
@@ -594,7 +605,8 @@ class AquaDeploymentApp(AquaApp):
 
         if not oci_aqua:
             raise AquaRuntimeError(
-                f"Target deployment {model_deployment_id} is not Aqua deployment."
+                f"Target deployment {model_deployment_id} is not Aqua deployment as it does not contain "
+                f"{Tags.AQUA_TAG} tag."
             )
 
         log_id = ""
@@ -652,7 +664,7 @@ class AquaDeploymentApp(AquaApp):
         config = self.get_config(model_id, AQUA_MODEL_DEPLOYMENT_CONFIG)
         if not config:
             logger.debug(
-                f"Deployment config for custom model: {model_id} is not available."
+                f"Deployment config for custom model: {model_id} is not available. Use defaults."
             )
         return config
 

ads/cli.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2021, 2024 Oracle and/or its affiliates.
+# Copyright (c) 2021, 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 logging
 import sys
 import traceback
-from dataclasses import is_dataclass
+import uuid
 
 import fire
+from pydantic import BaseModel
 
 from ads.common import logger
 
@@ -27,7 +28,7 @@ except Exception as ex:
     )
     logger.debug(ex)
     logger.debug(traceback.format_exc())
-    exit()
+    sys.exit()
 
 # https://packaging.python.org/en/latest/guides/single-sourcing-package-version/#single-sourcing-the-package-version
 if sys.version_info >= (3, 8):
@@ -84,7 +85,13 @@ def serialize(data):
         The string representation of each dataclass object.
     """
     if isinstance(data, list):
-        [print(str(item)) for item in data]
+        for item in data:
+            if isinstance(item, BaseModel):
+                print(json.dumps(item.dict(), indent=4))
+            else:
+                print(str(item))
+    elif isinstance(data, BaseModel):
+        print(json.dumps(data.dict(), indent=4))
     else:
         print(str(data))
 
@@ -122,8 +129,9 @@ def exit_program(ex: Exception, logger: "logging.Logger") -> None:
     ...     exit_program(e, logger)
     """
 
-    logger.debug(traceback.format_exc())
-    logger.error(str(ex))
+    request_id = str(uuid.uuid4())
+    logger.debug(f"Error Request ID: {request_id}\nError: {traceback.format_exc()}")
+    logger.error(f"Error Request ID: {request_id}\n" f"Error: {str(ex)}")
 
     exit_code = getattr(ex, "exit_code", 1)
     logger.error(f"Exit code: {exit_code}")

ads/common/auth.py

@@ -424,7 +424,7 @@ def create_signer(
             "signer": signer,
             "client_kwargs": client_kwargs,
         }
-        logger.info(f"Using authentication signer type {type(signer)}.")
+        logger.debug(f"Using authentication signer type {type(signer)}.")
         return signer_dict
     else:
         signer_args = dict(
@@ -492,7 +492,7 @@ def default_signer(client_kwargs: Optional[Dict] = None) -> Dict:
                 **(client_kwargs or {}),
             },
         }
-        logger.info(f"Using authentication signer type {type(signer)}.")
+        logger.debug(f"Using authentication signer type {type(signer)}.")
         return signer_dict
     else:
         signer_args = dict(
@@ -621,7 +621,7 @@ class APIKey(AuthSignerGenerator):
             )
 
         oci.config.validate_config(configuration)
-        logger.info(f"Using 'api_key' authentication.")
+        logger.debug(f"Using 'api_key' authentication.")
         return {
             "config": configuration,
             "signer": oci.signer.Signer(
@@ -684,7 +684,7 @@ class ResourcePrincipal(AuthSignerGenerator):
             "signer": oci.auth.signers.get_resource_principals_signer(),
             "client_kwargs": self.client_kwargs,
         }
-        logger.info(f"Using 'resource_principal' authentication.")
+        logger.debug(f"Using 'resource_principal' authentication.")
         return signer_dict
 
     @staticmethod
@@ -747,7 +747,7 @@ class InstancePrincipal(AuthSignerGenerator):
             ),
             "client_kwargs": self.client_kwargs,
         }
-        logger.info(f"Using 'instance_principal' authentication.")
+        logger.debug(f"Using 'instance_principal' authentication.")
         return signer_dict
 
 
@@ -814,7 +814,7 @@ class SecurityToken(AuthSignerGenerator):
                 oci.config.from_file(self.oci_config_location, self.oci_key_profile)
             )
 
-        logger.info(f"Using 'security_token' authentication.")
+        logger.debug(f"Using 'security_token' authentication.")
 
         for parameter in self.SECURITY_TOKEN_REQUIRED:
             if parameter not in configuration:
@@ -883,7 +883,7 @@ class SecurityToken(AuthSignerGenerator):
                     )
 
         date_time = datetime.fromtimestamp(time_expired).strftime("%Y-%m-%d %H:%M:%S")
-        logger.info(f"Session is valid until {date_time}.")
+        logger.debug(f"Session is valid until {date_time}.")
 
     def _read_security_token_file(self, security_token_file: str) -> str:
         """Reads security token from file.
@@ -1020,10 +1020,10 @@ class OCIAuthContext:
         """
         if self.profile:
             ads.set_auth(auth=AuthType.API_KEY, profile=self.profile)
-            logger.info(f"OCI profile set to {self.profile}")
+            logger.debug(f"OCI profile set to {self.profile}")
         else:
             ads.set_auth(auth=AuthType.RESOURCE_PRINCIPAL)
-            logger.info(f"OCI auth set to resource principal")
+            logger.debug(f"OCI auth set to resource principal")
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

ads/llm/autogen/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2024, Oracle and/or its affiliates.  All rights reserved.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

ads/llm/autogen/constants.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2024, Oracle and/or its affiliates.  All rights reserved.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+
+class Events:
+    KEY = "event_name"
+
+    EXCEPTION = "exception"
+    LLM_CALL = "llm_call"
+    TOOL_CALL = "tool_call"
+    NEW_AGENT = "new_agent"
+    NEW_CLIENT = "new_client"
+    RECEIVED_MESSAGE = "received_message"
+    SESSION_START = "logging_session_start"
+    SESSION_STOP = "logging_session_stop"

ads/llm/autogen/reports/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2024, Oracle and/or its affiliates.  All rights reserved.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

ads/llm/autogen/reports/base.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2024, Oracle and/or its affiliates.  All rights reserved.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+import json
+import logging
+import os
+
+from jinja2 import Environment, FileSystemLoader
+
+logger = logging.getLogger(__name__)
+
+
+class BaseReport:
+    """Base class containing utilities for generating reports."""
+
+    @staticmethod
+    def format_json_string(s) -> str:
+        """Formats the JSON string in markdown."""
+        return f"```json\n{json.dumps(json.loads(s), indent=2)}\n```"
+
+    @staticmethod
+    def _parse_date_time(datetime_string: str):
+        """Parses a datetime string in the logs into date and time.
+        Keeps only the seconds in the time.
+        """
+        date_str, time_str = datetime_string.split(" ", 1)
+        time_str = time_str.split(".", 1)[0]
+        return date_str, time_str
+
+    @staticmethod
+    def _preview_message(message: str, max_length=30) -> str:
+        """Shows the beginning part of a string message."""
+        # Return the entire string if it is less than the max_length
+        if len(message) <= max_length:
+            return message
+        # Go backward until we find the first whitespace
+        idx = 30
+        while not message[idx].isspace() and idx > 0:
+            idx -= 1
+        # If we found a whitespace
+        if idx > 0:
+            return message[:idx] + "..."
+        # If we didn't find a whitespace
+        return message[:30] + "..."
+
+    @classmethod
+    def _render_template(cls, template_path, **kwargs) -> str:
+        """Render Jinja template with kwargs."""
+        template_dir = os.path.join(os.path.dirname(__file__), "templates")
+        environment = Environment(
+            loader=FileSystemLoader(template_dir), autoescape=True
+        )
+        template = environment.get_template(template_path)
+        try:
+            html = template.render(**kwargs)
+        except Exception:
+            logger.error(
+                "Unable to render template %s with data:\n%s",
+                template_path,
+                str(kwargs),
+            )
+            return cls._render_template(
+                template_path=template_path,
+                sender=kwargs.get("sender", "N/A"),
+                content="TEMPLATE RENDER ERROR",
+                timestamp=kwargs.get("timestamp", ""),
+            )
+        return html

ads/llm/autogen/reports/data.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# 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/
+"""Contains the data structure for logging and reporting."""
+import copy
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Optional, Union
+
+from ads.llm.autogen.constants import Events
+
+
+@dataclass
+class LogData:
+    """Base class for the data field of LogRecord."""
+
+    def to_dict(self):
+        """Convert the log data to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class LogRecord:
+    """Represents a log record.
+
+    The `data` field is for pre-defined structured data, which should be an instance of LogData.
+    The `kwargs` field is for freeform key value pairs.
+    """
+
+    session_id: str
+    thread_id: int
+    timestamp: str
+    event_name: str
+    source_id: Optional[int] = None
+    source_name: Optional[str] = None
+    # Structured data for specific type of logs
+    data: Optional[LogData] = None
+    # Freeform data
+    kwargs: dict = field(default_factory=dict)
+
+    def to_dict(self):
+        """Convert the log record to dictionary."""
+        return asdict(self)
+
+    def to_string(self):
+        """Serialize the log record to JSON string."""
+        return json.dumps(self.to_dict(), default=str)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LogRecord":
+        """Initializes a LogRecord object from dictionary."""
+        event_mapping = {
+            Events.NEW_AGENT: AgentData,
+            Events.TOOL_CALL: ToolCallData,
+            Events.LLM_CALL: LLMCompletionData,
+        }
+        if Events.KEY not in data:
+            raise KeyError("event_name not found in data.")
+
+        data = copy.deepcopy(data)
+
+        event_name = data["event_name"]
+        if event_name in event_mapping and data.get("data"):
+            data["data"] = event_mapping[event_name](**data.pop("data"))
+
+        return cls(**data)
+
+
+@dataclass
+class AgentData(LogData):
+    """Represents agent log Data."""
+
+    agent_name: str
+    agent_class: str
+    agent_module: Optional[str] = None
+    is_manager: Optional[bool] = None
+
+
+@dataclass
+class LLMCompletionData(LogData):
+    """Represents LLM completion log data."""
+
+    invocation_id: str
+    request: dict
+    response: dict
+    start_time: str
+    end_time: str
+    cost: Optional[float] = None
+    is_cached: Optional[bool] = None
+
+
+@dataclass
+class ToolCallData(LogData):
+    """Represents tool call log data."""
+
+    tool_name: str
+    start_time: str
+    end_time: str
+    agent_name: str
+    agent_class: str
+    agent_module: Optional[str] = None
+    input_args: dict = field(default_factory=dict)
+    returns: Optional[Union[str, list, dict, tuple]] = None