camel-ai 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

camel/toolkits/code_execution.py

@@ -11,9 +11,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Union
 
-from camel.interpreters import InternalPythonInterpreter
+from camel.interpreters import (
+    DockerInterpreter,
+    E2BInterpreter,
+    InternalPythonInterpreter,
+    JupyterKernelInterpreter,
+    SubprocessInterpreter,
+)
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 
@@ -29,26 +35,58 @@ class CodeExecutionToolkit(BaseToolkit):
             by `eval()` without any security check. (default: :obj:`False`)
         import_white_list ( Optional[List[str]]): A list of allowed imports.
             (default: :obj:`None`)
+        require_confirm (bool): Whether to require confirmation before executing code.
+            (default: :obj:`False`)
     """
 
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker"
+            "internal_python", "jupyter", "docker", "subprocess", "e2b"
         ] = "internal_python",
         verbose: bool = False,
         unsafe_mode: bool = False,
         import_white_list: Optional[List[str]] = None,
+        require_confirm: bool = False,
     ) -> None:
-        # TODO: Add support for docker and jupyter.
         self.verbose = verbose
         self.unsafe_mode = unsafe_mode
         self.import_white_list = import_white_list or list()
+
+        # Type annotation for interpreter to allow all possible types
+        self.interpreter: Union[
+            InternalPythonInterpreter,
+            JupyterKernelInterpreter,
+            DockerInterpreter,
+            SubprocessInterpreter,
+            E2BInterpreter,
+        ]
+
         if sandbox == "internal_python":
             self.interpreter = InternalPythonInterpreter(
                 unsafe_mode=self.unsafe_mode,
                 import_white_list=self.import_white_list,
             )
+        elif sandbox == "jupyter":
+            self.interpreter = JupyterKernelInterpreter(
+                require_confirm=require_confirm,
+                print_stdout=self.verbose,
+                print_stderr=self.verbose,
+            )
+        elif sandbox == "docker":
+            self.interpreter = DockerInterpreter(
+                require_confirm=require_confirm,
+                print_stdout=self.verbose,
+                print_stderr=self.verbose,
+            )
+        elif sandbox == "subprocess":
+            self.interpreter = SubprocessInterpreter(
+                require_confirm=require_confirm,
+                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/human_toolkit.py

@@ -36,6 +36,7 @@ class HumanToolkit(BaseToolkit):
         Returns:
             str: The answer from the human.
         """
+        print(f"Question: {question}")
         logger.info(f"Question: {question}")
         reply = input("Your reply: ")
         logger.info(f"User reply: {reply}")

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

@@ -0,0 +1,185 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import os
+from typing import Any, Dict
+
+import requests
+
+from camel.toolkits.base import BaseToolkit
+from camel.utils import api_keys_required
+
+
+class MeshyToolkit(BaseToolkit):
+    r"""A class representing a toolkit for 3D model generation using Meshy.
+
+    This class provides methods that handle text/image to 3D model
+    generation using Meshy.
+
+    Call the generate_3d_model_complete method to generate a refined 3D model.
+
+    Ref:
+    https://docs.meshy.ai/api-text-to-3d-beta#create-a-text-to-3d-preview-task
+    """
+
+    @api_keys_required("MESHY_API_KEY")
+    def __init__(self):
+        r"""Initializes the MeshyToolkit with the API key from the
+        environment.
+        """
+        self.api_key = os.getenv('MESHY_API_KEY')
+
+    def generate_3d_preview(
+        self, prompt: str, art_style: str, negative_prompt: str
+    ) -> Dict[str, Any]:
+        r"""Generates a 3D preview using the Meshy API.
+
+        Args:
+            prompt (str): Description of the object.
+            art_style (str): Art style for the 3D model.
+            negative_prompt (str): What the model should not look like.
+
+        Returns:
+            Dict[str, Any]: The result property of the response contains the
+                task id of the newly created Text to 3D task.
+        """
+        payload = {
+            "mode": "preview",
+            "prompt": prompt,
+            "art_style": art_style,
+            "negative_prompt": negative_prompt,
+        }
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.post(
+            "https://api.meshy.ai/v2/text-to-3d",
+            headers=headers,
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def refine_3d_model(self, preview_task_id: str) -> Dict[str, Any]:
+        r"""Refines a 3D model using the Meshy API.
+
+        Args:
+            preview_task_id (str): The task ID of the preview to refine.
+
+        Returns:
+            Dict[str, Any]: The response from the Meshy API.
+        """
+        payload = {"mode": "refine", "preview_task_id": preview_task_id}
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.post(
+            "https://api.meshy.ai/v2/text-to-3d",
+            headers=headers,
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_task_status(self, task_id: str) -> Dict[str, Any]:
+        r"""Retrieves the status or result of a specific 3D model generation
+        task using the Meshy API.
+
+        Args:
+            task_id (str): The ID of the task to retrieve.
+
+        Returns:
+            Dict[str, Any]: The response from the Meshy API.
+        """
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.get(
+            f"https://api.meshy.ai/v2/text-to-3d/{task_id}",
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def wait_for_task_completion(
+        self, task_id: str, polling_interval: int = 10, timeout: int = 3600
+    ) -> Dict[str, Any]:
+        r"""Waits for a task to complete by polling its status.
+
+        Args:
+            task_id (str): The ID of the task to monitor.
+            polling_interval (int): Seconds to wait between status checks.
+                (default::obj:`10`)
+            timeout (int): Maximum seconds to wait before timing out.
+                (default::obj:`3600`)
+
+        Returns:
+            Dict[str, Any]: Final response from the API when task completes.
+
+        Raises:
+            TimeoutError: If task doesn't complete within timeout period.
+            RuntimeError: If task fails or is canceled.
+        """
+        import time
+
+        start_time = time.time()
+
+        while True:
+            if time.time() - start_time > timeout:
+                raise TimeoutError(
+                    f"Task {task_id} timed out after {timeout} seconds"
+                )
+
+            response = self.get_task_status(task_id)
+            status = response.get("status")  # Direct access to status field
+            elapsed = int(time.time() - start_time)
+
+            print(f"Status after {elapsed}s: {status}")
+
+            if status == "SUCCEEDED":
+                return response
+            elif status in [
+                "FAILED",
+                "CANCELED",
+            ]:  # Also updating these status values
+                raise RuntimeError(f"Task {task_id} {status}")
+
+            time.sleep(polling_interval)
+
+    def generate_3d_model_complete(
+        self, prompt: str, art_style: str, negative_prompt: str
+    ) -> Dict[str, Any]:
+        r"""Generates a complete 3D model by handling preview and refinement
+        stages
+
+        Args:
+            prompt (str): Description of the object.
+            art_style (str): Art style for the 3D model.
+            negative_prompt (str): What the model should not look like.
+
+        Returns:
+            Dict[str, Any]: The final refined 3D model response.
+        """
+        # Generate preview
+        preview_response = self.generate_3d_preview(
+            prompt, art_style, negative_prompt
+        )
+        preview_task_id = str(preview_response.get("result"))
+
+        # Wait for preview completion
+        self.wait_for_task_completion(preview_task_id)
+
+        # Start refinement
+        refine_response = self.refine_3d_model(preview_task_id)
+        refine_task_id = str(refine_response.get("result"))
+
+        # Wait for refinement completion and return final result
+        return self.wait_for_task_completion(refine_task_id)

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]
@@ -471,4 +622,5 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.search_duckduckgo),
             FunctionTool(self.query_wolfram_alpha),
             FunctionTool(self.tavily_search),
+            FunctionTool(self.search_brave),
         ]