camel-ai 0.2.3__py3-none-any.whl → 0.2.3a0__py3-none-any.whl

camel/bots/slack/slack_app.py

@@ -1,255 +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 logging
-import os
-from typing import TYPE_CHECKING, Any, Dict, Optional
-
-from slack_sdk.oauth.installation_store.async_installation_store import (
-    AsyncInstallationStore,
-)
-from starlette import requests, responses
-
-from camel.bots.slack.models import (
-    SlackAppMentionEventBody,
-    SlackAppMentionEventProfile,
-    SlackEventBody,
-    SlackEventProfile,
-)
-from camel.utils import dependencies_required
-
-if TYPE_CHECKING:
-    from slack_bolt.context.async_context import AsyncBoltContext
-    from slack_bolt.context.say.async_say import AsyncSay
-    from slack_sdk.web.async_client import AsyncWebClient
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class SlackApp:
-    r"""Represents a Slack app that is powered by a Slack Bolt `AsyncApp`.
-
-    This class is responsible for initializing and managing the Slack
-    application by setting up event handlers, running the app server, and
-    handling events such as messages and mentions from Slack.
-
-    Args:
-        token (Optional[str]): Slack API token for authentication.
-        scopes (Optional[str]): Slack app scopes for permissions.
-        signing_secret (Optional[str]): Signing secret for verifying Slack
-            requests.
-        client_id (Optional[str]): Slack app client ID.
-        client_secret (Optional[str]): Slack app client secret.
-        redirect_uri_path (str): The URI path for OAuth redirect, defaults to
-            "/slack/oauth_redirect".
-        installation_store (Optional[AsyncInstallationStore]): The installation
-            store for handling OAuth installations.
-    """
-
-    @dependencies_required('slack_bolt')
-    def __init__(
-        self,
-        token: Optional[str] = None,
-        scopes: Optional[str] = None,
-        signing_secret: Optional[str] = None,
-        client_id: Optional[str] = None,
-        client_secret: Optional[str] = None,
-        redirect_uri_path: str = "/slack/oauth_redirect",
-        installation_store: Optional[AsyncInstallationStore] = None,
-    ) -> None:
-        r"""Initializes the SlackApp instance by setting up the Slack Bolt app
-        and configuring event handlers and OAuth settings.
-
-        Args:
-            token (Optional[str]): The Slack API token.
-            scopes (Optional[str]): The scopes for Slack app permissions.
-            signing_secret (Optional[str]): The signing secret for verifying
-                requests.
-            client_id (Optional[str]): The Slack app client ID.
-            client_secret (Optional[str]): The Slack app client secret.
-            redirect_uri_path (str): The URI path for handling OAuth redirects
-                (default is "/slack/oauth_redirect").
-            installation_store (Optional[AsyncInstallationStore]): An optional
-                installation store for OAuth installations.
-        """
-        from slack_bolt.adapter.starlette.async_handler import (
-            AsyncSlackRequestHandler,
-        )
-        from slack_bolt.app.async_app import AsyncApp
-        from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
-
-        self.token: Optional[str] = token or os.getenv("SLACK_TOKEN")
-        self.scopes: Optional[str] = scopes or os.getenv("SLACK_SCOPES")
-        self.signing_secret: Optional[str] = signing_secret or os.getenv(
-            "SLACK_SIGNING_SECRET"
-        )
-        self.client_id: Optional[str] = client_id or os.getenv(
-            "SLACK_CLIENT_ID"
-        )
-        self.client_secret: Optional[str] = client_secret or os.getenv(
-            "SLACK_CLIENT_SECRET"
-        )
-
-        if not all([self.token, self.scopes, self.signing_secret]):
-            raise ValueError(
-                "`SLACK_TOKEN`, `SLACK_SCOPES`, and `SLACK_SIGNING_SECRET` "
-                "environment variables must be set. Get it here: "
-                "`https://api.slack.com/apps`."
-            )
-
-        # Setup OAuth settings if client ID and secret are provided
-        if self.client_id and self.client_secret:
-            self._app = AsyncApp(
-                oauth_settings=AsyncOAuthSettings(
-                    client_id=self.client_id,
-                    client_secret=self.client_secret,
-                    scopes=self.scopes,
-                    redirect_uri_path=redirect_uri_path,
-                ),
-                logger=logger,
-                signing_secret=self.signing_secret,
-                installation_store=installation_store,
-                token=self.token,
-            )
-        else:
-            # Initialize Slack Bolt AsyncApp with settings
-            self._app = AsyncApp(
-                logger=logger,
-                signing_secret=self.signing_secret,
-                installation_store=installation_store,
-                token=self.token,
-            )
-
-        self._handler = AsyncSlackRequestHandler(self._app)
-        self.setup_handlers()
-
-    def setup_handlers(self) -> None:
-        r"""Sets up the event handlers for Slack events, such as `app_mention`
-        and `message`.
-
-        This method registers the `app_mention` and `on_message` event handlers
-        with the Slack Bolt app to respond to Slack events.
-        """
-        self._app.event("app_mention")(self.app_mention)
-        self._app.event("message")(self.on_message)
-
-    def run(
-        self,
-        port: int = 3000,
-        path: str = "/slack/events",
-        host: Optional[str] = None,
-    ) -> None:
-        r"""Starts the Slack Bolt app server to listen for incoming Slack
-        events.
-
-        Args:
-            port (int): The port on which the server should run (default is
-                3000).
-            path (str): The endpoint path for receiving Slack events (default
-                is "/slack/events").
-            host (Optional[str]): The hostname to bind the server (default is
-                None).
-        """
-        self._app.start(port=port, path=path, host=host)
-
-    async def handle_request(
-        self, request: requests.Request
-    ) -> responses.Response:
-        r"""Handles incoming requests from Slack through the request handler.
-
-        Args:
-            request (Request): A Starlette request object representing the
-                incoming request.
-
-        Returns:
-            The response generated by the Slack Bolt handler.
-        """
-        return await self._handler.handle(request)
-
-    async def app_mention(
-        self,
-        context: "AsyncBoltContext",
-        client: "AsyncWebClient",
-        event: Dict[str, Any],
-        body: Dict[str, Any],
-        say: "AsyncSay",
-    ) -> None:
-        r"""Event handler for `app_mention` events.
-
-        This method is triggered when someone mentions the app in Slack.
-
-        Args:
-            context (AsyncBoltContext): The Slack Bolt context for the event.
-            client (AsyncWebClient): The Slack Web API client.
-            event (Dict[str, Any]): The event data for the app mention.
-            body (Dict[str, Any]): The full request body from Slack.
-            say (AsyncSay): A function to send a response back to the channel.
-        """
-        event_profile = SlackAppMentionEventProfile(**event)
-        event_body = SlackAppMentionEventBody(**body)
-
-        logger.info(f"app_mention, context: {context}")
-        logger.info(f"app_mention, client: {client}")
-        logger.info(f"app_mention, event_profile: {event_profile}")
-        logger.info(f"app_mention, event_body: {event_body}")
-        logger.info(f"app_mention, say: {say}")
-
-    async def on_message(
-        self,
-        context: "AsyncBoltContext",
-        client: "AsyncWebClient",
-        event: Dict[str, Any],
-        body: Dict[str, Any],
-        say: "AsyncSay",
-    ) -> None:
-        r"""Event handler for `message` events.
-
-        This method is triggered when the app receives a message in Slack.
-
-        Args:
-            context (AsyncBoltContext): The Slack Bolt context for the event.
-            client (AsyncWebClient): The Slack Web API client.
-            event (Dict[str, Any]): The event data for the message.
-            body (Dict[str, Any]): The full request body from Slack.
-            say (AsyncSay): A function to send a response back to the channel.
-        """
-        await context.ack()
-
-        event_profile = SlackEventProfile(**event)
-        event_body = SlackEventBody(**body)
-
-        logger.info(f"on_message, context: {context}")
-        logger.info(f"on_message, client: {client}")
-        logger.info(f"on_message, event_profile: {event_profile}")
-        logger.info(f"on_message, event_body: {event_body}")
-        logger.info(f"on_message, say: {say}")
-
-        logger.info(f"Received message: {event_profile.text}")
-
-    def mention_me(
-        self, context: "AsyncBoltContext", body: SlackEventBody
-    ) -> bool:
-        r"""Check if the bot is mentioned in the message.
-
-        Args:
-            context (AsyncBoltContext): The Slack Bolt context for the event.
-            body (SlackEventBody): The body of the Slack event.
-
-        Returns:
-            bool: True if the bot is mentioned in the message, False otherwise.
-        """
-        message = body.event.text
-        bot_user_id = context.bot_user_id
-        mention = f"<@{bot_user_id}>"
-        return mention in message

camel/loaders/chunkr_reader.py

@@ -1,163 +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 json
-import logging
-import os
-import time
-from typing import IO, Any, Optional, Union
-
-import requests
-
-from camel.utils import api_keys_required
-
-logger = logging.getLogger(__name__)
-
-
-class ChunkrReader:
-    r"""Chunkr Reader for processing documents and returning content
-    in various formats.
-
-    Args:
-        api_key (Optional[str], optional): The API key for Chunkr API. If not
-            provided, it will be retrieved from the environment variable
-            `CHUNKR_API_KEY`. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the Chunkr service.
-            (default: :obj:`https://api.chunkr.ai/api/v1/task`)
-        timeout (int, optional): The maximum time in seconds to wait for the
-            API responses. (default: :obj:`30`)
-        **kwargs (Any): Additional keyword arguments for request headers.
-    """
-
-    @api_keys_required("CHUNKR_API_KEY")
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        url: Optional[str] = "https://api.chunkr.ai/api/v1/task",
-        timeout: int = 30,
-        **kwargs: Any,
-    ) -> None:
-        self._api_key = api_key or os.getenv('CHUNKR_API_KEY')
-        self._url = os.getenv('CHUNKR_API_URL') or url
-        self._headers = {
-            "Authorization": f"{self._api_key}",
-            **kwargs,
-        }
-        self.timeout = timeout
-
-    def submit_task(
-        self,
-        file_path: str,
-        model: str = "Fast",
-        ocr_strategy: str = "Auto",
-        target_chunk_length: str = "512",
-    ) -> str:
-        r"""Submits a file to the Chunkr API and returns the task ID.
-
-        Args:
-            file_path (str): The path to the file to be uploaded.
-            model (str, optional): The model to be used for the task.
-                (default: :obj:`Fast`)
-            ocr_strategy (str, optional): The OCR strategy. Defaults to 'Auto'.
-            target_chunk_length (str, optional): The target chunk length.
-                (default: :obj:`512`)
-
-        Returns:
-            str: The task ID.
-        """
-        with open(file_path, 'rb') as file:
-            files: dict[
-                str, Union[tuple[None, IO[bytes]], tuple[None, str]]
-            ] = {
-                'file': (
-                    None,
-                    file,
-                ),  # Properly pass the file as a binary stream
-                'model': (None, model),
-                'ocr_strategy': (None, ocr_strategy),
-                'target_chunk_length': (None, target_chunk_length),
-            }
-            try:
-                response = requests.post(
-                    self._url,  # type: ignore[arg-type]
-                    headers=self._headers,
-                    files=files,
-                    timeout=self.timeout,
-                )
-                response.raise_for_status()
-                task_id = response.json().get('task_id')
-                if not task_id:
-                    raise ValueError("Task ID not returned in the response.")
-                logger.info(f"Task submitted successfully. Task ID: {task_id}")
-                return task_id
-            except Exception as e:
-                logger.error(f"Failed to submit task: {e}")
-                raise ValueError(f"Failed to submit task: {e}") from e
-
-    def get_task_output(self, task_id: str, max_retries: int = 5) -> str:
-        r"""Polls the Chunkr API to check the task status and returns the task
-        result.
-
-        Args:
-            task_id (str): The task ID to check the status for.
-            max_retries (int, optional): Maximum number of retry attempts.
-                (default: :obj:`5`)
-
-        Returns:
-            str: The formatted task result in JSON format.
-
-        Raises:
-            ValueError: If the task status cannot be retrieved.
-            RuntimeError: If the maximum number of retries is reached without
-                a successful task completion.
-        """
-        url_get = f"{self._url}/{task_id}"
-        attempts = 0
-
-        while attempts < max_retries:
-            try:
-                response = requests.get(
-                    url_get, headers=self._headers, timeout=self.timeout
-                )
-                response.raise_for_status()
-                task_status = response.json().get('status')
-
-                if task_status == "Succeeded":
-                    logger.info(f"Task {task_id} completed successfully.")
-                    return self._pretty_print_response(response.json())
-                else:
-                    logger.info(
-                        f"Task {task_id} is still {task_status}. Retrying "
-                        "in 5 seconds..."
-                    )
-            except Exception as e:
-                logger.error(f"Failed to retrieve task status: {e}")
-                raise ValueError(f"Failed to retrieve task status: {e}") from e
-
-            attempts += 1
-            time.sleep(5)
-
-        logger.error(f"Max retries reached for task {task_id}.")
-        raise RuntimeError(f"Max retries reached for task {task_id}.")
-
-    def _pretty_print_response(self, response_json: dict) -> str:
-        r"""Pretty prints the JSON response.
-
-        Args:
-            response_json (dict): The response JSON to pretty print.
-
-        Returns:
-            str: Formatted JSON as a string.
-        """
-        return json.dumps(response_json, indent=4)

camel/toolkits/arxiv_toolkit.py

@@ -1,155 +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 typing import Dict, Generator, List, Optional
-
-from camel.toolkits.base import BaseToolkit
-from camel.toolkits.function_tool import FunctionTool
-from camel.utils import dependencies_required
-
-
-class ArxivToolkit(BaseToolkit):
-    r"""A toolkit for interacting with the arXiv API to search and download
-    academic papers.
-    """
-
-    @dependencies_required('arxiv')
-    def __init__(self) -> None:
-        r"""Initializes the ArxivToolkit and sets up the arXiv client."""
-        import arxiv
-
-        self.client = arxiv.Client()
-
-    def _get_search_results(
-        self,
-        query: str,
-        paper_ids: Optional[List[str]] = None,
-        max_results: Optional[int] = 5,
-    ) -> Generator:
-        r"""Retrieves search results from the arXiv API based on the provided
-        query and optional paper IDs.
-
-        Args:
-            query (str): The search query string used to search for papers on
-                arXiv.
-            paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default::obj: `None`)
-            max_results (int, optional): The maximum number of search results
-                to retrieve. (default::obj: `5`)
-
-        Returns:
-            Generator: A generator that yields results from the arXiv search
-                query, which includes metadata about each paper matching the
-                query.
-        """
-        import arxiv
-
-        paper_ids = paper_ids or []
-        search_query = arxiv.Search(
-            query=query,
-            id_list=paper_ids,
-            max_results=max_results,
-        )
-        return self.client.results(search_query)
-
-    def search_papers(
-        self,
-        query: str,
-        paper_ids: Optional[List[str]] = None,
-        max_results: Optional[int] = 5,
-    ) -> List[Dict[str, str]]:
-        r"""Searches for academic papers on arXiv using a query string and
-        optional paper IDs.
-
-        Args:
-            query (str): The search query string.
-            paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default::obj: `None`)
-            max_results (int, optional): The maximum number of search results
-                to return. (default::obj: `5`)
-
-        Returns:
-            List[Dict[str, str]]: A list of dictionaries, each containing
-                information about a paper, including title, published date,
-                authors, entry ID, summary, and extracted text from the paper.
-        """
-        from arxiv2text import arxiv_to_text
-
-        search_results = self._get_search_results(
-            query, paper_ids, max_results
-        )
-        papers_data = []
-
-        for paper in search_results:
-            paper_info = {
-                "title": paper.title,
-                "published_date": paper.updated.date().isoformat(),
-                "authors": [author.name for author in paper.authors],
-                "entry_id": paper.entry_id,
-                "summary": paper.summary,
-                # TODO: Use chunkr instead of atxiv_to_text for better
-                # performance
-                "paper_text": arxiv_to_text(paper.pdf_url),
-            }
-            papers_data.append(paper_info)
-
-        return papers_data
-
-    def download_papers(
-        self,
-        query: str,
-        paper_ids: Optional[List[str]] = None,
-        max_results: Optional[int] = 5,
-        output_dir: Optional[str] = "./",
-    ) -> str:
-        r"""Downloads PDFs of academic papers from arXiv based on the provided
-        query.
-
-        Args:
-            query (str): The search query string.
-            paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to download. (default::obj: `None`)
-            max_results (int, optional): The maximum number of search results
-                to download. (default::obj: `5`)
-            output_dir (str, optional): The directory to save the downloaded
-                PDFs. Defaults to the current directory.
-
-        Returns:
-            str: Status message indicating success or failure.
-        """
-        try:
-            search_results = self._get_search_results(
-                query, paper_ids, max_results
-            )
-
-            for paper in search_results:
-                paper.download_pdf(
-                    dirpath=output_dir, filename=f"{paper.title}" + ".pdf"
-                )
-            return "papers downloaded successfully"
-        except Exception as e:
-            return f"An error occurred: {e}"
-
-    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.search_papers),
-            FunctionTool(self.download_papers),
-        ]