camel-ai 0.1.5__py3-none-any.whl → 0.1.5.2__py3-none-any.whl

camel/functions/open_api_specs/outschool/paths/search_teachers.py

@@ -0,0 +1,29 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+"""Search for teachers on Outschool."""
+
+from typing import Any, Dict
+
+import requests
+
+
+def call_api(input_json: Dict[str, Any]) -> Dict[str, Any]:
+    response = requests.get(
+        "https://chatgpt-plugin.outschool.com/api/teachers", params=input_json
+    )
+
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return {"status_code": response.status_code, "text": response.text}

camel/functions/open_api_specs/security_config.py

@@ -0,0 +1,21 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from camel.types import OpenAPIName
+
+openapi_security_config = {
+    OpenAPIName.NASA_APOD.value: {
+        "api_key": "NASA_API_KEY",
+        "get_api_key_url": "https://api.nasa.gov/",
+    },
+}

camel/functions/open_api_specs/web_scraper/__init__.py

@@ -0,0 +1,13 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========

camel/functions/open_api_specs/web_scraper/ai-plugin.json

@@ -0,0 +1,34 @@
+{
+    "id": "plugin-0609b24f-5c80-4864-af90-c7c570d65375",
+    "domain": "scraper.gafo.tech",
+    "namespace": "web_scraper",
+    "status": "approved",
+    "manifest": {
+        "schema_version": "v1",
+        "name_for_model": "web_scraper",
+        "name_for_human": "Scraper",
+        "description_for_model": "Scrape content from webpages by providing a URL.",
+        "description_for_human": "Scrape content from webpages by providing a URL.",
+        "auth": {
+            "type": "none"
+        },
+        "api": {
+            "type": "openapi",
+            "url": "https://scraper.gafo.tech/openapi.yaml"
+        },
+        "logo_url": "https://scraper.gafo.tech/logo.png",
+        "contact_email": "gafotech1@gmail.com",
+        "legal_info_url": "https://scraper.gafo.tech/legal"
+    },
+    "oauth_client_id": null,
+    "user_settings": {
+        "is_installed": false,
+        "is_authenticated": true
+    },
+    "categories": [
+        {
+            "id": "newly_added",
+            "title": "New"
+        }
+    ]
+}

camel/functions/open_api_specs/web_scraper/openapi.yaml

@@ -0,0 +1,71 @@
+openapi: 3.0.1
+info:
+  title: Scraper
+  description: Scrape content from webpages by providing a URL.
+  version: "v1"
+servers:
+  - url: https://scraper.gafo.tech
+paths:
+  /scrape:
+    post:
+      operationId: scrape
+      summary: Scrape content from a webpage
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                url:
+                  type: string
+                  format: uri
+                  example: https://example.com
+                type:
+                  type: string
+                  enum: [text, links, images]
+                  default: text
+                  example: text
+              required:
+                - url
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  text:
+                    type: string
+                    description: The text content of the webpage. Returned when type is text or not provided.
+                  links:
+                    type: array
+                    items:
+                      type: object
+                    description: The array of link objects with all attributes from the webpage. Returned when type is links.
+                  images:
+                    type: array
+                    items:
+                      type: object
+                    description: The array of image objects with all attributes from the webpage. Returned when type is images.
+        "400":
+          description: Bad Request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    description: The error message.
+        "500":
+          description: Internal Server Error
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    description: The error message.

camel/functions/open_api_specs/web_scraper/paths/__init__.py

@@ -0,0 +1,13 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========

camel/functions/open_api_specs/web_scraper/paths/scraper.py

@@ -0,0 +1,29 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+"""Scrape data from a website using the Scraper API."""
+
+from typing import Any, Dict
+
+import requests
+
+
+def call_api(input_json: Dict[str, Any]) -> Dict[str, Any]:
+    response = requests.post(
+        "https://scraper.gafo.tech/scrape", json=input_json
+    )
+
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return {"status_code": response.status_code, "text": response.text}

camel/functions/openai_function.py

@@ -173,7 +173,9 @@ class OpenAIFunction:
         )
 
     @staticmethod
-    def validate_openai_tool_schema(openai_tool_schema: Dict[str, Any]) -> None:
+    def validate_openai_tool_schema(
+        openai_tool_schema: Dict[str, Any],
+    ) -> None:
         r"""Validates the OpenAI tool schema against
         :obj:`ToolAssistantToolsFunction`.
         This function checks if the provided :obj:`openai_tool_schema` adheres

camel/functions/search_functions.py

@@ -14,15 +14,12 @@
 import os
 from typing import Any, Dict, List
 
-from camel.agents import ChatAgent
 from camel.functions.openai_function import OpenAIFunction
-from camel.messages import BaseMessage
-from camel.prompts import TextPrompt
 
 
 def search_wiki(entity: str) -> str:
-    r"""Search the entity in WikiPedia and return the summary of the
-    required page, containing factual information about the given entity.
+    r"""Search the entity in WikiPedia and return the summary of the required
+        page, containing factual information about the given entity.
 
     Args:
         entity (str): The entity to be searched.
@@ -59,11 +56,101 @@ def search_wiki(entity: str) -> str:
     return result
 
 
-def search_google(query: str) -> List[Dict[str, Any]]:
+def search_duckduckgo(
+    query: str, source: str = "text", max_results: int = 10
+) -> List[Dict[str, Any]]:
+    r"""Use DuckDuckGo search engine to search information for the given query.
+
+    This function queries the DuckDuckGo API for related topics to the given
+    search term. The results are formatted into a list of dictionaries, each
+    representing a search result.
+
+    Args:
+        query (str): The query to be searched.
+        source (str): The type of information to query (e.g., "text",
+            "images", "videos"). Defaults to "text".
+        max_results (int): Max number of results, defaults to `10`.
+
+    Returns:
+        List[Dict[str, Any]]: A list of dictionaries where each dictionary
+            represents a search result.
+    """
+    from duckduckgo_search import DDGS
+    from requests.exceptions import RequestException
+
+    ddgs = DDGS()
+    responses: List[Dict[str, Any]] = []
+
+    if source == "text":
+        try:
+            results = ddgs.text(keywords=query, max_results=max_results)
+        except RequestException as e:
+            # Handle specific exceptions or general request exceptions
+            responses.append({"error": f"duckduckgo search failed.{e}"})
+
+        # Iterate over results found
+        for i, result in enumerate(results, start=1):
+            # Creating a response object with a similar structure
+            response = {
+                "result_id": i,
+                "title": result["title"],
+                "description": result["body"],
+                "url": result["href"],
+            }
+            responses.append(response)
+
+    elif source == "images":
+        try:
+            results = ddgs.images(keywords=query, max_results=max_results)
+        except RequestException as e:
+            # Handle specific exceptions or general request exceptions
+            responses.append({"error": f"duckduckgo search failed.{e}"})
+
+        # Iterate over results found
+        for i, result in enumerate(results, start=1):
+            # Creating a response object with a similar structure
+            response = {
+                "result_id": i,
+                "title": result["title"],
+                "image": result["image"],
+                "url": result["url"],
+                "source": result["source"],
+            }
+            responses.append(response)
+
+    elif source == "videos":
+        try:
+            results = ddgs.videos(keywords=query, max_results=max_results)
+        except RequestException as e:
+            # Handle specific exceptions or general request exceptions
+            responses.append({"error": f"duckduckgo search failed.{e}"})
+
+        # Iterate over results found
+        for i, result in enumerate(results, start=1):
+            # Creating a response object with a similar structure
+            response = {
+                "result_id": i,
+                "title": result["title"],
+                "description": result["description"],
+                "embed_url": result["embed_url"],
+                "publisher": result["publisher"],
+                "duration": result["duration"],
+                "published": result["published"],
+            }
+            responses.append(response)
+
+    # If no answer found, return an empty list
+    return responses
+
+
+def search_google(
+    query: str, num_result_pages: int = 10
+) -> List[Dict[str, Any]]:
     r"""Use Google search engine to search information for the given query.
 
     Args:
         query (str): The query to be searched.
+        num_result_pages (int): The number of result pages to retrieve.
 
     Returns:
         List[Dict[str, Any]]: A list of dictionaries where each dictionary
@@ -82,7 +169,7 @@ def search_google(query: str) -> List[Dict[str, Any]]:
                 'description': 'An organization focused on ensuring that
                 artificial general intelligence benefits all of humanity.',
                 'long_description': 'OpenAI is a non-profit artificial
-                 intelligence research company. Our goal is to advance digital
+                intelligence research company. Our goal is to advance digital
                 intelligence in the way that is most likely to benefit humanity
                 as a whole',
                 'url': 'https://www.openai.com'
@@ -148,172 +235,12 @@ def search_google(query: str) -> List[Dict[str, Any]]:
             responses.append({"error": "google search failed."})
 
     except requests.RequestException:
+        # Handle specific exceptions or general request exceptions
         responses.append({"error": "google search failed."})
-
+    # If no answer found, return an empty list
     return responses
 
 
-def text_extract_from_web(url: str) -> str:
-    r"""Get the text information from given url.
-
-    Args:
-        url (str): The website you want to search.
-
-    Returns:
-        str: All texts extract from the web.
-    """
-    import requests
-    from bs4 import BeautifulSoup
-
-    try:
-        # Request the target page
-        response_text = requests.get(url).text
-
-        # Parse the obtained page
-        soup = BeautifulSoup(response_text, features="html.parser")
-
-        for script in soup(["script", "style"]):
-            script.extract()
-
-        text = soup.get_text()
-        # Strip text
-        lines = (line.strip() for line in text.splitlines())
-        chunks = (
-            phrase.strip() for line in lines for phrase in line.split("  ")
-        )
-        text = ".".join(chunk for chunk in chunks if chunk)
-
-    except requests.RequestException:
-        text = f"can't access {url}"
-
-    return text
-
-
-# Split a text into smaller chunks of size n
-def create_chunks(text: str, n: int) -> List[str]:
-    r"""Returns successive n-sized chunks from provided text."
-
-    Args:
-        text (str): The text to be split.
-        n (int): The max length of a single chunk.
-
-    Returns:
-        List[str]: A list of split texts.
-    """
-
-    chunks = []
-    i = 0
-    while i < len(text):
-        # Find the nearest end of sentence within a range of 0.5 * n
-        # and 1.5 * n tokens
-        j = min(i + int(1.2 * n), len(text))
-        while j > i + int(0.8 * n):
-            # Decode the tokens and check for full stop or newline
-            chunk = text[i:j]
-            if chunk.endswith(".") or chunk.endswith("\n"):
-                break
-            j -= 1
-        # If no end of sentence found, use n tokens as the chunk size
-        if j == i + int(0.8 * n):
-            j = min(i + n, len(text))
-        chunks.append(text[i:j])
-        i = j
-    return chunks
-
-
-def prompt_single_step_agent(prompt: str) -> str:
-    """Prompt a single-step agent to summarize texts or answer a question."""
-
-    assistant_sys_msg = BaseMessage.make_assistant_message(
-        role_name="Assistant",
-        content="You are a helpful assistant.",
-    )
-    agent = ChatAgent(assistant_sys_msg)
-    agent.reset()
-
-    user_msg = BaseMessage.make_user_message(
-        role_name="User",
-        content=prompt,
-    )
-    assistant_response = agent.step(user_msg)
-    if assistant_response.msgs is not None:
-        return assistant_response.msg.content
-    return ""
-
-
-def summarize_text(text: str, query: str) -> str:
-    r"""Summarize the information from the text, base on the query if query is
-    given.
-
-    Args:
-        text (str): Text to summarize.
-        query (str): What information you want.
-
-    Returns:
-        str: Strings with information.
-    """
-    summary_prompt = TextPrompt(
-        '''Gather information from this text that relative to the question, but
-         do not directly answer the question.\nquestion: {query}\ntext '''
-    )
-    summary_prompt = summary_prompt.format(query=query)
-    # Max length of each chunk
-    max_len = 3000
-    results = ""
-    chunks = create_chunks(text, max_len)
-    # Summarize
-    for i, chunk in enumerate(chunks, start=1):
-        prompt = summary_prompt + str(i) + ": " + chunk
-        result = prompt_single_step_agent(prompt)
-        results += result + "\n"
-
-    # Final summarise
-    final_prompt = TextPrompt(
-        '''Here are some summarized texts which split from one text, Using the
-        information to answer the question: {query}.\n\nText: '''
-    )
-    final_prompt = final_prompt.format(query=query)
-    prompt = final_prompt + results
-
-    response = prompt_single_step_agent(prompt)
-
-    return response
-
-
-def search_google_and_summarize(query: str) -> str:
-    r"""Search webs for information. Given a query, this function will use
-    the Google search engine to search for related information from the
-    internet, and then return a summarized answer.
-
-    Args:
-        query (str): Question you want to be answered.
-
-    Returns:
-        str: Summarized information from webs.
-    """
-    # Google search will return a list of urls
-    responses = search_google(query)
-    for item in responses:
-        if "url" in item:
-            url = item.get("url")
-            # Extract text
-            text = text_extract_from_web(str(url))
-            # Using chatgpt summarise text
-            answer = summarize_text(text, query)
-
-            # Let chatgpt decide whether to continue search or not
-            prompt = TextPrompt(
-                '''Do you think the answer: {answer} can answer the query:
-                {query}. Use only 'yes' or 'no' to answer.'''
-            )
-            prompt = prompt.format(answer=answer, query=query)
-            reply = prompt_single_step_agent(prompt)
-            if "yes" in str(reply).lower():
-                return answer
-
-    return "Failed to find the answer from google search."
-
-
 def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
     r"""Queries Wolfram|Alpha and returns the result. Wolfram|Alpha is an
     answer engine developed by Wolfram Research. It is offered as an online
@@ -332,7 +259,8 @@ def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
         import wolframalpha
     except ImportError:
         raise ImportError(
-            "Please install `wolframalpha` first. You can install it by running `pip install wolframalpha`."
+            "Please install `wolframalpha` first. You can install it by"
+            " running `pip install wolframalpha`."
         )
 
     WOLFRAMALPHA_APP_ID = os.environ.get('WOLFRAMALPHA_APP_ID')
@@ -370,5 +298,10 @@ def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
 
 SEARCH_FUNCS: List[OpenAIFunction] = [
     OpenAIFunction(func)  # type: ignore[arg-type]
-    for func in [search_wiki, search_google_and_summarize, query_wolfram_alpha]
+    for func in [
+        search_wiki,
+        search_google,
+        search_duckduckgo,
+        query_wolfram_alpha,
+    ]
 ]

camel/functions/slack_functions.py

@@ -65,7 +65,8 @@ def _login_slack(
         )
         if not slack_token:
             raise KeyError(
-                "SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variable not set."
+                "SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variable not "
+                "set."
             )
 
     client = WebClient(token=slack_token, ssl=ssl)

camel/human.py

@@ -112,7 +112,9 @@ class Human:
 
         return content
 
-    def reduce_step(self, messages: Sequence[BaseMessage]) -> ChatAgentResponse:
+    def reduce_step(
+        self, messages: Sequence[BaseMessage]
+    ) -> ChatAgentResponse:
         r"""Performs one step of the conversation by displaying options to the
         user, getting their input, and parsing their choice.
 

camel/loaders/base_io.py

@@ -65,7 +65,9 @@ class File(ABC):
         )
 
     def __str__(self) -> str:
-        return f"File(name={self.name}, id={self.id}, metadata={self.metadata})"
+        return (
+            f"File(name={self.name}, id={self.id}, metadata={self.metadata})"
+        )
 
     def copy(self) -> "File":
         r"""Create a deep copy of this File"""

camel/loaders/unstructured_io.py

@@ -131,30 +131,22 @@ class UnstructuredIO:
         self,
         input_path: str,
         **kwargs: Any,
-    ) -> Union[Any, List[Any]]:
-        r"""Loads a file or a URL and parses its contents as unstructured data.
+    ) -> List[Element]:
+        r"""Loads a file or a URL and parses its contents into elements.
 
         Args:
             input_path (str): Path to the file or URL to be parsed.
             **kwargs: Extra kwargs passed to the partition function.
 
         Returns:
-            List[Any]: The elements after parsing the file or URL, could be a
-                dict, list, etc., depending on the content. If return_str is
-                True, returns a tuple with a string representation of the
-                elements and the elements themselves.
+            List[Element]: List of elements after parsing the file or URL.
 
         Raises:
-            FileNotFoundError: If the file does not exist
-                at the path specified.
+            FileNotFoundError: If the file does not exist at the path
+                specified.
             Exception: For any other issues during file or URL parsing.
 
         Notes:
-            By default we use the basic "unstructured" library,
-            if you are processing document types beyond the basics,
-            you can install the necessary extras like:
-                `pip install "unstructured[docx,pptx]"` or
-                `pip install "unstructured[all-docs]"`.
             Available document types:
                 "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
                 "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
@@ -185,7 +177,9 @@ class UnstructuredIO:
 
             # Check if the file exists
             if not os.path.exists(input_path):
-                raise FileNotFoundError(f"The file {input_path} was not found.")
+                raise FileNotFoundError(
+                    f"The file {input_path} was not found."
+                )
 
             # Read the file
             try:
@@ -193,7 +187,9 @@ class UnstructuredIO:
                     elements = partition(file=f, **kwargs)
                     return elements
             except Exception as e:
-                raise Exception("Failed to parse the unstructured file.") from e
+                raise Exception(
+                    "Failed to parse the unstructured file."
+                ) from e
 
     def clean_text_data(
         self,
@@ -433,9 +429,8 @@ class UnstructuredIO:
                 els, kw.get('metadata', [])
             ),
             "stage_for_baseplate": baseplate.stage_for_baseplate,
-            "stage_for_datasaur": lambda els, **kw: datasaur.stage_for_datasaur(
-                els, kw.get('entities', [])
-            ),
+            "stage_for_datasaur": lambda els,
+            **kw: datasaur.stage_for_datasaur(els, kw.get('entities', [])),
             "stage_for_label_box": lambda els,
             **kw: label_box.stage_for_label_box(els, **kw),
             "stage_for_label_studio": lambda els,
@@ -450,11 +445,11 @@ class UnstructuredIO:
 
     def chunk_elements(
         self, elements: List[Any], chunk_type: str, **kwargs
-    ) -> List[Any]:
+    ) -> List[Element]:
         r"""Chunks elements by titles.
 
         Args:
-            elements (List[Any]): List of Element objects to be chunked.
+            elements (List[Element]): List of Element objects to be chunked.
             chunk_type (str): Type chunk going to apply. Supported types:
                 'chunk_by_title'.
             **kwargs: Additional keyword arguments for chunking.
@@ -531,8 +526,7 @@ class UnstructuredIO:
         account_name: str,
         num_processes: int = 2,
     ) -> None:
-        """
-        Processes documents from an Azure storage container and stores
+        r"""Processes documents from an Azure storage container and stores
         structured outputs locally.
 
         Args: