camel-ai 0.1.5.6__py3-none-any.whl → 0.1.5.7__py3-none-any.whl

camel/functions/search_functions.py

@@ -1,298 +0,0 @@
-# =========== 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. ===========
-import os
-from typing import Any, Dict, List
-
-from camel.functions.openai_function import OpenAIFunction
-from camel.utils import dependencies_required
-
-
-@dependencies_required('wikipedia')
-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.
-
-    Args:
-        entity (str): The entity to be searched.
-
-    Returns:
-        str: The search result. If the page corresponding to the entity
-            exists, return the summary of this entity in a string.
-    """
-    import 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
-        )
-    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."
-        )
-    except wikipedia.exceptions.WikipediaException as e:
-        result = f"An exception occurred during the search: {e}"
-
-    return result
-
-
-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
-        represents a website.
-            Each dictionary contains the following keys:
-            - 'result_id': A number in order.
-            - 'title': The title of the website.
-            - 'description': A brief description of the website.
-            - 'long_description': More detail of the website.
-            - 'url': The URL of the website.
-
-            Example:
-            {
-                'result_id': 1,
-                'title': 'OpenAI',
-                '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 in the way that is most likely to benefit humanity
-                as a whole',
-                'url': 'https://www.openai.com'
-            }
-        title, description, url of a website.
-    """
-    import requests
-
-    # https://developers.google.com/custom-search/v1/overview
-    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-    # https://cse.google.com/cse/all
-    SEARCH_ENGINE_ID = os.getenv("SEARCH_ENGINE_ID")
-
-    # Using the first page
-    start_page_idx = 1
-    # Different language may get different result
-    search_language = "en"
-    # How many pages to return
-    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}"
-    )
-
-    responses = []
-    # Fetch the results given the URL
-    try:
-        # Make the get
-        result = requests.get(url)
-        data = result.json()
-
-        # Get the result items
-        if "items" in data:
-            search_items = data.get("items")
-
-            # 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"
-                    ]
-                else:
-                    long_description = "N/A"
-                # Get the page title
-                title = search_item.get("title")
-                # Page snippet
-                snippet = search_item.get("snippet")
-
-                # Extract the page url
-                link = search_item.get("link")
-                response = {
-                    "result_id": i,
-                    "title": title,
-                    "description": snippet,
-                    "long_description": long_description,
-                    "url": link,
-                }
-                responses.append(response)
-        else:
-            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
-
-
-@dependencies_required('wolframalpha')
-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.
-    """
-    import 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)  # type: ignore[arg-type]
-    for func in [
-        search_wiki,
-        search_google,
-        search_duckduckgo,
-        query_wolfram_alpha,
-    ]
-]

camel/functions/slack_functions.py

@@ -1,286 +0,0 @@
-# =========== 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
-
-from camel.utils import dependencies_required
-
-if TYPE_CHECKING:
-    from ssl import SSLContext
-
-    from slack_sdk import WebClient
-
-from camel.functions import OpenAIFunction
-
-logger = logging.getLogger(__name__)
-
-
-@dependencies_required('slack_sdk')
-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.
-    """
-    from slack_sdk import WebClient
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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.
-    """
-    from slack_sdk.errors import SlackApiError
-
-    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,
-    ]
-]