oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.9rc1__py3-none-any.whl

ads/llm/requirements.txt

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

ads/llm/serialize.py

@@ -0,0 +1,219 @@
+#!/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

@@ -0,0 +1,153 @@
+#!/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

@@ -0,0 +1,27 @@
+#!/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

@@ -0,0 +1,155 @@
+# 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

@@ -0,0 +1,130 @@
+{%- 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 %}