chainlit 1.0.0rc2__py3-none-any.whl → 1.0.100__py3-none-any.whl

chainlit/__init__.py

@@ -7,6 +7,7 @@ env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
 import asyncio
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
+from fastapi import Request, Response
 from starlette.datastructures import Headers
 
 if TYPE_CHECKING:
@@ -54,7 +55,7 @@ from chainlit.user import PersistedUser, User
 from chainlit.user_session import user_session
 from chainlit.utils import make_module_getattr, wrap_user_function
 from chainlit.version import __version__
-from chainlit_client import ChatGeneration, CompletionGeneration, GenerationMessage
+from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
 
 if env_found:
     logger.info("Loaded .env file")
@@ -127,6 +128,17 @@ def oauth_callback(
     return func
 
 
+@trace
+def on_logout(func: Callable[[Request, Response], Any]) -> Callable:
+    """
+    Function called when the user logs out.
+    Takes the FastAPI request and response as parameters.
+    """
+
+    config.code.on_logout = wrap_user_function(func)
+    return func
+
+
 @trace
 def on_message(func: Callable) -> Callable:
     """
@@ -320,6 +332,7 @@ __all__ = [
     "ChatGeneration",
     "CompletionGeneration",
     "GenerationMessage",
+    "on_logout",
     "on_chat_start",
     "on_chat_end",
     "on_chat_resume",

chainlit/auth.py

@@ -20,7 +20,7 @@ def get_jwt_secret():
 def ensure_jwt_secret():
     if require_login() and get_jwt_secret() is None:
         raise ValueError(
-            "You must provide a JWT secret in the environment to use password authentication. Run `chainlit create-secret` to generate one."
+            "You must provide a JWT secret in the environment to use authentication. Run `chainlit create-secret` to generate one."
         )
 
 
@@ -30,7 +30,8 @@ def is_oauth_enabled():
 
 def require_login():
     return (
-        config.code.password_auth_callback is not None
+        bool(os.environ.get("CHAINLIT_CUSTOM_AUTH"))
+        or config.code.password_auth_callback is not None
         or config.code.header_auth_callback is not None
         or is_oauth_enabled()
     )
@@ -74,7 +75,7 @@ async def authenticate_user(token: str = Depends(reuseable_oauth)):
         try:
             persisted_user = await data_layer.get_user(user.identifier)
         except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
+            return user
         if persisted_user == None:
             raise HTTPException(status_code=401, detail="User does not exist")
 

chainlit/config.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from chainlit.action import Action
     from chainlit.types import ChatProfile, ThreadDict
     from chainlit.user import User
+    from fastapi import Request, Response
 
 
 BACKEND_ROOT = os.path.dirname(__file__)
@@ -118,8 +119,6 @@ hide_cot = false
 generated_by = "{__version__}"
 """
 
-chainlit_prod_url = os.environ.get("CHAINLIT_PROD_URL")
-
 
 DEFAULT_HOST = "0.0.0.0"
 DEFAULT_PORT = 8000
@@ -200,6 +199,7 @@ class CodeSettings:
     oauth_callback: Optional[
         Callable[[str, str, Dict[str, str], "User"], Optional["User"]]
     ] = None
+    on_logout: Optional[Callable[["Request", "Response"], Any]] = None
     on_stop: Optional[Callable[[], Any]] = None
     on_chat_start: Optional[Callable[[], Any]] = None
     on_chat_end: Optional[Callable[[], Any]] = None
@@ -234,9 +234,6 @@ class ChainlitConfig:
     root = APP_ROOT
     # Chainlit server URL. Used only for cloud features
     chainlit_server: str
-    # The url of the deployed app. Only set if the app is deployed.
-    chainlit_prod_url = chainlit_prod_url
-
     run: RunSettings
     features: FeaturesSettings
     ui: UISettings
@@ -347,7 +344,6 @@ def load_config():
 
     config = ChainlitConfig(
         chainlit_server=chainlit_server,
-        chainlit_prod_url=chainlit_prod_url,
         run=RunSettings(),
         **settings,
     )

chainlit/data/__init__.py

@@ -1,20 +1,21 @@
 import functools
 import os
 from collections import deque
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
+import aiofiles
 from chainlit.config import config
 from chainlit.context import context
 from chainlit.logger import logger
 from chainlit.session import WebsocketSession
 from chainlit.types import Feedback, Pagination, ThreadDict, ThreadFilter
 from chainlit.user import PersistedUser, User, UserDict
-from chainlit_client import Attachment
-from chainlit_client import Feedback as ClientFeedback
-from chainlit_client import PageInfo, PaginatedResponse
-from chainlit_client import Step as ClientStep
-from chainlit_client.thread import NumberListFilter, StringFilter, StringListFilter
-from chainlit_client.thread import ThreadFilter as ClientThreadFilter
+from literalai import Attachment
+from literalai import Feedback as ClientFeedback
+from literalai import PageInfo, PaginatedResponse
+from literalai import Step as ClientStep
+from literalai.thread import NumberListFilter, StringFilter, StringListFilter
+from literalai.thread import ThreadFilter as ClientThreadFilter
 
 if TYPE_CHECKING:
     from chainlit.element import Element, ElementDict
@@ -29,7 +30,7 @@ def queue_until_user_message():
         async def wrapper(self, *args, **kwargs):
             if (
                 isinstance(context.session, WebsocketSession)
-                and not context.session.has_user_message
+                and not context.session.has_first_interaction
             ):
                 # Queue the method invocation waiting for the first user message
                 queues = context.session.thread_queues
@@ -112,14 +113,29 @@ class BaseDataLayer:
     ):
         pass
 
+    async def create_user_session(
+        self,
+        id: str,
+        started_at: str,
+        anon_user_id: str,
+        user_id: Optional[str],
+    ) -> Dict:
+        return {}
+
+    async def update_user_session(
+        self, id: str, is_interactive: bool, ended_at: Optional[str]
+    ) -> Dict:
+        return {}
+
+    async def delete_user_session(self, id: str) -> bool:
+        return True
+
 
 class ChainlitDataLayer:
-    def __init__(
-        self, api_key: str, chainlit_server: Optional[str] = "https://cloud.chainlit.io"
-    ):
-        from chainlit_client import ChainlitClient
+    def __init__(self, api_key: str, server: Optional[str]):
+        from literalai import LiteralClient
 
-        self.client = ChainlitClient(api_key=api_key, url=chainlit_server)
+        self.client = LiteralClient(api_key=api_key, url=server)
         logger.info("Chainlit data layer initialized")
 
     def attachment_to_element_dict(self, attachment: Attachment) -> "ElementDict":
@@ -128,6 +144,7 @@ class ChainlitDataLayer:
             "chainlitKey": None,
             "display": metadata.get("display", "side"),
             "language": metadata.get("language"),
+            "page": metadata.get("page"),
             "size": metadata.get("size"),
             "type": metadata.get("type", "file"),
             "forId": attachment.step_id,
@@ -193,6 +210,8 @@ class ChainlitDataLayer:
             _user = await self.client.api.create_user(
                 identifier=user.identifier, metadata=user.metadata
             )
+        elif _user.id:
+            await self.client.api.update_user(id=_user.id, metadata=user.metadata)
         return PersistedUser(
             id=_user.id or "",
             identifier=_user.identifier or "",
@@ -230,17 +249,44 @@ class ChainlitDataLayer:
             "language": element.language,
             "display": element.display,
             "type": element.type,
+            "page": getattr(element, "page", None),
         }
 
-        await self.client.api.create_attachment(
-            thread_id=element.thread_id,
-            step_id=element.for_id or "",
-            mime=element.mime,
-            name=element.name,
-            url=element.url,
-            content=element.content,
-            path=element.path,
-            metadata=metadata,
+        if not element.for_id:
+            return
+
+        object_key = None
+
+        if not element.url:
+            if element.path:
+                async with aiofiles.open(element.path, "rb") as f:
+                    content = await f.read()  # type: Union[bytes, str]
+            elif element.content:
+                content = element.content
+            else:
+                raise ValueError("Either path or content must be provided")
+            uploaded = await self.client.api.upload_file(
+                content=content, mime=element.mime, thread_id=element.thread_id
+            )
+            object_key = uploaded["object_key"]
+
+        await self.client.api.send_steps(
+            [
+                {
+                    "id": element.for_id,
+                    "threadId": element.thread_id,
+                    "attachments": [
+                        {
+                            "id": element.id,
+                            "name": element.name,
+                            "metadata": metadata,
+                            "mime": element.mime,
+                            "url": element.url,
+                            "objectKey": object_key,
+                        }
+                    ],
+                }
+            ]
         )
 
     async def get_element(
@@ -337,6 +383,8 @@ class ChainlitDataLayer:
                     continue
                 for attachment in step.attachments:
                     elements.append(self.attachment_to_element_dict(attachment))
+                if not config.features.prompt_playground and step.generation:
+                    step.generation = None
                 steps.append(self.step_to_step_dict(step))
 
         user = None  # type: Optional["UserDict"]
@@ -372,10 +420,40 @@ class ChainlitDataLayer:
             tags=tags,
         )
 
+    async def create_user_session(
+        self,
+        id: str,
+        started_at: str,
+        anon_user_id: str,
+        user_id: Optional[str],
+    ) -> Dict:
+        existing_session = await self.client.api.get_user_session(id=id)
+        if existing_session:
+            return existing_session
+        session = await self.client.api.create_user_session(
+            id=id,
+            started_at=started_at,
+            participant_identifier=user_id,
+            anon_participant_identifier=anon_user_id,
+        )
+        return session
+
+    async def update_user_session(
+        self, id: str, is_interactive: bool, ended_at: Optional[str]
+    ) -> Dict:
+        session = await self.client.api.update_user_session(
+            id=id, is_interactive=is_interactive, ended_at=ended_at
+        )
+        return session
+
+    async def delete_user_session(self, id: str) -> bool:
+        await self.client.api.delete_user_session(id=id)
+        return True
+
 
-if api_key := os.environ.get("CHAINLIT_API_KEY"):
-    chainlit_server = os.environ.get("CHAINLIT_SERVER")
-    _data_layer = ChainlitDataLayer(api_key=api_key, chainlit_server=chainlit_server)
+if api_key := os.environ.get("LITERAL_API_KEY"):
+    server = os.environ.get("LITERAL_SERVER")
+    _data_layer = ChainlitDataLayer(api_key=api_key, server=server)
 
 
 def get_data_layer():

chainlit/element.py

@@ -37,6 +37,7 @@ class ElementDict(TypedDict):
     display: ElementDisplay
     size: Optional[ElementSize]
     language: Optional[str]
+    page: Optional[int]
     forId: Optional[str]
     mime: Optional[str]
 
@@ -46,7 +47,7 @@ class Element:
     # The type of the element. This will be used to determine how to display the element in the UI.
     type: ClassVar[ElementType]
     # Name of the element, this will be used to reference the element in the UI.
-    name: str
+    name: str = ""
     # The ID of the element. This is set automatically when the element is sent to the UI.
     id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     # The key of the element hosted on Chainlit.
@@ -91,6 +92,7 @@ class Element:
                 "display": self.display,
                 "objectKey": getattr(self, "object_key", None),
                 "size": getattr(self, "size", None),
+                "page": getattr(self, "page", None),
                 "language": getattr(self, "language", None),
                 "forId": getattr(self, "for_id", None),
                 "mime": getattr(self, "mime", None),
@@ -201,6 +203,7 @@ class Text(Element):
 class Pdf(Element):
     """Useful to send a pdf to the UI."""
 
+    page: Optional[int] = None
     type: ClassVar[ElementType] = "pdf"
 
 

chainlit/emitter.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Union, cast
 
 from chainlit.data import get_data_layer
 from chainlit.element import Element, File
+from chainlit.logger import logger
 from chainlit.message import Message
 from chainlit.session import BaseSession, WebsocketSession
 from chainlit.step import StepDict
@@ -64,8 +65,7 @@ class BaseChainlitEmitter:
         """Stub method to clear the prompt from the UI."""
         pass
 
-    async def init_thread(self, step_dict: StepDict):
-        """Signal the UI that a new thread (with a user message) exists"""
+    async def init_thread(self, interaction: str):
         pass
 
     async def process_user_message(self, payload: UIMessagePayload) -> Message:
@@ -167,23 +167,25 @@ class ChainlitEmitter(BaseChainlitEmitter):
 
         return self.emit("clear_ask", {})
 
-    async def flush_thread_queues(self, name: str):
+    async def flush_thread_queues(self, interaction: str):
         if data_layer := get_data_layer():
             if isinstance(self.session.user, PersistedUser):
                 user_id = self.session.user.id
             else:
                 user_id = None
-            await data_layer.update_thread(
-                thread_id=self.session.thread_id,
-                user_id=user_id,
-                metadata={"name": name},
-            )
+            try:
+                await data_layer.update_thread(
+                    thread_id=self.session.thread_id,
+                    user_id=user_id,
+                    metadata={"name": interaction},
+                )
+            except Exception as e:
+                logger.error(f"Error updating thread: {e}")
             await self.session.flush_method_queue()
 
-    async def init_thread(self, step: StepDict):
-        """Signal the UI that a new thread (with a user message) exists"""
-        await self.flush_thread_queues(name=step["output"])
-        await self.emit("init_thread", step)
+    async def init_thread(self, interaction: str):
+        await self.flush_thread_queues(interaction)
+        await self.emit("first_interaction", interaction)
 
     async def process_user_message(self, payload: UIMessagePayload):
         step_dict = payload["message"]
@@ -197,9 +199,9 @@ class ChainlitEmitter(BaseChainlitEmitter):
 
         asyncio.create_task(message._create())
 
-        if not self.session.has_user_message:
-            self.session.has_user_message = True
-            asyncio.create_task(self.init_thread(message.to_dict()))
+        if not self.session.has_first_interaction:
+            self.session.has_first_interaction = True
+            asyncio.create_task(self.init_thread(message.content))
 
         if file_refs:
             files = [
@@ -239,11 +241,13 @@ class ChainlitEmitter(BaseChainlitEmitter):
             ] = None
 
             if user_res:
+                interaction = None
                 if spec.type == "text":
                     message_dict_res = cast(StepDict, user_res)
                     await self.process_user_message(
                         {"message": message_dict_res, "fileReferences": None}
                     )
+                    interaction = message_dict_res["output"]
                     final_res = message_dict_res
                 elif spec.type == "file":
                     file_refs = cast(List[FileReference], user_res)
@@ -253,12 +257,7 @@ class ChainlitEmitter(BaseChainlitEmitter):
                         if file["id"] in self.session.files
                     ]
                     final_res = files
-                    if not self.session.has_user_message:
-                        self.session.has_user_message = True
-                        await self.flush_thread_queues(
-                            name=",".join([file["name"] for file in files])
-                        )
-
+                    interaction = ",".join([file["name"] for file in files])
                     if get_data_layer():
                         coros = [
                             File(
@@ -274,6 +273,12 @@ class ChainlitEmitter(BaseChainlitEmitter):
                 elif spec.type == "action":
                     action_res = cast(AskActionResponse, user_res)
                     final_res = action_res
+                    interaction = action_res["value"]
+
+                if not self.session.has_first_interaction and interaction:
+                    self.session.has_first_interaction = True
+                    await self.init_thread(interaction=interaction)
+
             await self.clear_ask()
             return final_res
         except TimeoutError as e: