PyPI - chainlit - Versions diffs - 1.1.0rc1__py3-none-any.whl → 1.1.101__py3-none-any.whl - Mend

chainlit 1.1.0rc1py3-none-any.whl → 1.1.101py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of chainlit might be problematic. Click here for more details.

Files changed (25) hide show

chainlit/config.py +4 -2
chainlit/context.py +19 -7
chainlit/copilot/dist/index.js +639 -521
chainlit/data/acl.py +4 -1
chainlit/data/sql_alchemy.py +22 -21
chainlit/discord/__init__.py +6 -0
chainlit/discord/app.py +322 -0
chainlit/element.py +5 -2
chainlit/emitter.py +11 -2
chainlit/frontend/dist/assets/{index-032fca02.js → index-37c9a5a9.js} +120 -120
chainlit/frontend/dist/assets/react-plotly-c55d0c95.js +3602 -0
chainlit/frontend/dist/index.html +1 -1
chainlit/server.py +27 -4
chainlit/session.py +72 -61
chainlit/slack/__init__.py +6 -0
chainlit/slack/app.py +379 -0
chainlit/socket.py +21 -15
chainlit/step.py +25 -1
chainlit/types.py +2 -1
chainlit/user_session.py +5 -2
{chainlit-1.1.0rc1.dist-info → chainlit-1.1.101.dist-info}/METADATA +4 -3
{chainlit-1.1.0rc1.dist-info → chainlit-1.1.101.dist-info}/RECORD +24 -20
chainlit/frontend/dist/assets/react-plotly-8c993614.js +0 -3484
{chainlit-1.1.0rc1.dist-info → chainlit-1.1.101.dist-info}/WHEEL +0 -0
{chainlit-1.1.0rc1.dist-info → chainlit-1.1.101.dist-info}/entry_points.txt +0 -0

chainlit/frontend/dist/index.html CHANGED Viewed

@@ -22,7 +22,7 @@
     <script>
       const global = globalThis;
     </script>
-    <script type="module" crossorigin src="/assets/index-032fca02.js"></script>
+    <script type="module" crossorigin src="/assets/index-37c9a5a9.js"></script>
     <link rel="stylesheet" href="/assets/index-d088547c.css">
   </head>
   <body>

chainlit/server.py CHANGED Viewed

@@ -119,16 +119,27 @@ async def lifespan(app: FastAPI):
         watch_task = asyncio.create_task(watch_files_for_changes())
+    discord_task = None
+    if discord_bot_token := os.environ.get("DISCORD_BOT_TOKEN"):
+        from chainlit.discord.app import client
+        discord_task = asyncio.create_task(client.start(discord_bot_token))
     try:
         yield
     finally:
-        if watch_task:
-            try:
+        try:
+            if watch_task:
                 stop_event.set()
                 watch_task.cancel()
                 await watch_task
-            except asyncio.exceptions.CancelledError:
-                pass
+            if discord_task:
+                discord_task.cancel()
+                await discord_task
+        except asyncio.exceptions.CancelledError:
+            pass
         if FILES_DIRECTORY.is_dir():
             shutil.rmtree(FILES_DIRECTORY)
@@ -195,6 +206,18 @@ socket = SocketManager(
 )
+# -------------------------------------------------------------------------------
+#                               SLACK HANDLER
+# -------------------------------------------------------------------------------
+if os.environ.get("SLACK_BOT_TOKEN") and os.environ.get("SLACK_SIGNING_SECRET"):
+    from chainlit.slack.app import slack_app_handler
+    @app.post("/slack/events")
+    async def endpoint(req: Request):
+        return await slack_app_handler.handle(req)
 # -------------------------------------------------------------------------------
 #                               HTTP HANDLERS
 # -------------------------------------------------------------------------------

chainlit/session.py CHANGED Viewed

@@ -24,7 +24,7 @@ if TYPE_CHECKING:
     from chainlit.types import FileDict, FileReference
     from chainlit.user import PersistedUser, User
-ClientType = Literal["app", "copilot", "teams", "slack"]
+ClientType = Literal["webapp", "copilot", "teams", "slack", "discord"]
 class JSONEncoderIgnoreNonSerializable(json.JSONEncoder):
@@ -35,11 +35,21 @@ class JSONEncoderIgnoreNonSerializable(json.JSONEncoder):
             return None
-def clean_metadata(metadata: Dict):
-    return json.loads(
+def clean_metadata(metadata: Dict, max_size: int = 1048576):
+    cleaned_metadata = json.loads(
         json.dumps(metadata, cls=JSONEncoderIgnoreNonSerializable, ensure_ascii=False)
     )
+    metadata_size = len(json.dumps(cleaned_metadata).encode('utf-8'))
+    if metadata_size > max_size:
+        # Redact the metadata if it exceeds the maximum size
+        cleaned_metadata = {
+            'message': f'Metadata size exceeds the limit of {max_size} bytes. Redacted.'
+        }
+    return cleaned_metadata
 class BaseSession:
     """Base object."""
@@ -80,18 +90,66 @@ class BaseSession:
         self.chat_profile = chat_profile
         self.http_referer = http_referer
+        self.files = {}  # type: Dict[str, "FileDict"]
         self.id = id
         self.chat_settings: Dict[str, Any] = {}
+    @property
+    def files_dir(self):
+        from chainlit.config import FILES_DIRECTORY
+        return FILES_DIRECTORY / self.id
     async def persist_file(
         self,
         name: str,
         mime: str,
         path: Optional[str] = None,
         content: Optional[Union[bytes, str]] = None,
-    ):
-        return None
+    ) -> "FileReference":
+        if not path and not content:
+            raise ValueError(
+                "Either path or content must be provided to persist a file"
+            )
+        self.files_dir.mkdir(exist_ok=True)
+        file_id = str(uuid.uuid4())
+        file_path = self.files_dir / file_id
+        file_extension = mimetypes.guess_extension(mime)
+        if file_extension:
+            file_path = file_path.with_suffix(file_extension)
+        if path:
+            # Copy the file from the given path
+            async with aiofiles.open(path, "rb") as src, aiofiles.open(
+                file_path, "wb"
+            ) as dst:
+                await dst.write(await src.read())
+        elif content:
+            # Write the provided content to the file
+            async with aiofiles.open(file_path, "wb") as buffer:
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+                await buffer.write(content)
+        # Get the file size
+        file_size = file_path.stat().st_size
+        # Store the file content in memory
+        self.files[file_id] = {
+            "id": file_id,
+            "path": file_path,
+            "name": name,
+            "type": mime,
+            "size": file_size,
+        }
+        return {"id": file_id}
     def to_persistable(self) -> Dict:
         from chainlit.user_session import user_sessions
@@ -99,6 +157,8 @@ class BaseSession:
         user_session = user_sessions.get(self.id) or {}  # type: Dict
         user_session["chat_settings"] = self.chat_settings
         user_session["chat_profile"] = self.chat_profile
+        user_session["http_referer"] = self.http_referer
+        user_session["client_type"] = self.client_type
         metadata = clean_metadata(user_session)
         return metadata
@@ -134,6 +194,11 @@ class HTTPSession(BaseSession):
             http_referer=http_referer,
         )
+    def delete(self):
+        """Delete the session."""
+        if self.files_dir.is_dir():
+            shutil.rmtree(self.files_dir)
 class WebsocketSession(BaseSession):
     """Internal web socket session object.
@@ -147,6 +212,8 @@ class WebsocketSession(BaseSession):
     socket id for convenience.
     """
+    to_clear: bool = False
     def __init__(
         self,
         # Id from the session cookie
@@ -194,68 +261,12 @@ class WebsocketSession(BaseSession):
         self.restored = False
         self.thread_queues = {}  # type: Dict[str, Deque[Callable]]
-        self.files = {}  # type: Dict[str, "FileDict"]
         ws_sessions_id[self.id] = self
         ws_sessions_sid[socket_id] = self
         self.languages = languages
-    @property
-    def files_dir(self):
-        from chainlit.config import FILES_DIRECTORY
-        return FILES_DIRECTORY / self.id
-    async def persist_file(
-        self,
-        name: str,
-        mime: str,
-        path: Optional[str] = None,
-        content: Optional[Union[bytes, str]] = None,
-    ) -> "FileReference":
-        if not path and not content:
-            raise ValueError(
-                "Either path or content must be provided to persist a file"
-            )
-        self.files_dir.mkdir(exist_ok=True)
-        file_id = str(uuid.uuid4())
-        file_path = self.files_dir / file_id
-        file_extension = mimetypes.guess_extension(mime)
-        if file_extension:
-            file_path = file_path.with_suffix(file_extension)
-        if path:
-            # Copy the file from the given path
-            async with aiofiles.open(path, "rb") as src, aiofiles.open(
-                file_path, "wb"
-            ) as dst:
-                await dst.write(await src.read())
-        elif content:
-            # Write the provided content to the file
-            async with aiofiles.open(file_path, "wb") as buffer:
-                if isinstance(content, str):
-                    content = content.encode("utf-8")
-                await buffer.write(content)
-        # Get the file size
-        file_size = file_path.stat().st_size
-        # Store the file content in memory
-        self.files[file_id] = {
-            "id": file_id,
-            "path": file_path,
-            "name": name,
-            "type": mime,
-            "size": file_size,
-        }
-        return {"id": file_id}
     def restore(self, new_socket_id: str):
         """Associate a new socket id to the session."""
         ws_sessions_sid.pop(self.socket_id, None)

chainlit/slack/__init__.py ADDED Viewed

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

chainlit/slack/app.py ADDED Viewed

@@ -0,0 +1,379 @@
+import asyncio
+import os
+import re
+import uuid
+from functools import partial
+from typing import Dict, List, Optional, Union
+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.message import Message, StepDict
+from chainlit.types import Feedback
+from chainlit.user import PersistedUser, User
+from chainlit.user_session import user_session
+from chainlit.logger import logger
+from chainlit.telemetry import trace
+from slack_bolt.adapter.fastapi.async_handler import AsyncSlackRequestHandler
+from slack_bolt.async_app import AsyncApp
+class SlackEmitter(BaseChainlitEmitter):
+    def __init__(
+        self,
+        session: HTTPSession,
+        app: AsyncApp,
+        channel_id: str,
+        say,
+        enabled=False,
+        thread_ts: Optional[str] = None,
+    ):
+        super().__init__(session)
+        self.app = app
+        self.channel_id = channel_id
+        self.say = say
+        self.enabled = enabled
+        self.thread_ts = thread_ts
+    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[bytes, str]] = None
+        if persisted_file:
+            file = str(persisted_file["path"])
+        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 = response.content
+        if not file:
+            return
+        await self.app.client.files_upload_v2(
+            channel=self.channel_id,
+            thread_ts=self.thread_ts,
+            file=file,
+            title=element_dict.get("name"),
+        )
+    async def send_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+        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:
+            return
+        enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+        blocks: List[Dict] = [
+            {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": step_dict["output"]},
+            }
+        ]
+        if enable_feedback:
+            blocks.append(
+                {
+                    "type": "actions",
+                    "elements": [
+                        {
+                            "action_id": "thumbdown",
+                            "type": "button",
+                            "text": {
+                                "type": "plain_text",
+                                "emoji": True,
+                                "text": ":thumbsdown:",
+                            },
+                            "value": step_dict.get("id"),
+                        },
+                        {
+                            "action_id": "thumbup",
+                            "type": "button",
+                            "text": {
+                                "type": "plain_text",
+                                "emoji": True,
+                                "text": ":thumbsup:",
+                            },
+                            "value": step_dict.get("id"),
+                        },
+                    ],
+                }
+            )
+        await self.say(
+            text=step_dict["output"], blocks=blocks, thread_ts=self.thread_ts
+        )
+    async def update_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+        await self.send_step(step_dict)
+slack_app = AsyncApp(
+    token=os.environ.get("SLACK_BOT_TOKEN"),
+    signing_secret=os.environ.get("SLACK_SIGNING_SECRET"),
+)
+@trace
+def init_slack_context(
+    session: HTTPSession,
+    slack_channel_id: str,
+    event,
+    say,
+    thread_ts: Optional[str] = None,
+) -> ChainlitContext:
+    emitter = SlackEmitter(
+        session=session,
+        app=slack_app,
+        channel_id=slack_channel_id,
+        say=say,
+        thread_ts=thread_ts,
+    )
+    context = ChainlitContext(session=session, emitter=emitter)
+    context_var.set(context)
+    user_session.set("slack_event", event)
+    user_session.set(
+        "fetch_slack_message_history",
+        partial(
+            fetch_message_history, channel_id=slack_channel_id, thread_ts=thread_ts
+        ),
+    )
+    return context
+slack_app_handler = AsyncSlackRequestHandler(slack_app)
+users_by_slack_id: Dict[str, Union[User, PersistedUser]] = {}
+USER_PREFIX = "slack_"
+def clean_content(message: str):
+    cleaned_text = re.sub(r"<@[\w]+>", "", message).strip()
+    return cleaned_text
+async def get_user(slack_user_id: str):
+    if slack_user_id in users_by_slack_id:
+        return users_by_slack_id[slack_user_id]
+    slack_user = await slack_app.client.users_info(user=slack_user_id)
+    slack_user_profile = slack_user["user"]["profile"]
+    user_email = slack_user_profile.get("email")
+    user = User(identifier=USER_PREFIX + user_email, metadata=slack_user_profile)
+    users_by_slack_id[slack_user_id] = user
+    if data_layer := get_data_layer():
+        try:
+            persisted_user = await data_layer.create_user(user)
+            if persisted_user:
+                users_by_slack_id[slack_user_id] = persisted_user
+        except Exception as e:
+            logger.error(f"Error creating user: {e}")
+    return users_by_slack_id[slack_user_id]
+async def fetch_message_history(
+    channel_id: str, thread_ts: Optional[str] = None, limit=30
+):
+    if not thread_ts:
+        result = await slack_app.client.conversations_history(
+            channel=channel_id, limit=limit
+        )
+    else:
+        result = await slack_app.client.conversations_replies(
+            channel=channel_id, ts=thread_ts, limit=limit
+        )
+    if result["ok"]:
+        messages = result["messages"]
+        return messages
+    else:
+        raise Exception(f"Failed to fetch messages: {result['error']}")
+async def download_slack_file(url, token):
+    headers = {"Authorization": f"Bearer {token}"}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, headers=headers)
+        if response.status_code == 200:
+            return response.content
+        else:
+            return None
+async def download_slack_files(session: HTTPSession, files, token):
+    download_coros = [
+        download_slack_file(file.get("url_private"), token) for file in files
+    ]
+    file_bytes_list = await asyncio.gather(*download_coros)
+    file_refs = []
+    for idx, file_bytes in enumerate(file_bytes_list):
+        if file_bytes:
+            name = files[idx].get("name")
+            mime_type = files[idx].get("mimetype")
+            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
+async def process_slack_message(
+    event,
+    say,
+    thread_name: Optional[str] = None,
+    bind_thread_to_user=False,
+    thread_ts: Optional[str] = None,
+):
+    user = await get_user(event["user"])
+    channel_id = event["channel"]
+    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, thread_ts or channel_id))
+    text = event.get("text")
+    slack_files = event.get("files", [])
+    session_id = str(uuid.uuid4())
+    session = HTTPSession(
+        id=session_id,
+        thread_id=thread_id,
+        user=user,
+        client_type="slack",
+    )
+    ctx = init_slack_context(
+        session=session,
+        slack_channel_id=channel_id,
+        event=event,
+        say=say,
+        thread_ts=thread_ts,
+    )
+    file_elements = await download_slack_files(
+        session, slack_files, slack_app.client.token
+    )
+    msg = Message(
+        content=clean_content(text),
+        elements=file_elements,
+        type="user_message",
+        author=user.metadata.get("real_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:
+        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 or msg.content,
+                metadata=ctx.session.to_persistable(),
+                user_id=user_id
+            )
+        except Exception as e:
+            logger.error(f"Error updating thread: {e}")
+    ctx.session.delete()
+@slack_app.event("app_home_opened")
+async def handle_app_home_opened(event, say):
+    pass
+@slack_app.event("app_mention")
+async def handle_app_mentions(event, say):
+    thread_ts = event.get("thread_ts", event["ts"])
+    await process_slack_message(event, say, thread_ts=thread_ts)
+@slack_app.event("message")
+async def handle_message(message, say):
+    user = await get_user(message["user"])
+    thread_name = f"{user.identifier} Slack DM"
+    await process_slack_message(message, say, thread_name)
+@slack_app.block_action("thumbdown")
+async def thumb_down(ack, context, body):
+    await ack()
+    step_id = body["actions"][0]["value"]
+    if data_layer := get_data_layer():
+        await data_layer.upsert_feedback(Feedback(forId=step_id, value=0))
+    text = body["message"]["text"]
+    blocks = body["message"]["blocks"]
+    updated_blocks = [block for block in blocks if block["type"] != "actions"]
+    updated_blocks.append(
+        {
+            "type": "section",
+            "text": {"type": "mrkdwn", "text": ":thumbsdown: Feedback received."},
+        }
+    )
+    await context.client.chat_update(
+        channel=body["channel"]["id"],
+        ts=body["container"]["message_ts"],
+        text=text,
+        blocks=updated_blocks,
+    )
+@slack_app.block_action("thumbup")
+async def thumb_up(ack, context, body):
+    await ack()
+    step_id = body["actions"][0]["value"]
+    if data_layer := get_data_layer():
+        await data_layer.upsert_feedback(Feedback(forId=step_id, value=1))
+    text = body["message"]["text"]
+    blocks = body["message"]["blocks"]
+    updated_blocks = [block for block in blocks if block["type"] != "actions"]
+    updated_blocks.append(
+        {
+            "type": "section",
+            "text": {"type": "mrkdwn", "text": ":thumbsup: Feedback received."},
+        }
+    )
+    await context.client.chat_update(
+        channel=body["channel"]["id"],
+        ts=body["container"]["message_ts"],
+        text=text,
+        blocks=updated_blocks,
+    )

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

Potentially problematic release.

chainlit 1.1.0rc1py3-none-any.whl → 1.1.101py3-none-any.whl