chainlit 1.0.400__py3-none-any.whl → 2.0.3__py3-none-any.whl

chainlit/cli/__init__.py

@@ -5,24 +5,38 @@ import click
 import nest_asyncio
 import uvicorn
 
+# Not sure if it is necessary to call nest_asyncio.apply() before the other imports
 nest_asyncio.apply()
 
+# ruff: noqa: E402
 from chainlit.auth import ensure_jwt_secret
 from chainlit.cache import init_lc_cache
-from chainlit.cli.utils import check_file
 from chainlit.config import (
     BACKEND_ROOT,
     DEFAULT_HOST,
     DEFAULT_PORT,
+    DEFAULT_ROOT_PATH,
     config,
     init_config,
+    lint_translations,
     load_module,
 )
 from chainlit.logger import logger
 from chainlit.markdown import init_markdown
 from chainlit.secret import random_secret
-from chainlit.server import app, register_wildcard_route_handler
 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"
+        )
 
 
 # Create the main command group for Chainlit CLI
@@ -34,8 +48,14 @@ def cli():
 
 # Define the function to run Chainlit with provided options
 def run_chainlit(target: str):
+    from chainlit.server import app
+
     host = os.environ.get("CHAINLIT_HOST", DEFAULT_HOST)
     port = int(os.environ.get("CHAINLIT_PORT", DEFAULT_PORT))
+    root_path = os.environ.get("CHAINLIT_ROOT_PATH", DEFAULT_ROOT_PATH)
+
+    ssl_certfile = os.environ.get("CHAINLIT_SSL_CERT", None)
+    ssl_keyfile = os.environ.get("CHAINLIT_SSL_KEY", None)
 
     ws_per_message_deflate_env = os.environ.get(
         "UVICORN_WS_PER_MESSAGE_DEFLATE", "true"
@@ -46,8 +66,11 @@ def run_chainlit(target: str):
         "yes",
     ]  # Convert to boolean
 
+    ws_protocol = os.environ.get("UVICORN_WS_PROTOCOL", "auto")
+
     config.run.host = host
     config.run.port = port
+    config.run.root_path = root_path
 
     check_file(target)
     # Load the module provided by the user
@@ -55,8 +78,7 @@ def run_chainlit(target: str):
     load_module(config.run.module_name)
 
     ensure_jwt_secret()
-
-    register_wildcard_route_handler()
+    assert_app()
 
     # Create the chainlit.md file if it doesn't exist
     init_markdown(config.root)
@@ -72,8 +94,11 @@ def run_chainlit(target: str):
             app,
             host=host,
             port=port,
+            ws=ws_protocol,
             log_level=log_level,
             ws_per_message_deflate=ws_per_message_deflate,
+            ssl_keyfile=ssl_keyfile,
+            ssl_certfile=ssl_certfile,
         )
         server = uvicorn.Server(config)
         await server.serve()
@@ -125,13 +150,47 @@ def run_chainlit(target: str):
     envvar="NO_CACHE",
     help="Useful to disable third parties cache, such as langchain.",
 )
+@click.option(
+    "--ssl-cert",
+    default=None,
+    envvar="CHAINLIT_SSL_CERT",
+    help="Specify the file path for the SSL certificate.",
+)
+@click.option(
+    "--ssl-key",
+    default=None,
+    envvar="CHAINLIT_SSL_KEY",
+    help="Specify the file path for the SSL key",
+)
 @click.option("--host", help="Specify a different host to run the server on")
 @click.option("--port", help="Specify a different port to run the server on")
-def chainlit_run(target, watch, headless, debug, ci, no_cache, host, port):
+@click.option("--root-path", help="Specify a different root path to run the server on")
+def chainlit_run(
+    target,
+    watch,
+    headless,
+    debug,
+    ci,
+    no_cache,
+    ssl_cert,
+    ssl_key,
+    host,
+    port,
+    root_path,
+):
     if host:
         os.environ["CHAINLIT_HOST"] = host
     if port:
         os.environ["CHAINLIT_PORT"] = port
+    if bool(ssl_cert) != bool(ssl_key):
+        raise click.UsageError(
+            "Both --ssl-cert and --ssl-key must be provided together."
+        )
+    if ssl_cert:
+        os.environ["CHAINLIT_SSL_CERT"] = ssl_cert
+        os.environ["CHAINLIT_SSL_KEY"] = ssl_key
+    if root_path:
+        os.environ["CHAINLIT_ROOT_PATH"] = root_path
     if ci:
         logger.info("Running in CI mode")
 
@@ -139,8 +198,8 @@ def chainlit_run(target, watch, headless, debug, ci, no_cache, host, port):
         no_cache = True
         # 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 authenticationt tests
-        os.environ["CHAINLIT_AUTH_SECRET"] = "SUPER_SECRET"
+        # This is required for authentication tests
+        os.environ["CHAINLIT_AUTH_SECRET"] = "SUPER_SECRET"  # nosec B105
     else:
         trace_event("chainlit run")
 
@@ -149,6 +208,8 @@ def chainlit_run(target, watch, headless, debug, ci, no_cache, host, port):
     config.run.no_cache = no_cache
     config.run.ci = ci
     config.run.watch = watch
+    config.run.ssl_cert = ssl_cert
+    config.run.ssl_key = ssl_key
 
     run_chainlit(target)
 
@@ -174,5 +235,13 @@ def chainlit_create_secret(args=None, **kwargs):
     trace_event("chainlit secret")
 
     print(
-        f"Copy the following secret into your .env file. Once it is set, changing it will logout all users with active sessions.\nCHAINLIT_AUTH_SECRET={random_secret()}"
+        f'Copy the following secret into your .env file. Once it is set, changing it will logout all users with active sessions.\nCHAINLIT_AUTH_SECRET="{random_secret()}"'
     )
+
+
+@cli.command("lint-translations")
+@click.argument("args", nargs=-1)
+def chainlit_lint_translations(args=None, **kwargs):
+    trace_event("chainlit lint-translation")
+
+    lint_translations()

chainlit/config.py

@@ -1,23 +1,46 @@
 import json
 import os
+import site
 import sys
 from importlib import util
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+)
 
 import tomli
-from chainlit.logger import logger
-from chainlit.version import __version__
 from dataclasses_json import DataClassJsonMixin
-from pydantic.dataclasses import Field, dataclass
+from pydantic import Field
+from pydantic.dataclasses import dataclass
 from starlette.datastructures import Headers
 
+from chainlit.data.base import BaseDataLayer
+from chainlit.logger import logger
+from chainlit.translations import lint_translation_json
+from chainlit.version import __version__
+
+from ._utils import is_path_inside
+
 if TYPE_CHECKING:
-    from chainlit.action import Action
-    from chainlit.types import ChatProfile, ThreadDict
-    from chainlit.user import User
     from fastapi import Request, Response
 
+    from chainlit.action import Action
+    from chainlit.message import Message
+    from chainlit.types import ChatProfile, InputAudioChunk, Starter, ThreadDict
+    from chainlit.user import User
+else:
+    # Pydantic needs to resolve forward annotations. Because all of these are used
+    # within `typing.Callable`, alias to `Any` as Pydantic does not perform validation
+    # of callable argument/return types anyway.
+    Request = Response = Action = Message = ChatProfile = InputAudioChunk = Starter = ThreadDict = User = Any  # fmt: off
 
 BACKEND_ROOT = os.path.dirname(__file__)
 PACKAGE_ROOT = os.path.dirname(os.path.dirname(BACKEND_ROOT))
@@ -25,13 +48,14 @@ TRANSLATIONS_DIR = os.path.join(BACKEND_ROOT, "translations")
 
 
 # Get the directory the script is running from
-APP_ROOT = os.getcwd()
+APP_ROOT = os.getenv("CHAINLIT_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")
+public_dir = os.path.join(APP_ROOT, "public")
 config_file = os.path.join(config_dir, "config.toml")
 config_translation_dir = os.path.join(config_dir, "translations")
 
@@ -47,52 +71,52 @@ user_env = []
 # Duration (in seconds) during which the session is saved when the connection is lost
 session_timeout = 3600
 
+# Duration (in seconds) of the user session expiry
+user_session_timeout = 1296000  # 15 days
+
 # Enable third parties caching (e.g LangChain cache)
 cache = false
 
-# Authorized origins 
+# Authorized origins
 allow_origins = ["*"]
 
-# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
-# follow_symlink = false
-
 [features]
-# Show the prompt playground
-prompt_playground = true
-
 # Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
 unsafe_allow_html = false
 
 # Process and display mathematical expressions. This can clash with "$" characters in messages.
 latex = false
 
-# Authorize users to upload files with messages
-multi_modal = true
+# Automatically tag threads with the current chat profile (if a chat profile is used)
+auto_tag_thread = true
 
-# Allows user to use speech to text
-[features.speech_to_text]
-    enabled = false
-    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
-    # language = "en-US"
+# Allow users to edit their own messages
+edit_message = true
 
-[UI]
-# Name of the app and chatbot.
-name = "Chatbot"
+# Authorize users to spontaneously upload files with messages
+[features.spontaneous_file_upload]
+    enabled = true
+    accept = ["*/*"]
+    max_files = 20
+    max_size_mb = 500
 
-# Show the readme while the thread is empty.
-show_readme_as_default = true
+[features.audio]
+    # Sample rate of the audio
+    sample_rate = 24000
 
-# Description of the app and chatbot. This is used for HTML tags.
-# description = ""
+[UI]
+# Name of the assistant.
+name = "Assistant"
 
-# Large size content are by default collapsed for a cleaner ui
-default_collapse_content = true
+# default_theme = "dark"
 
-# The default value for the expand messages settings.
-default_expand_messages = false
+# layout = "wide"
 
-# Hide the chain of thought details from the user in the UI.
-hide_cot = false
+# Description of the assistant. This is used for HTML tags.
+# description = ""
+
+# Chain of Thought (CoT) display mode. Can be "hidden", "tool_call" or "full".
+cot = "full"
 
 # Link to your github repo. This will add a github button in the UI's header.
 # github = ""
@@ -105,39 +129,22 @@ hide_cot = false
 # The Javascript file can be served from the public directory.
 # custom_js = "/public/test.js"
 
-# Specify a custom font url.
-# custom_font = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap"
-
-# Override default MUI light theme. (Check theme.ts)
-[UI.theme]
-    #font_family = "Inter, sans-serif"
-[UI.theme.light]
-    #background = "#FAFAFA"
-    #paper = "#FFFFFF"
-
-    [UI.theme.light.primary]
-        #main = "#F80061"
-        #dark = "#980039"
-        #light = "#FFE7EB"
-
-# Override default MUI dark theme. (Check theme.ts)
-[UI.theme.dark]
-    #background = "#FAFAFA"
-    #paper = "#FFFFFF"
-
-    [UI.theme.dark.primary]
-        #main = "#F80061"
-        #dark = "#980039"
-        #light = "#FFE7EB"
+# Specify a custom meta image url.
+# custom_meta_image_url = "https://chainlit-cloud.s3.eu-west-3.amazonaws.com/logo/chainlit_banner.png"
 
+# Specify a custom build directory for the frontend.
+# This can be used to customize the frontend code.
+# Be careful: If this is a relative path, it should not start with a slash.
+# custom_build = "./public/build"
 
 [meta]
 generated_by = "{__version__}"
 """
 
 
-DEFAULT_HOST = "0.0.0.0"
+DEFAULT_HOST = "127.0.0.1"
 DEFAULT_PORT = 8000
+DEFAULT_ROOT_PATH = ""
 
 
 @dataclass()
@@ -146,6 +153,9 @@ class RunSettings:
     module_name: Optional[str] = None
     host: str = DEFAULT_HOST
     port: int = DEFAULT_PORT
+    ssl_cert: Optional[str] = None
+    ssl_key: Optional[str] = None
+    root_path: str = DEFAULT_ROOT_PATH
     headless: bool = False
     watch: bool = False
     no_cache: bool = False
@@ -160,50 +170,60 @@ class PaletteOptions(DataClassJsonMixin):
     dark: Optional[str] = ""
 
 
+@dataclass()
+class TextOptions(DataClassJsonMixin):
+    primary: Optional[str] = ""
+    secondary: Optional[str] = ""
+
+
 @dataclass()
 class Palette(DataClassJsonMixin):
     primary: Optional[PaletteOptions] = None
     background: Optional[str] = ""
     paper: Optional[str] = ""
+    text: Optional[TextOptions] = None
 
 
-@dataclass()
-class Theme(DataClassJsonMixin):
-    font_family: Optional[str] = None
-    light: Optional[Palette] = None
-    dark: Optional[Palette] = None
+@dataclass
+class SpontaneousFileUploadFeature(DataClassJsonMixin):
+    enabled: Optional[bool] = None
+    accept: Optional[Union[List[str], Dict[str, List[str]]]] = None
+    max_files: Optional[int] = None
+    max_size_mb: Optional[int] = None
 
 
 @dataclass
-class SpeechToTextFeature:
-    enabled: Optional[bool] = None
-    language: Optional[str] = None
+class AudioFeature(DataClassJsonMixin):
+    sample_rate: int = 24000
+    enabled: bool = False
 
 
 @dataclass()
 class FeaturesSettings(DataClassJsonMixin):
-    prompt_playground: bool = True
-    multi_modal: bool = True
+    spontaneous_file_upload: Optional[SpontaneousFileUploadFeature] = None
+    audio: Optional[AudioFeature] = Field(default_factory=AudioFeature)
     latex: bool = False
     unsafe_allow_html: bool = False
-    speech_to_text: Optional[SpeechToTextFeature] = None
+    auto_tag_thread: bool = True
+    edit_message: bool = True
 
 
 @dataclass()
 class UISettings(DataClassJsonMixin):
     name: str
-    show_readme_as_default: bool = True
     description: str = ""
-    hide_cot: bool = False
-    # Large size content are by default collapsed for a cleaner ui
-    default_collapse_content: bool = True
-    default_expand_messages: bool = False
+    cot: Literal["hidden", "tool_call", "full"] = "full"
+    font_family: Optional[str] = None
+    default_theme: Optional[Literal["light", "dark"]] = "dark"
+    layout: Optional[Literal["default", "wide"]] = "default"
     github: Optional[str] = None
-    theme: Optional[Theme] = None
     # Optional custom CSS file that allows you to customize the UI
     custom_css: Optional[str] = None
     custom_js: Optional[str] = None
-    custom_font: Optional[str] = None
+    # Optional custom meta tag for image preview
+    custom_meta_image_url: Optional[str] = None
+    # Optional custom build directory for the frontend
+    custom_build: Optional[str] = None
 
 
 @dataclass()
@@ -213,27 +233,42 @@ 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["User"]]] = None
-    header_auth_callback: Optional[Callable[[Headers], Optional["User"]]] = None
+    password_auth_callback: Optional[
+        Callable[[str, str], Awaitable[Optional["User"]]]
+    ] = None
+    header_auth_callback: Optional[Callable[[Headers], Awaitable[Optional["User"]]]] = (
+        None
+    )
     oauth_callback: Optional[
-        Callable[[str, str, Dict[str, str], "User"], Optional["User"]]
+        Callable[[str, str, Dict[str, str], "User"], Awaitable[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
     on_chat_resume: Optional[Callable[["ThreadDict"], Any]] = None
-    on_message: Optional[Callable[[str], Any]] = None
-    author_rename: Optional[Callable[[str], str]] = None
+    on_message: Optional[Callable[["Message"], Any]] = None
+    on_window_message: Optional[Callable[[str], Any]] = None
+    on_audio_start: Optional[Callable[[], Any]] = None
+    on_audio_chunk: Optional[Callable[["InputAudioChunk"], Any]] = None
+    on_audio_end: Optional[Callable[[], Any]] = None
+
+    author_rename: Optional[Callable[[str], Awaitable[str]]] = None
     on_settings_update: Optional[Callable[[Dict[str, Any]], Any]] = None
-    set_chat_profiles: Optional[Callable[[Optional["User"]], List["ChatProfile"]]] = (
+    set_chat_profiles: Optional[
+        Callable[[Optional["User"]], Awaitable[List["ChatProfile"]]]
+    ] = None
+    set_starters: Optional[Callable[[Optional["User"]], Awaitable[List["Starter"]]]] = (
         None
     )
+    data_layer: Optional[Callable[[], BaseDataLayer]] = None
 
 
 @dataclass()
 class ProjectSettings(DataClassJsonMixin):
     allow_origins: List[str] = Field(default_factory=lambda: ["*"])
+    # Socket.io client transports option
+    transports: Optional[List[str]] = None
     enable_telemetry: bool = True
     # List of environment variables to be provided by each user to use the app. If empty, no environment variables will be asked to the user.
     user_env: Optional[List[str]] = None
@@ -242,10 +277,10 @@ class ProjectSettings(DataClassJsonMixin):
     # Path to the local chat db
     # Duration (in seconds) during which the session is saved when the connection is lost
     session_timeout: int = 3600
+    # Duration (in seconds) of the user session expiry
+    user_session_timeout: int = 1296000  # 15 days
     # Enable third parties caching (e.g LangChain cache)
     cache: bool = False
-    # Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
-    follow_symlink: bool = False
 
 
 @dataclass()
@@ -263,23 +298,44 @@ class ChainlitConfig:
     def load_translation(self, language: str):
         translation = {}
         default_language = "en-US"
+        # fallback to root language (ex: `de` when `de-DE` is not found)
+        parent_language = language.split("-")[0]
 
-        translation_lib_file_path = os.path.join(
-            config_translation_dir, f"{language}.json"
-        )
-        default_translation_lib_file_path = os.path.join(
-            config_translation_dir, f"{default_language}.json"
-        )
+        translation_dir = Path(config_translation_dir)
 
-        if os.path.exists(translation_lib_file_path):
-            with open(translation_lib_file_path, "r", encoding="utf-8") as f:
-                translation = json.load(f)
-        elif os.path.exists(default_translation_lib_file_path):
+        translation_lib_file_path = translation_dir / f"{language}.json"
+        translation_lib_parent_language_file_path = (
+            translation_dir / f"{parent_language}.json"
+        )
+        default_translation_lib_file_path = translation_dir / f"{default_language}.json"
+
+        if (
+            is_path_inside(translation_lib_file_path, translation_dir)
+            and translation_lib_file_path.is_file()
+        ):
+            translation = json.loads(
+                translation_lib_file_path.read_text(encoding="utf-8")
+            )
+        elif (
+            is_path_inside(translation_lib_parent_language_file_path, translation_dir)
+            and translation_lib_parent_language_file_path.is_file()
+        ):
+            logger.warning(
+                f"Translation file for {language} not found. Using parent translation {parent_language}."
+            )
+            translation = json.loads(
+                translation_lib_parent_language_file_path.read_text(encoding="utf-8")
+            )
+        elif (
+            is_path_inside(default_translation_lib_file_path, translation_dir)
+            and default_translation_lib_file_path.is_file()
+        ):
             logger.warning(
                 f"Translation file for {language} not found. Using default translation {default_language}."
             )
-            with open(default_translation_lib_file_path, "r", encoding="utf-8") as f:
-                translation = json.load(f)
+            translation = json.loads(
+                default_translation_lib_file_path.read_text(encoding="utf-8")
+            )
 
         return translation
 
@@ -305,7 +361,7 @@ def init_config(log=False):
             dst = os.path.join(config_translation_dir, file)
             if not os.path.exists(dst):
                 src = os.path.join(TRANSLATIONS_DIR, file)
-                with open(src, "r", encoding="utf-8") as f:
+                with open(src, encoding="utf-8") as f:
                     translation = json.load(f)
                     with open(dst, "w", encoding="utf-8") as f:
                         json.dump(translation, f, indent=4)
@@ -322,12 +378,16 @@ def load_module(target: str, force_refresh: bool = False):
     sys.path.insert(0, target_dir)
 
     if force_refresh:
+        # Get current site packages dirs
+        site_package_dirs = site.getsitepackages()
+
         # Clear the modules related to the app from sys.modules
         for module_name, module in list(sys.modules.items()):
             if (
                 hasattr(module, "__file__")
                 and module.__file__
                 and module.__file__.startswith(target_dir)
+                and not any(module.__file__.startswith(p) for p in site_package_dirs)
             ):
                 sys.modules.pop(module_name, None)
 
@@ -358,7 +418,7 @@ def load_settings():
 
         if not meta or meta.get("generated_by") <= "0.3.0":
             raise ValueError(
-                "Your config file is outdated. Please delete it and restart the app to regenerate it."
+                f"Your config file '{config_file}' is outdated. Please delete it and restart the app to regenerate it."
             )
 
         lc_cache_path = os.path.join(config_dir, ".langchain.db")
@@ -372,11 +432,13 @@ def load_settings():
 
         ui_settings = UISettings(**ui_settings)
 
+        code_settings = CodeSettings(action_callbacks={})
+
         return {
             "features": features_settings,
             "ui": ui_settings,
             "project": project_settings,
-            "code": CodeSettings(action_callbacks={}),
+            "code": code_settings,
         }
 
 
@@ -411,4 +473,22 @@ def load_config():
     return config
 
 
+def lint_translations():
+    # Load the ground truth (en-US.json file from chainlit source code)
+    src = os.path.join(TRANSLATIONS_DIR, "en-US.json")
+    with open(src, encoding="utf-8") as f:
+        truth = json.load(f)
+
+        # Find the local app translations
+        for file in os.listdir(config_translation_dir):
+            if file.endswith(".json"):
+                # Load the translation file
+                to_lint = os.path.join(config_translation_dir, file)
+                with open(to_lint, encoding="utf-8") as f:
+                    translation = json.load(f)
+
+                    # Lint the translation file
+                    lint_translation_json(file, truth, translation)
+
+
 config = load_config()