camel-ai 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

camel/configs/openai_config.py

@@ -0,0 +1,132 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import TYPE_CHECKING, Optional, Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
+
+
+@dataclass(frozen=True)
+class ChatGPTConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    OpenAI API.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        logit_bias (dict, optional): Modify the likelihood of specified tokens
+            appearing in the completion. Accepts a json object that maps tokens
+            (specified by their token ID in the tokenizer) to an associated
+            bias value from :obj:`-100` to :obj:`100`. Mathematically, the bias
+            is added to the logits generated by the model prior to sampling.
+            The exact effect will vary per model, but values between:obj:` -1`
+            and :obj:`1` should decrease or increase likelihood of selection;
+            values like :obj:`-100` or :obj:`100` should result in a ban or
+            exclusive selection of the relevant token. (default: :obj:`{}`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+        tools (list[OpenAIFunction], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    presence_penalty: float = 0.0
+    frequency_penalty: float = 0.0
+    logit_bias: dict = field(default_factory=dict)
+    user: str = ""
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[dict[str, str] | str] = None
+
+    def __post_init__(self):
+        if self.tools is not None:
+            object.__setattr__(
+                self,
+                'tools',
+                [tool.get_openai_tool_schema() for tool in self.tools],
+            )
+
+
+OPENAI_API_PARAMS = {param for param in asdict(ChatGPTConfig()).keys()}
+
+
+@dataclass(frozen=True)
+class OpenSourceConfig(BaseConfig):
+    r"""Defines parameters for setting up open-source models and includes
+    parameters to be passed to chat completion function of OpenAI API.
+
+    Args:
+        model_path (str): The path to a local folder containing the model
+            files or the model card in HuggingFace hub.
+        server_url (str): The URL to the server running the model inference
+            which will be used as the API base of OpenAI API.
+        api_params (ChatGPTConfig): An instance of :obj:ChatGPTConfig to
+            contain the arguments to be passed to OpenAI API.
+    """
+
+    model_path: str
+    server_url: str
+    api_params: ChatGPTConfig = field(default_factory=ChatGPTConfig)

camel/embeddings/openai_embedding.py

@@ -11,7 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from typing import Any, List
+import os
+from typing import Any, List, Optional
 
 from openai import OpenAI
 
@@ -26,6 +27,8 @@ class OpenAIEmbedding(BaseEmbedding[str]):
     Args:
         model (OpenAiEmbeddingModel, optional): The model type to be used for
             generating embeddings. (default: :obj:`ModelType.ADA_2`)
+        api_key (Optional[str]): The API key for authenticating with the
+            OpenAI service. (default: :obj:`None`)
 
     Raises:
         RuntimeError: If an unsupported model type is specified.
@@ -34,12 +37,14 @@ class OpenAIEmbedding(BaseEmbedding[str]):
     def __init__(
         self,
         model_type: EmbeddingModelType = EmbeddingModelType.ADA_2,
+        api_key: Optional[str] = None,
     ) -> None:
         if not model_type.is_openai:
             raise ValueError("Invalid OpenAI embedding model type.")
         self.model_type = model_type
         self.output_dim = model_type.output_dim
-        self.client = OpenAI()
+        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        self.client = OpenAI(timeout=60, max_retries=3, api_key=self._api_key)
 
     @api_key_required
     def embed_list(

camel/functions/__init__.py

@@ -11,27 +11,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-
-from ..loaders.unstructured_io import UnstructuredIO
-from .google_maps_function import MAP_FUNCS
-from .math_functions import MATH_FUNCS
+# ruff: noqa: I001
 from .openai_function import (
     OpenAIFunction,
     get_openai_function_schema,
     get_openai_tool_schema,
 )
+
+from .google_maps_function import MAP_FUNCS
+from .math_functions import MATH_FUNCS
+from .open_api_function import OPENAPI_FUNCS
+from .retrieval_functions import RETRIEVAL_FUNCS
 from .search_functions import SEARCH_FUNCS
 from .twitter_function import TWITTER_FUNCS
 from .weather_functions import WEATHER_FUNCS
+from .slack_functions import SLACK_FUNCS
 
 __all__ = [
     'OpenAIFunction',
-    'get_openai_tool_schema',
     'get_openai_function_schema',
+    'get_openai_tool_schema',
+    'MAP_FUNCS',
     'MATH_FUNCS',
+    'OPENAPI_FUNCS',
+    'RETRIEVAL_FUNCS',
     'SEARCH_FUNCS',
-    'WEATHER_FUNCS',
-    'MAP_FUNCS',
     'TWITTER_FUNCS',
-    'UnstructuredIO',
+    'WEATHER_FUNCS',
+    'SLACK_FUNCS',
 ]

camel/functions/open_api_function.py

@@ -0,0 +1,380 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import json
+import os
+from typing import Any, Callable, Dict, List, Tuple
+
+import prance
+import requests
+
+from camel.functions import OpenAIFunction
+from camel.types import OpenAPIName
+
+
+def parse_openapi_file(openapi_spec_path: str) -> Dict[str, Any]:
+    r"""Load and parse an OpenAPI specification file.
+
+    This function utilizes the `prance.ResolvingParser` to parse and resolve
+    the given OpenAPI specification file, returning the parsed OpenAPI
+    specification as a dictionary.
+
+    Args:
+        openapi_spec_path (str): The file path or URL to the OpenAPI
+            specification.
+
+    Returns:
+        Dict[str, Any]: The parsed OpenAPI specification as a dictionary.
+    """
+    # Load the OpenAPI spec
+    parser = prance.ResolvingParser(openapi_spec_path)
+    openapi_spec = parser.specification
+    return openapi_spec
+
+
+def openapi_spec_to_openai_schemas(
+    api_name: str, openapi_spec: Dict[str, Any]
+) -> List[Dict[str, Any]]:
+    r"""Convert OpenAPI specification to OpenAI schema format.
+
+    This function iterates over the paths and operations defined in an
+    OpenAPI specification, filtering out deprecated operations. For each
+    operation, it constructs a schema in a format suitable for OpenAI,
+    including operation metadata such as function name, description,
+    parameters, and request bodies. It raises a ValueError if an operation
+    lacks a description or summary.
+
+    Args:
+        api_name (str): The name of the API, used to prefix generated function
+            names.
+        openapi_spec (Dict[str, Any]): The OpenAPI specification as a
+            dictionary.
+
+    Returns:
+        List[Dict[str, Any]]: A list of dictionaries, each representing a
+            function in the OpenAI schema format, including details about the
+            function's name, description, and parameters.
+
+    Raises:
+        ValueError: If an operation in the OpenAPI specification does not have
+            a description or summary.
+
+    Note:
+        This function assumes that the OpenAPI specification follows the 3.0+
+            format.
+
+    Reference:
+        https://swagger.io/specification/
+    """
+    result = []
+
+    for path, path_item in openapi_spec.get('paths', {}).items():
+        for method, op in path_item.items():
+            if op.get('deprecated') is True:
+                continue
+
+            # Get the function name from the operationId
+            # or construct it from the API method, and path
+            function_name = f"{api_name}"
+            operation_id = op.get('operationId')
+            if operation_id:
+                function_name += f"_{operation_id}"
+            else:
+                function_name += f"{method}{path.replace('/', '_')}"
+
+            description = op.get('description') or op.get('summary')
+            if not description:
+                raise ValueError(
+                    f"{method} {path} Operation from {api_name} "
+                    f"does not have a description or summary."
+                )
+            description += " " if description[-1] != " " else ""
+            description += f"This function is from {api_name} API. "
+
+            # If the OpenAPI spec has a description,
+            # add it to the operation description
+            if 'description' in openapi_spec.get('info', {}):
+                description += f"{openapi_spec['info']['description']}"
+
+            # Get the parameters for the operation, if any
+            params = op.get('parameters', [])
+            properties: Dict[str, Any] = {}
+            required = []
+
+            for param in params:
+                if not param.get('deprecated', False):
+                    param_name = param['name'] + '_in_' + param['in']
+                    properties[param_name] = {}
+
+                    if 'description' in param:
+                        properties[param_name]['description'] = param[
+                            'description'
+                        ]
+
+                    if 'schema' in param:
+                        if (
+                            properties[param_name].get('description')
+                            and 'description' in param['schema']
+                        ):
+                            param['schema'].pop('description')
+                        properties[param_name].update(param['schema'])
+
+                    if param.get('required'):
+                        required.append(param_name)
+
+                    # If the property dictionary does not have a description,
+                    # use the parameter name as the description
+                    if 'description' not in properties[param_name]:
+                        properties[param_name]['description'] = param['name']
+
+                    if 'type' not in properties[param_name]:
+                        properties[param_name]['type'] = 'Any'
+
+            # Process requestBody if present
+            if 'requestBody' in op:
+                properties['requestBody'] = {}
+                requestBody = op['requestBody']
+                if requestBody.get('required') is True:
+                    required.append('requestBody')
+
+                content = requestBody.get('content', {})
+                json_content = content.get('application/json', {})
+                json_schema = json_content.get('schema', {})
+                if json_schema:
+                    properties['requestBody'] = json_schema
+                if 'description' not in properties['requestBody']:
+                    properties['requestBody']['description'] = (
+                        "The request body, with parameters specifically "
+                        "described under the `properties` key"
+                    )
+
+            function = {
+                "type": "function",
+                "function": {
+                    "name": function_name,
+                    "description": description,
+                    "parameters": {
+                        "type": "object",
+                        "properties": properties,
+                        "required": required,
+                    },
+                },
+            }
+            result.append(function)
+
+    return result  # Return the result list
+
+
+def openapi_function_decorator(
+    base_url: str, path: str, method: str, operation: Dict[str, Any]
+) -> Callable:
+    r"""Decorate a function to make HTTP requests based on OpenAPI operation
+    details.
+
+    This decorator takes the base URL, path, HTTP method, and operation details
+    from an OpenAPI specification, and returns a decorator. The decorated
+    function can then be called with keyword arguments corresponding to the
+    operation's parameters. The decorator handles constructing the request URL,
+    setting headers, query parameters, and the request body as specified by the
+    operation details.
+
+    Args:
+        base_url (str): The base URL for the API.
+        path (str): The path for the API endpoint, relative to the base URL.
+        method (str): The HTTP method (e.g., 'get', 'post') for the request.
+        operation (Dict[str, Any]): A dictionary containing the OpenAPI
+            operation details, including parameters and request body
+            definitions.
+
+    Returns:
+        Callable: A decorator that, when applied to a function, enables the
+            function to make HTTP requests based on the provided OpenAPI
+            operation details.
+    """
+
+    def inner_decorator(openapi_function: Callable) -> Callable:
+        def wrapper(**kwargs):
+            request_url = f"{base_url.rstrip('/')}/{path.lstrip('/')}"
+            headers = {}
+            params = {}
+            cookies = {}
+
+            # Assign parameters to the correct position
+            for param in operation.get('parameters', []):
+                input_param_name = param['name'] + '_in_' + param['in']
+                # Irrelevant arguments does not affect function operation
+                if input_param_name in kwargs:
+                    if param['in'] == 'path':
+                        request_url = request_url.replace(
+                            f"{{{param['name']}}}",
+                            str(kwargs[input_param_name]),
+                        )
+                    elif param['in'] == 'query':
+                        params[param['name']] = kwargs[input_param_name]
+                    elif param['in'] == 'header':
+                        headers[param['name']] = kwargs[input_param_name]
+                    elif param['in'] == 'cookie':
+                        cookies[param['name']] = kwargs[input_param_name]
+
+            if 'requestBody' in operation:
+                request_body = kwargs.get('requestBody', {})
+                content_type_list = list(
+                    operation.get('requestBody', {}).get('content', {}).keys()
+                )
+                if content_type_list:
+                    content_type = content_type_list[0]
+                    headers.update({"Content-Type": content_type})
+
+                # send the request body based on the Content-Type
+                if content_type == "application/json":
+                    response = requests.request(
+                        method.upper(),
+                        request_url,
+                        params=params,
+                        headers=headers,
+                        cookies=cookies,
+                        json=request_body,
+                    )
+                else:
+                    raise ValueError(
+                        f"Unsupported content type: {content_type}"
+                    )
+            else:
+                # If there is no requestBody, no request body is sent
+                response = requests.request(
+                    method.upper(),
+                    request_url,
+                    params=params,
+                    headers=headers,
+                    cookies=cookies,
+                )
+
+            try:
+                return response.json()
+            except json.JSONDecodeError:
+                raise ValueError(
+                    "Response could not be decoded as JSON. "
+                    "Please check the input parameters."
+                )
+
+        return wrapper
+
+    return inner_decorator
+
+
+def generate_openapi_funcs(
+    api_name: str, openapi_spec: Dict[str, Any]
+) -> List[Callable]:
+    r"""Generates a list of Python functions based on an OpenAPI specification.
+
+    This function dynamically creates a list of callable functions that
+    represent the API operations defined in an OpenAPI specification document.
+    Each function is designed to perform an HTTP request corresponding to an
+    API operation (e.g., GET, POST) as defined in the specification. The
+    functions are decorated with `openapi_function_decorator`, which
+    configures them to construct and send the HTTP requests with appropriate
+    parameters, headers, and body content.
+
+    Args:
+        api_name (str): The name of the API, used to prefix generated function
+            names.
+        openapi_spec (Dict[str, Any]): The OpenAPI specification as a
+            dictionary.
+
+    Returns:
+        List[Callable]: A list containing the generated functions. Each
+            function, when called, will make an HTTP request according to its
+            corresponding API operation defined in the OpenAPI specification.
+
+    Raises:
+        ValueError: If the OpenAPI specification does not contain server
+            information, which is necessary for determining the base URL for
+            the API requests.
+    """
+    # Check server information
+    servers = openapi_spec.get('servers', [])
+    if not servers:
+        raise ValueError("No server information found in OpenAPI spec.")
+    base_url = servers[0].get('url')  # Use the first server URL
+
+    functions = []
+
+    # Traverse paths and methods
+    for path, methods in openapi_spec.get('paths', {}).items():
+        for method, operation in methods.items():
+            # Get the function name from the operationId
+            # or construct it from the API method, and path
+            operation_id = operation.get('operationId')
+            if operation_id:
+                function_name = f"{api_name}_{operation_id}"
+            else:
+                sanitized_path = path.replace('/', '_').strip('_')
+                function_name = f"{api_name}_{method}_{sanitized_path}"
+
+            @openapi_function_decorator(base_url, path, method, operation)
+            def openapi_function(**kwargs):
+                pass
+
+            openapi_function.__name__ = function_name
+
+            functions.append(openapi_function)
+
+    return functions
+
+
+def combine_all_funcs_schemas() -> Tuple[List[Callable], List[Dict[str, Any]]]:
+    r"""Combines functions and schemas from multiple OpenAPI specifications.
+
+    Iterates over a list of OpenAPI specs, parses each, and generates functions
+    and schemas based on the defined operations and schemas respectively.
+    Assumes specification files are named 'openapi.yaml' located in
+    `open_api_specs/<api_name>/`.
+
+    Returns:
+        Tuple[List[Callable], List[Dict[str, Any]]]:: one of callable
+            functions for API operations, and another of dictionaries
+            representing the schemas from the specifications.
+    """
+    combined_func_lst = []
+    combined_schemas_list = []
+
+    for api_name in OpenAPIName:
+        # Parse the OpenAPI specification for each API
+        current_dir = os.path.dirname(__file__)
+        spec_file_path = os.path.join(
+            current_dir, 'open_api_specs', f'{api_name.value}', 'openapi.yaml'
+        )
+
+        openapi_spec = parse_openapi_file(spec_file_path)
+
+        # Generate and merge function schemas
+        openapi_functions_schemas = openapi_spec_to_openai_schemas(
+            api_name.value, openapi_spec
+        )
+        combined_schemas_list.extend(openapi_functions_schemas)
+
+        # Generate and merge function lists
+        openapi_functions_list = generate_openapi_funcs(
+            api_name.value, openapi_spec
+        )
+        combined_func_lst.extend(openapi_functions_list)
+
+    return combined_func_lst, combined_schemas_list
+
+
+combined_funcs_lst, combined_schemas_list = combine_all_funcs_schemas()
+
+OPENAPI_FUNCS: List[OpenAIFunction] = [
+    OpenAIFunction(a_func, a_schema)
+    for a_func, a_schema in zip(combined_funcs_lst, combined_schemas_list)
+]

camel/functions/open_api_specs/coursera/__init__.py

@@ -0,0 +1,13 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========

camel/functions/open_api_specs/coursera/openapi.yaml

@@ -0,0 +1,82 @@
+openapi: 3.0.1
+info:
+  title: Search API
+  version: v1
+  description: Find recommendation for courses, specializations, and degrees on Coursera.
+servers:
+  - url: https://www.coursera.org
+    description: API schema for search APIs exposed to 3rd party services (e.g. OpenAI)
+tags:
+  - name: SearchV1Controller
+    description: the Search V1 Controller API
+paths:
+  /api/rest/v1/search:
+    post:
+      summary:
+        A public API that searches the Coursera catalog for products (e.g. courses) that
+        are relevant to the provided query string.
+      tags:
+        - search-v1-controller
+      operationId:
+        search
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SearchQuery'
+        required: true
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SearchResponse'
+components:
+  schemas:
+    SearchQuery:
+      type: object
+      properties:
+        query:
+          type: string
+      required:
+        - query
+      example:
+        query: machine learning
+    SearchResponse:
+      properties:
+        hits:
+          type: array
+          items:
+            $ref: '#/components/schemas/SearchHit'
+    SearchHit:
+      type: object
+      properties:
+        name:
+          type: string
+        partners:
+          type: array
+          items:
+            type: string
+        duration:
+          type: string
+        partnerLogos:
+          type: array
+          items:
+            type: string
+        productDifficultyLevel:
+          type: string
+        entityType:
+          type: string
+        avgProductRating:
+          type: string
+        skills:
+          type: string
+        imageUrl:
+          type: string
+        isCourseFree:
+          type: string
+        isPartOfCourseraPlus:
+          type: string
+        objectUrl:
+          type: string