camel-ai 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

camel/societies/workforce/single_agent_worker.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
+import json
 from typing import Any, List
 
 from colorama import Fore
@@ -87,7 +87,7 @@ class SingleAgentWorker(Worker):
 
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
 
         color = Fore.RED if task_result.failed else Fore.GREEN

camel/societies/workforce/workforce.py

@@ -13,8 +13,8 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
 import asyncio
+import json
 import logging
 from collections import deque
 from typing import Deque, Dict, List, Optional
@@ -289,7 +289,7 @@ class Workforce(BaseNode):
         response = self.coordinator_agent.step(
             req, response_format=TaskAssignResult
         )
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_assign_result = TaskAssignResult(**result_dict)
         return task_assign_result.assignee_id
 
@@ -320,7 +320,7 @@ class Workforce(BaseNode):
             content=prompt,
         )
         response = self.coordinator_agent.step(req, response_format=WorkerConf)
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         new_node_conf = WorkerConf(**result_dict)
 
         new_agent = self._create_new_agent(

camel/storages/object_storages/amazon_s3.py

@@ -17,7 +17,7 @@ from pathlib import Path, PurePath
 from typing import Optional, Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -156,7 +156,7 @@ class AmazonS3Storage(BaseObjectStorage):
             Bucket=self._bucket_name, Key=file_key
         )
         raw_bytes = response["Body"].read()
-        return File.create_file_from_raw_bytes(raw_bytes, filename)
+        return create_file_from_raw_bytes(raw_bytes, filename)
 
     def _upload_file(
         self, local_file_path: Path, remote_file_key: str

camel/storages/object_storages/azure_blob.py

@@ -16,7 +16,7 @@ from pathlib import Path, PurePath
 from typing import Optional, Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -123,7 +123,7 @@ class AzureBlobStorage(BaseObjectStorage):
             File: The object from the container.
         """
         raw_bytes = self._client.download_blob(file_key).readall()
-        file = File.create_file_from_raw_bytes(raw_bytes, filename)
+        file = create_file_from_raw_bytes(raw_bytes, filename)
         return file
 
     def _upload_file(

camel/storages/object_storages/google_cloud.py

@@ -15,7 +15,7 @@ from pathlib import Path, PurePath
 from typing import Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -111,7 +111,7 @@ class GoogleCloudStorage(BaseObjectStorage):
             File: The object from the S3 bucket.
         """
         raw_bytes = self._client.get_blob(file_key).download_as_bytes()
-        return File.create_file_from_raw_bytes(raw_bytes, filename)
+        return create_file_from_raw_bytes(raw_bytes, filename)
 
     def _upload_file(
         self, local_file_path: Path, remote_file_key: str

camel/toolkits/__init__.py

@@ -41,6 +41,7 @@ from .open_api_toolkit import OpenAPIToolkit
 from .retrieval_toolkit import RetrievalToolkit
 from .notion_toolkit import NotionToolkit
 from .human_toolkit import HumanToolkit
+from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 
 __all__ = [
@@ -70,5 +71,6 @@ __all__ = [
     'ArxivToolkit',
     'HumanToolkit',
     'VideoDownloaderToolkit',
+    'StripeToolkit',
     'MeshyToolkit',
 ]

camel/toolkits/arxiv_toolkit.py

@@ -44,9 +44,9 @@ class ArxivToolkit(BaseToolkit):
             query (str): The search query string used to search for papers on
                 arXiv.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default::obj: `None`)
+                IDs to search for. (default: :obj: `None`)
             max_results (int, optional): The maximum number of search results
-                to retrieve. (default::obj: `5`)
+                to retrieve. (default: :obj: `5`)
 
         Returns:
             Generator: A generator that yields results from the arXiv search
@@ -75,9 +75,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default::obj: `None`)
+                IDs to search for. (default: :obj: `None`)
             max_results (int, optional): The maximum number of search results
-                to return. (default::obj: `5`)
+                to return. (default: :obj: `5`)
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries, each containing
@@ -119,9 +119,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to download. (default::obj: `None`)
+                IDs to download. (default: :obj: `None`)
             max_results (int, optional): The maximum number of search results
-                to download. (default::obj: `5`)
+                to download. (default: :obj: `5`)
             output_dir (str, optional): The directory to save the downloaded
                 PDFs. Defaults to the current directory.
 

camel/toolkits/ask_news_toolkit.py

@@ -228,7 +228,7 @@ class AskNewsToolkit(BaseToolkit):
                 return value. (default: :obj:`"string"`)
             method (Literal["nl", "kw"]): The search method, either "nl" for
                 natural language or "kw" for keyword search.
-                (default::obj:`"kw"`)
+                (default: :obj:`"kw"`)
 
         Returns:
             Union[str, dict, Tuple[str, dict]]: The Reddit search
@@ -523,7 +523,7 @@ class AsyncAskNewsToolkit(BaseToolkit):
                 return value. (default: :obj:"string")
             method (Literal["nl", "kw"]): The search method, either "nl" for
                 natural language or "kw" for keyword search.
-                (default::obj:"kw")
+                (default: :obj:"kw")
 
         Returns:
             Union[str, dict, Tuple[str, dict]]: The Reddit search

camel/toolkits/code_execution.py

@@ -15,6 +15,7 @@ from typing import List, Literal, Optional, Union
 
 from camel.interpreters import (
     DockerInterpreter,
+    E2BInterpreter,
     InternalPythonInterpreter,
     JupyterKernelInterpreter,
     SubprocessInterpreter,
@@ -41,7 +42,7 @@ class CodeExecutionToolkit(BaseToolkit):
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker", "subprocess"
+            "internal_python", "jupyter", "docker", "subprocess", "e2b"
         ] = "internal_python",
         verbose: bool = False,
         unsafe_mode: bool = False,
@@ -58,6 +59,7 @@ class CodeExecutionToolkit(BaseToolkit):
             JupyterKernelInterpreter,
             DockerInterpreter,
             SubprocessInterpreter,
+            E2BInterpreter,
         ]
 
         if sandbox == "internal_python":
@@ -83,6 +85,8 @@ class CodeExecutionToolkit(BaseToolkit):
                 print_stdout=self.verbose,
                 print_stderr=self.verbose,
             )
+        elif sandbox == "e2b":
+            self.interpreter = E2BInterpreter(require_confirm=require_confirm)
         else:
             raise RuntimeError(
                 f"The sandbox type `{sandbox}` is not supported."

camel/toolkits/function_tool.py

@@ -165,9 +165,15 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
     else:
         func_description = short_description
 
+    # OpenAI client.beta.chat.completions.parse for structured output has
+    # additional requirements for the schema, refer:
+    # https://platform.openai.com/docs/guides/structured-outputs/some-type-specific-keywords-are-not-yet-supported#supported-schemas
+    parameters_dict["additionalProperties"] = False
+
     openai_function_schema = {
         "name": func.__name__,
         "description": func_description,
+        "strict": True,
         "parameters": parameters_dict,
     }
 
@@ -175,9 +181,44 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
         "type": "function",
         "function": openai_function_schema,
     }
+
+    openai_tool_schema = sanitize_and_enforce_required(openai_tool_schema)
     return openai_tool_schema
 
 
+def sanitize_and_enforce_required(parameters_dict):
+    r"""Cleans and updates the function schema to conform with OpenAI's
+    requirements:
+    - Removes invalid 'default' fields from the parameters schema.
+    - Ensures all fields or function parameters are marked as required.
+
+    Args:
+        parameters_dict (dict): The dictionary representing the function
+            schema.
+
+    Returns:
+        dict: The updated dictionary with invalid defaults removed and all
+            fields set as required.
+    """
+    # Check if 'function' and 'parameters' exist
+    if (
+        'function' in parameters_dict
+        and 'parameters' in parameters_dict['function']
+    ):
+        # Access the 'parameters' section
+        parameters = parameters_dict['function']['parameters']
+        properties = parameters.get('properties', {})
+
+        # Remove 'default' key from each property
+        for field in properties.values():
+            field.pop('default', None)
+
+        # Mark all keys in 'properties' as required
+        parameters['required'] = list(properties.keys())
+
+    return parameters_dict
+
+
 def generate_docstring(
     code: str,
     model: Optional[BaseModelBackend] = None,

camel/toolkits/github_toolkit.py

@@ -139,7 +139,7 @@ class GithubToolkit(BaseToolkit):
 
         Args:
             state (Literal["open", "closed", "all"]): The state of pull
-                requests to retrieve. (default::obj: `all`)
+                requests to retrieve. (default: :obj: `all`)
                 Options are:
                 - "open": Retrieve only open pull requests.
                 - "closed": Retrieve only closed pull requests.
@@ -179,7 +179,7 @@ class GithubToolkit(BaseToolkit):
 
         Args:
             state (Literal["open", "closed", "all"]): The state of pull
-                requests to retrieve. (default::obj: `all`)
+                requests to retrieve. (default: :obj: `all`)
                 Options are:
                 - "open": Retrieve only open pull requests.
                 - "closed": Retrieve only closed pull requests.
@@ -254,7 +254,7 @@ class GithubToolkit(BaseToolkit):
         Args:
             path (str): The repository path to start the traversal from.
                 empty string means starts from the root directory.
-                (default::obj: `""`)
+                (default: :obj: `""`)
 
         Returns:
             List[str]: A list of file paths within the specified directory

camel/toolkits/google_scholar_toolkit.py

@@ -33,7 +33,11 @@ class GoogleScholarToolkit(BaseToolkit):
     """
 
     def __init__(
-        self, author_identifier: str, is_author_name: bool = False
+        self,
+        author_identifier: str,
+        is_author_name: bool = False,
+        proxy_http: Optional[str] = None,
+        proxy_https: Optional[str] = None,
     ) -> None:
         r"""Initializes the GoogleScholarToolkit with the author's identifier.
 
@@ -42,8 +46,18 @@ class GoogleScholarToolkit(BaseToolkit):
                 of the author to search for.
             is_author_name (bool): Flag to indicate if the identifier is a
                 name. (default: :obj:`False`)
+            proxy_http ( Optional[str]): Proxy http address pass to pg.
+                SingleProxy. (default: :obj:`None`)
+            proxy_https ( Optional[str]): Proxy https address pass to pg.
+                SingleProxy. (default: :obj:`None`)
         """
-        from scholarly import scholarly
+        from scholarly import ProxyGenerator, scholarly
+
+        # Set Proxy is HTTP or HTTPS provided
+        if proxy_http or proxy_https:
+            pg = ProxyGenerator()
+            pg.SingleProxy(http=proxy_http, https=proxy_https)
+            scholarly.use_proxy(pg)
 
         self.scholarly = scholarly
         self.author_identifier = author_identifier

camel/toolkits/math_toolkit.py

@@ -22,44 +22,73 @@ class MathToolkit(BaseToolkit):
     r"""A class representing a toolkit for mathematical operations.
 
     This class provides methods for basic mathematical operations such as
-    addition, subtraction, and multiplication.
+    addition, subtraction, multiplication, division, and rounding.
     """
 
-    def add(self, a: int, b: int) -> int:
+    def add(self, a: float, b: float) -> float:
         r"""Adds two numbers.
 
         Args:
-            a (int): The first number to be added.
-            b (int): The second number to be added.
+            a (float): The first number to be added.
+            b (float): The second number to be added.
 
         Returns:
-            integer: The sum of the two numbers.
+            float: The sum of the two numbers.
         """
         return a + b
 
-    def sub(self, a: int, b: int) -> int:
+    def sub(self, a: float, b: float) -> float:
         r"""Do subtraction between two numbers.
 
         Args:
-            a (int): The minuend in subtraction.
-            b (int): The subtrahend in subtraction.
+            a (float): The minuend in subtraction.
+            b (float): The subtrahend in subtraction.
 
         Returns:
-            integer: The result of subtracting :obj:`b` from :obj:`a`.
+            float: The result of subtracting :obj:`b` from :obj:`a`.
         """
         return a - b
 
-    def mul(self, a: int, b: int) -> int:
-        r"""Multiplies two integers.
+    def multiply(self, a: float, b: float, decimal_places: int = 2) -> float:
+        r"""Multiplies two numbers.
 
         Args:
-            a (int): The multiplier in the multiplication.
-            b (int): The multiplicand in the multiplication.
+            a (float): The multiplier in the multiplication.
+            b (float): The multiplicand in the multiplication.
+            decimal_places (int, optional): The number of decimal
+                places to round to. Defaults to 2.
 
         Returns:
-            integer: The product of the two numbers.
+            float: The product of the two numbers.
         """
-        return a * b
+        return round(a * b, decimal_places)
+
+    def divide(self, a: float, b: float, decimal_places: int = 2) -> float:
+        r"""Divides two numbers.
+
+        Args:
+            a (float): The dividend in the division.
+            b (float): The divisor in the division.
+            decimal_places (int, optional): The number of
+                decimal places to round to. Defaults to 2.
+
+        Returns:
+            float: The result of dividing :obj:`a` by :obj:`b`.
+        """
+        return round(a / b, decimal_places)
+
+    def round(self, a: float, decimal_places: int = 0) -> float:
+        r"""Rounds a number to a specified number of decimal places.
+
+        Args:
+            a (float): The number to be rounded.
+            decimal_places (int, optional): The number of decimal places
+                to round to. Defaults to 0.
+
+        Returns:
+            float: The rounded number.
+        """
+        return round(a, decimal_places)
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
@@ -72,5 +101,7 @@ class MathToolkit(BaseToolkit):
         return [
             FunctionTool(self.add),
             FunctionTool(self.sub),
-            FunctionTool(self.mul),
+            FunctionTool(self.multiply),
+            FunctionTool(self.divide),
+            FunctionTool(self.round),
         ]

camel/toolkits/meshy_toolkit.py

@@ -117,9 +117,9 @@ class MeshyToolkit(BaseToolkit):
         Args:
             task_id (str): The ID of the task to monitor.
             polling_interval (int): Seconds to wait between status checks.
-                (default::obj:`10`)
+                (default: :obj:`10`)
             timeout (int): Maximum seconds to wait before timing out.
-                (default::obj:`3600`)
+                (default: :obj:`3600`)
 
         Returns:
             Dict[str, Any]: Final response from the API when task completes.

camel/toolkits/search_toolkit.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, TypeAlias, Union
 
 import requests
 
@@ -26,7 +26,7 @@ class SearchToolkit(BaseToolkit):
     r"""A class representing a toolkit for web search.
 
     This class provides methods for searching information on the web using
-    search engines like Google, DuckDuckGo, Wikipedia and Wolfram Alpha.
+    search engines like Google, DuckDuckGo, Wikipedia and Wolfram Alpha, Brave.
     """
 
     @dependencies_required("wikipedia")
@@ -151,6 +151,152 @@ class SearchToolkit(BaseToolkit):
         # If no answer found, return an empty list
         return responses
 
+    @api_keys_required("BRAVE_API_KEY")
+    def search_brave(
+        self,
+        q: str,
+        country: str = "US",
+        search_lang: str = "en",
+        ui_lang: str = "en-US",
+        count: int = 20,
+        offset: int = 0,
+        safesearch: str = "moderate",
+        freshness: Optional[str] = None,
+        text_decorations: bool = True,
+        spellcheck: bool = True,
+        result_filter: Optional[str] = None,
+        goggles_id: Optional[str] = None,
+        units: Optional[str] = None,
+        extra_snippets: Optional[bool] = None,
+        summary: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        r"""This function queries the Brave search engine API and returns a
+        dictionary, representing a search result.
+        See https://api.search.brave.com/app/documentation/web-search/query
+        for more details.
+
+        Args:
+            q (str): The user's search query term. Query cannot be empty.
+                Maximum of 400 characters and 50 words in the query.
+            country (str): The search query country where results come from.
+                The country string is limited to 2 character country codes of
+                supported countries. For a list of supported values, see
+                Country Codes. (default: :obj:`US `)
+            search_lang (str): The search language preference. The 2 or more
+                character language code for which search results are provided.
+                For a list of possible values, see Language Codes.
+            ui_lang (str): User interface language preferred in response.
+                Usually of the format '<language_code>-<country_code>'. For
+                more, see RFC 9110. For a list of supported values, see UI
+                Language Codes.
+            count (int): The number of search results returned in response.
+                The maximum is 20. The actual number delivered may be less than
+                requested. Combine this parameter with offset to paginate
+                search results.
+            offset (int): The zero based offset that indicates number of search
+                results per page (count) to skip before returning the result.
+                The maximum is 9. The actual number delivered may be less than
+                requested based on the query. In order to paginate results use
+                this parameter together with count. For example, if your user
+                interface displays 20 search results per page, set count to 20
+                and offset to 0 to show the first page of results. To get
+                subsequent pages, increment offset by 1 (e.g. 0, 1, 2). The
+                results may overlap across multiple pages.
+            safesearch (str): Filters search results for adult content.
+                The following values are supported:
+                - 'off': No filtering is done.
+                - 'moderate': Filters explicit content, like images and videos,
+                    but allows adult domains in the search results.
+                - 'strict': Drops all adult content from search results.
+            freshness (Optional[str]): Filters search results by when they were
+                discovered:
+                - 'pd': Discovered within the last 24 hours.
+                - 'pw': Discovered within the last 7 Days.
+                - 'pm': Discovered within the last 31 Days.
+                - 'py': Discovered within the last 365 Days.
+                - 'YYYY-MM-DDtoYYYY-MM-DD': Timeframe is also supported by
+                    specifying the date range e.g. '2022-04-01to2022-07-30'.
+            text_decorations (bool): Whether display strings (e.g. result
+                snippets) should include decoration markers (e.g. highlighting
+                characters).
+            spellcheck (bool): Whether to spellcheck provided query. If the
+                spellchecker is enabled, the modified query is always used for
+                search. The modified query can be found in altered key from the
+                query response model.
+            result_filter (Optional[str]): A comma delimited string of result
+                types to include in the search response. Not specifying this
+                parameter will return back all result types in search response
+                where data is available and a plan with the corresponding
+                option is subscribed. The response always includes query and
+                type to identify any query modifications and response type
+                respectively. Available result filter values are:
+                - 'discussions'
+                - 'faq'
+                - 'infobox'
+                - 'news'
+                - 'query'
+                - 'summarizer'
+                - 'videos'
+                - 'web'
+                - 'locations'
+            goggles_id (Optional[str]): Goggles act as a custom re-ranking on
+                top of Brave's search index. For more details, refer to the
+                Goggles repository.
+            units (Optional[str]): The measurement units. If not provided,
+                units are derived from search country. Possible values are:
+                - 'metric': The standardized measurement system
+                - 'imperial': The British Imperial system of units.
+            extra_snippets (Optional[bool]): A snippet is an excerpt from a
+                page you get as a result of the query, and extra_snippets
+                allow you to get up to 5 additional, alternative excerpts. Only
+                available under Free AI, Base AI, Pro AI, Base Data, Pro Data
+                and Custom plans.
+            summary (Optional[bool]): This parameter enables summary key
+                generation in web search results. This is required for
+                summarizer to be enabled.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing a search result.
+        """
+
+        import requests
+
+        BRAVE_API_KEY = os.getenv("BRAVE_API_KEY")
+
+        url = "https://api.search.brave.com/res/v1/web/search"
+        headers = {
+            "Content-Type": "application/json",
+            "X-BCP-APIV": "1.0",
+            "X-Subscription-Token": BRAVE_API_KEY,
+        }
+
+        ParamsType: TypeAlias = Dict[
+            str,
+            Union[str, int, float, List[Union[str, int, float]], None],
+        ]
+
+        params: ParamsType = {
+            "q": q,
+            "country": country,
+            "search_lang": search_lang,
+            "ui_lang": ui_lang,
+            "count": count,
+            "offset": offset,
+            "safesearch": safesearch,
+            "freshness": freshness,
+            "text_decorations": text_decorations,
+            "spellcheck": spellcheck,
+            "result_filter": result_filter,
+            "goggles_id": goggles_id,
+            "units": units,
+            "extra_snippets": extra_snippets,
+            "summary": summary,
+        }
+
+        response = requests.get(url, headers=headers, params=params)
+        data = response.json()["web"]
+        return data
+
     @api_keys_required("GOOGLE_API_KEY", "SEARCH_ENGINE_ID")
     def search_google(
         self, query: str, num_result_pages: int = 5
@@ -219,6 +365,11 @@ class SearchToolkit(BaseToolkit):
 
                 # Iterate over 10 results found
                 for i, search_item in enumerate(search_items, start=1):
+                    # Check metatags are present
+                    if "pagemap" not in search_item:
+                        continue
+                    if "metatags" not in search_item["pagemap"]:
+                        continue
                     if (
                         "og:description"
                         in search_item["pagemap"]["metatags"][0]
@@ -265,7 +416,7 @@ class SearchToolkit(BaseToolkit):
             query (str): The query to send to Wolfram Alpha.
             is_detailed (bool): Whether to include additional details
                 including step by step information in the result.
-                (default::obj:`False`)
+                (default: :obj:`False`)
 
         Returns:
             Union[str, Dict[str, Any]]: The result from Wolfram Alpha.
@@ -471,4 +622,5 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.search_duckduckgo),
             FunctionTool(self.query_wolfram_alpha),
             FunctionTool(self.tavily_search),
+            FunctionTool(self.search_brave),
         ]