Skip to content

armgit / camel

Public Imported from GitHub
0

🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

feat: new implementation of timeout functionality for all toolkits (#1595)

Xiaotian Jin02bf930147da
diff --git a/.github/workflows/build_package.yml b/.github/workflows/build_package.yml
index 43c5cd7aa..ef1c333dc 100644
--- a/.github/workflows/build_package.yml
+++ b/.github/workflows/build_package.yml
@@ -83,6 +83,7 @@ jobs:
SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"
MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"
AIML_API_KEY: "${{ secrets.AIML_API_KEY }}"
+ NVIDIA_API_KEY: "${{ secrets.NVIDIA_API_KEY }}"
run: |
source venv/bin/activate
pytest --fast-test-mode ./test
diff --git a/camel/toolkits/arxiv_toolkit.py b/camel/toolkits/arxiv_toolkit.py
index b686e79c6..ff9003f41 100644
--- a/camel/toolkits/arxiv_toolkit.py
+++ b/camel/toolkits/arxiv_toolkit.py
@@ -28,8 +28,9 @@ class ArxivToolkit(BaseToolkit):
"""
@dependencies_required('arxiv')
- def __init__(self) -> None:
+ def __init__(self, timeout: Optional[float] = None) -> None:
r"""Initializes the ArxivToolkit and sets up the arXiv client."""
+ super().__init__(timeout=timeout)
import arxiv
self.client = arxiv.Client()
diff --git a/camel/toolkits/ask_news_toolkit.py b/camel/toolkits/ask_news_toolkit.py
index c0aff1bff..e3a8a9135 100644
--- a/camel/toolkits/ask_news_toolkit.py
+++ b/camel/toolkits/ask_news_toolkit.py
@@ -62,10 +62,11 @@ class AskNewsToolkit(BaseToolkit):
based on user queries using the AskNews API.
"""
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
r"""Initialize the AskNewsToolkit with API clients.The API keys and
credentials are retrieved from environment variables.
"""
+ super().__init__(timeout=timeout)
from asknews_sdk import AskNewsSDK
client_id = os.environ.get("ASKNEWS_CLIENT_ID")
diff --git a/camel/toolkits/base.py b/camel/toolkits/base.py
index 9694af699..c0cf168a0 100644
--- a/camel/toolkits/base.py
+++ b/camel/toolkits/base.py
@@ -12,14 +12,33 @@
# limitations under the License.
# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List
+from typing import List, Optional
from camel.toolkits import FunctionTool
-from camel.utils import AgentOpsMeta
+from camel.utils import AgentOpsMeta, with_timeout
class BaseToolkit(metaclass=AgentOpsMeta):
- r"""Base class for toolkits."""
+ r"""Base class for toolkits.
+
+ Args:
+ timeout (Optional[float]): The timeout for the toolkit.
+ """
+
+ timeout: Optional[float] = None
+
+ def __init__(self, timeout: Optional[float] = None):
+ # check if timeout is a positive number
+ if timeout is not None and timeout <= 0:
+ raise ValueError("Timeout must be a positive number.")
+ self.timeout = timeout
+
+ # Add timeout to all callable methods in the toolkit
+ def __init_subclass__(cls, **kwargs):
+ super().__init_subclass__(**kwargs)
+ for attr_name, attr_value in cls.__dict__.items():
+ if callable(attr_value) and not attr_name.startswith("__"):
+ setattr(cls, attr_name, with_timeout(attr_value))
def get_tools(self) -> List[FunctionTool]:
r"""Returns a list of FunctionTool objects representing the
diff --git a/camel/toolkits/code_execution.py b/camel/toolkits/code_execution.py
index dbc845ecb..acd4ec600 100644
--- a/camel/toolkits/code_execution.py
+++ b/camel/toolkits/code_execution.py
@@ -48,7 +48,9 @@ class CodeExecutionToolkit(BaseToolkit):
unsafe_mode: bool = False,
import_white_list: Optional[List[str]] = None,
require_confirm: bool = False,
+ timeout: Optional[float] = None,
) -> None:
+ super().__init__(timeout=timeout)
self.verbose = verbose
self.unsafe_mode = unsafe_mode
self.import_white_list = import_white_list or list()
diff --git a/camel/toolkits/dappier_toolkit.py b/camel/toolkits/dappier_toolkit.py
index 6f8fd9d34..0dbf5128f 100644
--- a/camel/toolkits/dappier_toolkit.py
+++ b/camel/toolkits/dappier_toolkit.py
@@ -33,10 +33,11 @@ class DappierToolkit(BaseToolkit):
(None, "DAPPIER_API_KEY"),
]
)
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
r"""Initialize the DappierTookit with API clients.The API keys and
credentials are retrieved from environment variables.
"""
+ super().__init__(timeout=timeout)
from dappier import Dappier
dappier_api_key = os.environ.get("DAPPIER_API_KEY")
diff --git a/camel/toolkits/data_commons_toolkit.py b/camel/toolkits/data_commons_toolkit.py
index 208ed5738..153500bdd 100644
--- a/camel/toolkits/data_commons_toolkit.py
+++ b/camel/toolkits/data_commons_toolkit.py
@@ -14,6 +14,7 @@
import logging
from typing import Any, Dict, List, Optional, Union
+from camel.toolkits import FunctionTool
from camel.toolkits.base import BaseToolkit
logger = logging.getLogger(__name__)
@@ -35,8 +36,18 @@ class DataCommonsToolkit(BaseToolkit):
Refer to https://datacommons.org/browser/ for more details.
"""
- @staticmethod
+ def __init__(self, timeout: Optional[float] = None):
+ r"""Initialize the DataCommonsToolkit.
+
+ Args:
+ timeout (Optional[float], optional): Maximum time in seconds to
+ wait for API calls to complete. If None, will wait indefinitely.
+ (default: :obj:`None`)
+ """
+ super().__init__(timeout=timeout)
+
def query_data_commons(
+ self,
query_string: str,
) -> Optional[List[Dict[str, Any]]]:
r"""Query the Data Commons knowledge graph using SPARQL.
@@ -76,9 +87,8 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
def get_triples(
- dcids: Union[str, List[str]], limit: int = 500
+ self, dcids: Union[str, List[str]], limit: int = 500
) -> Optional[Dict[str, List[tuple]]]:
r"""Retrieve triples associated with nodes.
@@ -117,8 +127,8 @@ class DataCommonsToolkit(BaseToolkit):
logger.error(f"An error occurred: {e!s}")
return None
- @staticmethod
def get_stat_time_series(
+ self,
place: str,
stat_var: str,
measurement_method: Optional[str] = None,
@@ -166,9 +176,8 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
def get_property_labels(
- dcids: Union[str, List[str]], out: bool = True
+ self, dcids: Union[str, List[str]], out: bool = True
) -> Optional[Dict[str, List[str]]]:
r"""Retrieves and analyzes property labels for given DCIDs.
@@ -195,8 +204,8 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
def get_property_values(
+ self,
dcids: Union[str, List[str]],
prop: str,
out: Optional[bool] = True,
@@ -239,9 +248,8 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
def get_places_in(
- dcids: list, place_type: str
+ self, dcids: list, place_type: str
) -> Optional[Dict[str, Any]]:
r"""Retrieves places within a given place type.
@@ -269,8 +277,8 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
def get_stat_value(
+ self,
place: str,
stat_var: str,
date: Optional[str] = None,
@@ -326,8 +334,7 @@ class DataCommonsToolkit(BaseToolkit):
)
return None
- @staticmethod
- def get_stat_all(places: str, stat_vars: str) -> Optional[dict]:
+ def get_stat_all(self, places: str, stat_vars: str) -> Optional[dict]:
r"""Retrieves the value of a statistical variable for a given place
and date.
@@ -358,3 +365,22 @@ class DataCommonsToolkit(BaseToolkit):
f"statistical variable: {e!s}"
)
return None
+
+ def get_tools(self) -> List[FunctionTool]:
+ r"""Returns a list of FunctionTool objects representing the functions
+ in the toolkit.
+
+ Returns:
+ List[FunctionTool]: A list of FunctionTool objects representing
+ the functions in the toolkit.
+ """
+ return [
+ FunctionTool(self.query_data_commons),
+ FunctionTool(self.get_triples),
+ FunctionTool(self.get_stat_time_series),
+ FunctionTool(self.get_property_labels),
+ FunctionTool(self.get_property_values),
+ FunctionTool(self.get_places_in),
+ FunctionTool(self.get_stat_value),
+ FunctionTool(self.get_stat_all),
+ ]
diff --git a/camel/toolkits/github_toolkit.py b/camel/toolkits/github_toolkit.py
index 2ebfb6d72..77ea4705a 100644
--- a/camel/toolkits/github_toolkit.py
+++ b/camel/toolkits/github_toolkit.py
@@ -39,7 +39,10 @@ class GithubToolkit(BaseToolkit):
@dependencies_required('github')
def __init__(
- self, repo_name: str, access_token: Optional[str] = None
+ self,
+ repo_name: str,
+ access_token: Optional[str] = None,
+ timeout: Optional[float] = None,
) -> None:
r"""Initializes a new instance of the GitHubToolkit class.
@@ -49,6 +52,7 @@ class GithubToolkit(BaseToolkit):
with GitHub. If not provided, it will be obtained using the
`get_github_access_token` method.
"""
+ super().__init__(timeout=timeout)
from github import Auth, Github
if access_token is None:
diff --git a/camel/toolkits/google_maps_toolkit.py b/camel/toolkits/google_maps_toolkit.py
index bddf119d6..c83c5b0cc 100644
--- a/camel/toolkits/google_maps_toolkit.py
+++ b/camel/toolkits/google_maps_toolkit.py
@@ -101,7 +101,8 @@ class GoogleMapsToolkit(BaseToolkit):
"""
@dependencies_required('googlemaps')
- def __init__(self) -> None:
+ def __init__(self, timeout: Optional[float] = None) -> None:
+ super().__init__(timeout=timeout)
import googlemaps
api_key = os.environ.get('GOOGLE_API_KEY')
diff --git a/camel/toolkits/google_scholar_toolkit.py b/camel/toolkits/google_scholar_toolkit.py
index a770454b3..d8ff11387 100644
--- a/camel/toolkits/google_scholar_toolkit.py
+++ b/camel/toolkits/google_scholar_toolkit.py
@@ -39,6 +39,7 @@ class GoogleScholarToolkit(BaseToolkit):
use_free_proxies: bool = False,
proxy_http: Optional[str] = None,
proxy_https: Optional[str] = None,
+ timeout: Optional[float] = None,
) -> None:
r"""Initializes the GoogleScholarToolkit with the author's identifier.
@@ -54,6 +55,7 @@ class GoogleScholarToolkit(BaseToolkit):
proxy_https ( Optional[str]): Proxy https address pass to pg.
SingleProxy. (default: :obj:`None`)
"""
+ super().__init__(timeout=timeout)
from scholarly import ProxyGenerator, scholarly
# Set Free Proxies is needed
diff --git a/camel/toolkits/human_toolkit.py b/camel/toolkits/human_toolkit.py
index 42746961c..2c2a93e40 100644
--- a/camel/toolkits/human_toolkit.py
+++ b/camel/toolkits/human_toolkit.py
@@ -24,9 +24,6 @@ logger = logging.getLogger(__name__)
class HumanToolkit(BaseToolkit):
r"""A class representing a toolkit for human interaction."""
- def __init__(self):
- pass
-
def ask_human_via_console(self, question: str) -> str:
r"""Ask a question to the human via the console.
diff --git a/camel/toolkits/linkedin_toolkit.py b/camel/toolkits/linkedin_toolkit.py
index 840f4c418..4ca6770b0 100644
--- a/camel/toolkits/linkedin_toolkit.py
+++ b/camel/toolkits/linkedin_toolkit.py
@@ -15,7 +15,7 @@
import json
import os
from http import HTTPStatus
-from typing import List
+from typing import List, Optional
import requests
@@ -33,7 +33,8 @@ class LinkedInToolkit(BaseToolkit):
retrieving the authenticated user's profile information.
"""
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
+ super().__init__(timeout=timeout)
self._access_token = self._get_access_token()
def create_post(self, text: str) -> dict:
diff --git a/camel/toolkits/meshy_toolkit.py b/camel/toolkits/meshy_toolkit.py
index 42cbebd5b..19f8cc30c 100644
--- a/camel/toolkits/meshy_toolkit.py
+++ b/camel/toolkits/meshy_toolkit.py
@@ -13,7 +13,7 @@
# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
import os
-from typing import Any, Dict
+from typing import Any, Dict, Optional
import requests
@@ -38,10 +38,11 @@ class MeshyToolkit(BaseToolkit):
(None, 'MESHY_API_KEY'),
]
)
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
r"""Initializes the MeshyToolkit with the API key from the
environment.
"""
+ super().__init__(timeout=timeout)
self.api_key = os.getenv('MESHY_API_KEY')
def generate_3d_preview(
diff --git a/camel/toolkits/mineru_toolkit.py b/camel/toolkits/mineru_toolkit.py
index efc799bd3..d0569cc9c 100644
--- a/camel/toolkits/mineru_toolkit.py
+++ b/camel/toolkits/mineru_toolkit.py
@@ -111,7 +111,7 @@ class MinerUToolkit(BaseToolkit):
if self.wait:
return self.client.wait_for_completion(
response['task_id'],
- timeout=self.timeout,
+ timeout=self.timeout, # type: ignore[arg-type]
)
return response
else:
@@ -125,7 +125,7 @@ class MinerUToolkit(BaseToolkit):
return self.client.wait_for_completion(
batch_id,
is_batch=True,
- timeout=self.timeout if self.timeout > 300 else 600,
+ timeout=self.timeout if self.timeout > 300 else 600, # type: ignore[arg-type,operator]
)
return {"batch_id": batch_id}
diff --git a/camel/toolkits/notion_toolkit.py b/camel/toolkits/notion_toolkit.py
index f9c20de53..4b5b6ebde 100644
--- a/camel/toolkits/notion_toolkit.py
+++ b/camel/toolkits/notion_toolkit.py
@@ -79,6 +79,7 @@ class NotionToolkit(BaseToolkit):
def __init__(
self,
notion_token: Optional[str] = None,
+ timeout: Optional[float] = None,
) -> None:
r"""Initializes the NotionToolkit.
@@ -86,6 +87,7 @@ class NotionToolkit(BaseToolkit):
notion_token (Optional[str], optional): The optional notion_token
used to interact with notion APIs.(default: :obj:`None`)
"""
+ super().__init__(timeout=timeout)
from notion_client import Client
self.notion_token = notion_token or os.environ.get("NOTION_TOKEN")
diff --git a/camel/toolkits/openbb_toolkit.py b/camel/toolkits/openbb_toolkit.py
index 6e379d4a5..d89ddf156 100644
--- a/camel/toolkits/openbb_toolkit.py
+++ b/camel/toolkits/openbb_toolkit.py
@@ -37,12 +37,13 @@ class OpenBBToolkit(BaseToolkit):
(None, "OPENBB_TOKEN"),
]
)
- def __init__(self) -> None:
+ def __init__(self, timeout: Optional[float] = None) -> None:
r"""Initialize the OpenBBToolkit.
This method sets up the OpenBB client and initializes the OpenBB
Hub account system.
"""
+ super().__init__(timeout=timeout)
import os
from openbb import obb
diff --git a/camel/toolkits/reddit_toolkit.py b/camel/toolkits/reddit_toolkit.py
index 6d8f8778b..19c67a24e 100644
--- a/camel/toolkits/reddit_toolkit.py
+++ b/camel/toolkits/reddit_toolkit.py
@@ -14,7 +14,7 @@
import os
import time
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
from camel.toolkits import FunctionTool
from camel.toolkits.base import BaseToolkit
@@ -30,11 +30,16 @@ class RedditToolkit(BaseToolkit):
Attributes:
retries (int): Number of retries for API requests in case of failure.
- delay (int): Delay between retries in seconds.
+ delay (float): Delay between retries in seconds.
reddit (Reddit): An instance of the Reddit client.
"""
- def __init__(self, retries: int = 3, delay: int = 0):
+ def __init__(
+ self,
+ retries: int = 3,
+ delay: float = 0.0,
+ timeout: Optional[float] = None,
+ ):
r"""Initializes the RedditToolkit with the specified number of retries
and delay.
@@ -43,7 +48,10 @@ class RedditToolkit(BaseToolkit):
failure. Defaults to `3`.
delay (int): Time in seconds to wait between retries. Defaults to
`0`.
+ timeout (float): Timeout for API requests in seconds. Defaults to
+ `None`.
"""
+ super().__init__(timeout=timeout)
from praw import Reddit # type: ignore[import-untyped]
self.retries = retries
diff --git a/camel/toolkits/retrieval_toolkit.py b/camel/toolkits/retrieval_toolkit.py
index f628da298..c1dc0486d 100644
--- a/camel/toolkits/retrieval_toolkit.py
+++ b/camel/toolkits/retrieval_toolkit.py
@@ -27,8 +27,13 @@ class RetrievalToolkit(BaseToolkit):
storage system based on a specified query.
"""
- def __init__(self, auto_retriever: Optional[AutoRetriever] = None) -> None:
+ def __init__(
+ self,
+ auto_retriever: Optional[AutoRetriever] = None,
+ timeout: Optional[float] = None,
+ ) -> None:
r"""Initializes a new instance of the RetrievalToolkit class."""
+ super().__init__(timeout=timeout)
self.ar = auto_retriever or AutoRetriever(
vector_storage_local_path="camel/temp_storage",
storage_type=StorageType.QDRANT,
diff --git a/camel/toolkits/semantic_scholar_toolkit.py b/camel/toolkits/semantic_scholar_toolkit.py
index 235f8faec..5ab330aa9 100644
--- a/camel/toolkits/semantic_scholar_toolkit.py
+++ b/camel/toolkits/semantic_scholar_toolkit.py
@@ -26,8 +26,9 @@ class SemanticScholarToolkit(BaseToolkit):
API to fetch paper and author data.
"""
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
r"""Initializes the SemanticScholarToolkit."""
+ super().__init__(timeout=timeout)
self.base_url = "https://api.semanticscholar.org/graph/v1"
def fetch_paper_data_title(
diff --git a/camel/toolkits/stripe_toolkit.py b/camel/toolkits/stripe_toolkit.py
index f31fff8d5..b7980d5d1 100644
--- a/camel/toolkits/stripe_toolkit.py
+++ b/camel/toolkits/stripe_toolkit.py
@@ -15,7 +15,7 @@
import json
import logging
import os
-from typing import List
+from typing import List, Optional
from camel.toolkits import FunctionTool
from camel.toolkits.base import BaseToolkit
@@ -41,7 +41,12 @@ class StripeToolkit(BaseToolkit):
(None, "STRIPE_API_KEY"),
]
)
- def __init__(self, retries: int = 3):
+ def __init__(
+ self,
+ retries: int = 3,
+ timeout: Optional[float] = None,
+ ):
+ super().__init__(timeout=timeout)
r"""Initializes the StripeToolkit with the specified number of
retries.
@@ -49,6 +54,7 @@ class StripeToolkit(BaseToolkit):
retries (int,optional): Number of times to retry the request in
case of failure. (default: :obj:`3`)
"""
+ super().__init__(timeout=timeout)
import stripe
stripe.max_network_retries = retries
diff --git a/camel/toolkits/sympy_toolkit.py b/camel/toolkits/sympy_toolkit.py
index 4f641d2f0..17ff41733 100644
--- a/camel/toolkits/sympy_toolkit.py
+++ b/camel/toolkits/sympy_toolkit.py
@@ -28,13 +28,18 @@ class SymPyToolkit(BaseToolkit):
and Linear Algebra.
"""
- def __init__(self, default_variable: str = 'x'):
+ def __init__(
+ self,
+ default_variable: str = 'x',
+ timeout: Optional[float] = None,
+ ):
r"""Initializes the toolkit with a default variable and logging.
Args:
default_variable (str): The default variable for
operations (default: :obj: `x`)
"""
+ super().__init__(timeout=timeout)
self.default_variable = default_variable
logger.info(f"Default variable set to: {self.default_variable}")
diff --git a/camel/toolkits/video_toolkit.py b/camel/toolkits/video_toolkit.py
index 1987cfdef..4a5a5c510 100644
--- a/camel/toolkits/video_toolkit.py
+++ b/camel/toolkits/video_toolkit.py
@@ -85,7 +85,9 @@ class VideoDownloaderToolkit(BaseToolkit):
self,
download_directory: Optional[str] = None,
cookies_path: Optional[str] = None,
+ timeout: Optional[float] = None,
) -> None:
+ super().__init__(timeout=timeout)
self._cleanup = download_directory is None
self._cookies_path = cookies_path
diff --git a/camel/toolkits/whatsapp_toolkit.py b/camel/toolkits/whatsapp_toolkit.py
index f2859e675..804377854 100644
--- a/camel/toolkits/whatsapp_toolkit.py
+++ b/camel/toolkits/whatsapp_toolkit.py
@@ -13,7 +13,7 @@
# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
import os
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
import requests
@@ -36,8 +36,9 @@ class WhatsAppToolkit(BaseToolkit):
version (str): API version.
"""
- def __init__(self):
+ def __init__(self, timeout: Optional[float] = None):
r"""Initializes the WhatsAppToolkit."""
+ super().__init__(timeout=timeout)
self.base_url = "https://graph.facebook.com"
self.version = "v17.0"
diff --git a/camel/utils/__init__.py b/camel/utils/__init__.py
index 7ac7f0a8d..ffdc26a0a 100644
--- a/camel/utils/__init__.py
+++ b/camel/utils/__init__.py
@@ -37,6 +37,7 @@ from .commons import (
text_extract_from_web,
to_pascal,
track_agent,
+ with_timeout,
)
from .constants import Constants
from .deduplication import DeduplicationResult, deduplicate_internally
@@ -86,4 +87,5 @@ __all__ = [
"DeduplicationResult",
"retry_on_error",
"BatchProcessor",
+ "with_timeout",
]
diff --git a/camel/utils/commons.py b/camel/utils/commons.py
index b16ec0893..d0aa11331 100644
--- a/camel/utils/commons.py
+++ b/camel/utils/commons.py
@@ -19,6 +19,7 @@ import platform
import re
import socket
import subprocess
+import threading
import time
import zipfile
from functools import wraps
@@ -869,3 +870,106 @@ def download_github_subdirectory(
download_github_subdirectory(
repo, f'{subdir}/{file["name"]}', file_path, branch
)
+
+
+def generate_prompt_for_structured_output(
+ response_format: Optional[Type[BaseModel]],
+ user_message: str,
+) -> str:
+ """
+ This function generates a prompt based on the provided Pydantic model and
+ user message.
+
+ Args:
+ response_format (Type[BaseModel]): The Pydantic model class.
+ user_message (str): The user message to be used in the prompt.
+
+ Returns:
+ str: A prompt string for the LLM.
+ """
+ if response_format is None:
+ return user_message
+
+ json_schema = response_format.model_json_schema()
+ sys_prompt = (
+ "Given the user message, please generate a JSON response adhering "
+ "to the following JSON schema:\n"
+ f"{json_schema}\n"
+ "Make sure the JSON response is valid and matches the EXACT structure "
+ "defined in the schema. Your result should only be a valid json "
+ "object, without any other text or comments.\n"
+ )
+ user_prompt = f"User message: {user_message}\n"
+
+ final_prompt = f"""
+ {sys_prompt}
+ {user_prompt}
+ """
+ return final_prompt
+
+
+def with_timeout(timeout=None):
+ r"""Decorator that adds timeout functionality to functions.
+
+ Executes functions with a specified timeout value. Returns a timeout
+ message if execution time is exceeded.
+
+ Args:
+ timeout (float, optional): The timeout duration in seconds. If None,
+ will try to get timeout from the instance's timeout attribute.
+ (default: :obj:`None`)
+
+ Example:
+ >>> @with_timeout(5)
+ ... def my_function():
+ ... return "Success"
+ >>> my_function()
+
+ >>> class MyClass:
+ ... timeout = 5
+ ... @with_timeout()
+ ... def my_method(self):
+ ... return "Success"
+ """
+
+ def decorator(func):
+ @functools.wraps(func)
+ def wrapper(*args, **kwargs):
+ # Determine the effective timeout value
+ effective_timeout = timeout
+ if effective_timeout is None and args:
+ effective_timeout = getattr(args[0], 'timeout', None)
+
+ # If no timeout value is provided, execute function normally
+ if effective_timeout is None:
+ return func(*args, **kwargs)
+
+ # Container to hold the result of the function call
+ result_container = []
+
+ def target():
+ result_container.append(func(*args, **kwargs))
+
+ # Start the function in a new thread
+ thread = threading.Thread(target=target)
+ thread.start()
+ thread.join(effective_timeout)
+
+ # Check if the thread is still alive after the timeout
+ if thread.is_alive():
+ return (
+ f"Function `{func.__name__}` execution timed out, "
+ f"exceeded {effective_timeout} seconds."
+ )
+ else:
+ return result_container[0]
+
+ return wrapper
+
+ # Handle both @with_timeout and @with_timeout() usage
+ if callable(timeout):
+ # If timeout is passed as a function, apply it to the decorator
+ func, timeout = timeout, None
+ return decorator(func)
+
+ return decorator
diff --git a/examples/test/test_ai_society_example.py b/examples/test/test_ai_society_example.py
index b49ab7472..2cf89937d 100644
--- a/examples/test/test_ai_society_example.py
+++ b/examples/test/test_ai_society_example.py
@@ -33,4 +33,8 @@ def test_ai_society_role_playing_example():
def test_role_playing_with_function_example():
with patch('time.sleep', return_value=None):
- examples.toolkits.role_playing_with_functions.main(chat_turn_limit=2)
+ examples.toolkits.role_playing_with_functions.main(
+ model_platform=ModelPlatformType.DEFAULT,
+ model_type=ModelType.STUB,
+ chat_turn_limit=2,
+ )
diff --git a/examples/toolkits/toolkit_timeout.py b/examples/toolkits/toolkit_timeout.py
new file mode 100644
index 000000000..900bac3a6
--- /dev/null
+++ b/examples/toolkits/toolkit_timeout.py
@@ -0,0 +1,117 @@
+# ========= 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 time
+from typing import Optional
+
+from camel.toolkits.base import BaseToolkit
+from camel.utils import with_timeout
+
+
+# Example 1: Basic function with timeout
+@with_timeout(1.0)
+def basic_function() -> str:
+ r"""A basic function with a 1-second timeout."""
+ time.sleep(0.5) # Simulating some work
+ return "Basic function completed successfully!"
+
+
+# Example 2: Function that exceeds timeout
+@with_timeout(1.0)
+def slow_function() -> str:
+ r"""A slow function that will exceed the timeout."""
+ time.sleep(2.0) # This will exceed the timeout
+ return "This message will never be returned"
+
+
+# Example 3: Class with configurable timeout
+class TimeoutExample:
+ def __init__(self, timeout: Optional[float] = None):
+ self.timeout = timeout
+
+ @with_timeout() # Uses instance timeout
+ def instance_timeout_method(self) -> str:
+ r"""Method using the instance's timeout value."""
+ time.sleep(0.5)
+ return "Instance timeout method completed!"
+
+ @with_timeout(0.1) # Uses decorator-specific timeout
+ def decorator_timeout_method(self) -> str:
+ r"""Method using the decorator's timeout value."""
+ time.sleep(0.5)
+ return "This will timeout"
+
+
+# Example 4: Toolkit with timeout
+class TimeoutToolkit(BaseToolkit):
+ def __init__(self, timeout: Optional[float] = None):
+ super().__init__(timeout=timeout)
+
+ @with_timeout()
+ def fast_operation(self) -> str:
+ r"""A fast operation that completes within timeout."""
+ time.sleep(0.1)
+ return "Fast operation completed!"
+
+ @with_timeout()
+ def slow_operation(self) -> str:
+ r"""A slow operation that exceeds timeout."""
+ time.sleep(1.0)
+ return "Slow operation completed!"
+
+
+def main():
+ # Example 1: Basic function
+ print("\nExample 1: Basic function")
+ print(basic_function())
+
+ # Example 2: Slow function
+ print("\nExample 2: Slow function")
+ print(slow_function())
+
+ # Example 3: Class with timeout
+ print("\nExample 3: Class with timeout")
+ example = TimeoutExample(timeout=0.2)
+ print(example.instance_timeout_method())
+ print(example.decorator_timeout_method())
+
+ # Example 4: Toolkit
+ print("\nExample 4: Toolkit with timeout")
+ toolkit = TimeoutToolkit(timeout=0.5)
+ print(toolkit.fast_operation())
+ print(toolkit.slow_operation())
+
+
+if __name__ == "__main__":
+ main()
+
+"""
+===============================================================================
+Example 1: Basic function
+Basic function completed successfully!
+
+Example 2: Slow function
+Function `slow_function` execution timed out, exceeded 1.0 seconds.
+
+Example 3: Class with timeout
+Function `instance_timeout_method` execution timed out, exceeded 0.2 seconds.
+Function `decorator_timeout_method` execution timed out, exceeded 0.1 seconds.
+
+Example 4: Toolkit with timeout
+Fast operation completed!
+Function `slow_operation` execution timed out, exceeded 0.5 seconds.
+===============================================================================
+"""
diff --git a/test/toolkits/test_data_commons_toolkit.py b/test/toolkits/test_data_commons_toolkit.py
index cd7b8757a..b16ac52ba 100644
--- a/test/toolkits/test_data_commons_toolkit.py
+++ b/test/toolkits/test_data_commons_toolkit.py
@@ -67,10 +67,7 @@ def test_get_triples():
mock_get_triples.return_value = expected_result
result = dc_toolkit.get_triples(dcids)
assert result == expected_result
- mock_get_triples.assert_called()
- assert (
- mock_get_triples.call_args[0][0] == dcids
- ) # Check that dcids were passed correctly
+ mock_get_triples.assert_called_once_with(dcids, 500)
print("test_get_triples passed successfully")
diff --git a/test/toolkits/test_mineru_toolkit.py b/test/toolkits/test_mineru_toolkit.py
index b1bda1c9c..d29a14e22 100644
--- a/test/toolkits/test_mineru_toolkit.py
+++ b/test/toolkits/test_mineru_toolkit.py
@@ -136,6 +136,10 @@ def test_error_handling(mineru_toolkit):
"""Test error handling when API calls fail."""
# Test single URL extraction error
mineru_toolkit.client.extract_url.side_effect = Exception("API Error")
+ mineru_toolkit.client.wait_for_completion.side_effect = (
+ None # Reset any side effects
+ )
+ mineru_toolkit.timeout = None # Disable timeout to avoid threading issues
with pytest.raises(Exception) as exc_info:
mineru_toolkit.extract_from_urls("https://test.com/doc.pdf")
assert "API Error" in str(exc_info.value)
diff --git a/test/utils/test_commons.py b/test/utils/test_commons.py
index 9a8e9cfff..ebed8a80d 100644
--- a/test/utils/test_commons.py
+++ b/test/utils/test_commons.py
@@ -12,11 +12,14 @@
# limitations under the License.
# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
import os
+import time
from unittest import TestCase
from unittest.mock import patch
import pytest
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
from camel.utils import (
BatchProcessor,
api_keys_required,
@@ -26,6 +29,7 @@ from camel.utils import (
is_docker_running,
retry_on_error,
to_pascal,
+ with_timeout,
)
@@ -318,3 +322,64 @@ class TestBatchProcessor(TestCase):
self.assertAlmostEqual(metrics['error_rate'], 33.33333333333333)
self.assertAlmostEqual(metrics['avg_processing_time'], 1.5)
self.assertEqual(metrics['current_workers'], 2)
+
+
+def test_tool_function():
+ return "test result"
+
+
+class MockToolkit(BaseToolkit):
+ def __init__(self, delay_seconds=0, timeout=None):
+ super().__init__(timeout=timeout)
+ self.delay_seconds = delay_seconds
+ self.tools = [FunctionTool(func=test_tool_function)]
+
+ def run(self):
+ time.sleep(self.delay_seconds)
+ return "run success"
+
+
+def test_toolkit_custom_timeout():
+ r"""Test that toolkit accepts custom timeout."""
+ custom_timeout = 300
+ toolkit = MockToolkit(timeout=custom_timeout)
+ assert toolkit.timeout == custom_timeout
+
+
+def test_toolkit_within_timeout():
+ r"""Test toolkit operation completes within timeout period."""
+ toolkit = MockToolkit(delay_seconds=1, timeout=2)
+ assert toolkit.run() == "run success"
+
+
+def test_toolkit_timeout_exceeded():
+ r"""Test that operation times out when exceeding timeout period."""
+ toolkit = MockToolkit(delay_seconds=2, timeout=1)
+ result = toolkit.run()
+ assert result == "Function `run` execution timed out, exceeded 1 seconds."
+
+
+def test_direct_timeout_decorator():
+ r"""Test direct use of timeout decorator with explicit value."""
+
+ @with_timeout(1)
+ def slow_function():
+ time.sleep(2)
+ return "success"
+
+ result = slow_function()
+ assert (
+ result
+ == "Function `slow_function` execution timed out, exceeded 1 seconds."
+ )
+
+
+def test_direct_timeout_no_delay():
+ r"""Test direct use of timeout decorator with no delay."""
+
+ @with_timeout(2)
+ def fast_function():
+ return "success"
+
+ result = fast_function()
+ assert result == "success"