camel-ai 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

camel/toolkits/__init__.py

@@ -45,6 +45,8 @@ from .human_toolkit import HumanToolkit
 from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 from .dappier_toolkit import DappierToolkit
+from .sympy_toolkit import SymPyToolkit
+from .semantic_scholar_toolkit import SemanticScholarToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -77,4 +79,6 @@ __all__ = [
     'MeshyToolkit',
     'OpenBBToolkit',
     'DappierToolkit',
+    'SymPyToolkit',
+    'SemanticScholarToolkit',
 ]

camel/toolkits/reddit_toolkit.py

@@ -16,10 +16,9 @@ import os
 import time
 from typing import Any, Dict, List, Union
 
-from requests.exceptions import RequestException
-
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import retry_on_error
 
 
 class RedditToolkit(BaseToolkit):
@@ -61,30 +60,7 @@ class RedditToolkit(BaseToolkit):
             request_timeout=30,  # Set a timeout to handle delays
         )
 
-    def _retry_request(self, func, *args, **kwargs):
-        r"""Retries a function in case of network-related errors.
-
-        Args:
-            func (callable): The function to be retried.
-            *args: Arguments to pass to the function.
-            **kwargs: Keyword arguments to pass to the function.
-
-        Returns:
-            Any: The result of the function call if successful.
-
-        Raises:
-            RequestException: If all retry attempts fail.
-        """
-        for attempt in range(self.retries):
-            try:
-                return func(*args, **kwargs)
-            except RequestException as e:
-                print(f"Attempt {attempt + 1}/{self.retries} failed: {e}")
-                if attempt < self.retries - 1:
-                    time.sleep(self.delay)
-                else:
-                    raise
-
+    @retry_on_error()
     def collect_top_posts(
         self,
         subreddit_name: str,
@@ -113,8 +89,8 @@ class RedditToolkit(BaseToolkit):
                 "Please set the environment variables."
             )
 
-        subreddit = self._retry_request(self.reddit.subreddit, subreddit_name)
-        top_posts = self._retry_request(subreddit.top, limit=post_limit)
+        subreddit = self.reddit.subreddit(subreddit_name)
+        top_posts = subreddit.top(limit=post_limit)
         data = []
 
         for post in top_posts:
@@ -122,9 +98,7 @@ class RedditToolkit(BaseToolkit):
                 "Post Title": post.title,
                 "Comments": [
                     {"Comment Body": comment.body, "Upvotes": comment.score}
-                    for comment in self._retry_request(
-                        lambda post=post: list(post.comments)
-                    )[:comment_limit]
+                    for comment in list(post.comments)[:comment_limit]
                 ],
             }
             data.append(post_data)
@@ -192,15 +166,11 @@ class RedditToolkit(BaseToolkit):
         data = []
 
         for subreddit_name in subreddits:
-            subreddit = self._retry_request(
-                self.reddit.subreddit, subreddit_name
-            )
-            top_posts = self._retry_request(subreddit.top, limit=post_limit)
+            subreddit = self.reddit.subreddit(subreddit_name)
+            top_posts = subreddit.top(limit=post_limit)
 
             for post in top_posts:
-                for comment in self._retry_request(
-                    lambda post=post: list(post.comments)
-                )[:comment_limit]:
+                for comment in list(post.comments)[:comment_limit]:
                     # Print comment body for debugging
                     if any(
                         keyword.lower() in comment.body.lower()

camel/toolkits/search_toolkit.py

@@ -13,10 +13,9 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, List, Literal, Optional, Type, TypeAlias, Union
+from typing import Any, Dict, List, Literal, Optional, TypeAlias, Union
 
 import requests
-from pydantic import BaseModel
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
@@ -77,7 +76,7 @@ class SearchToolkit(BaseToolkit):
         output_type: Literal[
             "searchResults", "sourcedAnswer", "structured"
         ] = "searchResults",
-        structured_output_schema: Union[Type[BaseModel], str, None] = None,
+        structured_output_schema: Optional[str] = None,
     ) -> Dict[str, Any]:
         r"""Search for a query in the Linkup API and return results in various
         formats.
@@ -92,9 +91,9 @@ class SearchToolkit(BaseToolkit):
                 - "searchResults" for raw search results,
                 - "sourcedAnswer" for an answer with supporting sources,
                 - "structured" for output based on a provided schema.
-            structured_output_schema (Union[Type[BaseModel], str, None]): If
-                `output_type` is "structured",specify the schema of the
-                output. Can be a Pydantic BaseModel or a JSON schema string.
+            structured_output_schema (Optional[str]): If `output_type` is
+                "structured", specify the schema of the output. Must be a
+                string representing a valid object JSON schema.
 
         Returns:
             Dict[str, Any]: A dictionary representing the search result. The
@@ -581,6 +580,18 @@ class SearchToolkit(BaseToolkit):
                 "image_url": image_url,
             }
 
+            # For Results pod, collect all plaintext values from subpods
+            if pod.get("@title") == "Results":
+                results_text = []
+                if isinstance(subpod_data, list):
+                    for subpod in subpod_data:
+                        if subpod.get("plaintext"):
+                            results_text.append(subpod["plaintext"])
+                else:
+                    if description:
+                        results_text.append(description)
+                pod_info["description"] = "\n".join(results_text)
+
             # Add to steps list
             output["pod_info"].append(pod_info)
 

camel/toolkits/semantic_scholar_toolkit.py

@@ -0,0 +1,308 @@
+# ========= 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 json
+from typing import List, Optional
+
+import requests
+
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+
+
+class SemanticScholarToolkit(BaseToolkit):
+    r"""A toolkit for interacting with the Semantic Scholar
+    API to fetch paper and author data.
+    """
+
+    def __init__(self):
+        r"""Initializes the SemanticScholarToolkit."""
+        self.base_url = "https://api.semanticscholar.org/graph/v1"
+
+    def fetch_paper_data_title(
+        self,
+        paper_title: str,
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches a SINGLE paper from the Semantic Scholar
+        API based on a paper title.
+
+        Args:
+            paper_title (str): The title of the paper to fetch.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "abstract", "authors", "year", "citationCount",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information if the
+                 request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "abstract",
+                "authors",
+                "year",
+                "citationCount",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/search"
+        query_params = {"query": paper_title, "fields": ",".join(fields)}
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_paper_data_id(
+        self,
+        paper_id: str,
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches a SINGLE paper from the Semantic Scholar
+        API based on a paper ID.
+
+        Args:
+            paper_id (str): The ID of the paper to fetch.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "abstract", "authors", "year", "citationCount",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information
+                if the request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "abstract",
+                "authors",
+                "year",
+                "citationCount",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/{paper_id}"
+        query_params = {"fields": ",".join(fields)}
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_bulk_paper_data(
+        self,
+        query: str,
+        year: str = "2023-",
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches MULTIPLE papers at once from the Semantic Scholar
+        API based on a related topic.
+
+        Args:
+            query (str): The text query to match against the paper's title and
+                abstract. For example, you can use the following operators and
+                techniques to construct your query: Example 1: ((cloud
+                computing) | virtualization) +security -privacy This will
+                match papers whose title or abstract contains "cloud" and
+                "computing", or contains the word "virtualization". The papers
+                must also include the term "security" but exclude papers that
+                contain the word "privacy".
+            year (str, optional): The year filter for papers (default:
+                :obj:`"2023-"`).
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "url", "publicationTypes", "publicationDate",
+                "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information if the
+                request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "url",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/search/bulk"
+        query_params = {
+            "query": query,
+            "fields": ",".join(fields),
+            "year": year,
+        }
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_recommended_papers(
+        self,
+        positive_paper_ids: List[str],
+        negative_paper_ids: List[str],
+        fields: Optional[List[str]] = None,
+        limit: int = 500,
+        save_to_file: bool = False,
+    ) -> dict:
+        r"""Fetches recommended papers from the Semantic Scholar
+        API based on the positive and negative paper IDs.
+
+        Args:
+            positive_paper_ids (list): A list of paper IDs (as strings)
+                that are positively correlated to the recommendation.
+            negative_paper_ids (list): A list of paper IDs (as strings)
+                that are negatively correlated to the recommendation.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "url", "citationCount", "authors",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+            limit (int, optional): The maximum number of recommended papers to
+                return (default: :obj:`500`).
+            save_to_file (bool, optional): If True, saves the response data to
+                a file (default: :obj:`False`).
+
+        Returns:
+            dict: A dictionary containing recommended papers sorted by
+                citation count.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "url",
+                "citationCount",
+                "authors",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = "https://api.semanticscholar.org/recommendations/v1/papers"
+        query_params = {"fields": ",".join(fields), "limit": str(limit)}
+        data = {
+            "positive_paper_ids": positive_paper_ids,
+            "negative_paper_ids": negative_paper_ids,
+        }
+        try:
+            response = requests.post(url, params=query_params, json=data)
+            response.raise_for_status()
+            papers = response.json()
+            if save_to_file:
+                with open('recommended_papers.json', 'w') as output:
+                    json.dump(papers, output)
+            return papers
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_author_data(
+        self,
+        ids: List[str],
+        fields: Optional[List[str]] = None,
+        save_to_file: bool = False,
+    ) -> dict:
+        r"""Fetches author information from the Semantic Scholar
+        API based on author IDs.
+
+        Args:
+            ids (list): A list of author IDs (as strings) to fetch
+                data for.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["name", "url", "paperCount", "hIndex", "papers"].
+            save_to_file (bool, optional): Whether to save the results to a
+                file (default: :obj:`False`).
+
+        Returns:
+            dict: The response data from the API or error information if
+                the request fails.
+        """
+        if fields is None:
+            fields = ["name", "url", "paperCount", "hIndex", "papers"]
+
+        url = f"{self.base_url}/author/batch"
+        query_params = {"fields": ",".join(fields)}
+        data = {"ids": ids}
+        try:
+            response = requests.post(url, params=query_params, json=data)
+            response.raise_for_status()
+            response_data = response.json()
+            if save_to_file:
+                with open('author_information.json', 'w') as output:
+                    json.dump(response_data, output)
+            return response_data
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    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.fetch_paper_data_title),
+            FunctionTool(self.fetch_paper_data_id),
+            FunctionTool(self.fetch_bulk_paper_data),
+            FunctionTool(self.fetch_recommended_papers),
+            FunctionTool(self.fetch_author_data),
+        ]