chainlit 1.0.401__py3-none-any.whl → 2.0.4__py3-none-any.whl

chainlit/session.py

@@ -1,50 +1,51 @@
+import asyncio
 import json
 import mimetypes
 import shutil
 import uuid
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Deque,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Deque, Dict, Literal, Optional, Union
 
 import aiofiles
+
 from chainlit.logger import logger
+from chainlit.types import FileReference
 
 if TYPE_CHECKING:
-    from chainlit.message import Message
-    from chainlit.step import Step
-    from chainlit.types import FileDict, FileReference
+    from chainlit.types import FileDict
     from chainlit.user import PersistedUser, User
 
-ClientType = Literal["app", "copilot", "teams", "slack"]
+ClientType = Literal["webapp", "copilot", "teams", "slack", "discord"]
 
 
 class JSONEncoderIgnoreNonSerializable(json.JSONEncoder):
-    def default(self, obj):
+    def default(self, o):
         try:
-            return super(JSONEncoderIgnoreNonSerializable, self).default(obj)
+            return super().default(o)
         except TypeError:
             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."""
 
     thread_id_to_resume: Optional[str] = None
     client_type: ClientType
+    current_task: Optional[asyncio.Task] = None
 
     def __init__(
         self,
@@ -53,16 +54,18 @@ class BaseSession:
         client_type: ClientType,
         # Thread id
         thread_id: Optional[str],
-        # Logged-in user informations
+        # Logged-in user information
         user: Optional[Union["User", "PersistedUser"]],
         # Logged-in user token
         token: Optional[str],
         # User specific environment variables. Empty if no user environment variables are required.
         user_env: Optional[Dict[str, str]],
-        # Last message at the root of the chat
-        root_message: Optional["Message"] = None,
         # Chat profile selected before the session was created
         chat_profile: Optional[str] = None,
+        # Origin of the request
+        http_referer: Optional[str] = None,
+        # Cookie
+        http_cookie: Optional[str] = None,
     ):
         if thread_id:
             self.thread_id_to_resume = thread_id
@@ -70,23 +73,73 @@ class BaseSession:
         self.user = user
         self.client_type = client_type
         self.token = token
-        self.root_message = root_message
         self.has_first_interaction = False
         self.user_env = user_env or {}
         self.chat_profile = chat_profile
+        self.http_referer = http_referer
+        self.http_cookie = http_cookie
+
+        self.files: 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
@@ -94,6 +147,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
 
@@ -108,14 +163,15 @@ class HTTPSession(BaseSession):
         client_type: ClientType,
         # Thread id
         thread_id: Optional[str] = None,
-        # Logged-in user informations
+        # Logged-in user information
         user: Optional[Union["User", "PersistedUser"]] = None,
         # Logged-in user token
         token: Optional[str] = None,
         user_env: Optional[Dict[str, str]] = None,
-        # Last message at the root of the chat
-        root_message: Optional["Message"] = None,
-        # User specific environment variables. Empty if no user environment variables are required.
+        # Origin of the request
+        http_referer: Optional[str] = None,
+        # Cookie
+        http_cookie: Optional[str] = None,
     ):
         super().__init__(
             id=id,
@@ -124,9 +180,18 @@ class HTTPSession(BaseSession):
             token=token,
             client_type=client_type,
             user_env=user_env,
-            root_message=root_message,
+            http_referer=http_referer,
+            http_cookie=http_cookie,
         )
 
+    def delete(self):
+        """Delete the session."""
+        if self.files_dir.is_dir():
+            shutil.rmtree(self.files_dir)
+
+
+ThreadQueue = Deque[tuple[Callable, object, tuple, Dict]]
+
 
 class WebsocketSession(BaseSession):
     """Internal web socket session object.
@@ -140,6 +205,8 @@ class WebsocketSession(BaseSession):
     socket id for convenience.
     """
 
+    to_clear: bool = False
+
     def __init__(
         self,
         # Id from the session cookie
@@ -155,14 +222,18 @@ class WebsocketSession(BaseSession):
         client_type: ClientType,
         # Thread id
         thread_id: Optional[str] = None,
-        # Logged-in user informations
+        # Logged-in user information
         user: Optional[Union["User", "PersistedUser"]] = None,
         # Logged-in user token
         token: Optional[str] = None,
-        # Last message at the root of the chat
-        root_message: Optional["Message"] = None,
         # Chat profile selected before the session was created
         chat_profile: Optional[str] = None,
+        # Languages of the user's browser
+        languages: Optional[str] = None,
+        # Origin of the request
+        http_referer: Optional[str] = None,
+        # Cookie
+        http_cookie: Optional[str] = None,
     ):
         super().__init__(
             id=id,
@@ -171,76 +242,23 @@ class WebsocketSession(BaseSession):
             token=token,
             user_env=user_env,
             client_type=client_type,
-            root_message=root_message,
             chat_profile=chat_profile,
+            http_referer=http_referer,
+            http_cookie=http_cookie,
         )
 
         self.socket_id = socket_id
         self.emit_call = emit_call
         self.emit = emit
 
-        self.should_stop = False
         self.restored = False
 
-        self.thread_queues = {}  # type: Dict[str, Deque[Callable]]
-        self.files = {}  # type: Dict[str, "FileDict"]
+        self.thread_queues: Dict[str, ThreadQueue] = {}
 
         ws_sessions_id[self.id] = self
         ws_sessions_sid[socket_id] = self
 
-    @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}
+        self.languages = languages
 
     def restore(self, new_socket_id: str):
         """Associate a new socket id to the session."""

chainlit/slack/__init__.py

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