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

camel/agents/knowledge_graph_agent.py

@@ -11,12 +11,10 @@
 # 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 Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
-try:
+if TYPE_CHECKING:
     from unstructured.documents.elements import Element
-except ImportError:
-    Element = None
 
 from camel.agents import ChatAgent
 from camel.messages import BaseMessage
@@ -144,13 +142,13 @@ class KnowledgeGraphAgent(ChatAgent):
 
     def run(
         self,
-        element: Union[str, Element],
+        element: "Element",
         parse_graph_elements: bool = False,
     ) -> Union[str, GraphElement]:
         r"""Run the agent to extract node and relationship information.
 
         Args:
-            element (Union[str, Element]): The input element or string.
+            element (Element): The input element.
             parse_graph_elements (bool, optional): Whether to parse into
                 `GraphElement`. Defaults to `False`.
 

camel/bots/__init__.py

@@ -0,0 +1,34 @@
+# =========== 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 .discord_app import DiscordApp
+from .slack.models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack.slack_app import SlackApp
+from .telegram_bot import TelegramBot
+
+__all__ = [
+    'DiscordApp',
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
+    'TelegramBot',
+]

camel/bots/discord_app.py

@@ -0,0 +1,138 @@
+# =========== 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, List, Optional
+
+from camel.utils import dependencies_required
+
+if TYPE_CHECKING:
+    from discord import Message
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DiscordApp:
+    r"""A class representing a Discord app that uses the `discord.py` library
+    to interact with Discord servers.
+
+    This bot can respond to messages in specific channels and only reacts to
+    messages that mention the bot.
+
+    Attributes:
+        channel_ids (Optional[List[int]]): A list of allowed channel IDs. If
+            provided, the bot will only respond to messages in these channels.
+        token (Optional[str]): The Discord bot token used for authentication.
+    """
+
+    @dependencies_required('discord')
+    def __init__(
+        self,
+        channel_ids: Optional[List[int]] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        r"""Initialize the DiscordApp instance by setting up the Discord client
+        and event handlers.
+
+        Args:
+            channel_ids (Optional[List[int]]): A list of allowed channel IDs.
+                The bot will only respond to messages in these channels if
+                provided.
+            token (Optional[str]): The Discord bot token for authentication.
+                If not provided, the token will be retrieved from the
+                environment variable `DISCORD_TOKEN`.
+
+        Raises:
+            ValueError: If the `DISCORD_TOKEN` is not found in environment
+                variables.
+        """
+        self.token = token or os.getenv('DISCORD_TOKEN')
+        self.channel_ids = channel_ids
+
+        if not self.token:
+            raise ValueError(
+                "`DISCORD_TOKEN` not found in environment variables. Get it"
+                " here: `https://discord.com/developers/applications`."
+            )
+
+        import discord
+
+        intents = discord.Intents.default()
+        intents.message_content = True
+        self._client = discord.Client(intents=intents)
+
+        # Register event handlers
+        self._client.event(self.on_ready)
+        self._client.event(self.on_message)
+
+    async def start(self):
+        r"""Asynchronously start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord asynchronously using
+        the provided token. It should be awaited when used in an async
+        environment.
+        """
+        await self._client.start(self.token)
+
+    def run(self) -> None:
+        r"""Start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord synchronously using
+        the provided token. It blocks execution and keeps the bot running.
+        """
+        self._client.run(self.token)  # type: ignore[arg-type]
+
+    async def on_ready(self) -> None:
+        r"""Event handler that is called when the bot has successfully
+        connected to the Discord server.
+
+        When the bot is ready and logged into Discord, it prints a message
+        displaying the bot's username.
+        """
+        logger.info(f'We have logged in as {self._client.user}')
+
+    async def on_message(self, message: 'Message') -> None:
+        r"""Event handler for processing incoming messages.
+
+        This method is called whenever a new message is received by the bot. It
+        will ignore messages sent by the bot itself, only respond to messages
+        in allowed channels (if specified), and only to messages that mention
+        the bot.
+
+        Args:
+            message (discord.Message): The message object received from
+                Discord.
+        """
+        # If the message author is the bot itself,
+        # do not respond to this message
+        if message.author == self._client.user:
+            return
+
+        # If allowed channel IDs are provided,
+        # only respond to messages in those channels
+        if self.channel_ids and message.channel.id not in self.channel_ids:
+            return
+
+        # Only respond to messages that mention the bot
+        if not self._client.user or not self._client.user.mentioned_in(
+            message
+        ):
+            return
+
+        logger.info(f"Received message: {message.content}")
+
+    @property
+    def client(self):
+        return self._client

camel/bots/slack/__init__.py

@@ -0,0 +1,30 @@
+# =========== 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 .models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack_app import SlackApp
+
+__all__ = [
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
+]

camel/bots/slack/models.py

@@ -0,0 +1,158 @@
+# =========== 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 Optional
+
+from pydantic import BaseModel
+
+
+class SlackAuthProfile(BaseModel):
+    r"""Represents the authorization profile within a Slack event.
+
+    Events will contain a single, compact authorizations field that shows one
+    installation of your app that the event is visible to.
+    In other words, lists of authorizations will be truncated to one element.
+
+    If there's more than one installing party that your app is keeping track
+    of, it's best not to rely on the single party listed in authorizations to
+    be any particular one.
+
+    To get a full list of who can see events, call the apps.event.
+    authorizations.list method after obtaining an app-level token. Read more on
+    the changes here; they have taken effect for existing apps as of
+    February 24, 2021.
+
+    References:
+
+    - https://api.slack.com/apis/events-api#authorizations
+    - https://api.slack.com/changelog/2020-09-15-events-api-truncate-authed-users#no_context
+    """
+
+    enterprise_id: Optional[str] = None
+    """The ID of the enterprise associated with the authorization."""
+
+    team_id: str
+    """The ID of the team associated with the authorization."""
+
+    user_id: str
+    """The ID of the user associated with the authorization."""
+
+    is_bot: bool
+    """Whether the authorized user is a bot."""
+
+    is_enterprise_install: bool
+    """Whether the authorization is for an enterprise installation."""
+
+
+class SlackEventProfile(BaseModel):
+    r"""Represents the detailed profile of a Slack event, including user,
+    message, and context data.
+    """
+
+    user: str
+    """The ID of the user associated with the event."""
+
+    type: str
+    """The type of the event (e.g., 'message')."""
+
+    ts: str
+    """A timestamp representing when the event was triggered."""
+
+    thread_ts: Optional[str] = None
+    """The timestamp of the parent message in a thread."""
+
+    client_msg_id: str
+    """A unique ID generated by the client for the message (if available)."""
+
+    text: str
+    """The message content text."""
+
+    team: str
+    """The ID of the team that the event is associated with."""
+
+    blocks: list
+    """The list of message blocks, providing structured information."""
+
+    channel: str
+    """The ID of the Slack channel where the event happened."""
+
+    event_ts: str
+    """The event-specific timestamp when it occurred."""
+
+    channel_type: Optional[str]
+    """The type of Slack channel (e.g., 'channel', 'im')."""
+
+
+class SlackEventBody(BaseModel):
+    r"""Represents the entire body of a Slack event, including the event
+    profile, authorization, and context.
+    """
+
+    token: str
+    """The token to verify the source of the event."""
+
+    team_id: str
+    """The ID of the team where the event is happening."""
+
+    context_team_id: Optional[str]
+    """The team ID for the shared channel context, if applicable."""
+
+    context_enterprise_id: Optional[str] = None
+    """The enterprise ID for the shared channel context, if applicable."""
+
+    api_app_id: str
+    """The unique identifier for the Slack app that received the event."""
+
+    event: SlackEventProfile
+    """A detailed profile of the event"""
+
+    type: str
+    """The overall type of event received (e.g., 'event_callback')."""
+
+    event_id: str
+    """A unique identifier assigned to this event by Slack."""
+
+    event_time: int
+    """The timestamp (in seconds) representing when the event was triggered."""
+
+    authorizations: Optional[list[SlackAuthProfile]] = None
+    """An optional list of authorizations that describe which installation can 
+    see the event."""
+
+    is_ext_shared_channel: bool
+    """Indicates if the event is part of a shared channel between different 
+    organizations."""
+
+    event_context: str
+    """A unique string representing the context of the event."""
+
+
+class SlackAppMentionEventProfile(SlackEventProfile):
+    r"""Represents the detailed profile of a Slack event where the app was
+    mentioned in a message.
+    """
+
+    channel_type: Optional[str] = None
+    """The type of Slack channel. it's None for app mentions."""
+
+
+class SlackAppMentionEventBody(SlackEventBody):
+    r"""Represents the entire body of a Slack event where the app was mentioned
+    in a message.
+    """
+
+    context_team_id: Optional[str] = None
+    """A detailed profile of the event. it's None for app mentions."""
+
+    event: SlackAppMentionEventProfile
+    """A detailed profile of the event"""

camel/bots/slack/slack_app.py

@@ -0,0 +1,255 @@
+# =========== 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