camel-ai 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

camel/functions/search_functions.py

@@ -14,8 +14,8 @@
 import os
 from typing import Any, Dict, List
 
-import camel.agents
-from camel.functions import OpenAIFunction
+from camel.agents import ChatAgent
+from camel.functions.openai_function import OpenAIFunction
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 
@@ -25,10 +25,10 @@ def search_wiki(entity: str) -> str:
     required page, containing factual information about the given entity.
 
     Args:
-        entity (string): The entity to be searched.
+        entity (str): The entity to be searched.
 
     Returns:
-        string: The search result. If the page corresponding to the entity
+        str: The search result. If the page corresponding to the entity
             exists, return the summary of this entity in a string.
     """
     try:
@@ -36,19 +36,23 @@ def search_wiki(entity: str) -> str:
     except ImportError:
         raise ImportError(
             "Please install `wikipedia` first. You can install it by running "
-            "`pip install wikipedia`.")
+            "`pip install wikipedia`."
+        )
 
     result: str
 
     try:
         result = wikipedia.summary(entity, sentences=5, auto_suggest=False)
     except wikipedia.exceptions.DisambiguationError as e:
-        result = wikipedia.summary(e.options[0], sentences=5,
-                                   auto_suggest=False)
+        result = wikipedia.summary(
+            e.options[0], sentences=5, auto_suggest=False
+        )
     except wikipedia.exceptions.PageError:
-        result = ("There is no page in Wikipedia corresponding to entity "
-                  f"{entity}, please specify another word to describe the"
-                  " entity to be searched.")
+        result = (
+            "There is no page in Wikipedia corresponding to entity "
+            f"{entity}, please specify another word to describe the"
+            " entity to be searched."
+        )
     except wikipedia.exceptions.WikipediaException as e:
         result = f"An exception occurred during the search: {e}"
 
@@ -59,7 +63,7 @@ def search_google(query: str) -> List[Dict[str, Any]]:
     r"""Use Google search engine to search information for the given query.
 
     Args:
-        query (string): The query to be searched.
+        query (str): The query to be searched.
 
     Returns:
         List[Dict[str, Any]]: A list of dictionaries where each dictionary
@@ -83,7 +87,7 @@ def search_google(query: str) -> List[Dict[str, Any]]:
                 as a whole',
                 'url': 'https://www.openai.com'
             }
-        title, descrption, url of a website.
+        title, description, url of a website.
     """
     import requests
 
@@ -100,9 +104,11 @@ def search_google(query: str) -> List[Dict[str, Any]]:
     num_result_pages = 10
     # Constructing the URL
     # Doc: https://developers.google.com/custom-search/v1/using_rest
-    url = f"https://www.googleapis.com/customsearch/v1?" \
-          f"key={GOOGLE_API_KEY}&cx={SEARCH_ENGINE_ID}&q={query}&start=" \
-          f"{start_page_idx}&lr={search_language}&num={num_result_pages}"
+    url = (
+        f"https://www.googleapis.com/customsearch/v1?"
+        f"key={GOOGLE_API_KEY}&cx={SEARCH_ENGINE_ID}&q={query}&start="
+        f"{start_page_idx}&lr={search_language}&num={num_result_pages}"
+    )
 
     responses = []
     # Fetch the results given the URL
@@ -118,8 +124,9 @@ def search_google(query: str) -> List[Dict[str, Any]]:
             # Iterate over 10 results found
             for i, search_item in enumerate(search_items, start=1):
                 if "og:description" in search_item["pagemap"]["metatags"][0]:
-                    long_description = \
-                        search_item["pagemap"]["metatags"][0]["og:description"]
+                    long_description = search_item["pagemap"]["metatags"][0][
+                        "og:description"
+                    ]
                 else:
                     long_description = "N/A"
                 # Get the page title
@@ -134,7 +141,7 @@ def search_google(query: str) -> List[Dict[str, Any]]:
                     "title": title,
                     "description": snippet,
                     "long_description": long_description,
-                    "url": link
+                    "url": link,
                 }
                 responses.append(response)
         else:
@@ -150,10 +157,10 @@ def text_extract_from_web(url: str) -> str:
     r"""Get the text information from given url.
 
     Args:
-        url (string): The web site you want to search.
+        url (str): The website you want to search.
 
     Returns:
-        string: All texts extract from the web.
+        str: All texts extract from the web.
     """
     import requests
     from bs4 import BeautifulSoup
@@ -171,8 +178,9 @@ def text_extract_from_web(url: str) -> str:
         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("  "))
+        chunks = (
+            phrase.strip() for line in lines for phrase in line.split("  ")
+        )
         text = ".".join(chunk for chunk in chunks if chunk)
 
     except requests.RequestException:
@@ -186,11 +194,11 @@ def create_chunks(text: str, n: int) -> List[str]:
     r"""Returns successive n-sized chunks from provided text."
 
     Args:
-        text (string): The text to be split.
+        text (str): The text to be split.
         n (int): The max length of a single chunk.
 
     Returns:
-        List[str]: A list of splited texts.
+        List[str]: A list of split texts.
     """
 
     chunks = []
@@ -220,7 +228,7 @@ def prompt_single_step_agent(prompt: str) -> str:
         role_name="Assistant",
         content="You are a helpful assistant.",
     )
-    agent = camel.agents.ChatAgent(assistant_sys_msg)
+    agent = ChatAgent(assistant_sys_msg)
     agent.reset()
 
     user_msg = BaseMessage.make_user_message(
@@ -238,15 +246,16 @@ def summarize_text(text: str, query: str) -> str:
     given.
 
     Args:
-        text (string): Text to summarise.
-        query (string): What information you want.
+        text (str): Text to summarize.
+        query (str): What information you want.
 
     Returns:
-        string: Strings with information.
+        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 ''')
+         do not directly answer the question.\nquestion: {query}\ntext '''
+    )
     summary_prompt = summary_prompt.format(query=query)
     # Max length of each chunk
     max_len = 3000
@@ -261,7 +270,8 @@ def summarize_text(text: str, query: str) -> str:
     # 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: ''')
+        information to answer the question: {query}.\n\nText: '''
+    )
     final_prompt = final_prompt.format(query=query)
     prompt = final_prompt + results
 
@@ -276,10 +286,10 @@ def search_google_and_summarize(query: str) -> str:
     internet, and then return a summarized answer.
 
     Args:
-        query (string): Question you want to be answered.
+        query (str): Question you want to be answered.
 
     Returns:
-        string: Summarized information from webs.
+        str: Summarized information from webs.
     """
     # Google search will return a list of urls
     responses = search_google(query)
@@ -294,7 +304,8 @@ def search_google_and_summarize(query: str) -> str:
             # 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.''')
+                {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():
@@ -303,7 +314,61 @@ def search_google_and_summarize(query: str) -> str:
     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
+    service that answers factual queries by computing answers from externally
+    sourced data.
+
+    Args:
+        query (str): The query to send to Wolfram Alpha.
+        is_detailed (bool): Whether to include additional details in the
+            result.
+
+    Returns:
+        str: The result from Wolfram Alpha, formatted as a string.
+    """
+    try:
+        import wolframalpha
+    except ImportError:
+        raise ImportError(
+            "Please install `wolframalpha` first. You can install it by running `pip install wolframalpha`."
+        )
+
+    WOLFRAMALPHA_APP_ID = os.environ.get('WOLFRAMALPHA_APP_ID')
+    if not WOLFRAMALPHA_APP_ID:
+        raise ValueError(
+            "`WOLFRAMALPHA_APP_ID` not found in environment "
+            "variables. Get `WOLFRAMALPHA_APP_ID` here: "
+            "`https://products.wolframalpha.com/api/`."
+        )
+
+    try:
+        client = wolframalpha.Client(WOLFRAMALPHA_APP_ID)
+        res = client.query(query)
+        assumption = next(res.pods).text or "No assumption made."
+        answer = next(res.results).text or "No answer found."
+    except Exception as e:
+        if isinstance(e, StopIteration):
+            return "Wolfram Alpha wasn't able to answer it"
+        else:
+            error_message = f"Wolfram Alpha wasn't able to answer it" f"{e!s}."
+            return error_message
+
+    result = f"Assumption:\n{assumption}\n\nAnswer:\n{answer}"
+
+    # Add additional details in the result
+    if is_detailed:
+        result += '\n'
+        for pod in res.pods:
+            result += '\n' + pod['@title'] + ':\n'
+            for sub in pod.subpods:
+                result += (sub.plaintext or "None") + '\n'
+
+    return result.rstrip()  # Remove trailing whitespace
+
+
 SEARCH_FUNCS: List[OpenAIFunction] = [
-    OpenAIFunction(func)
-    for func in [search_wiki, search_google_and_summarize]
+    OpenAIFunction(func)  # type: ignore[arg-type]
+    for func in [search_wiki, search_google_and_summarize, query_wolfram_alpha]
 ]

camel/functions/slack_functions.py

@@ -0,0 +1,275 @@
+# =========== 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 __future__ import annotations
+
+import json
+import logging
+import os
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from ssl import SSLContext
+
+    from slack_sdk import WebClient
+
+from slack_sdk.errors import SlackApiError
+
+from camel.functions import OpenAIFunction
+
+logger = logging.getLogger(__name__)
+
+
+def _login_slack(
+    slack_token: Optional[str] = None,
+    ssl: Optional[SSLContext] = None,
+) -> WebClient:
+    r"""Authenticate using the Slack API.
+
+    Args:
+        slack_token (str, optional): The Slack API token. If not provided, it
+            attempts to retrieve the token from the environment variable
+            SLACK_BOT_TOKEN or SLACK_USER_TOKEN.
+        ssl (SSLContext, optional): SSL context for secure connections.
+            Defaults to `None`.
+
+    Returns:
+        WebClient: A WebClient object for interacting with Slack API.
+
+    Raises:
+        ImportError: If slack_sdk package is not installed.
+        KeyError: If SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variables
+            are not set.
+    """
+    try:
+        from slack_sdk import WebClient
+    except ImportError as e:
+        raise ImportError(
+            "Cannot import slack_sdk. Please install the package with \
+            `pip install slack_sdk`."
+        ) from e
+    if not slack_token:
+        slack_token = os.environ.get("SLACK_BOT_TOKEN") or os.environ.get(
+            "SLACK_USER_TOKEN"
+        )
+        if not slack_token:
+            raise KeyError(
+                "SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variable not set."
+            )
+
+    client = WebClient(token=slack_token, ssl=ssl)
+    logger.info("Slack login successful.")
+    return client
+
+
+def create_slack_channel(name: str, is_private: Optional[bool] = True) -> str:
+    r"""Creates a new slack channel, either public or private.
+
+    Args:
+        name (str): Name of the public or private channel to create.
+        is_private (bool, optional): Whether to create a private channel
+            instead of a public one. Defaults to `True`.
+
+    Returns:
+        str: JSON string containing information about Slack channel created.
+
+    Raises:
+        SlackApiError: If there is an error during get slack channel
+            information.
+    """
+    try:
+        slack_client = _login_slack()
+        response = slack_client.conversations_create(
+            name=name, is_private=is_private
+        )
+        channel_id = response["channel"]["id"]
+        response = slack_client.conversations_archive(channel=channel_id)
+        return str(response)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+def join_slack_channel(channel_id: str) -> str:
+    r"""Joins an existing Slack channel.
+
+    Args:
+        channel_id (str): The ID of the Slack channel to join.
+
+    Returns:
+        str: A confirmation message indicating whether join successfully or an
+            error message.
+
+    Raises:
+        SlackApiError: If there is an error during get slack channel
+            information.
+    """
+    try:
+        slack_client = _login_slack()
+        response = slack_client.conversations_join(channel=channel_id)
+        return str(response)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+def leave_slack_channel(channel_id: str) -> str:
+    r"""Leaves an existing Slack channel.
+
+    Args:
+        channel_id (str): The ID of the Slack channel to leave.
+
+    Returns:
+        str: A confirmation message indicating whether leave successfully or an
+            error message.
+
+    Raises:
+        SlackApiError: If there is an error during get slack channel
+            information.
+    """
+    try:
+        slack_client = _login_slack()
+        response = slack_client.conversations_leave(channel=channel_id)
+        return str(response)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+def get_slack_channel_information() -> str:
+    r"""Retrieve Slack channels and return relevant information in JSON format.
+
+    Returns:
+        str: JSON string containing information about Slack channels.
+
+    Raises:
+        SlackApiError: If there is an error during get slack channel
+            information.
+    """
+    try:
+        slack_client = _login_slack()
+        response = slack_client.conversations_list()
+        conversations = response["channels"]
+        # Filtering conversations and extracting required information
+        filtered_result = [
+            {
+                key: conversation[key]
+                for key in ("id", "name", "created", "num_members")
+            }
+            for conversation in conversations
+            if all(
+                key in conversation
+                for key in ("id", "name", "created", "num_members")
+            )
+        ]
+        return json.dumps(filtered_result, ensure_ascii=False)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+def get_slack_channel_message(channel_id: str) -> str:
+    r"""Retrieve messages from a Slack channel.
+
+    Args:
+        channel_id (str): The ID of the Slack channel to retrieve messages
+            from.
+
+    Returns:
+        str: JSON string containing filtered message data.
+
+    Raises:
+        SlackApiError: If there is an error during get slack channel message.
+    """
+    try:
+        slack_client = _login_slack()
+        result = slack_client.conversations_history(channel=channel_id)
+        messages = result["messages"]
+        filtered_messages = [
+            {key: message[key] for key in ("user", "text", "ts")}
+            for message in messages
+            if all(key in message for key in ("user", "text", "ts"))
+        ]
+        return json.dumps(filtered_messages, ensure_ascii=False)
+    except SlackApiError as e:
+        return f"Error retrieving messages: {e.response['error']}"
+
+
+def send_slack_message(
+    message: str,
+    channel_id: str,
+    user: Optional[str] = None,
+) -> str:
+    r"""Send a message to a Slack channel.
+
+    Args:
+        message (str): The message to send.
+        channel_id (str): The ID of the Slack channel to send message.
+        user (Optional[str]): The user ID of the recipient. Defaults to `None`.
+
+    Returns:
+        str: A confirmation message indicating whether the message was sent
+            successfully or an error message.
+
+    Raises:
+        SlackApiError: If an error occurs while sending the message.
+    """
+    try:
+        slack_client = _login_slack()
+        if user:
+            response = slack_client.chat_postEphemeral(
+                channel=channel_id, text=message, user=user
+            )
+        else:
+            response = slack_client.chat_postMessage(
+                channel=channel_id, text=message
+            )
+        return str(response)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+def delete_slack_message(
+    time_stamp: str,
+    channel_id: str,
+) -> str:
+    r"""Delete a message to a Slack channel.
+
+    Args:
+        time_stamp (str): Timestamp of the message to be deleted.
+        channel_id (str): The ID of the Slack channel to delete message.
+
+    Returns:
+        str: A confirmation message indicating whether the message was delete
+            successfully or an error message.
+
+    Raises:
+        SlackApiError: If an error occurs while sending the message.
+    """
+    try:
+        slack_client = _login_slack()
+        response = slack_client.chat_delete(channel=channel_id, ts=time_stamp)
+        return str(response)
+    except SlackApiError as e:
+        return f"Error creating conversation: {e.response['error']}"
+
+
+SLACK_FUNCS: List[OpenAIFunction] = [
+    OpenAIFunction(func)  # type: ignore[arg-type]
+    for func in [
+        create_slack_channel,
+        join_slack_channel,
+        leave_slack_channel,
+        get_slack_channel_information,
+        get_slack_channel_message,
+        send_slack_message,
+        delete_slack_message,
+    ]
+]