chainlit 2.0.0__py3-none-any.whl → 2.0.dev0__py3-none-any.whl

chainlit/__init__.py

@@ -14,9 +14,6 @@ if env_found:
 import asyncio
 from typing import TYPE_CHECKING, Any, Dict
 
-from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
-from pydantic.dataclasses import dataclass
-
 import chainlit.input_widget as input_widget
 from chainlit.action import Action
 from chainlit.cache import cache
@@ -25,8 +22,7 @@ from chainlit.chat_settings import ChatSettings
 from chainlit.context import context
 from chainlit.element import (
     Audio,
-    CustomElement,
-    Dataframe,
+    Component,
     File,
     Image,
     Pdf,
@@ -47,21 +43,22 @@ from chainlit.message import (
 )
 from chainlit.step import Step, step
 from chainlit.sync import make_async, run_sync
-from chainlit.types import ChatProfile, InputAudioChunk, OutputAudioChunk, Starter
+from chainlit.types import InputAudioChunk, OutputAudioChunk, ChatProfile, Starter
 from chainlit.user import PersistedUser, User
 from chainlit.user_session import user_session
 from chainlit.utils import make_module_getattr
 from chainlit.version import __version__
+from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
+from pydantic.dataclasses import dataclass
 
 from .callbacks import (
     action_callback,
     author_rename,
-    data_layer,
     header_auth_callback,
     oauth_callback,
+    on_audio_start,
     on_audio_chunk,
     on_audio_end,
-    on_audio_start,
     on_chat_end,
     on_chat_resume,
     on_chat_start,
@@ -69,9 +66,7 @@ from .callbacks import (
     on_message,
     on_settings_update,
     on_stop,
-    on_window_message,
     password_auth_callback,
-    send_window_message,
     set_chat_profiles,
     set_starters,
 )
@@ -117,73 +112,79 @@ __getattr__ = make_module_getattr(
 )
 
 __all__ = [
-    "Action",
-    "AskActionMessage",
-    "AskFileMessage",
-    "AskUserMessage",
-    "AsyncLangchainCallbackHandler",
-    "Audio",
-    "ChatGeneration",
+    "__version__",
     "ChatProfile",
-    "ChatSettings",
-    "CompletionGeneration",
+    "Starter",
+    "user_session",
+    "chat_context",
     "CopilotFunction",
-    "CustomElement",
-    "Dataframe",
-    "ErrorMessage",
-    "File",
-    "GenerationMessage",
-    "HaystackAgentCallbackHandler",
-    "Image",
     "InputAudioChunk",
-    "LangchainCallbackHandler",
-    "LlamaIndexCallbackHandler",
-    "Message",
     "OutputAudioChunk",
-    "Pdf",
+    "Action",
+    "User",
     "PersistedUser",
+    "Audio",
+    "Pdf",
     "Plotly",
+    "Image",
+    "Text",
+    "Component",
     "Pyplot",
-    "Starter",
-    "Step",
+    "File",
     "Task",
     "TaskList",
     "TaskStatus",
-    "Text",
-    "User",
     "Video",
-    "__version__",
+    "ChatSettings",
+    "input_widget",
+    "Message",
+    "ErrorMessage",
+    "AskUserMessage",
+    "AskActionMessage",
+    "AskFileMessage",
+    "Step",
+    "step",
+    "ChatGeneration",
+    "CompletionGeneration",
+    "GenerationMessage",
+    "on_logout",
+    "on_chat_start",
+    "on_chat_end",
+    "on_chat_resume",
+    "on_stop",
     "action_callback",
     "author_rename",
+    "on_settings_update",
+    "password_auth_callback",
+    "header_auth_callback",
+    "sleep",
+    "run_sync",
+    "make_async",
     "cache",
-    "chat_context",
     "context",
-    "data_layer",
-    "header_auth_callback",
-    "input_widget",
-    "instrument_mistralai",
+    "LangchainCallbackHandler",
+    "AsyncLangchainCallbackHandler",
+    "LlamaIndexCallbackHandler",
+    "HaystackAgentCallbackHandler",
     "instrument_openai",
-    "make_async",
+    "instrument_mistralai",
+    "password_auth_callback",
+    "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",
-    "run_sync",
-    "send_window_message",
+    "on_chat_start",
+    "on_chat_resume",
     "set_chat_profiles",
     "set_starters",
-    "sleep",
-    "step",
-    "user_session",
+    "on_chat_end",
+    "on_audio_start",
+    "on_audio_chunk",
+    "on_audio_end",
+    "author_rename",
+    "on_stop",
+    "action_callback",
+    "on_settings_update",
 ]
 
 

chainlit/action.py

@@ -1,30 +1,28 @@
 import uuid
-from typing import Dict, Optional
-
-from dataclasses_json import DataClassJsonMixin
-from pydantic import Field
-from pydantic.dataclasses import dataclass
+from typing import Optional
 
 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 parameters to call this action with.
-    payload: Dict
-    # The label of the action. This is what the user will see.
+    # 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.
     label: 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
+    # The description of the action. This is what the user will see when they hover the action.
+    description: str = ""
     # 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/__init__.py → auth.py}

@@ -1,16 +1,20 @@
 import os
+from datetime import datetime, timedelta
+from typing import Any, Dict
 
-from fastapi import Depends, HTTPException
-
+import jwt
 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
 
-reuseable_oauth = OAuth2PasswordBearerWithCookie(tokenUrl="/login", auto_error=False)
+def get_jwt_secret():
+    return os.environ.get("CHAINLIT_AUTH_SECRET")
 
 
 def ensure_jwt_secret():
@@ -41,36 +45,43 @@ def get_configuration():
         "oauthProviders": (
             get_configured_oauth_providers() if is_oauth_enabled() else []
         ),
-        "default_theme": config.ui.default_theme,
     }
 
 
+def create_jwt(data: User) -> str:
+    to_encode: Dict[str, Any] = data.to_dict()
+    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:
-        user = decode_jwt(token)
-    except Exception as e:
-        raise HTTPException(
-            status_code=401, detail="Invalid authentication token"
-        ) from e
-
+        dict = jwt.decode(
+            token,
+            get_jwt_secret(),
+            algorithms=["HS256"],
+            options={"verify_signature": True},
+        )
+        del dict["exp"]
+        user = User(**dict)
+    except Exception:
+        raise HTTPException(status_code=401, detail="Invalid authentication token")
     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 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)
+        except Exception:
             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
-
-    return user
+    else:
+        return user
 
 
 async def get_current_user(token: str = Depends(reuseable_oauth)):
@@ -78,6 +89,3 @@ 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"]

chainlit/cache.py

@@ -1,7 +1,5 @@
-import importlib.util
 import os
 import threading
-from typing import Any
 
 from chainlit.config import config
 from chainlit.logger import logger
@@ -10,7 +8,11 @@ from chainlit.logger import logger
 def init_lc_cache():
     use_cache = config.project.cache is True and config.run.no_cache is False
 
-    if use_cache and importlib.util.find_spec("langchain") is not None:
+    if use_cache:
+        try:
+            import langchain
+        except ImportError:
+            return
         from langchain.cache import SQLiteCache
         from langchain.globals import set_llm_cache
 
@@ -23,7 +25,7 @@ def init_lc_cache():
                 )
 
 
-_cache: dict[tuple, Any] = {}
+_cache = {}
 _cache_lock = threading.Lock()
 
 

chainlit/callbacks.py

@@ -1,13 +1,8 @@
 import inspect
 from typing import Any, Awaitable, Callable, Dict, List, Optional
 
-from fastapi import Request, Response
-from starlette.datastructures import Headers
-
 from chainlit.action import Action
 from chainlit.config import config
-from chainlit.context import context
-from chainlit.data.base import BaseDataLayer
 from chainlit.message import Message
 from chainlit.oauth_providers import get_configured_oauth_providers
 from chainlit.step import Step, step
@@ -15,11 +10,13 @@ from chainlit.telemetry import trace
 from chainlit.types import ChatProfile, Starter, ThreadDict
 from chainlit.user import User
 from chainlit.utils import wrap_user_function
+from fastapi import Request, Response
+from starlette.datastructures import Headers
 
 
 @trace
 def password_auth_callback(
-    func: Callable[[str, str], Awaitable[Optional[User]]],
+    func: Callable[[str, str], Awaitable[Optional[User]]]
 ) -> Callable:
     """
     Framework agnostic decorator to authenticate the user.
@@ -41,7 +38,7 @@ def password_auth_callback(
 
 @trace
 def header_auth_callback(
-    func: Callable[[Headers], Awaitable[Optional[User]]],
+    func: Callable[[Headers], Awaitable[Optional[User]]]
 ) -> Callable:
     """
     Framework agnostic decorator to authenticate the user via a header
@@ -126,33 +123,6 @@ def on_message(func: Callable) -> Callable:
     return func
 
 
-@trace
-async def send_window_message(data: Any):
-    """
-    Send custom data to the host window via a window.postMessage event.
-
-    Args:
-        data (Any): The data to send with the event.
-    """
-    await context.emitter.send_window_message(data)
-
-
-@trace
-def on_window_message(func: Callable[[str], Any]) -> Callable:
-    """
-    Hook to react to javascript postMessage events coming from the UI.
-
-    Args:
-        func (Callable[[str], Any]): The function to be called when a window message is received.
-                                     Takes the message content as a string parameter.
-
-    Returns:
-        Callable[[str], Any]: The decorated on_window_message function.
-    """
-    config.code.on_window_message = wrap_user_function(func)
-    return func
-
-
 @trace
 def on_chat_start(func: Callable) -> Callable:
     """
@@ -207,7 +177,7 @@ def set_chat_profiles(
 
 @trace
 def set_starters(
-    func: Callable[[Optional["User"]], Awaitable[List["Starter"]]],
+    func: Callable[[Optional["User"]], Awaitable[List["Starter"]]]
 ) -> Callable:
     """
     Programmatic declaration of the available starter (can depend on the User from the session if authentication is setup).
@@ -251,7 +221,6 @@ def on_audio_start(func: Callable) -> Callable:
     config.code.on_audio_start = wrap_user_function(func, with_task=False)
     return func
 
-
 @trace
 def on_audio_chunk(func: Callable) -> Callable:
     """
@@ -285,7 +254,7 @@ def on_audio_end(func: Callable) -> Callable:
 
 @trace
 def author_rename(
-    func: Callable[[str], Awaitable[str]],
+    func: Callable[[str], Awaitable[str]]
 ) -> Callable[[str], Awaitable[str]]:
     """
     Useful to rename the author of message to display more friendly author names in the UI.
@@ -325,7 +294,7 @@ def action_callback(name: str) -> Callable:
     """
 
     def decorator(func: Callable[[Action], Any]):
-        config.code.action_callbacks[name] = wrap_user_function(func, with_task=False)
+        config.code.action_callbacks[name] = wrap_user_function(func, with_task=True)
         return func
 
     return decorator
@@ -346,17 +315,3 @@ def on_settings_update(
 
     config.code.on_settings_update = wrap_user_function(func, with_task=True)
     return func
-
-
-def data_layer(
-    func: Callable[[], BaseDataLayer],
-) -> Callable[[], BaseDataLayer]:
-    """
-    Hook to configure custom data layer.
-    """
-
-    # We don't use wrap_user_function here because:
-    # 1. We don't need to support async here and;
-    # 2. We don't want to change the API for get_data_layer() to be async, everywhere (at this point).
-    config.code.data_layer = func
-    return func

chainlit/chat_context.py

@@ -25,10 +25,10 @@ class ChatContext:
 
         if context.session.id not in chat_contexts:
             chat_contexts[context.session.id] = []
-
+            
         if message not in chat_contexts[context.session.id]:
             chat_contexts[context.session.id].append(message)
-
+        
         return message
 
     def remove(self, message: "Message") -> bool:

chainlit/chat_settings.py

@@ -1,10 +1,8 @@
 from typing import List
 
-from pydantic import Field
-from pydantic.dataclasses import dataclass
-
 from chainlit.context import context
 from chainlit.input_widget import InputWidget
+from pydantic.dataclasses import Field, dataclass
 
 
 @dataclass

chainlit/cli/__init__.py

@@ -9,7 +9,6 @@ import uvicorn
 nest_asyncio.apply()
 
 # ruff: noqa: E402
-from chainlit.auth import ensure_jwt_secret
 from chainlit.cache import init_lc_cache
 from chainlit.config import (
     BACKEND_ROOT,
@@ -25,18 +24,7 @@ from chainlit.logger import logger
 from chainlit.markdown import init_markdown
 from chainlit.secret import random_secret
 from chainlit.telemetry import trace_event
-from chainlit.utils import check_file
-
-
-def assert_app():
-    if (
-        not config.code.on_chat_start
-        and not config.code.on_message
-        and not config.code.on_audio_chunk
-    ):
-        raise Exception(
-            "You need to configure at least one of on_chat_start, on_message or on_audio_chunk callback"
-        )
+from chainlit.utils import check_file, ensure_jwt_secret
 
 
 # Create the main command group for Chainlit CLI
@@ -78,7 +66,6 @@ def run_chainlit(target: str):
     load_module(config.run.module_name)
 
     ensure_jwt_secret()
-    assert_app()
 
     # Create the chainlit.md file if it doesn't exist
     init_markdown(config.root)
@@ -199,7 +186,7 @@ def chainlit_run(
         # This is required to have OpenAI LLM providers available for the CI run
         os.environ["OPENAI_API_KEY"] = "sk-FAKE-OPENAI-API-KEY"
         # This is required for authentication tests
-        os.environ["CHAINLIT_AUTH_SECRET"] = "SUPER_SECRET"  # nosec B105
+        os.environ["CHAINLIT_AUTH_SECRET"] = "SUPER_SECRET"
     else:
         trace_event("chainlit run")