chainlit 0.7.700__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

chainlit/__init__.py

@@ -5,7 +5,7 @@ from dotenv import load_dotenv
 env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
 
 import asyncio
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
 from starlette.datastructures import Headers
 
@@ -21,8 +21,8 @@ import chainlit.input_widget as input_widget
 from chainlit.action import Action
 from chainlit.cache import cache
 from chainlit.chat_settings import ChatSettings
-from chainlit.client.base import AppUser, ConversationDict, PersistedAppUser
 from chainlit.config import config
+from chainlit.context import context
 from chainlit.element import (
     Audio,
     Avatar,
@@ -46,31 +46,34 @@ from chainlit.message import (
     Message,
 )
 from chainlit.oauth_providers import get_configured_oauth_providers
+from chainlit.step import Step, step
 from chainlit.sync import make_async, run_sync
 from chainlit.telemetry import trace
-from chainlit.types import ChatProfile, FileSpec
+from chainlit.types import ChatProfile, ThreadDict
+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
 
 if env_found:
     logger.info("Loaded .env file")
 
 
 @trace
-def password_auth_callback(func: Callable[[str, str], Optional[AppUser]]) -> Callable:
+def password_auth_callback(func: Callable[[str, str], Optional[User]]) -> Callable:
     """
     Framework agnostic decorator to authenticate the user.
 
     Args:
-        func (Callable[[str, str], Optional[AppUser]]): The authentication callback to execute. Takes the email and password as parameters.
+        func (Callable[[str, str], Optional[User]]): The authentication callback to execute. Takes the email and password as parameters.
 
     Example:
         @cl.password_auth_callback
-        async def password_auth_callback(username: str, password: str) -> Optional[AppUser]:
+        async def password_auth_callback(username: str, password: str) -> Optional[User]:
 
     Returns:
-        Callable[[str, str], Optional[AppUser]]: The decorated authentication callback.
+        Callable[[str, str], Optional[User]]: The decorated authentication callback.
     """
 
     config.code.password_auth_callback = wrap_user_function(func)
@@ -78,19 +81,19 @@ def password_auth_callback(func: Callable[[str, str], Optional[AppUser]]) -> Cal
 
 
 @trace
-def header_auth_callback(func: Callable[[Headers], Optional[AppUser]]) -> Callable:
+def header_auth_callback(func: Callable[[Headers], Optional[User]]) -> Callable:
     """
     Framework agnostic decorator to authenticate the user via a header
 
     Args:
-        func (Callable[[Headers], Optional[AppUser]]): The authentication callback to execute.
+        func (Callable[[Headers], Optional[User]]): The authentication callback to execute.
 
     Example:
         @cl.header_auth_callback
-        async def header_auth_callback(headers: Headers) -> Optional[AppUser]:
+        async def header_auth_callback(headers: Headers) -> Optional[User]:
 
     Returns:
-        Callable[[Headers], Optional[AppUser]]: The decorated authentication callback.
+        Callable[[Headers], Optional[User]]: The decorated authentication callback.
     """
 
     config.code.header_auth_callback = wrap_user_function(func)
@@ -99,20 +102,20 @@ def header_auth_callback(func: Callable[[Headers], Optional[AppUser]]) -> Callab
 
 @trace
 def oauth_callback(
-    func: Callable[[str, str, Dict[str, str], AppUser], Optional[AppUser]]
+    func: Callable[[str, str, Dict[str, str], User], Optional[User]]
 ) -> Callable:
     """
     Framework agnostic decorator to authenticate the user via oauth
 
     Args:
-        func (Callable[[str, str, Dict[str, str], AppUser], Optional[AppUser]]): The authentication callback to execute.
+        func (Callable[[str, str, Dict[str, str], User], Optional[User]]): The authentication callback to execute.
 
     Example:
         @cl.oauth_callback
-        async def oauth_callback(provider_id: str, token: str, raw_user_data: Dict[str, str], default_app_user: AppUser) -> Optional[AppUser]:
+        async def oauth_callback(provider_id: str, token: str, raw_user_data: Dict[str, str], default_app_user: User) -> Optional[User]:
 
     Returns:
-        Callable[[str, str, Dict[str, str], AppUser], Optional[AppUser]]: The decorated authentication callback.
+        Callable[[str, str, Dict[str, str], User], Optional[User]]: The decorated authentication callback.
     """
 
     if len(get_configured_oauth_providers()) == 0:
@@ -158,7 +161,7 @@ def on_chat_start(func: Callable) -> Callable:
 
 
 @trace
-def on_chat_resume(func: Callable[[ConversationDict], Any]) -> Callable:
+def on_chat_resume(func: Callable[[ThreadDict], Any]) -> Callable:
     """
     Hook to react to resume websocket connection event.
 
@@ -175,16 +178,16 @@ def on_chat_resume(func: Callable[[ConversationDict], Any]) -> Callable:
 
 @trace
 def set_chat_profiles(
-    func: Callable[[Optional["AppUser"]], List["ChatProfile"]]
+    func: Callable[[Optional["User"]], List["ChatProfile"]]
 ) -> Callable:
     """
-    Programmatic declaration of the available chat profiles (can depend on the AppUser from the session if authentication is setup).
+    Programmatic declaration of the available chat profiles (can depend on the User from the session if authentication is setup).
 
     Args:
-        func (Callable[[Optional["AppUser"]], List["ChatProfile"]]): The function declaring the chat profiles.
+        func (Callable[[Optional["User"]], List["ChatProfile"]]): The function declaring the chat profiles.
 
     Returns:
-        Callable[[Optional["AppUser"]], List["ChatProfile"]]: The decorated function.
+        Callable[[Optional["User"]], List["ChatProfile"]]: The decorated function.
     """
 
     config.code.set_chat_profiles = wrap_user_function(func)
@@ -225,7 +228,7 @@ def author_rename(func: Callable[[str], str]) -> Callable[[str], str]:
 @trace
 def on_stop(func: Callable) -> Callable:
     """
-    Hook to react to the user stopping a conversation.
+    Hook to react to the user stopping a thread.
 
     Args:
         func (Callable[[], Any]): The stop hook to execute.
@@ -291,8 +294,8 @@ __getattr__ = make_module_getattr(
 __all__ = [
     "user_session",
     "Action",
-    "AppUser",
-    "PersistedAppUser",
+    "User",
+    "PersistedUser",
     "Audio",
     "Pdf",
     "Plotly",
@@ -312,6 +315,11 @@ __all__ = [
     "AskUserMessage",
     "AskActionMessage",
     "AskFileMessage",
+    "Step",
+    "step",
+    "ChatGeneration",
+    "CompletionGeneration",
+    "GenerationMessage",
     "on_chat_start",
     "on_chat_end",
     "on_chat_resume",
@@ -325,6 +333,7 @@ __all__ = [
     "run_sync",
     "make_async",
     "cache",
+    "context",
     "LangchainCallbackHandler",
     "AsyncLangchainCallbackHandler",
     "LlamaIndexCallbackHandler",

chainlit/auth.py

@@ -3,10 +3,10 @@ from datetime import datetime, timedelta
 from typing import Any, Dict
 
 import jwt
-from chainlit.client.cloud import AppUser
 from chainlit.config import config
-from chainlit.data import chainlit_client
+from chainlit.data import get_data_layer
 from chainlit.oauth_providers import get_configured_oauth_providers
+from chainlit.user import User
 from fastapi import Depends, HTTPException
 from fastapi.security import OAuth2PasswordBearer
 
@@ -47,7 +47,7 @@ def get_configuration():
     }
 
 
-def create_jwt(data: AppUser) -> str:
+def create_jwt(data: User) -> str:
     to_encode = data.to_dict()  # type: Dict[str, Any]
     to_encode.update(
         {
@@ -67,21 +67,20 @@ async def authenticate_user(token: str = Depends(reuseable_oauth)):
             options={"verify_signature": True},
         )
         del dict["exp"]
-        app_user = AppUser(**dict)
+        user = User(**dict)
     except Exception as e:
         raise HTTPException(status_code=401, detail="Invalid authentication token")
-
-    if chainlit_client:
+    if data_layer := get_data_layer():
         try:
-            persisted_app_user = await chainlit_client.get_app_user(app_user.username)
+            persisted_user = await data_layer.get_user(user.identifier)
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
-        if persisted_app_user == None:
+        if persisted_user == None:
             raise HTTPException(status_code=401, detail="User does not exist")
 
-        return persisted_app_user
+        return persisted_user
     else:
-        return app_user
+        return user
 
 
 async def get_current_user(token: str = Depends(reuseable_oauth)):

chainlit/cli/__init__.py

@@ -21,7 +21,7 @@ from chainlit.config import (
 from chainlit.logger import logger
 from chainlit.markdown import init_markdown
 from chainlit.secret import random_secret
-from chainlit.server import app, max_message_size, register_wildcard_route_handler
+from chainlit.server import app, register_wildcard_route_handler
 from chainlit.telemetry import trace_event
 
 
@@ -73,7 +73,6 @@ def run_chainlit(target: str):
             host=host,
             port=port,
             log_level=log_level,
-            ws_max_size=max_message_size,
             ws_per_message_deflate=ws_per_message_deflate,
         )
         server = uvicorn.Server(config)

chainlit/config.py

@@ -1,6 +1,7 @@
 import os
 import sys
 from importlib import util
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
 import tomli
@@ -12,8 +13,8 @@ from starlette.datastructures import Headers
 
 if TYPE_CHECKING:
     from chainlit.action import Action
-    from chainlit.client.base import AppUser, ConversationDict
-    from chainlit.types import ChatProfile
+    from chainlit.types import ChatProfile, ThreadDict
+    from chainlit.user import User
 
 
 BACKEND_ROOT = os.path.dirname(__file__)
@@ -23,6 +24,10 @@ PACKAGE_ROOT = os.path.dirname(os.path.dirname(BACKEND_ROOT))
 # Get the directory the script is running from
 APP_ROOT = os.getcwd()
 
+# Create the directory to store the uploaded files
+FILES_DIRECTORY = Path(APP_ROOT) / ".files"
+FILES_DIRECTORY.mkdir(exist_ok=True)
+
 config_dir = os.path.join(APP_ROOT, ".chainlit")
 config_file = os.path.join(config_dir, "config.toml")
 
@@ -66,7 +71,7 @@ multi_modal = true
 # Name of the app and chatbot.
 name = "Chatbot"
 
-# Show the readme while the conversation is empty.
+# Show the readme while the thread is empty.
 show_readme_as_default = true
 
 # Description of the app and chatbot. This is used for HTML tags.
@@ -190,20 +195,20 @@ class CodeSettings:
     # Module object loaded from the module_name
     module: Any = None
     # Bunch of callbacks defined by the developer
-    password_auth_callback: Optional[Callable[[str, str], Optional["AppUser"]]] = None
-    header_auth_callback: Optional[Callable[[Headers], Optional["AppUser"]]] = None
+    password_auth_callback: Optional[Callable[[str, str], Optional["User"]]] = None
+    header_auth_callback: Optional[Callable[[Headers], Optional["User"]]] = None
     oauth_callback: Optional[
-        Callable[[str, str, Dict[str, str], "AppUser"], Optional["AppUser"]]
+        Callable[[str, str, Dict[str, str], "User"], Optional["User"]]
     ] = None
     on_stop: Optional[Callable[[], Any]] = None
     on_chat_start: Optional[Callable[[], Any]] = None
     on_chat_end: Optional[Callable[[], Any]] = None
-    on_chat_resume: Optional[Callable[["ConversationDict"], Any]] = None
+    on_chat_resume: Optional[Callable[["ThreadDict"], Any]] = None
     on_message: Optional[Callable[[str], Any]] = None
     author_rename: Optional[Callable[[str], str]] = None
     on_settings_update: Optional[Callable[[Dict[str, Any]], Any]] = None
     set_chat_profiles: Optional[
-        Callable[[Optional["AppUser"]], List["ChatProfile"]]
+        Callable[[Optional["User"]], List["ChatProfile"]]
     ] = None
 
 
@@ -229,8 +234,6 @@ class ChainlitConfig:
     root = APP_ROOT
     # Chainlit server URL. Used only for cloud features
     chainlit_server: str
-    # Whether or not a chainlit api key has been provided
-    data_persistence: bool
     # The url of the deployed app. Only set if the app is deployed.
     chainlit_prod_url = chainlit_prod_url
 
@@ -341,11 +344,9 @@ def load_config():
     settings = load_settings()
 
     chainlit_server = os.environ.get("CHAINLIT_SERVER", "https://cloud.chainlit.io")
-    data_persistence = "CHAINLIT_API_KEY" in os.environ
 
     config = ChainlitConfig(
         chainlit_server=chainlit_server,
-        data_persistence=data_persistence,
         chainlit_prod_url=chainlit_prod_url,
         run=RunSettings(),
         **settings,

chainlit/context.py

@@ -7,9 +7,8 @@ from chainlit.session import HTTPSession, WebsocketSession
 from lazify import LazyProxy
 
 if TYPE_CHECKING:
-    from chainlit.client.cloud import AppUser, PersistedAppUser
     from chainlit.emitter import BaseChainlitEmitter
-    from chainlit.message import Message
+    from chainlit.user import PersistedUser, User
 
 
 class ChainlitContextException(Exception):
@@ -22,6 +21,11 @@ class ChainlitContext:
     emitter: "BaseChainlitEmitter"
     session: Union["HTTPSession", "WebsocketSession"]
 
+    @property
+    def current_step(self):
+        if self.session.active_steps:
+            return self.session.active_steps[-1]
+
     def __init__(self, session: Union["HTTPSession", "WebsocketSession"]):
         from chainlit.emitter import BaseChainlitEmitter, ChainlitEmitter
 
@@ -47,7 +51,7 @@ def init_ws_context(session_or_sid: Union[WebsocketSession, str]) -> ChainlitCon
 
 
 def init_http_context(
-    user: Optional[Union["AppUser", "PersistedAppUser"]] = None,
+    user: Optional[Union["User", "PersistedUser"]] = None,
     auth_token: Optional[str] = None,
     user_env: Optional[Dict[str, str]] = None,
 ) -> ChainlitContext: