chainlit 1.0.0rc3__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
@@ -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":
@@ -194,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 "",
@@ -237,15 +255,38 @@ class ChainlitDataLayer:
         if not element.for_id:
             return
 
-        await self.client.api.create_attachment(
-            thread_id=element.thread_id,
-            step_id=element.for_id,
-            mime=element.mime,
-            name=element.name,
-            url=element.url,
-            content=element.content,
-            path=element.path,
-            metadata=metadata,
+        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(
@@ -342,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"]
@@ -377,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/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
@@ -172,11 +173,14 @@ class ChainlitEmitter(BaseChainlitEmitter):
                 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": interaction},
-            )
+            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, interaction: str):