oracle-ads 2.12.9__py3-none-any.whl → 2.12.10rc0__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/langchain/plugins/chat_models/oci_data_science.py

@@ -769,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
@@ -786,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
@@ -798,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
@@ -812,7 +814,7 @@ 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
@@ -822,15 +824,15 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     """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
@@ -842,7 +844,7 @@ class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
     """Whether to ignore the EOS token and continue generating tokens after
     the EOS token is generated."""
 
-    min_tokens: Optional[int] = 0
+    min_tokens: Optional[int] = None
     """Minimum number of tokens to generate per output sequence before
     EOS or stop_token_ids can be generated"""
 
@@ -851,12 +853,11 @@ 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.

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.
 

ads/model/extractor/embedding_onnx_extractor.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+from ads.common.decorator.runtime_dependency import (
+    OptionalDependency,
+    runtime_dependency,
+)
+from ads.model.extractor.model_info_extractor import ModelInfoExtractor
+from ads.model.model_metadata import Framework
+
+
+class EmbeddingONNXExtractor(ModelInfoExtractor):
+    """Class that extract model metadata from EmbeddingONNXModel models.
+
+    Attributes
+    ----------
+    model: object
+        The model to extract metadata from.
+
+    Methods
+    -------
+    framework(self) -> str
+        Returns the framework of the model.
+    algorithm(self) -> object
+        Returns the algorithm of the model.
+    version(self) -> str
+        Returns the version of framework of the model.
+    hyperparameter(self) -> dict
+        Returns the hyperparameter of the model.
+    """
+
+    def __init__(self, model=None):
+        self.model = model
+
+    @property
+    def framework(self):
+        """Extracts the framework of the model.
+
+        Returns
+        ----------
+        str:
+           The framework of the model.
+        """
+        return Framework.EMBEDDING_ONNX
+
+    @property
+    def algorithm(self):
+        """Extracts the algorithm of the model.
+
+        Returns
+        ----------
+        object:
+           The algorithm of the model.
+        """
+        return "Embedding_ONNX"
+
+    @property
+    @runtime_dependency(module="onnxruntime", install_from=OptionalDependency.ONNX)
+    def version(self):
+        """Extracts the framework version of the model.
+
+        Returns
+        ----------
+        str:
+           The framework version of the model.
+        """
+        return onnxruntime.__version__
+
+    @property
+    def hyperparameter(self):
+        """Extracts the hyperparameters of the model.
+
+        Returns
+        ----------
+        dict:
+           The hyperparameters of the model.
+        """
+        return None