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

ads/llm/autogen/v02/runtime_logging.py

@@ -0,0 +1,163 @@
+# 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 logging
+import traceback
+from sqlite3 import Connection
+from typing import Any, Dict, List, Optional
+
+import autogen.runtime_logging
+from autogen.logger.base_logger import BaseLogger
+from autogen.logger.logger_factory import LoggerFactory
+
+logger = logging.getLogger(__name__)
+
+
+class LoggerManager(BaseLogger):
+    """Manages multiple AutoGen loggers."""
+
+    def __init__(self) -> None:
+        self.loggers: List[BaseLogger] = []
+        super().__init__()
+
+    def add_logger(self, logger: BaseLogger) -> None:
+        """Adds a new AutoGen logger."""
+        self.loggers.append(logger)
+
+    def _call_loggers(self, method: str, *args, **kwargs) -> None:
+        """Calls the specific method on each AutoGen logger in self.loggers."""
+        for autogen_logger in self.loggers:
+            try:
+                getattr(autogen_logger, method)(*args, **kwargs)
+            except Exception as e:
+                # Catch the logging exception so that the program will not be interrupted.
+                logger.error(
+                    "Failed to %s with %s: %s",
+                    method,
+                    autogen_logger.__class__.__name__,
+                    str(e),
+                )
+                logger.debug(traceback.format_exc())
+
+    def start(self) -> str:
+        """Starts all loggers."""
+        return self._call_loggers("start")
+
+    def stop(self) -> None:
+        self._call_loggers("stop")
+        # Remove the loggers once they are stopped.
+        self.loggers = []
+
+    def get_connection(self) -> None | Connection:
+        return self._call_loggers("get_connection")
+
+    def log_chat_completion(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_chat_completion", *args, **kwargs)
+
+    def log_new_agent(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_new_agent", *args, **kwargs)
+
+    def log_event(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_event", *args, **kwargs)
+
+    def log_new_wrapper(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_new_wrapper", *args, **kwargs)
+
+    def log_new_client(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_new_client", *args, **kwargs)
+
+    def log_function_use(self, *args, **kwargs) -> None:
+        return self._call_loggers("log_function_use", *args, **kwargs)
+
+    def __repr__(self) -> str:
+        return "\n\n".join(
+            [
+                f"{str(logger.__class__)}:\n{logger.__repr__()}"
+                for logger in self.loggers
+            ]
+        )
+
+
+def start(
+    autogen_logger: Optional[BaseLogger] = None,
+    logger_type: str = None,
+    config: Optional[Dict[str, Any]] = None,
+) -> str:
+    """Starts logging with AutoGen logger.
+    Specify your custom autogen_logger, or the logger_type and config to use a built-in logger.
+
+    Parameters
+    ----------
+    autogen_logger : BaseLogger, optional
+        An AutoGen logger, which should be a subclass of autogen.logger.base_logger.BaseLogger.
+    logger_type : str, optional
+        Logger type, which can be a built-in AutoGen logger type ("file", or "sqlite"), by default None.
+    config : dict, optional
+        Configurations for the built-in AutoGen logger, by default None
+
+    Returns
+    -------
+    str
+        A unique session ID returned from starting the logger.
+
+    """
+    if autogen_logger and logger_type:
+        raise ValueError(
+            "Please specify only autogen_logger(%s) or logger_type(%s).",
+            autogen_logger,
+            logger_type,
+        )
+
+    # Check if a logger is already configured
+    existing_logger = autogen.runtime_logging.autogen_logger
+    if not existing_logger:
+        # No logger is configured
+        logger_manager = LoggerManager()
+    elif isinstance(existing_logger, LoggerManager):
+        # Logger is already configured with ADS
+        logger_manager = existing_logger
+    else:
+        # Logger is configured but it is not via ADS
+        logger.warning("AutoGen is already configured with %s", str(existing_logger))
+        logger_manager = LoggerManager()
+        logger_manager.add_logger(existing_logger)
+
+    # Add AutoGen logger
+    if not autogen_logger:
+        autogen_logger = LoggerFactory.get_logger(
+            logger_type=logger_type, config=config
+        )
+    logger_manager.add_logger(autogen_logger)
+
+    try:
+        session_id = autogen_logger.start()
+        autogen.runtime_logging.is_logging = True
+        autogen.runtime_logging.autogen_logger = logger_manager
+    except Exception as e:
+        logger.error(f"Failed to start logging: {e}")
+    return session_id
+
+
+def stop(*loggers) -> BaseLogger:
+    """Stops AutoGen logger.
+    If loggers are managed by LoggerManager,
+    you may specify one or more loggers to be stopped.
+    If no logger is specified, all loggers will be stopped.
+    Stopped loggers will be removed from the LoggerManager.
+    """
+    autogen_logger = autogen.runtime_logging.autogen_logger
+    if isinstance(autogen_logger, LoggerManager) and loggers:
+        for logger in loggers:
+            logger.stop()
+            if logger in autogen_logger.loggers:
+                autogen_logger.loggers.remove(logger)
+    else:
+        autogen.runtime_logging.stop()
+    return autogen_logger
+
+
+def get_loggers() -> List[BaseLogger]:
+    """Gets a list of existing AutoGen loggers."""
+    autogen_logger = autogen.runtime_logging.autogen_logger
+    if isinstance(autogen_logger, LoggerManager):
+        return autogen_logger.loggers
+    return [autogen_logger]

ads/llm/guardrails/base.py

@@ -1,17 +1,16 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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 datetime
 import functools
-import operator
 import importlib.util
+import operator
 import sys
+from typing import Any, List, Optional, Union
 
-from typing import Any, List, Dict, Tuple
 from langchain.schema.prompt import PromptValue
 from langchain.tools.base import BaseTool, ToolException
 from pydantic import BaseModel, model_validator
@@ -207,7 +206,9 @@ class Guardrail(BaseTool):
             return input.to_string()
         return str(input)
 
-    def _to_args_and_kwargs(self, tool_input: Any) -> Tuple[Tuple, Dict]:
+    def _to_args_and_kwargs(
+        self, tool_input: Union[str, dict], tool_call_id: Optional[str]
+    ) -> tuple[tuple, dict]:
         if isinstance(tool_input, dict):
             return (), tool_input
         else:

ads/llm/langchain/plugins/chat_models/oci_data_science.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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/
 """Chat model for OCI data science model deployment endpoint."""
 
@@ -50,6 +49,7 @@ from ads.llm.langchain.plugins.llms.oci_data_science_model_deployment_endpoint i
 )
 
 logger = logging.getLogger(__name__)
+DEFAULT_INFERENCE_ENDPOINT_CHAT = "/v1/chat/completions"
 
 
 def _is_pydantic_class(obj: Any) -> bool:
@@ -93,6 +93,8 @@ class ChatOCIModelDeployment(BaseChatModel, BaseOCIModelDeployment):
     Key init args — client params:
         auth: dict
             ADS auth dictionary for OCI authentication.
+        default_headers: Optional[Dict]
+            The headers to be added to the Model Deployment request.
 
     Instantiate:
         .. code-block:: python
@@ -109,6 +111,10 @@ class ChatOCIModelDeployment(BaseChatModel, BaseOCIModelDeployment):
                     "temperature": 0.2,
                     # other model parameters ...
                 },
+                default_headers={
+                    "route": "/v1/chat/completions",
+                    # other request headers ...
+                },
             )
 
     Invocation:
@@ -291,6 +297,25 @@ class ChatOCIModelDeployment(BaseChatModel, BaseOCIModelDeployment):
             "stream": self.streaming,
         }
 
+    def _headers(
+        self, is_async: Optional[bool] = False, body: Optional[dict] = None
+    ) -> Dict:
+        """Construct and return the headers for a request.
+
+        Args:
+            is_async (bool, optional): Indicates if the request is asynchronous.
+                Defaults to `False`.
+            body (optional): The request body to be included in the headers if
+                the request is asynchronous.
+
+        Returns:
+            Dict: A dictionary containing the appropriate headers for the request.
+        """
+        return {
+            "route": DEFAULT_INFERENCE_ENDPOINT_CHAT,
+            **super()._headers(is_async=is_async, body=body),
+        }
+
     def _generate(
         self,
         messages: List[BaseMessage],
@@ -704,7 +729,7 @@ class ChatOCIModelDeployment(BaseChatModel, BaseOCIModelDeployment):
 
         for choice in choices:
             message = _convert_dict_to_message(choice["message"])
-            generation_info = dict(finish_reason=choice.get("finish_reason"))
+            generation_info = {"finish_reason": choice.get("finish_reason")}
             if "logprobs" in choice:
                 generation_info["logprobs"] = choice["logprobs"]
 
@@ -744,6 +769,8 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     Science Model Deployment endpoint. See:
     https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-policies-auth.htm#model_dep_policies_auth__predict-endpoint
 
+    See https://docs.vllm.ai/en/latest/api/inference_params.html for the defaults of the parameters.
+
     Example:
 
         .. code-block:: python
@@ -761,7 +788,7 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
 
     """  # noqa: E501
 
-    frequency_penalty: float = 0.0
+    frequency_penalty: Optional[float] = None
     """Penalizes repeated tokens according to frequency. Between 0 and 1."""
 
     logit_bias: Optional[Dict[str, float]] = None
@@ -773,7 +800,7 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     n: int = 1
     """Number of output sequences to return for the given prompt."""
 
-    presence_penalty: float = 0.0
+    presence_penalty: Optional[float] = None
     """Penalizes repeated tokens. Between 0 and 1."""
 
     temperature: float = 0.2
@@ -787,25 +814,25 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     (the one with the highest log probability per token).
     """
 
-    use_beam_search: Optional[bool] = False
+    use_beam_search: Optional[bool] = None
     """Whether to use beam search instead of sampling."""
 
     top_k: Optional[int] = -1
     """Number of most likely tokens to consider at each step."""
 
     min_p: Optional[float] = 0.0
-    """Float that represents the minimum probability for a token to be considered. 
+    """Float that represents the minimum probability for a token to be considered.
     Must be in [0,1]. 0 to disable this."""
 
-    repetition_penalty: Optional[float] = 1.0
+    repetition_penalty: Optional[float] = None
     """Float that penalizes new tokens based on their frequency in the
     generated text. Values > 1 encourage the model to use new tokens."""
 
-    length_penalty: Optional[float] = 1.0
+    length_penalty: Optional[float] = None
     """Float that penalizes sequences based on their length. Used only
     when `use_beam_search` is True."""
 
-    early_stopping: Optional[bool] = False
+    early_stopping: Optional[bool] = None
     """Controls the stopping condition for beam search. It accepts the
     following values: `True`, where the generation stops as soon as there
     are `best_of` complete candidates; `False`, where a heuristic is applied
@@ -817,8 +844,8 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     """Whether to ignore the EOS token and continue generating tokens after
     the EOS token is generated."""
 
-    min_tokens: Optional[int] = 0
-    """Minimum number of tokens to generate per output sequence before 
+    min_tokens: Optional[int] = None
+    """Minimum number of tokens to generate per output sequence before
     EOS or stop_token_ids can be generated"""
 
     stop_token_ids: Optional[List[int]] = None
@@ -826,17 +853,16 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     The returned output will contain the stop tokens unless the stop tokens
     are special tokens."""
 
-    skip_special_tokens: Optional[bool] = True
+    skip_special_tokens: Optional[bool] = None
     """Whether to skip special tokens in the output. Defaults to True."""
 
-    spaces_between_special_tokens: Optional[bool] = True
-    """Whether to add spaces between special tokens in the output.
-    Defaults to True."""
+    spaces_between_special_tokens: Optional[bool] = None
+    """Whether to add spaces between special tokens in the output."""
 
     tool_choice: Optional[str] = None
     """Whether to use tool calling.
     Defaults to None, tool calling is disabled.
-    Tool calling requires model support and the vLLM to be configured 
+    Tool calling requires model support and the vLLM to be configured
     with `--tool-call-parser`.
     Set this to `auto` for the model to make tool calls automatically.
     Set this to `required` to force the model to always call one or more tools.
@@ -956,9 +982,9 @@ class ChatOCIModelDeploymentTGI(ChatOCIModelDeployment):
     """Total probability mass of tokens to consider at each step."""
 
     top_logprobs: Optional[int] = None
-    """An integer between 0 and 5 specifying the number of most 
-    likely tokens to return at each token position, each with an 
-    associated log probability. logprobs must be set to true if 
+    """An integer between 0 and 5 specifying the number of most
+    likely tokens to return at each token position, each with an
+    associated log probability. logprobs must be set to true if
     this parameter is used."""
 
     @property

ads/llm/langchain/plugins/llms/oci_data_science_model_deployment_endpoint.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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/
 
 
@@ -24,6 +23,7 @@ from typing import (
 
 import aiohttp
 import requests
+from langchain_community.utilities.requests import Requests
 from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
@@ -34,14 +34,13 @@ from langchain_core.outputs import Generation, GenerationChunk, LLMResult
 from langchain_core.utils import get_from_dict_or_env
 from pydantic import Field, model_validator
 
-from langchain_community.utilities.requests import Requests
-
 logger = logging.getLogger(__name__)
 
 
 DEFAULT_TIME_OUT = 300
 DEFAULT_CONTENT_TYPE_JSON = "application/json"
 DEFAULT_MODEL_NAME = "odsc-llm"
+DEFAULT_INFERENCE_ENDPOINT = "/v1/completions"
 
 
 class TokenExpiredError(Exception):
@@ -86,6 +85,9 @@ class BaseOCIModelDeployment(Serializable):
     max_retries: int = 3
     """Maximum number of retries to make when generating."""
 
+    default_headers: Optional[Dict[str, Any]] = None
+    """The headers to be added to the Model Deployment request."""
+
     @model_validator(mode="before")
     @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
@@ -101,7 +103,7 @@ class BaseOCIModelDeployment(Serializable):
                 "Please install it with `pip install oracle_ads`."
             ) from ex
 
-        if not values.get("auth", None):
+        if not values.get("auth"):
             values["auth"] = ads.common.auth.default_signer()
 
         values["endpoint"] = get_from_dict_or_env(
@@ -125,12 +127,12 @@ class BaseOCIModelDeployment(Serializable):
         Returns:
             Dict: A dictionary containing the appropriate headers for the request.
         """
+        headers = self.default_headers or {}
         if is_async:
             signer = self.auth["signer"]
             _req = requests.Request("POST", self.endpoint, json=body)
             req = _req.prepare()
             req = signer(req)
-            headers = {}
             for key, value in req.headers.items():
                 headers[key] = value
 
@@ -140,7 +142,7 @@ class BaseOCIModelDeployment(Serializable):
                 )
             return headers
 
-        return (
+        headers.update(
             {
                 "Content-Type": DEFAULT_CONTENT_TYPE_JSON,
                 "enable-streaming": "true",
@@ -152,6 +154,8 @@ class BaseOCIModelDeployment(Serializable):
             }
         )
 
+        return headers
+
     def completion_with_retry(
         self, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any
     ) -> Any:
@@ -357,7 +361,7 @@ class BaseOCIModelDeployment(Serializable):
             self.auth["signer"].refresh_security_token()
             return True
         return False
-    
+
     @classmethod
     def is_lc_serializable(cls) -> bool:
         """Return whether this model can be serialized by LangChain."""
@@ -388,6 +392,10 @@ class OCIModelDeploymentLLM(BaseLLM, BaseOCIModelDeployment):
                 model="odsc-llm",
                 streaming=True,
                 model_kwargs={"frequency_penalty": 1.0},
+                headers={
+                    "route": "/v1/completions",
+                    # other request headers ...
+                }
             )
             llm.invoke("tell me a joke.")
 
@@ -477,6 +485,25 @@ class OCIModelDeploymentLLM(BaseLLM, BaseOCIModelDeployment):
             **self._default_params,
         }
 
+    def _headers(
+        self, is_async: Optional[bool] = False, body: Optional[dict] = None
+    ) -> Dict:
+        """Construct and return the headers for a request.
+
+        Args:
+            is_async (bool, optional): Indicates if the request is asynchronous.
+                Defaults to `False`.
+            body (optional): The request body to be included in the headers if
+                the request is asynchronous.
+
+        Returns:
+            Dict: A dictionary containing the appropriate headers for the request.
+        """
+        return {
+            "route": DEFAULT_INFERENCE_ENDPOINT,
+            **super()._headers(is_async=is_async, body=body),
+        }
+
     def _generate(
         self,
         prompts: List[str],
@@ -712,9 +739,9 @@ class OCIModelDeploymentLLM(BaseLLM, BaseOCIModelDeployment):
     def _generate_info(self, choice: dict) -> Any:
         """Extracts generation info from the response."""
         gen_info = {}
-        finish_reason = choice.get("finish_reason", None)
-        logprobs = choice.get("logprobs", None)
-        index = choice.get("index", None)
+        finish_reason = choice.get("finish_reason")
+        logprobs = choice.get("logprobs")
+        index = choice.get("index")
         if finish_reason:
             gen_info.update({"finish_reason": finish_reason})
         if logprobs is not None:

ads/model/__init__.py

@@ -1,29 +1,26 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2021, 2023 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/
 
-from ads.model.generic_model import GenericModel, ModelState
 from ads.model.datascience_model import DataScienceModel
-from ads.model.model_properties import ModelProperties
+from ads.model.deployment.model_deployer import ModelDeployer
+from ads.model.deployment.model_deployment import ModelDeployment
+from ads.model.deployment.model_deployment_properties import ModelDeploymentProperties
 from ads.model.framework.automl_model import AutoMLModel
+from ads.model.framework.embedding_onnx_model import EmbeddingONNXModel
+from ads.model.framework.huggingface_model import HuggingFacePipelineModel
 from ads.model.framework.lightgbm_model import LightGBMModel
 from ads.model.framework.pytorch_model import PyTorchModel
 from ads.model.framework.sklearn_model import SklearnModel
+from ads.model.framework.spark_model import SparkPipelineModel
 from ads.model.framework.tensorflow_model import TensorFlowModel
 from ads.model.framework.xgboost_model import XGBoostModel
-from ads.model.framework.spark_model import SparkPipelineModel
-from ads.model.framework.huggingface_model import HuggingFacePipelineModel
-
-from ads.model.deployment.model_deployer import ModelDeployer
-from ads.model.deployment.model_deployment import ModelDeployment
-from ads.model.deployment.model_deployment_properties import ModelDeploymentProperties
-
+from ads.model.generic_model import GenericModel, ModelState
+from ads.model.model_properties import ModelProperties
+from ads.model.model_version_set import ModelVersionSet, experiment
 from ads.model.serde.common import SERDE
 from ads.model.serde.model_input import ModelInputSerializer
-
-from ads.model.model_version_set import ModelVersionSet, experiment
 from ads.model.service.oci_datascience_model_version_set import (
     ModelVersionSetNotExists,
     ModelVersionSetNotSaved,
@@ -42,6 +39,7 @@ __all__ = [
     "XGBoostModel",
     "SparkPipelineModel",
     "HuggingFacePipelineModel",
+    "EmbeddingONNXModel",
     "ModelDeployer",
     "ModelDeployment",
     "ModelDeploymentProperties",

ads/model/artifact.py

@@ -1,28 +1,28 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+# Copyright (c) 2022, 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 fnmatch
 import importlib
 import os
-import sys
 import shutil
+import sys
 import tempfile
 import uuid
-import fsspec
+from datetime import datetime
 from typing import Dict, Optional, Tuple
+
+import fsspec
+from jinja2 import Environment, PackageLoader
+
+from ads import __version__
 from ads.common import auth as authutil
 from ads.common import logger, utils
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.config import CONDA_BUCKET_NAME, CONDA_BUCKET_NS
 from ads.model.runtime.env_info import EnvInfo, InferenceEnvInfo, TrainingEnvInfo
 from ads.model.runtime.runtime_info import RuntimeInfo
-from jinja2 import Environment, PackageLoader
-import warnings
-from ads import __version__
-from datetime import datetime
 
 MODEL_ARTIFACT_VERSION = "3.0"
 REQUIRED_ARTIFACT_FILES = ("runtime.yaml", "score.py")
@@ -378,6 +378,45 @@ class ModelArtifact:
         ) as f:
             f.write(scorefn_template.render(context))
 
+    def prepare_schema(self, schema_name: str):
+        """Copies schema to artifact directory.
+
+        Parameters
+        ----------
+        schema_name: str
+            The schema name
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        FileExistsError
+            If `schema_name` doesn't exist.
+        """
+        uri_src = os.path.join(
+            os.path.abspath(os.path.join(os.path.dirname(__file__), "..")),
+            "templates",
+            "schemas",
+            f"{schema_name}",
+        )
+
+        if not os.path.exists(uri_src):
+            raise FileExistsError(
+                f"{schema_name} does not exists. "
+                "Ensure the schema name is valid or specify a different one."
+            )
+
+        uri_dst = os.path.join(self.artifact_dir, os.path.basename(uri_src))
+
+        utils.copy_file(
+            uri_src=uri_src,
+            uri_dst=uri_dst,
+            force_overwrite=True,
+            auth=self.auth,
+        )
+
     def reload(self):
         """Syncs the `score.py` to reload the model and predict function.