chainlit 1.1.0rc1__py3-none-any.whl → 1.1.200__py3-none-any.whl

chainlit/data/acl.py

@@ -5,9 +5,12 @@ from fastapi import HTTPException
 async def is_thread_author(username: str, thread_id: str):
     data_layer = get_data_layer()
     if not data_layer:
-        raise HTTPException(status_code=401, detail="Unauthorized")
+        raise HTTPException(status_code=400, detail="Data layer not initialized")
 
     thread_author = await data_layer.get_thread_author(thread_id)
+    
+    if not thread_author:
+        raise HTTPException(status_code=404, detail="Thread not found")
 
     if thread_author != username:
         raise HTTPException(status_code=401, detail="Unauthorized")

chainlit/data/sql_alchemy.py

@@ -39,9 +39,11 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         ssl_require: bool = False,
         storage_provider: Optional[BaseStorageClient] = None,
         user_thread_limit: Optional[int] = 1000,
+        show_logger: Optional[bool] = False,
     ):
         self._conninfo = conninfo
         self.user_thread_limit = user_thread_limit
+        self.show_logger = show_logger
         ssl_args = {}
         if ssl_require:
             # Create an SSL context to require an SSL connection
@@ -55,7 +57,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self.async_session = sessionmaker(bind=self.engine, expire_on_commit=False, class_=AsyncSession)  # type: ignore
         if storage_provider:
             self.storage_provider: Optional[BaseStorageClient] = storage_provider
-            logger.info("SQLAlchemyDataLayer storage client initialized")
+            if self.show_logger: logger.info("SQLAlchemyDataLayer storage client initialized")
         else:
             self.storage_provider = None
             logger.warn(
@@ -102,7 +104,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### User ######
     async def get_user(self, identifier: str) -> Optional[PersistedUser]:
-        logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
         query = "SELECT * FROM users WHERE identifier = :identifier"
         parameters = {"identifier": identifier}
         result = await self.execute_sql(query=query, parameters=parameters)
@@ -112,20 +114,20 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return None
 
     async def create_user(self, user: User) -> Optional[PersistedUser]:
-        logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
         existing_user: Optional["PersistedUser"] = await self.get_user(user.identifier)
         user_dict: Dict[str, Any] = {
             "identifier": str(user.identifier),
             "metadata": json.dumps(user.metadata) or {},
         }
         if not existing_user:  # create the user
-            logger.info("SQLAlchemy: create_user, creating the user")
+            if self.show_logger: logger.info("SQLAlchemy: create_user, creating the user")
             user_dict["id"] = str(uuid.uuid4())
             user_dict["createdAt"] = await self.get_current_timestamp()
             query = """INSERT INTO users ("id", "identifier", "createdAt", "metadata") VALUES (:id, :identifier, :createdAt, :metadata)"""
             await self.execute_sql(query=query, parameters=user_dict)
         else:  # update the user
-            logger.info("SQLAlchemy: update user metadata")
+            if self.show_logger: logger.info("SQLAlchemy: update user metadata")
             query = """UPDATE users SET "metadata" = :metadata WHERE "identifier" = :identifier"""
             await self.execute_sql(
                 query=query, parameters=user_dict
@@ -134,19 +136,18 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Threads ######
     async def get_thread_author(self, thread_id: str) -> str:
-        logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
         query = """SELECT "userIdentifier" FROM threads WHERE "id" = :id"""
         parameters = {"id": thread_id}
         result = await self.execute_sql(query=query, parameters=parameters)
         if isinstance(result, list) and result[0]:
             author_identifier = result[0].get("userIdentifier")
             if author_identifier is not None:
-                print(f"Author found: {author_identifier}")
                 return author_identifier
         raise ValueError(f"Author not found for thread_id {thread_id}")
 
     async def get_thread(self, thread_id: str) -> Optional[ThreadDict]:
-        logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
         user_threads: Optional[List[ThreadDict]] = await self.get_all_user_threads(
             thread_id=thread_id
         )
@@ -163,7 +164,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         metadata: Optional[Dict] = None,
         tags: Optional[List[str]] = None,
     ):
-        logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
         if context.session.user is not None:
             user_identifier = context.session.user.identifier
         else:
@@ -200,7 +201,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         await self.execute_sql(query=query, parameters=parameters)
 
     async def delete_thread(self, thread_id: str):
-        logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
         # Delete feedbacks/elements/steps/thread
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" IN (SELECT "id" FROM steps WHERE "threadId" = :id)"""
         elements_query = """DELETE FROM elements WHERE "threadId" = :id"""
@@ -215,7 +216,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     async def list_threads(
         self, pagination: Pagination, filters: ThreadFilter
     ) -> PaginatedResponse:
-        logger.info(
+        if self.show_logger: logger.info(
             f"SQLAlchemy: list_threads, pagination={pagination}, filters={filters}"
         )
         if not filters.userId:
@@ -275,7 +276,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Steps ######
     @queue_until_user_message()
     async def create_step(self, step_dict: "StepDict"):
-        logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         step_dict["showInput"] = (
@@ -305,12 +306,12 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def update_step(self, step_dict: "StepDict"):
-        logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
+        if self.show_logger: logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
         await self.create_step(step_dict)
 
     @queue_until_user_message()
     async def delete_step(self, step_id: str):
-        logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
         # Delete feedbacks/elements/steps
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" = :id"""
         elements_query = """DELETE FROM elements WHERE "forId" = :id"""
@@ -322,7 +323,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Feedback ######
     async def upsert_feedback(self, feedback: Feedback) -> str:
-        logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
         feedback.id = feedback.id or str(uuid.uuid4())
         feedback_dict = asdict(feedback)
         parameters = {
@@ -344,7 +345,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return feedback.id
 
     async def delete_feedback(self, feedback_id: str) -> bool:
-        logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
         query = """DELETE FROM feedbacks WHERE "id" = :feedback_id"""
         parameters = {"feedback_id": feedback_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -353,7 +354,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Elements ######
     @queue_until_user_message()
     async def create_element(self, element: "Element"):
-        logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         if isinstance(element, Avatar):  # Skip creating elements of type avatar
@@ -416,7 +417,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def delete_element(self, element_id: str):
-        logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
         query = """DELETE FROM elements WHERE "id" = :id"""
         parameters = {"id": element_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -428,7 +429,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self, user_id: Optional[str] = None, thread_id: Optional[str] = None
     ) -> Optional[List[ThreadDict]]:
         """Fetch all user threads up to self.user_thread_limit, or one thread by id if thread_id is provided."""
-        logger.info(f"SQLAlchemy: get_all_user_threads")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_all_user_threads")
         user_threads_query = """
             SELECT
                 "id" AS thread_id,
@@ -562,8 +563,8 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                         tags=step_feedback.get("step_tags"),
                         input=(
                             step_feedback.get("step_input", "")
-                            if step_feedback["step_showinput"]
-                            else ""
+                            if step_feedback["step_showinput"] == "true" 
+                            else None
                         ),
                         output=step_feedback.get("step_output", ""),
                         createdAt=step_feedback.get("step_createdat"),

chainlit/discord/__init__.py

@@ -0,0 +1,6 @@
+try:
+    import discord
+except ModuleNotFoundError:
+    raise ValueError(
+        "The discord package is required to integrate Chainlit with a Slack app. Run `pip install discord --upgrade`"
+    )

chainlit/discord/app.py

@@ -0,0 +1,331 @@
+import asyncio
+import mimetypes
+import re
+import uuid
+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 chainlit.config import config
+from chainlit.context import ChainlitContext, HTTPSession, 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.telemetry import trace
+from chainlit.types import Feedback
+from chainlit.user import PersistedUser, User
+from chainlit.user_session import user_session
+from discord.ui import Button, View
+
+
+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:
+                thread_id = context_var.get().session.thread_id
+                feedback = Feedback(forId=self.step_id, threadId=thread_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:
+                thread_id = context_var.get().session.thread_id
+                feedback = Feedback(forId=self.step_id, threadId=thread_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", enabled=False
+    ):
+        super().__init__(session)
+        self.channel = channel
+        self.enabled = enabled
+
+    async def send_element(self, element_dict: ElementDict):
+        if not self.enabled or 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 self.enabled:
+            return
+
+        step_type = step_dict.get("type")
+        is_message = step_type in [
+            "user_message",
+            "assistant_message",
+            "system_message",
+        ]
+        is_chain_of_thought = bool(step_dict.get("parentId"))
+        is_empty_output = not step_dict.get("output")
+
+        if is_chain_of_thought or is_empty_output or not is_message:
+            return
+        else:
+            enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+            message = await self.channel.send(step_dict["output"])
+
+            if enable_feedback:
+                view = FeedbackView(step_dict.get("id", ""))
+                await message.edit(view=view)
+
+    async def update_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+
+        await self.send_step(step_dict)
+
+
+intents = discord.Intents.default()
+intents.message_content = True
+
+client = discord.Client(intents=intents)
+
+
+@trace
+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
+    ]
+
+    file_elements = [Element.from_dict(file_dict) for file_dict in files_dicts]
+
+    return file_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_name: str,
+    channel: "MessageableChannel",
+    bind_thread_to_user=False,
+):
+    user = await get_user(message.author)
+
+    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, str(channel.id)))
+
+    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)
+
+    msg = Message(
+        content=text,
+        elements=file_elements,
+        type="user_message",
+        author=user.metadata.get("name"),
+    )
+
+    await msg.send()
+
+    ctx.emitter.enabled = True
+
+    if on_chat_start := config.code.on_chat_start:
+        await on_chat_start()
+
+    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}")
+
+    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 = ""
+    bind_thread_to_user = False
+    channel = message.channel
+
+    if isinstance(message.channel, discord.Thread):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.ForumChannel):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.DMChannel):
+        thread_name = f"{message.author} Discord DM"
+        bind_thread_to_user = True
+    elif isinstance(message.channel, discord.GroupChannel):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.TextChannel):
+        channel = await message.channel.create_thread(
+            name=clean_content(message), 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_name=thread_name,
+        channel=channel,
+        bind_thread_to_user=bind_thread_to_user,
+    )

chainlit/element.py

@@ -5,6 +5,7 @@ from io import BytesIO
 from typing import Any, ClassVar, List, Literal, Optional, TypedDict, TypeVar, Union
 
 import filetype
+import mimetypes
 from chainlit.context import context
 from chainlit.data import get_data_layer
 from chainlit.logger import logger
@@ -165,14 +166,16 @@ class Element:
                 if self.type in mime_types
                 else filetype.guess_mime(self.path or self.content)
             )
-
+            if not self.mime and self.url:
+                self.mime = mimetypes.guess_type(self.url)[0]
+            
         await self._create()
 
         if not self.url and not self.chainlit_key:
             raise ValueError("Must provide url or chainlit key to send element")
 
         trace_event(f"send {self.__class__.__name__}")
-        await context.emitter.emit("element", self.to_dict())
+        await context.emitter.send_element(self.to_dict())
 
 
 ElementBased = TypeVar("ElementBased", bound=Element)

chainlit/emitter.py

@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Literal, Optional, Union, cast
 
 from chainlit.config import config
 from chainlit.data import get_data_layer
-from chainlit.element import Element, File
+from chainlit.element import Element, ElementDict, File
 from chainlit.logger import logger
 from chainlit.message import Message
-from chainlit.session import BaseSession, WebsocketSession
+from chainlit.session import BaseSession, HTTPSession, WebsocketSession
 from chainlit.step import StepDict
 from chainlit.types import (
     AskActionResponse,
@@ -29,6 +29,7 @@ class BaseChainlitEmitter:
     """
 
     session: BaseSession
+    enabled: bool = True
 
     def __init__(self, session: BaseSession) -> None:
         """Initialize with the user session."""
@@ -46,6 +47,10 @@ class BaseChainlitEmitter:
         """Stub method to resume a thread."""
         pass
 
+    async def send_element(self, element_dict: ElementDict):
+        """Stub method to send an element to the UI."""
+        pass
+
     async def send_step(self, step_dict: StepDict):
         """Stub method to send a message to the UI."""
         pass
@@ -151,6 +156,10 @@ class ChainlitEmitter(BaseChainlitEmitter):
         """Send a thread to the UI to resume it"""
         return self.emit("resume_thread", thread_dict)
 
+    async def send_element(self, element_dict: ElementDict):
+        """Stub method to send an element to the UI."""
+        await self.emit("element", element_dict)
+
     def send_step(self, step_dict: StepDict):
         """Send a message to the UI."""
         return self.emit("new_message", step_dict)