Move off v1

src/crewai_tools/tools/serply_api_tool/serply_job_search_tool.py

@@ -1,19 +1,27 @@
 import os
-import requests
+from typing import Any, Optional, Type
 from urllib.parse import urlencode
-from typing import Type, Any, Optional
-from pydantic.v1 import BaseModel, Field
+
+import requests
+from pydantic import BaseModel, Field
+
 from crewai_tools.tools.rag.rag_tool import RagTool
 
 
 class SerplyJobSearchToolSchema(BaseModel):
     """Input for Job Search."""
-    search_query: str = Field(..., description="Mandatory search query you want to use to fetch jobs postings.")
+
+    search_query: str = Field(
+        ...,
+        description="Mandatory search query you want to use to fetch jobs postings.",
+    )
 
 
 class SerplyJobSearchTool(RagTool):
     name: str = "Job Search"
-    description: str = "A tool to perform to perform a job search in the US with a search_query."
+    description: str = (
+        "A tool to perform to perform a job search in the US with a search_query."
+    )
     args_schema: Type[BaseModel] = SerplyJobSearchToolSchema
     request_url: str = "https://api.serply.io/v1/job/search/"
     proxy_location: Optional[str] = "US"
@@ -23,20 +31,17 @@ class SerplyJobSearchTool(RagTool):
     """
     headers: Optional[dict] = {}
 
-    def __init__(
-            self,
-            **kwargs
-    ):
+    def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.headers = {
             "X-API-KEY": os.environ["SERPLY_API_KEY"],
             "User-Agent": "crew-tools",
-            "X-Proxy-Location": self.proxy_location
+            "X-Proxy-Location": self.proxy_location,
         }
 
     def _run(
-            self,
-            **kwargs: Any,
+        self,
+        **kwargs: Any,
     ) -> Any:
         query_payload = {}
 
@@ -58,18 +63,22 @@ class SerplyJobSearchTool(RagTool):
         string = []
         for job in jobs:
             try:
-                string.append('\n'.join([
-                    f"Position: {job['position']}",
-                    f"Employer: {job['employer']}",
-                    f"Location: {job['location']}",
-                    f"Link: {job['link']}",
-                    f"""Highest: {', '.join([h for h in job['highlights']])}""",
-                    f"Is Remote: {job['is_remote']}",
-                    f"Is Hybrid: {job['is_remote']}",
-                    "---"
-                ]))
+                string.append(
+                    "\n".join(
+                        [
+                            f"Position: {job['position']}",
+                            f"Employer: {job['employer']}",
+                            f"Location: {job['location']}",
+                            f"Link: {job['link']}",
+                            f"""Highest: {', '.join([h for h in job['highlights']])}""",
+                            f"Is Remote: {job['is_remote']}",
+                            f"Is Hybrid: {job['is_remote']}",
+                            "---",
+                        ]
+                    )
+                )
             except KeyError:
                 continue
 
-        content = '\n'.join(string)
+        content = "\n".join(string)
         return f"\nSearch results: {content}\n"

src/crewai_tools/tools/serply_api_tool/serply_news_search_tool.py

@@ -1,14 +1,19 @@
 import os
-import requests
+from typing import Any, Optional, Type
 from urllib.parse import urlencode
-from typing import Type, Any, Optional
-from pydantic.v1 import BaseModel, Field
+
+import requests
+from pydantic import BaseModel, Field
+
 from crewai_tools.tools.base_tool import BaseTool
 
 
 class SerplyNewsSearchToolSchema(BaseModel):
     """Input for Serply News Search."""
-    search_query: str = Field(..., description="Mandatory search query you want to use to fetch news articles")
+
+    search_query: str = Field(
+        ..., description="Mandatory search query you want to use to fetch news articles"
+    )
 
 
 class SerplyNewsSearchTool(BaseTool):
@@ -21,15 +26,12 @@ class SerplyNewsSearchTool(BaseTool):
     limit: Optional[int] = 10
 
     def __init__(
-            self,
-            limit: Optional[int] = 10,
-            proxy_location: Optional[str] = "US",
-            **kwargs
+        self, limit: Optional[int] = 10, proxy_location: Optional[str] = "US", **kwargs
     ):
         """
-            param: limit (int): The maximum number of results to return [10-100, defaults to 10]
-            proxy_location: (str): Where to get news, specifically for a specific country results.
-                 ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
+        param: limit (int): The maximum number of results to return [10-100, defaults to 10]
+        proxy_location: (str): Where to get news, specifically for a specific country results.
+             ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
         """
         super().__init__(**kwargs)
         self.limit = limit
@@ -37,12 +39,12 @@ class SerplyNewsSearchTool(BaseTool):
         self.headers = {
             "X-API-KEY": os.environ["SERPLY_API_KEY"],
             "User-Agent": "crew-tools",
-            "X-Proxy-Location": proxy_location
+            "X-Proxy-Location": proxy_location,
         }
 
     def _run(
-            self,
-            **kwargs: Any,
+        self,
+        **kwargs: Any,
     ) -> Any:
         # build query parameters
         query_payload = {}
@@ -58,24 +60,28 @@ class SerplyNewsSearchTool(BaseTool):
         response = requests.request("GET", url, headers=self.headers)
         results = response.json()
         if "entries" in results:
-            results = results['entries']
+            results = results["entries"]
             string = []
-            for result in results[:self.limit]:
+            for result in results[: self.limit]:
                 try:
                     # follow url
-                    r = requests.get(result['link'])
-                    final_link = r.history[-1].headers['Location']
-                    string.append('\n'.join([
-                        f"Title: {result['title']}",
-                        f"Link: {final_link}",
-                        f"Source: {result['source']['title']}",
-                        f"Published: {result['published']}",
-                        "---"
-                    ]))
+                    r = requests.get(result["link"])
+                    final_link = r.history[-1].headers["Location"]
+                    string.append(
+                        "\n".join(
+                            [
+                                f"Title: {result['title']}",
+                                f"Link: {final_link}",
+                                f"Source: {result['source']['title']}",
+                                f"Published: {result['published']}",
+                                "---",
+                            ]
+                        )
+                    )
                 except KeyError:
                     continue
 
-            content = '\n'.join(string)
+            content = "\n".join(string)
             return f"\nSearch results: {content}\n"
         else:
             return results

src/crewai_tools/tools/serply_api_tool/serply_scholar_search_tool.py

@@ -1,36 +1,39 @@
 import os
-import requests
+from typing import Any, Optional, Type
 from urllib.parse import urlencode
-from typing import Type, Any, Optional
-from pydantic.v1 import BaseModel, Field
+
+import requests
+from pydantic import BaseModel, Field
+
 from crewai_tools.tools.base_tool import BaseTool
 
 
 class SerplyScholarSearchToolSchema(BaseModel):
     """Input for Serply Scholar Search."""
-    search_query: str = Field(..., description="Mandatory search query you want to use to fetch scholarly literature")
+
+    search_query: str = Field(
+        ...,
+        description="Mandatory search query you want to use to fetch scholarly literature",
+    )
 
 
 class SerplyScholarSearchTool(BaseTool):
     name: str = "Scholar Search"
-    description: str = "A tool to perform scholarly literature search with a search_query."
+    description: str = (
+        "A tool to perform scholarly literature search with a search_query."
+    )
     args_schema: Type[BaseModel] = SerplyScholarSearchToolSchema
     search_url: str = "https://api.serply.io/v1/scholar/"
     hl: Optional[str] = "us"
     proxy_location: Optional[str] = "US"
     headers: Optional[dict] = {}
 
-    def __init__(
-            self,
-            hl: str = "us",
-            proxy_location: Optional[str] = "US",
-            **kwargs
-    ):
+    def __init__(self, hl: str = "us", proxy_location: Optional[str] = "US", **kwargs):
         """
-            param: hl (str): host Language code to display results in
-                (reference https://developers.google.com/custom-search/docs/xml_results?hl=en#wsInterfaceLanguages)
-            proxy_location: (str): Specify the proxy location for the search, specifically for a specific country results.
-                 ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
+        param: hl (str): host Language code to display results in
+            (reference https://developers.google.com/custom-search/docs/xml_results?hl=en#wsInterfaceLanguages)
+        proxy_location: (str): Specify the proxy location for the search, specifically for a specific country results.
+             ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
         """
         super().__init__(**kwargs)
         self.hl = hl
@@ -38,16 +41,14 @@ class SerplyScholarSearchTool(BaseTool):
         self.headers = {
             "X-API-KEY": os.environ["SERPLY_API_KEY"],
             "User-Agent": "crew-tools",
-            "X-Proxy-Location": proxy_location
+            "X-Proxy-Location": proxy_location,
         }
 
     def _run(
-            self,
-            **kwargs: Any,
+        self,
+        **kwargs: Any,
     ) -> Any:
-        query_payload = {
-            "hl": self.hl
-        }
+        query_payload = {"hl": self.hl}
 
         if "query" in kwargs:
             query_payload["q"] = kwargs["query"]
@@ -67,20 +68,24 @@ class SerplyScholarSearchTool(BaseTool):
         for article in articles:
             try:
                 if "doc" in article:
-                    link = article['doc']['link']
+                    link = article["doc"]["link"]
                 else:
-                    link = article['link']
-                authors = [author['name'] for author in article['author']['authors']]
-                string.append('\n'.join([
-                    f"Title: {article['title']}",
-                    f"Link: {link}",
-                    f"Description: {article['description']}",
-                    f"Cite: {article['cite']}",
-                    f"Authors: {', '.join(authors)}",
-                    "---"
-                ]))
+                    link = article["link"]
+                authors = [author["name"] for author in article["author"]["authors"]]
+                string.append(
+                    "\n".join(
+                        [
+                            f"Title: {article['title']}",
+                            f"Link: {link}",
+                            f"Description: {article['description']}",
+                            f"Cite: {article['cite']}",
+                            f"Authors: {', '.join(authors)}",
+                            "---",
+                        ]
+                    )
+                )
             except KeyError:
                 continue
 
-        content = '\n'.join(string)
+        content = "\n".join(string)
         return f"\nSearch results: {content}\n"

src/crewai_tools/tools/serply_api_tool/serply_web_search_tool.py

@@ -1,14 +1,19 @@
 import os
-import requests
+from typing import Any, Optional, Type
 from urllib.parse import urlencode
-from typing import Type, Any, Optional
-from pydantic.v1 import BaseModel, Field
+
+import requests
+from pydantic import BaseModel, Field
+
 from crewai_tools.tools.base_tool import BaseTool
 
 
 class SerplyWebSearchToolSchema(BaseModel):
     """Input for Serply Web Search."""
-    search_query: str = Field(..., description="Mandatory search query you want to use to Google search")
+
+    search_query: str = Field(
+        ..., description="Mandatory search query you want to use to Google search"
+    )
 
 
 class SerplyWebSearchTool(BaseTool):
@@ -24,21 +29,21 @@ class SerplyWebSearchTool(BaseTool):
     headers: Optional[dict] = {}
 
     def __init__(
-            self,
-            hl: str = "us",
-            limit: int = 10,
-            device_type: str = "desktop",
-            proxy_location: str = "US",
-            **kwargs
+        self,
+        hl: str = "us",
+        limit: int = 10,
+        device_type: str = "desktop",
+        proxy_location: str = "US",
+        **kwargs,
     ):
         """
-            param: query (str): The query to search for
-            param: hl (str): host Language code to display results in
-                (reference https://developers.google.com/custom-search/docs/xml_results?hl=en#wsInterfaceLanguages)
-            param: limit (int): The maximum number of results to return [10-100, defaults to 10]
-            param: device_type (str): desktop/mobile results (defaults to desktop)
-            proxy_location: (str): Where to perform the search, specifically for local/regional results.
-                 ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
+        param: query (str): The query to search for
+        param: hl (str): host Language code to display results in
+            (reference https://developers.google.com/custom-search/docs/xml_results?hl=en#wsInterfaceLanguages)
+        param: limit (int): The maximum number of results to return [10-100, defaults to 10]
+        param: device_type (str): desktop/mobile results (defaults to desktop)
+        proxy_location: (str): Where to perform the search, specifically for local/regional results.
+             ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
         """
         super().__init__(**kwargs)
 
@@ -50,18 +55,18 @@ class SerplyWebSearchTool(BaseTool):
         self.query_payload = {
             "num": limit,
             "gl": proxy_location.upper(),
-            "hl": hl.lower()
+            "hl": hl.lower(),
         }
         self.headers = {
             "X-API-KEY": os.environ["SERPLY_API_KEY"],
             "X-User-Agent": device_type,
             "User-Agent": "crew-tools",
-            "X-Proxy-Location": proxy_location
+            "X-Proxy-Location": proxy_location,
         }
 
     def _run(
-            self,
-            **kwargs: Any,
+        self,
+        **kwargs: Any,
     ) -> Any:
         if "query" in kwargs:
             self.query_payload["q"] = kwargs["query"]
@@ -74,20 +79,24 @@ class SerplyWebSearchTool(BaseTool):
         response = requests.request("GET", url, headers=self.headers)
         results = response.json()
         if "results" in results:
-            results = results['results']
+            results = results["results"]
             string = []
             for result in results:
                 try:
-                    string.append('\n'.join([
-                        f"Title: {result['title']}",
-                        f"Link: {result['link']}",
-                        f"Description: {result['description'].strip()}",
-                        "---"
-                    ]))
+                    string.append(
+                        "\n".join(
+                            [
+                                f"Title: {result['title']}",
+                                f"Link: {result['link']}",
+                                f"Description: {result['description'].strip()}",
+                                "---",
+                            ]
+                        )
+                    )
                 except KeyError:
                     continue
 
-            content = '\n'.join(string)
+            content = "\n".join(string)
             return f"\nSearch results: {content}\n"
         else:
             return results

src/crewai_tools/tools/serply_api_tool/serply_webpage_to_markdown_tool.py

@@ -1,48 +1,50 @@
 import os
+from typing import Any, Optional, Type
+
 import requests
-from typing import Type, Any, Optional
-from pydantic.v1 import BaseModel, Field
+from pydantic import BaseModel, Field
+
 from crewai_tools.tools.rag.rag_tool import RagTool
 
 
 class SerplyWebpageToMarkdownToolSchema(BaseModel):
     """Input for Serply Search."""
-    url: str = Field(..., description="Mandatory url you want to use to fetch and convert to markdown")
+
+    url: str = Field(
+        ...,
+        description="Mandatory url you want to use to fetch and convert to markdown",
+    )
 
 
 class SerplyWebpageToMarkdownTool(RagTool):
     name: str = "Webpage to Markdown"
-    description: str = "A tool to perform convert a webpage to markdown to make it easier for LLMs to understand"
+    description: str = (
+        "A tool to perform convert a webpage to markdown to make it easier for LLMs to understand"
+    )
     args_schema: Type[BaseModel] = SerplyWebpageToMarkdownToolSchema
     request_url: str = "https://api.serply.io/v1/request"
     proxy_location: Optional[str] = "US"
     headers: Optional[dict] = {}
 
-    def __init__(
-            self,
-            proxy_location: Optional[str] = "US",
-            **kwargs
-    ):
+    def __init__(self, proxy_location: Optional[str] = "US", **kwargs):
         """
-            proxy_location: (str): Where to perform the search, specifically for a specific country results.
-                 ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
+        proxy_location: (str): Where to perform the search, specifically for a specific country results.
+             ['US', 'CA', 'IE', 'GB', 'FR', 'DE', 'SE', 'IN', 'JP', 'KR', 'SG', 'AU', 'BR'] (defaults to US)
         """
         super().__init__(**kwargs)
         self.proxy_location = proxy_location
         self.headers = {
             "X-API-KEY": os.environ["SERPLY_API_KEY"],
             "User-Agent": "crew-tools",
-            "X-Proxy-Location": proxy_location
+            "X-Proxy-Location": proxy_location,
         }
 
     def _run(
-            self,
-            **kwargs: Any,
+        self,
+        **kwargs: Any,
     ) -> Any:
-        data = {
-            "url": kwargs["url"],
-            "method": "GET",
-            "response_type": "markdown"
-        }
-        response = requests.request("POST", self.request_url, headers=self.headers, json=data)
+        data = {"url": kwargs["url"], "method": "GET", "response_type": "markdown"}
+        response = requests.request(
+            "POST", self.request_url, headers=self.headers, json=data
+        )
         return response.text