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

chainlit/__init__.py

@@ -2,33 +2,31 @@ import os
 
 from dotenv import load_dotenv
 
+# ruff: noqa: E402
+# Keep this here to ensure imports have environment available.
 env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
 
+from chainlit.logger import logger
+
+if env_found:
+    logger.info("Loaded .env file")
+
 import asyncio
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict
 
-from fastapi import Request, Response
+from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
 from pydantic.dataclasses import dataclass
-from starlette.datastructures import Headers
-
-if TYPE_CHECKING:
-    from chainlit.haystack.callbacks import HaystackAgentCallbackHandler
-    from chainlit.langchain.callbacks import (
-        LangchainCallbackHandler,
-        AsyncLangchainCallbackHandler,
-    )
-    from chainlit.llama_index.callbacks import LlamaIndexCallbackHandler
-    from chainlit.openai import instrument_openai
 
 import chainlit.input_widget as input_widget
 from chainlit.action import Action
 from chainlit.cache import cache
+from chainlit.chat_context import chat_context
 from chainlit.chat_settings import ChatSettings
-from chainlit.config import config
 from chainlit.context import context
 from chainlit.element import (
     Audio,
-    Avatar,
+    CustomElement,
+    Dataframe,
     File,
     Image,
     Pdf,
@@ -40,7 +38,6 @@ from chainlit.element import (
     Text,
     Video,
 )
-from chainlit.logger import logger
 from chainlit.message import (
     AskActionMessage,
     AskFileMessage,
@@ -48,243 +45,46 @@ from chainlit.message import (
     ErrorMessage,
     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, ThreadDict
+from chainlit.types import ChatProfile, InputAudioChunk, OutputAudioChunk, Starter
 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.utils import make_module_getattr
 from chainlit.version import __version__
-from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
-
-if env_found:
-    logger.info("Loaded .env file")
-
-
-@trace
-def password_auth_callback(func: Callable[[str, str], Optional[User]]) -> Callable:
-    """
-    Framework agnostic decorator to authenticate the user.
-
-    Args:
-        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[User]:
-
-    Returns:
-        Callable[[str, str], Optional[User]]: The decorated authentication callback.
-    """
-
-    config.code.password_auth_callback = wrap_user_function(func)
-    return func
-
-
-@trace
-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[User]]): The authentication callback to execute.
-
-    Example:
-        @cl.header_auth_callback
-        async def header_auth_callback(headers: Headers) -> Optional[User]:
-
-    Returns:
-        Callable[[Headers], Optional[User]]: The decorated authentication callback.
-    """
-
-    config.code.header_auth_callback = wrap_user_function(func)
-    return func
-
-
-@trace
-def oauth_callback(
-    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], 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: User) -> Optional[User]:
-
-    Returns:
-        Callable[[str, str, Dict[str, str], User], Optional[User]]: The decorated authentication callback.
-    """
-
-    if len(get_configured_oauth_providers()) == 0:
-        raise ValueError(
-            "You must set the environment variable for at least one oauth provider to use oauth authentication."
-        )
-
-    config.code.oauth_callback = wrap_user_function(func)
-    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:
-    """
-    Framework agnostic decorator to react to messages coming from the UI.
-    The decorated function is called every time a new message is received.
-
-    Args:
-        func (Callable[[Message], Any]): The function to be called when a new message is received. Takes a cl.Message.
-
-    Returns:
-        Callable[[str], Any]: The decorated on_message function.
-    """
-
-    config.code.on_message = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_chat_start(func: Callable) -> Callable:
-    """
-    Hook to react to the user websocket connection event.
-
-    Args:
-        func (Callable[], Any]): The connection hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_start = wrap_user_function(func, with_task=True)
-    return func
-
-
-@trace
-def on_chat_resume(func: Callable[[ThreadDict], Any]) -> Callable:
-    """
-    Hook to react to resume websocket connection event.
-
-    Args:
-        func (Callable[], Any]): The connection hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_resume = wrap_user_function(func, with_task=True)
-    return func
-
-
-@trace
-def set_chat_profiles(
-    func: Callable[[Optional["User"]], List["ChatProfile"]]
-) -> Callable:
-    """
-    Programmatic declaration of the available chat profiles (can depend on the User from the session if authentication is setup).
-
-    Args:
-        func (Callable[[Optional["User"]], List["ChatProfile"]]): The function declaring the chat profiles.
-
-    Returns:
-        Callable[[Optional["User"]], List["ChatProfile"]]: The decorated function.
-    """
-
-    config.code.set_chat_profiles = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_chat_end(func: Callable) -> Callable:
-    """
-    Hook to react to the user websocket disconnect event.
-
-    Args:
-        func (Callable[], Any]): The disconnect hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_end = wrap_user_function(func, with_task=True)
-    return func
-
-
-@trace
-def author_rename(func: Callable[[str], str]) -> Callable[[str], str]:
-    """
-    Useful to rename the author of message to display more friendly author names in the UI.
-    Args:
-        func (Callable[[str], str]): The function to be called to rename an author. Takes the original author name as parameter.
-
-    Returns:
-        Callable[[Any, str], Any]: The decorated function.
-    """
 
-    config.code.author_rename = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_stop(func: Callable) -> Callable:
-    """
-    Hook to react to the user stopping a thread.
-
-    Args:
-        func (Callable[[], Any]): The stop hook to execute.
-
-    Returns:
-        Callable[[], Any]: The decorated stop hook.
-    """
-
-    config.code.on_stop = wrap_user_function(func)
-    return func
-
-
-def action_callback(name: str) -> Callable:
-    """
-    Callback to call when an action is clicked in the UI.
-
-    Args:
-        func (Callable[[Action], Any]): The action callback to execute. First parameter is the action.
-    """
-
-    def decorator(func: Callable[[Action], Any]):
-        config.code.action_callbacks[name] = wrap_user_function(func, with_task=True)
-        return func
-
-    return decorator
-
-
-def on_settings_update(
-    func: Callable[[Dict[str, Any]], Any]
-) -> Callable[[Dict[str, Any]], Any]:
-    """
-    Hook to react to the user changing any settings.
-
-    Args:
-        func (Callable[], Any]): The hook to execute after settings were changed.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
+from .callbacks import (
+    action_callback,
+    author_rename,
+    data_layer,
+    header_auth_callback,
+    oauth_callback,
+    on_audio_chunk,
+    on_audio_end,
+    on_audio_start,
+    on_chat_end,
+    on_chat_resume,
+    on_chat_start,
+    on_logout,
+    on_message,
+    on_settings_update,
+    on_stop,
+    on_window_message,
+    password_auth_callback,
+    send_window_message,
+    set_chat_profiles,
+    set_starters,
+)
 
-    config.code.on_settings_update = wrap_user_function(func, with_task=True)
-    return func
+if TYPE_CHECKING:
+    from chainlit.haystack.callbacks import HaystackAgentCallbackHandler
+    from chainlit.langchain.callbacks import (
+        AsyncLangchainCallbackHandler,
+        LangchainCallbackHandler,
+    )
+    from chainlit.llama_index.callbacks import LlamaIndexCallbackHandler
+    from chainlit.mistralai import instrument_mistralai
+    from chainlit.openai import instrument_openai
 
 
 def sleep(duration: int):
@@ -312,59 +112,78 @@ __getattr__ = make_module_getattr(
         "LlamaIndexCallbackHandler": "chainlit.llama_index.callbacks",
         "HaystackAgentCallbackHandler": "chainlit.haystack.callbacks",
         "instrument_openai": "chainlit.openai",
+        "instrument_mistralai": "chainlit.mistralai",
     }
 )
 
 __all__ = [
-    "user_session",
-    "CopilotFunction",
     "Action",
-    "User",
-    "PersistedUser",
+    "AskActionMessage",
+    "AskFileMessage",
+    "AskUserMessage",
+    "AsyncLangchainCallbackHandler",
     "Audio",
+    "ChatGeneration",
+    "ChatProfile",
+    "ChatSettings",
+    "CompletionGeneration",
+    "CopilotFunction",
+    "CustomElement",
+    "Dataframe",
+    "ErrorMessage",
+    "File",
+    "GenerationMessage",
+    "HaystackAgentCallbackHandler",
+    "Image",
+    "InputAudioChunk",
+    "LangchainCallbackHandler",
+    "LlamaIndexCallbackHandler",
+    "Message",
+    "OutputAudioChunk",
     "Pdf",
+    "PersistedUser",
     "Plotly",
-    "Image",
-    "Text",
-    "Avatar",
     "Pyplot",
-    "File",
+    "Starter",
+    "Step",
     "Task",
     "TaskList",
     "TaskStatus",
+    "Text",
+    "User",
     "Video",
-    "ChatSettings",
+    "__version__",
+    "action_callback",
+    "author_rename",
+    "cache",
+    "chat_context",
+    "context",
+    "data_layer",
+    "header_auth_callback",
     "input_widget",
-    "Message",
-    "ErrorMessage",
-    "AskUserMessage",
-    "AskActionMessage",
-    "AskFileMessage",
-    "Step",
-    "step",
-    "ChatGeneration",
-    "CompletionGeneration",
-    "GenerationMessage",
-    "on_logout",
-    "on_chat_start",
+    "instrument_mistralai",
+    "instrument_openai",
+    "make_async",
+    "oauth_callback",
+    "on_audio_chunk",
+    "on_audio_end",
+    "on_audio_start",
     "on_chat_end",
     "on_chat_resume",
-    "on_stop",
-    "action_callback",
-    "author_rename",
+    "on_chat_start",
+    "on_logout",
+    "on_message",
     "on_settings_update",
+    "on_stop",
+    "on_window_message",
     "password_auth_callback",
-    "header_auth_callback",
-    "sleep",
     "run_sync",
-    "make_async",
-    "cache",
-    "context",
-    "LangchainCallbackHandler",
-    "AsyncLangchainCallbackHandler",
-    "LlamaIndexCallbackHandler",
-    "HaystackAgentCallbackHandler",
-    "instrument_openai",
+    "send_window_message",
+    "set_chat_profiles",
+    "set_starters",
+    "sleep",
+    "step",
+    "user_session",
 ]
 
 

chainlit/_utils.py

@@ -0,0 +1,8 @@
+"""Util functions which are explicitly not part of the public API."""
+
+from pathlib import Path
+
+
+def is_path_inside(child_path: Path, parent_path: Path) -> bool:
+    """Check if the child path is inside the parent path."""
+    return parent_path.resolve() in child_path.resolve().parents

chainlit/action.py

@@ -1,28 +1,30 @@
 import uuid
-from typing import Optional
+from typing import Dict, Optional
+
+from dataclasses_json import DataClassJsonMixin
+from pydantic import Field
+from pydantic.dataclasses import dataclass
 
 from chainlit.context import context
 from chainlit.telemetry import trace_event
-from dataclasses_json import DataClassJsonMixin
-from pydantic.dataclasses import Field, dataclass
 
 
 @dataclass
 class Action(DataClassJsonMixin):
     # Name of the action, this should be used in the action_callback
     name: str
-    # The value associated with the action. This is useful to differentiate between multiple actions with the same name.
-    value: str
-    # The label of the action. This is what the user will see. If not provided the name will be used.
+    # The parameters to call this action with.
+    payload: Dict
+    # The label of the action. This is what the user will see.
     label: str = ""
-    # The description of the action. This is what the user will see when they hover the action.
-    description: str = ""
+    # The tooltip of the action button. This is what the user will see when they hover the action.
+    tooltip: str = ""
+    # The lucid icon name for this action.
+    icon: Optional[str] = None
     # This should not be set manually, only used internally.
     forId: Optional[str] = None
     # The ID of the action
     id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    # Show the action in a drawer menu
-    collapsed: bool = False
 
     def __post_init__(self) -> None:
         trace_event(f"init {self.__class__.__name__}")

chainlit/{auth.py → auth/__init__.py}

@@ -1,20 +1,16 @@
 import os
-from datetime import datetime, timedelta
-from typing import Any, Dict
 
-import jwt
+from fastapi import Depends, HTTPException
+
 from chainlit.config import config
 from chainlit.data import get_data_layer
+from chainlit.logger import logger
 from chainlit.oauth_providers import get_configured_oauth_providers
-from chainlit.user import User
-from fastapi import Depends, HTTPException
-from fastapi.security import OAuth2PasswordBearer
-
-reuseable_oauth = OAuth2PasswordBearer(tokenUrl="/login", auto_error=False)
 
+from .cookie import OAuth2PasswordBearerWithCookie
+from .jwt import create_jwt, decode_jwt, get_jwt_secret
 
-def get_jwt_secret():
-    return os.environ.get("CHAINLIT_AUTH_SECRET")
+reuseable_oauth = OAuth2PasswordBearerWithCookie(tokenUrl="/login", auto_error=False)
 
 
 def ensure_jwt_secret():
@@ -42,46 +38,39 @@ def get_configuration():
         "requireLogin": require_login(),
         "passwordAuth": config.code.password_auth_callback is not None,
         "headerAuth": config.code.header_auth_callback is not None,
-        "oauthProviders": get_configured_oauth_providers()
-        if is_oauth_enabled()
-        else [],
+        "oauthProviders": (
+            get_configured_oauth_providers() if is_oauth_enabled() else []
+        ),
+        "default_theme": config.ui.default_theme,
     }
 
 
-def create_jwt(data: User) -> str:
-    to_encode = data.to_dict()  # type: Dict[str, Any]
-    to_encode.update(
-        {
-            "exp": datetime.utcnow() + timedelta(minutes=60 * 24 * 15),  # 15 days
-        }
-    )
-    encoded_jwt = jwt.encode(to_encode, get_jwt_secret(), algorithm="HS256")
-    return encoded_jwt
-
-
 async def authenticate_user(token: str = Depends(reuseable_oauth)):
     try:
-        dict = jwt.decode(
-            token,
-            get_jwt_secret(),
-            algorithms=["HS256"],
-            options={"verify_signature": True},
-        )
-        del dict["exp"]
-        user = User(**dict)
+        user = decode_jwt(token)
     except Exception as e:
-        raise HTTPException(status_code=401, detail="Invalid authentication token")
+        raise HTTPException(
+            status_code=401, detail="Invalid authentication token"
+        ) from e
+
     if data_layer := get_data_layer():
+        # Get or create persistent user if we've a data layer available.
         try:
             persisted_user = await data_layer.get_user(user.identifier)
-            if persisted_user == None:
+            if persisted_user is None:
                 persisted_user = await data_layer.create_user(user)
+                assert persisted_user
         except Exception as e:
+            logger.exception("Unable to get persisted_user from data layer: %s", e)
             return user
 
+        if user and user.display_name:
+            # Copy ephemeral display_name from authenticated user to persistent user.
+            persisted_user.display_name = user.display_name
+
         return persisted_user
-    else:
-        return user
+
+    return user
 
 
 async def get_current_user(token: str = Depends(reuseable_oauth)):
@@ -89,3 +78,6 @@ async def get_current_user(token: str = Depends(reuseable_oauth)):
         return None
 
     return await authenticate_user(token)
+
+
+__all__ = ["create_jwt", "get_configuration", "get_current_user"]