oracle-ads 2.13.8__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

ads/llm/requirements.txt

@@ -1,3 +0,0 @@
-langchain>=0.3
-pydantic>=2,<3
-typing-extensions>=4.2.0

ads/llm/serialize.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2023 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 os
-import tempfile
-from typing import Any, Dict, List, Optional
-
-import fsspec
-import yaml
-from langchain import llms
-from langchain.chains.loading import load_chain_from_config
-from langchain.llms import loading
-from langchain.load.load import Reviver
-from langchain.load.serializable import Serializable
-from langchain.schema.runnable import RunnableParallel
-
-from ads.common.auth import default_signer
-from ads.common.object_storage_details import ObjectStorageDetails
-from ads.llm import OCIModelDeploymentVLLM, OCIModelDeploymentTGI
-from ads.llm.chain import GuardrailSequence
-from ads.llm.guardrails.base import CustomGuardrailBase
-from ads.llm.serializers.runnable_parallel import RunnableParallelSerializer
-from ads.llm.serializers.retrieval_qa import RetrievalQASerializer
-
-# This is a temp solution for supporting custom LLM in legacy load_chain
-__lc_llm_dict = llms.get_type_to_cls_dict()
-__lc_llm_dict[OCIModelDeploymentTGI.__name__] = lambda: OCIModelDeploymentTGI
-__lc_llm_dict[OCIModelDeploymentVLLM.__name__] = lambda: OCIModelDeploymentVLLM
-
-
-def __new_type_to_cls_dict():
-    return __lc_llm_dict
-
-
-llms.get_type_to_cls_dict = __new_type_to_cls_dict
-loading.get_type_to_cls_dict = __new_type_to_cls_dict
-
-
-# Mapping class to custom serialization functions
-custom_serialization = {
-    GuardrailSequence: GuardrailSequence.save,
-    CustomGuardrailBase: CustomGuardrailBase.save,
-    RunnableParallel: RunnableParallelSerializer.save,
-}
-
-# Mapping _type to custom deserialization functions
-# Note that the load function should take **kwargs
-custom_deserialization = {
-    GuardrailSequence.type(): GuardrailSequence.load,
-    CustomGuardrailBase.type(): CustomGuardrailBase.load,
-    RunnableParallelSerializer.type(): RunnableParallelSerializer.load,
-    RetrievalQASerializer.type(): RetrievalQASerializer.load,
-}
-
-
-def load(
-    obj: Any,
-    *,
-    secrets_map: Optional[Dict[str, str]] = None,
-    valid_namespaces: Optional[List[str]] = None,
-    **kwargs,
-) -> Any:
-    """Revive an ADS/LangChain class from a JSON object. Use this if you already
-    have a parsed JSON object, eg. from `json.load` or `json.loads`.
-
-    This is a drop in replacement for load() in langchain.load.load to support loading compatible class from ADS.
-
-    Args:
-        obj: The object to load.
-        secrets_map: A map of secrets to load.
-        valid_namespaces: A list of additional namespaces (modules)
-            to allow to be deserialized.
-
-    Returns:
-        Revived LangChain objects.
-    """
-    # Add ADS as valid namespace
-    if not valid_namespaces:
-        valid_namespaces = []
-    if "ads" not in valid_namespaces:
-        valid_namespaces.append("ads")
-
-    reviver = Reviver(secrets_map, valid_namespaces)
-
-    def _load(obj: Any) -> Any:
-        if isinstance(obj, dict):
-            if "_type" in obj and obj["_type"] in custom_deserialization:
-                if valid_namespaces:
-                    kwargs["valid_namespaces"] = valid_namespaces
-                if secrets_map:
-                    kwargs["secret_map"] = secrets_map
-                return custom_deserialization[obj["_type"]](obj, **kwargs)
-            # Need to revive leaf nodes before reviving this node
-            loaded_obj = {k: _load(v) for k, v in obj.items()}
-            return reviver(loaded_obj)
-        if isinstance(obj, list):
-            return [_load(o) for o in obj]
-        return obj
-
-    if isinstance(obj, dict) and "_type" in obj:
-        obj_type = obj["_type"]
-        # Check if the object has custom load function.
-        if obj_type in custom_deserialization:
-            if valid_namespaces:
-                kwargs["valid_namespaces"] = valid_namespaces
-            if secrets_map:
-                kwargs["secret_map"] = secrets_map
-            return custom_deserialization[obj_type](obj, **kwargs)
-        # Legacy chain
-        return load_chain_from_config(obj, **kwargs)
-
-    return _load(obj)
-
-
-def load_from_yaml(
-    uri: str,
-    *,
-    secrets_map: Optional[Dict[str, str]] = None,
-    valid_namespaces: Optional[List[str]] = None,
-    **kwargs,
-):
-    """Revive an ADS/LangChain class from a YAML file."""
-
-    class _SafeLoaderIgnoreUnknown(yaml.SafeLoader):
-        """Loader ignoring unknown tags in YAML"""
-
-        def ignore_unknown(self, node):
-            """Ignores unknown tags in YAML"""
-            return node.value[0].value
-
-    _SafeLoaderIgnoreUnknown.add_constructor(
-        None, _SafeLoaderIgnoreUnknown.ignore_unknown
-    )
-
-    storage_options = default_signer() if ObjectStorageDetails.is_oci_path(uri) else {}
-
-    with fsspec.open(uri, **storage_options) as f:
-        config = yaml.load(f, Loader=_SafeLoaderIgnoreUnknown)
-
-    return load(
-        config, secrets_map=secrets_map, valid_namespaces=valid_namespaces, **kwargs
-    )
-
-
-def default(obj: Any) -> Any:
-    """Calls the to_json() method to serialize the object.
-
-    Parameters
-    ----------
-    obj : Any
-        The object to be serialized.
-
-    Returns
-    -------
-    Any
-        The serialized representation of the object.
-
-    Raises
-    ------
-    TypeError
-        If the object is not LangChain serializable.
-    """
-    for super_class, save_fn in custom_serialization.items():
-        if isinstance(obj, super_class):
-            return save_fn(obj)
-    if isinstance(obj, Serializable) and obj.is_lc_serializable():
-        return obj.to_json()
-    raise TypeError(f"Serialization of {type(obj)} is not supported.")
-
-
-def __save(obj):
-    """Calls the legacy save method to save the object to temp json
-    then load it into a dictionary.
-    """
-    try:
-        temp_file = tempfile.NamedTemporaryFile(
-            mode="w", encoding="utf-8", suffix=".json", delete=False
-        )
-        temp_file.close()
-        obj.save(temp_file.name)
-        with open(temp_file.name, "r", encoding="utf-8") as f:
-            return json.load(f)
-    finally:
-        os.unlink(temp_file.name)
-
-
-def dump(obj: Any) -> Dict[str, Any]:
-    """Return a json dict representation of an object.
-
-    This is a drop in replacement of the dumpd() in langchain.load.dump
-    to support serializing legacy LangChain chain and ADS GuardrailSequence.
-
-    This method will raise TypeError when the object is not serializable.
-    """
-    for super_class, save_fn in custom_serialization.items():
-        if isinstance(obj, super_class):
-            return save_fn(obj)
-    if (
-        isinstance(obj, Serializable)
-        and not obj.is_lc_serializable()
-        and hasattr(obj, "save")
-    ):
-        # The object is not is_lc_serializable.
-        # However, it supports the legacy save() method.
-        return __save(obj)
-    # The object is is_lc_serializable.
-    # However, some properties may not be serializable
-    # Here we try to dump the object and fallback to the save() method
-    # if there is an error.
-    try:
-        return json.loads(json.dumps(obj, default=default))
-    except TypeError as ex:
-        if isinstance(obj, Serializable) and hasattr(obj, "save"):
-            return __save(obj)
-        raise ex

ads/llm/serializers/retrieval_qa.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# Copyright (c) 2023 Oracle and/or its affiliates.
-# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-import base64
-import json
-import os
-from copy import deepcopy
-from langchain.load import dumpd
-from langchain.chains.loading import load_chain_from_config
-from langchain.vectorstores import FAISS, OpenSearchVectorSearch
-
-
-class OpenSearchVectorDBSerializer:
-    """
-    Serializer for OpenSearchVectorSearch class
-    """
-
-    @staticmethod
-    def type():
-        return OpenSearchVectorSearch.__name__
-
-    @staticmethod
-    def load(config: dict, **kwargs):
-        from ads.llm.serialize import load
-
-        config["kwargs"]["embedding_function"] = load(
-            config["kwargs"]["embedding_function"], **kwargs
-        )
-        return OpenSearchVectorSearch(
-            **config["kwargs"],
-            http_auth=(
-                os.environ.get("OCI_OPENSEARCH_USERNAME", None),
-                os.environ.get("OCI_OPENSEARCH_PASSWORD", None),
-            ),
-            verify_certs=True
-            if os.environ.get("OCI_OPENSEARCH_VERIFY_CERTS", None) == "True"
-            else False,
-            ca_certs=os.environ.get("OCI_OPENSEARCH_CA_CERTS", None),
-        )
-
-    @staticmethod
-    def save(obj):
-        from ads.llm.serialize import dump
-        from opensearchpy.client import OpenSearch
-
-        serialized = dumpd(obj)
-        serialized["type"] = "constructor"
-        serialized["_type"] = OpenSearchVectorDBSerializer.type()
-        kwargs = {}
-        for component_name, component in obj.__dict__.items():
-            if component_name == "client":
-                if isinstance(component, OpenSearch):
-                    client_info = component.transport.hosts[0]
-                    opensearch_url = (
-                        f"https://{client_info['host']}:{client_info['port']}"
-                    )
-                    kwargs.update({"opensearch_url": opensearch_url})
-                else:
-                    raise NotImplementedError("Only support OpenSearch client.")
-                continue
-            kwargs[component_name] = dump(component)
-        serialized["kwargs"] = kwargs
-        return serialized
-
-
-class FaissSerializer:
-    """
-    Serializer for OpenSearchVectorSearch class
-    """
-
-    @staticmethod
-    def type():
-        return FAISS.__name__
-
-    @staticmethod
-    def load(config: dict, **kwargs):
-        from ads.llm.serialize import load
-
-        embedding_function = load(config["embedding_function"], **kwargs)
-        decoded_pkl = base64.b64decode(json.loads(config["vectordb"]))
-        return FAISS.deserialize_from_bytes(
-            embeddings=embedding_function, serialized=decoded_pkl
-        )  # Load the index
-
-    @staticmethod
-    def save(obj):
-        from ads.llm.serialize import dump
-
-        serialized = {}
-        serialized["_type"] = FaissSerializer.type()
-        pkl = obj.serialize_to_bytes()
-        # Encoding bytes to a base64 string
-        encoded_pkl = base64.b64encode(pkl).decode("utf-8")
-        # Serializing the base64 string
-        serialized["vectordb"] = json.dumps(encoded_pkl)
-        serialized["embedding_function"] = dump(obj.__dict__["embedding_function"])
-        return serialized
-
-
-class RetrievalQASerializer:
-    """
-    Serializer for RetrieverQA class
-    """
-
-    # Mapping class to vector store serialization functions
-    vectordb_serialization = {
-        "OpenSearchVectorSearch": OpenSearchVectorDBSerializer,
-        "FAISS": FaissSerializer,
-    }
-
-    @staticmethod
-    def type():
-        return "retrieval_qa"
-
-    @staticmethod
-    def load(config: dict, **kwargs):
-        config_param = deepcopy(config)
-        retriever_kwargs = config_param.pop("retriever_kwargs")
-        vectordb_serializer = RetrievalQASerializer.vectordb_serialization[
-            config_param["vectordb"]["class"]
-        ]
-        vectordb = vectordb_serializer.load(config_param.pop("vectordb"), **kwargs)
-        retriever = vectordb.as_retriever(**retriever_kwargs)
-        return load_chain_from_config(config=config_param, retriever=retriever)
-
-    @staticmethod
-    def save(obj):
-        serialized = obj.dict()
-        retriever_kwargs = {}
-        for key, val in obj.retriever.__dict__.items():
-            if key not in ["tags", "metadata", "vectorstore"]:
-                retriever_kwargs[key] = val
-        serialized["retriever_kwargs"] = retriever_kwargs
-        serialized["vectordb"] = {"class": obj.retriever.vectorstore.__class__.__name__}
-
-        vectordb_serializer = RetrievalQASerializer.vectordb_serialization[
-            serialized["vectordb"]["class"]
-        ]
-        serialized["vectordb"].update(
-            vectordb_serializer.save(obj.retriever.vectorstore)
-        )
-
-        if (
-            serialized["vectordb"]["class"]
-            not in RetrievalQASerializer.vectordb_serialization
-        ):
-            raise NotImplementedError(
-                f"VectorDBSerializer for {serialized['vectordb']['class']} is not implemented."
-            )
-        return serialized

ads/llm/serializers/runnable_parallel.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*--
-
-# 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/
-
-from langchain.schema.runnable import RunnableParallel
-from langchain.load.dump import dumpd
-from langchain.load.load import load
-
-
-class RunnableParallelSerializer:
-    @staticmethod
-    def type():
-        return RunnableParallel.__name__
-
-    @staticmethod
-    def load(config: dict, **kwargs):
-        steps = config.get("kwargs", dict()).get("steps", dict())
-        steps = {k: load(v, **kwargs) for k, v in steps.items()}
-        return RunnableParallel(**steps)
-
-    @staticmethod
-    def save(obj):
-        serialized = dumpd(obj)
-        serialized["_type"] = RunnableParallelSerializer.type()
-        return serialized

ads/llm/templates/score_chain.jinja2

@@ -1,155 +0,0 @@
-# score.py {{SCORE_VERSION}} generated by ADS {{ADS_VERSION}} on {{time_created}}
-import os
-import sys
-import json
-from functools import lru_cache
-from ads import set_auth
-from ads.llm.deploy import ChainDeployment
-from ads.llm.chain import LOG_ADS_GUARDRAIL_INFO
-from ads.config import OCI_RESOURCE_PRINCIPAL_VERSION
-
-if OCI_RESOURCE_PRINCIPAL_VERSION:
-    set_auth("resource_principal")
-
-if LOG_ADS_GUARDRAIL_INFO not in os.environ:
-    os.environ[LOG_ADS_GUARDRAIL_INFO] = "1"
-
-
-"""
-   Inference script. This script is used for prediction by scoring server when schema is known.
-"""
-
-
-@lru_cache(maxsize=10)
-def load_model():
-    """
-    Loads model from the yaml
-
-    Returns
-    -------
-    model:  a model instance on which predict API can be invoked
-    """
-    chain_yaml_path = os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),
-        "chain.yaml"
-    )
-    return ChainDeployment.load_chain(chain_yaml_path)
-
-@lru_cache(maxsize=1)
-def fetch_data_type_from_schema(input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
-    """
-    Returns data type information fetch from input_schema.json.
-
-    Parameters
-    ----------
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data_type: data type fetch from input_schema.json.
-
-    """
-    data_type = {}
-    if os.path.exists(input_schema_path):
-        schema = json.load(open(input_schema_path))
-        for col in schema['schema']:
-            data_type[col['name']] = col['dtype']
-    else:
-        print("input_schema has to be passed in in order to recover the same data type. pass `X_sample` in `ads.model.framework.sklearn_model.SklearnModel.prepare` function to generate the input_schema. Otherwise, the data type might be changed after serialization/deserialization.")
-    return data_type
-
-def deserialize(data, input_schema_path):
-    """
-    Deserialize json serialization data to data in original type when sent to predict.
-
-    Parameters
-    ----------
-    data: serialized input data.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data: deserialized input data.
-
-    """
-{% if data_deserializer == "json" %}
-    import pandas as pd
-    import numpy as np
-    import base64
-    from io import BytesIO
-    if isinstance(data, bytes):
-        return data
-
-    data_type = data.get('data_type', '') if isinstance(data, dict) else ''
-    json_data = data.get('data', data) if isinstance(data, dict) else data
-
-    if "numpy.ndarray" in data_type:
-        load_bytes = BytesIO(base64.b64decode(json_data.encode('utf-8')))
-        return np.load(load_bytes, allow_pickle=True)
-    if "pandas.core.series.Series" in data_type:
-        return pd.Series(json_data)
-    if "pandas.core.frame.DataFrame" in data_type or isinstance(json_data, str):
-        return pd.read_json(json_data, dtype=fetch_data_type_from_schema(input_schema_path))
-    if isinstance(json_data, dict):
-        return pd.DataFrame.from_dict(json_data)
-
-    return json_data
-
-{% elif data_deserializer == "cloudpickle" %}
-    import cloudpickle
-    from pickle import UnpicklingError
-    deserialized_data = data
-    try:
-        deserialized_data = cloudpickle.loads(data)
-    except TypeError:
-        pass
-    except UnpicklingError:
-        logger.warning(
-            "bytes are passed directly to the model. If the model expects a specific data format, you need to write the conversion logic in `deserialize()` yourself."
-        )
-
-    return deserialized_data
-
-{% else %}
-    # Add further data deserialization if needed
-    return data
-{% endif %}
-
-def pre_inference(data, input_schema_path):
-    """
-    Preprocess data
-
-    Parameters
-    ----------
-    data: Data format as expected by the predict API of the core estimator.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data: Data format after any processing.
-
-    """
-    return deserialize(data, input_schema_path)
-
-def predict(data, model=load_model(), input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
-    """
-    Returns prediction given the model and data to predict
-
-    Parameters
-    ----------
-    model: Model instance returned by load_model API.
-    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Pandas DataFrame.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    predictions: Output from scoring server
-        Format: {'prediction': output from model.predict method}
-
-    """
-    features = pre_inference(data, input_schema_path)
-    output = model.invoke(features)
-    # Return the output as is if the output is a dictionary
-    if isinstance(output, dict):
-        return output
-    return {'output': output}

ads/llm/templates/tool_chat_template_hermes.jinja

@@ -1,130 +0,0 @@
-{%- macro json_to_python_type(json_spec) %}
-    {%- set basic_type_map = {
-    "string": "str",
-    "number": "float",
-    "integer": "int",
-    "boolean": "bool"
-} %}
-
-    {%- if basic_type_map[json_spec.type] is defined %}
-        {{- basic_type_map[json_spec.type] }}
-    {%- elif json_spec.type == "array" %}
-        {{- "list[" +  json_to_python_type(json_spec|items) + "]" }}
-    {%- elif json_spec.type == "object" %}
-        {%- if json_spec.additionalProperties is defined %}
-            {{- "dict[str, " + json_to_python_type(json_spec.additionalProperties) + ']' }}
-        {%- else %}
-            {{- "dict" }}
-        {%- endif %}
-    {%- elif json_spec.type is iterable %}
-        {{- "Union[" }}
-        {%- for t in json_spec.type %}
-            {{- json_to_python_type({"type": t}) }}
-            {%- if not loop.last %}
-                {{- "," }}
-            {%- endif %}
-        {%- endfor %}
-        {{- "]" }}
-    {%- else %}
-        {{- "Any" }}
-    {%- endif %}
-{%- endmacro %}
-
-
-{{- bos_token }}
-{{- "<|im_start|>system\nYou are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> " }}
-{%- if tools is iterable and tools | length > 0 %}
-    {%- for tool in tools %}
-        {%- if tool.function is defined %}
-            {%- set tool = tool.function %}
-        {%- endif %}
-        {{- '{"type": "function", "function": ' }}
-        {{- '{"name": "' + tool.name + '", ' }}
-        {{- '"description": "' + tool.name + '(' }}
-        {%- for param_name, param_fields in tool.parameters.properties|items %}
-            {{- param_name + ": " + json_to_python_type(param_fields) }}
-            {%- if not loop.last %}
-                {{- ", " }}
-            {%- endif %}
-        {%- endfor %}
-        {{- ")" }}
-        {%- if tool.return is defined %}
-            {{- " -> " + json_to_python_type(tool.return) }}
-        {%- endif %}
-        {{- " - " + tool.description + "\n\n" }}
-        {%- for param_name, param_fields in tool.parameters.properties|items %}
-            {%- if loop.first %}
-                {{- "    Args:\n" }}
-            {%- endif %}
-            {{- "        " + param_name + "(" + json_to_python_type(param_fields) + "): " + param_fields.description|trim }}
-        {%- endfor %}
-        {%- if tool.return is defined and tool.return.description is defined %}
-            {{- "\n    Returns:\n        " + tool.return.description }}
-        {%- endif %}
-        {{- '"' }}
-        {{- ', "parameters": ' }}
-        {%- if tool.parameters.properties | length == 0 %}
-            {{- "{}" }}
-        {%- else %}
-            {{- tool.parameters|tojson }}
-        {%- endif %}
-        {{- "}" }}
-        {%- if not loop.last %}
-            {{- "\n" }}
-        {%- endif %}
-    {%- endfor %}
-{%- endif %}
-{{- " </tools>" }}
-{{- 'Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
-' }}
-{{- "For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
-" }}
-{{- "<tool_call>
-" }}
-{{- '{"name": <function-name>, "arguments": <args-dict>}
-' }}
-{{- '</tool_call><|im_end|>' }}
-{%- for message in messages %}
-    {%- if message.role == "user" or message.role == "system" or (message.role == "assistant" and message.tool_calls is not defined) %}
-        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
-    {%- elif message.role == "assistant" and message.tool_calls is defined %}
-        {{- '<|im_start|>' + message.role }}
-        {%- for tool_call in message.tool_calls %}
-            {{- '\n<tool_call>\n' }}
-            {%- if tool_call.function is defined %}
-                {%- set tool_call = tool_call.function %}
-            {%- endif %}
-            {{- '{' }}
-            {{- '"name": "' }}
-            {{- tool_call.name }}
-            {{- '"' }}
-            {%- if tool_call.arguments is defined %}
-                {{- ', ' }}
-                {{- '"arguments": ' }}
-                {{- tool_call.arguments|tojson }}
-            {%- endif %}
-            {{- '}' }}
-            {{- '\n</tool_call>' }}
-        {%- endfor %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == "tool" %}
-        {%- if loop.previtem and loop.previtem.role != "tool" %}
-            {{- '<|im_start|>tool\n' }}
-        {%- endif %}
-        {{- '<tool_response>\n' }}
-        {{- message.content }}
-        {%- if not loop.last %}
-            {{- '\n</tool_response>\n' }}
-        {%- else %}
-            {{- '\n</tool_response>' }}
-        {%- endif %}
-        {%- if not loop.last and loop.nextitem.role != "tool" %}
-            {{- '<|im_end|>' }}
-        {%- elif loop.last %}
-            {{- '<|im_end|>' }}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-{%- endif %}