chainlit 2.7.0__py3-none-any.whl → 2.7.1__py3-none-any.whl

chainlit/discord/app.py

@@ -1,364 +0,0 @@
-import asyncio
-import mimetypes
-import re
-import uuid
-from datetime import datetime
-from io import BytesIO
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
-
-if TYPE_CHECKING:
-    from discord.abc import MessageableChannel
-
-import discord
-import filetype
-import httpx
-from discord.ui import Button, View
-
-from chainlit.config import config
-from chainlit.context import ChainlitContext, HTTPSession, context, context_var
-from chainlit.data import get_data_layer
-from chainlit.element import Element, ElementDict
-from chainlit.emitter import BaseChainlitEmitter
-from chainlit.logger import logger
-from chainlit.message import Message, StepDict
-from chainlit.types import Feedback
-from chainlit.user import PersistedUser, User
-from chainlit.user_session import user_session
-
-
-class FeedbackView(View):
-    def __init__(self, step_id: str):
-        super().__init__(timeout=None)
-        self.step_id = step_id
-
-    @discord.ui.button(label="👎")
-    async def thumbs_down(self, interaction: discord.Interaction, button: Button):
-        if data_layer := get_data_layer():
-            try:
-                feedback = Feedback(forId=self.step_id, value=0)
-                await data_layer.upsert_feedback(feedback)
-            except Exception as e:
-                logger.error(f"Error upserting feedback: {e}")
-        if interaction.message:
-            await interaction.message.edit(view=None)
-            await interaction.message.add_reaction("👎")
-
-    @discord.ui.button(label="👍")
-    async def thumbs_up(self, interaction: discord.Interaction, button: Button):
-        if data_layer := get_data_layer():
-            try:
-                feedback = Feedback(forId=self.step_id, value=1)
-                await data_layer.upsert_feedback(feedback)
-            except Exception as e:
-                logger.error(f"Error upserting feedback: {e}")
-        if interaction.message:
-            await interaction.message.edit(view=None)
-            await interaction.message.add_reaction("👍")
-
-
-class DiscordEmitter(BaseChainlitEmitter):
-    def __init__(self, session: HTTPSession, channel: "MessageableChannel"):
-        super().__init__(session)
-        self.channel = channel
-
-    async def send_element(self, element_dict: ElementDict):
-        if element_dict.get("display") != "inline":
-            return
-
-        persisted_file = self.session.files.get(element_dict.get("chainlitKey") or "")
-        file: Optional[Union[BytesIO, str]] = None
-        mime: Optional[str] = None
-
-        if persisted_file:
-            file = str(persisted_file["path"])
-            mime = element_dict.get("mime")
-        elif file_url := element_dict.get("url"):
-            async with httpx.AsyncClient() as client:
-                response = await client.get(file_url)
-                if response.status_code == 200:
-                    file = BytesIO(response.content)
-                    mime = filetype.guess_mime(file)
-
-        if not file:
-            return
-
-        element_name: str = element_dict.get("name", "Untitled")
-
-        if mime:
-            file_extension = mimetypes.guess_extension(mime)
-            if file_extension:
-                element_name += file_extension
-
-        file_obj = discord.File(file, filename=element_name)
-        await self.channel.send(file=file_obj)
-
-    async def send_step(self, step_dict: StepDict):
-        if not step_dict["type"] == "assistant_message":
-            return
-
-        step_type = step_dict.get("type")
-        is_message = step_type in [
-            "user_message",
-            "assistant_message",
-        ]
-        is_empty_output = not step_dict.get("output")
-
-        if is_empty_output or not is_message:
-            return
-        else:
-            enable_feedback = get_data_layer()
-            message = await self.channel.send(step_dict["output"])
-
-            if enable_feedback:
-                current_run = context.current_run
-                scorable_id = current_run.id if current_run else step_dict.get("id")
-                if not scorable_id:
-                    return
-                view = FeedbackView(scorable_id)
-                await message.edit(view=view)
-
-    async def update_step(self, step_dict: StepDict):
-        if not step_dict["type"] == "assistant_message":
-            return
-
-        await self.send_step(step_dict)
-
-
-intents = discord.Intents.default()
-intents.message_content = True
-
-client = discord.Client(intents=intents)
-
-
-def init_discord_context(
-    session: HTTPSession,
-    channel: "MessageableChannel",
-    message: discord.Message,
-) -> ChainlitContext:
-    emitter = DiscordEmitter(session=session, channel=channel)
-    context = ChainlitContext(session=session, emitter=emitter)
-    context_var.set(context)
-    user_session.set("discord_message", message)
-    user_session.set("discord_channel", channel)
-    return context
-
-
-users_by_discord_id: Dict[int, Union[User, PersistedUser]] = {}
-
-USER_PREFIX = "discord_"
-
-
-async def get_user(discord_user: Union[discord.User, discord.Member]):
-    if discord_user.id in users_by_discord_id:
-        return users_by_discord_id[discord_user.id]
-
-    metadata = {
-        "name": discord_user.name,
-        "id": discord_user.id,
-    }
-    user = User(identifier=USER_PREFIX + str(discord_user.name), metadata=metadata)
-
-    users_by_discord_id[discord_user.id] = user
-
-    if data_layer := get_data_layer():
-        try:
-            persisted_user = await data_layer.create_user(user)
-            if persisted_user:
-                users_by_discord_id[discord_user.id] = persisted_user
-        except Exception as e:
-            logger.error(f"Error creating user: {e}")
-
-    return users_by_discord_id[discord_user.id]
-
-
-async def download_discord_file(url: str):
-    async with httpx.AsyncClient() as client:
-        response = await client.get(url)
-        if response.status_code == 200:
-            return response.content
-        else:
-            return None
-
-
-async def download_discord_files(
-    session: HTTPSession, attachments: List[discord.Attachment]
-):
-    download_coros = [
-        download_discord_file(attachment.url) for attachment in attachments
-    ]
-    file_bytes_list = await asyncio.gather(*download_coros)
-    file_refs = []
-    for idx, file_bytes in enumerate(file_bytes_list):
-        if file_bytes:
-            name = attachments[idx].filename
-            mime_type = attachments[idx].content_type or "application/octet-stream"
-            file_ref = await session.persist_file(
-                name=name, mime=mime_type, content=file_bytes
-            )
-            file_refs.append(file_ref)
-
-    files_dicts = [
-        session.files[file["id"]] for file in file_refs if file["id"] in session.files
-    ]
-
-    elements = [
-        Element.from_dict(
-            {
-                "id": file["id"],
-                "name": file["name"],
-                "path": str(file["path"]),
-                "chainlitKey": file["id"],
-                "display": "inline",
-                "type": Element.infer_type_from_mime(file["type"]),
-            }
-        )
-        for file in files_dicts
-    ]
-
-    return elements
-
-
-def clean_content(message: discord.Message):
-    if not client.user:
-        return message.content
-
-    # Regex to find mentions of the bot
-    bot_mention = f"<@!?{client.user.id}>"
-    # Replace the bot's mention with nothing
-    return re.sub(bot_mention, "", message.content).strip()
-
-
-async def process_discord_message(
-    message: discord.Message,
-    thread_id: str,
-    thread_name: str,
-    channel: "MessageableChannel",
-    bind_thread_to_user=False,
-):
-    user = await get_user(message.author)
-
-    text = clean_content(message)
-    discord_files = message.attachments
-
-    session_id = str(uuid.uuid4())
-    session = HTTPSession(
-        id=session_id,
-        thread_id=thread_id,
-        user=user,
-        client_type="discord",
-    )
-
-    ctx = init_discord_context(
-        session=session,
-        channel=channel,
-        message=message,
-    )
-
-    file_elements = await download_discord_files(session, discord_files)
-
-    if on_chat_start := config.code.on_chat_start:
-        await on_chat_start()
-
-    msg = Message(
-        content=text,
-        elements=file_elements,
-        type="user_message",
-        author=user.metadata.get("name"),
-    )
-
-    await msg.send()
-
-    if on_message := config.code.on_message:
-        async with channel.typing():
-            await on_message(msg)
-
-    if on_chat_end := config.code.on_chat_end:
-        await on_chat_end()
-
-    if data_layer := get_data_layer():
-        user_id = None
-        if isinstance(user, PersistedUser):
-            user_id = user.id if bind_thread_to_user else None
-
-        try:
-            await data_layer.update_thread(
-                thread_id=thread_id,
-                name=thread_name,
-                metadata=ctx.session.to_persistable(),
-                user_id=user_id,
-            )
-        except Exception as e:
-            logger.error(f"Error updating thread: {e}")
-
-    await ctx.session.delete()
-
-
-@client.event
-async def on_ready():
-    logger.info(f"Logged in as {client.user}")
-
-
-@client.event
-async def on_message(message: discord.Message):
-    if not client.user or message.author == client.user:
-        return
-
-    is_dm = isinstance(message.channel, discord.DMChannel)
-    if not client.user.mentioned_in(message) and not is_dm:
-        return
-
-    thread_name: str = ""
-    thread_id: str = ""
-    bind_thread_to_user = False
-    channel = message.channel
-
-    if isinstance(message.channel, discord.Thread):
-        thread_name = f"{message.channel.name}"
-        thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, str(channel.id)))
-    elif isinstance(message.channel, discord.ForumChannel):
-        thread_name = f"{message.channel.name}"
-        thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, str(channel.id)))
-    elif isinstance(message.channel, discord.DMChannel):
-        thread_id = str(
-            uuid.uuid5(
-                uuid.NAMESPACE_DNS,
-                str(channel.id) + datetime.today().strftime("%Y-%m-%d"),
-            )
-        )
-        thread_name = (
-            f"{message.author} Discord DM {datetime.today().strftime('%Y-%m-%d')}"
-        )
-        bind_thread_to_user = True
-    elif isinstance(message.channel, discord.GroupChannel):
-        thread_id = str(
-            uuid.uuid5(
-                uuid.NAMESPACE_DNS,
-                str(channel.id) + datetime.today().strftime("%Y-%m-%d"),
-            )
-        )
-        thread_name = f"{message.channel.name}"
-    elif isinstance(message.channel, discord.TextChannel):
-        # Discord limits thread names to 100 characters and does not create
-        # threads from empty messages.
-        thread_id = str(
-            uuid.uuid5(
-                uuid.NAMESPACE_DNS,
-                str(channel.id) + datetime.today().strftime("%Y-%m-%d"),
-            )
-        )
-        discord_thread_name = clean_content(message)[:100] or "Untitled"
-        channel = await message.channel.create_thread(
-            name=discord_thread_name, message=message
-        )
-        thread_name = f"{channel.name}"
-    else:
-        logger.warning(f"Unsupported channel type: {message.channel.type}")
-        return
-
-    await process_discord_message(
-        message=message,
-        thread_id=thread_id,
-        thread_name=thread_name,
-        channel=channel,
-        bind_thread_to_user=bind_thread_to_user,
-    )