chainlit 2.7.0__tar.gz → 2.7.1__tar.gz

{chainlit-2.7.0 → chainlit-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chainlit
-Version: 2.7.0
+Version: 2.7.1
 Summary: Build Conversational AI.
 Project-URL: Homepage, https://chainlit.io/
 Project-URL: Documentation, https://docs.chainlit.io/

{chainlit-2.7.0 → chainlit-2.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chainlit"
-version = "2.7.0"
+version = "2.7.1"
 keywords = [
     "LLM",
     "Agents",
@@ -109,11 +109,23 @@ custom-data = [
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.build]
+exclude = [
+  "chainlit/frontend/**/*",
+  "chainlit/copilot/**/**/"
+]
+
 [tool.hatch.build.targets.wheel]
 packages = ["chainlit"]
 include = [
-    "chainlit/frontend/dist/**/*",
-    "chainlit/copilot/dist/**/*"
+  "chainlit/frontend/dist/**/*",
+  "chainlit/copilot/dist/**/*"
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "chainlit/frontend/dist/**/*",
+  "chainlit/copilot/dist/**/*"
 ]
 
 [tool.mypy]

chainlit-2.7.0/build.py

@@ -1,102 +0,0 @@
-"""Build script gets called on uv/pip build."""
-
-import os
-import pathlib
-import shutil
-import subprocess
-import sys
-
-
-class BuildError(Exception):
-    """Custom exception for build failures"""
-
-    pass
-
-
-def run_subprocess(cmd: list[str], cwd: os.PathLike) -> None:
-    """
-    Run a subprocess, allowing natural signal propagation.
-
-    Args:
-        cmd: Command and arguments as a list of strings
-        cwd: Working directory for the subprocess
-    """
-
-    print(f"-- Running: {' '.join(cmd)}")
-    subprocess.run(cmd, cwd=cwd, check=True)
-
-
-def pnpm_install(project_root, pnpm_path):
-    run_subprocess([pnpm_path, "install", "--frozen-lockfile"], project_root)
-
-
-def pnpm_buildui(project_root, pnpm_path):
-    run_subprocess([pnpm_path, "buildUi"], project_root)
-
-
-def copy_directory(src, dst, description):
-    """Copy directory with proper error handling"""
-    print(f"Copying {src} to {dst}")
-    try:
-        dst.mkdir(parents=True, exist_ok=True)
-        shutil.copytree(src, dst, dirs_exist_ok=True)
-    except KeyboardInterrupt:
-        print("\nInterrupt received during copy operation...")
-        # Clean up partial copies
-        if dst.exists():
-            shutil.rmtree(dst)
-        raise
-    except Exception as e:
-        raise BuildError(f"Failed to copy {src} to {dst}: {e!s}")
-
-
-def copy_frontend(project_root):
-    """Copy the frontend dist directory to the backend for inclusion in the package."""
-    backend_frontend_dir = project_root / "backend" / "chainlit" / "frontend" / "dist"
-    frontend_dist = project_root / "frontend" / "dist"
-    copy_directory(frontend_dist, backend_frontend_dir, "frontend assets")
-
-
-def copy_copilot(project_root):
-    """Copy the copilot dist directory to the backend for inclusion in the package."""
-    backend_copilot_dir = project_root / "backend" / "chainlit" / "copilot" / "dist"
-    copilot_dist = project_root / "libs" / "copilot" / "dist"
-    copy_directory(copilot_dist, backend_copilot_dir, "copilot assets")
-
-
-def build():
-    """Main build function with proper error handling"""
-
-    print(
-        "\n-- Building frontend, this might take a while!\n\n"
-        "   If you don't need to build the frontend and just want dependencies installed, use:\n"
-        "   `uv sync --no-build`\n"
-    )
-
-    try:
-        # Find directory containing this file
-        backend_dir = pathlib.Path(__file__).resolve().parent
-        project_root = backend_dir.parent
-
-        pnpm = shutil.which("pnpm")
-        if not pnpm:
-            raise BuildError("pnpm not found!")
-
-        pnpm_install(project_root, pnpm)
-        pnpm_buildui(project_root, pnpm)
-        copy_frontend(project_root)
-        copy_copilot(project_root)
-
-    except KeyboardInterrupt:
-        print("\nBuild interrupted by user")
-        sys.exit(1)
-    except BuildError as e:
-        print(f"\nBuild failed: {e!s}")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\nUnexpected error: {e!s}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    build()

chainlit-2.7.0/chainlit/__init__.py

@@ -1,207 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-
-# ruff: noqa: E402
-# Keep this here to ensure imports have environment available.
-env_file = os.getenv("CHAINLIT_ENV_FILE", ".env")
-env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), env_file))
-
-from chainlit.logger import logger
-
-if env_found:
-    logger.info(f"Loaded {env_file} file")
-
-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
-from chainlit.chat_context import chat_context
-from chainlit.chat_settings import ChatSettings
-from chainlit.context import context
-from chainlit.element import (
-    Audio,
-    CustomElement,
-    Dataframe,
-    File,
-    Image,
-    Pdf,
-    Plotly,
-    Pyplot,
-    Task,
-    TaskList,
-    TaskStatus,
-    Text,
-    Video,
-)
-from chainlit.message import (
-    AskActionMessage,
-    AskElementMessage,
-    AskFileMessage,
-    AskUserMessage,
-    ErrorMessage,
-    Message,
-)
-from chainlit.sidebar import ElementSidebar
-from chainlit.step import Step, step
-from chainlit.sync import make_async, run_sync
-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
-from chainlit.version import __version__
-
-from .callbacks import (
-    action_callback,
-    author_rename,
-    data_layer,
-    header_auth_callback,
-    oauth_callback,
-    on_app_shutdown,
-    on_app_startup,
-    on_audio_chunk,
-    on_audio_end,
-    on_audio_start,
-    on_chat_end,
-    on_chat_resume,
-    on_chat_start,
-    on_feedback,
-    on_logout,
-    on_mcp_connect,
-    on_mcp_disconnect,
-    on_message,
-    on_settings_update,
-    on_stop,
-    on_window_message,
-    password_auth_callback,
-    send_window_message,
-    set_chat_profiles,
-    set_starters,
-)
-
-if TYPE_CHECKING:
-    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
-    from chainlit.semantic_kernel import SemanticKernelFilter
-
-
-def sleep(duration: int):
-    """
-    Sleep for a given duration.
-    Args:
-        duration (int): The duration in seconds.
-    """
-    return asyncio.sleep(duration)
-
-
-@dataclass()
-class CopilotFunction:
-    name: str
-    args: Dict[str, Any]
-
-    def acall(self):
-        return context.emitter.send_call_fn(self.name, self.args)
-
-
-__getattr__ = make_module_getattr(
-    {
-        "LangchainCallbackHandler": "chainlit.langchain.callbacks",
-        "AsyncLangchainCallbackHandler": "chainlit.langchain.callbacks",
-        "LlamaIndexCallbackHandler": "chainlit.llama_index.callbacks",
-        "instrument_openai": "chainlit.openai",
-        "instrument_mistralai": "chainlit.mistralai",
-        "SemanticKernelFilter": "chainlit.semantic_kernel",
-        "server": "chainlit.server",
-    }
-)
-
-__all__ = [
-    "Action",
-    "AskActionMessage",
-    "AskElementMessage",
-    "AskFileMessage",
-    "AskUserMessage",
-    "AsyncLangchainCallbackHandler",
-    "Audio",
-    "ChatGeneration",
-    "ChatProfile",
-    "ChatSettings",
-    "CompletionGeneration",
-    "CopilotFunction",
-    "CustomElement",
-    "Dataframe",
-    "ElementSidebar",
-    "ErrorMessage",
-    "File",
-    "GenerationMessage",
-    "Image",
-    "InputAudioChunk",
-    "LangchainCallbackHandler",
-    "LlamaIndexCallbackHandler",
-    "Message",
-    "OutputAudioChunk",
-    "Pdf",
-    "PersistedUser",
-    "Plotly",
-    "Pyplot",
-    "SemanticKernelFilter",
-    "Starter",
-    "Step",
-    "Task",
-    "TaskList",
-    "TaskStatus",
-    "Text",
-    "User",
-    "Video",
-    "__version__",
-    "action_callback",
-    "author_rename",
-    "cache",
-    "chat_context",
-    "context",
-    "data_layer",
-    "header_auth_callback",
-    "input_widget",
-    "instrument_mistralai",
-    "instrument_openai",
-    "make_async",
-    "oauth_callback",
-    "on_app_shutdown",
-    "on_app_startup",
-    "on_audio_chunk",
-    "on_audio_end",
-    "on_audio_start",
-    "on_chat_end",
-    "on_chat_resume",
-    "on_chat_start",
-    "on_feedback",
-    "on_logout",
-    "on_mcp_connect",
-    "on_mcp_disconnect",
-    "on_message",
-    "on_settings_update",
-    "on_stop",
-    "on_window_message",
-    "password_auth_callback",
-    "run_sync",
-    "send_window_message",
-    "set_chat_profiles",
-    "set_starters",
-    "sleep",
-    "step",
-    "user_session",
-]
-
-
-def __dir__():
-    return __all__

chainlit-2.7.0/chainlit/__main__.py

@@ -1,4 +0,0 @@
-from chainlit.cli import cli
-
-if __name__ == "__main__":
-    cli(prog_name="chainlit")

chainlit-2.7.0/chainlit/_utils.py

@@ -1,8 +0,0 @@
-"""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-2.7.0/chainlit/action.py

@@ -1,33 +0,0 @@
-import uuid
-from typing import Dict, Optional
-
-from dataclasses_json import DataClassJsonMixin
-from pydantic import Field
-from pydantic.dataclasses import dataclass
-
-from chainlit.context import context
-
-
-@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.
-    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
-    # 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()))
-
-    async def send(self, for_id: str):
-        self.forId = for_id
-        await context.emitter.emit("action", self.to_dict())
-
-    async def remove(self):
-        await context.emitter.emit("remove_action", self.to_dict())

chainlit-2.7.0/chainlit/auth/__init__.py

@@ -1,95 +0,0 @@
-import os
-
-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 .cookie import (
-    OAuth2PasswordBearerWithCookie,
-    clear_auth_cookie,
-    get_token_from_cookies,
-    set_auth_cookie,
-)
-from .jwt import create_jwt, decode_jwt, get_jwt_secret
-
-reuseable_oauth = OAuth2PasswordBearerWithCookie(tokenUrl="/login", auto_error=False)
-
-
-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 authentication. Run `chainlit create-secret` to generate one."
-        )
-
-
-def is_oauth_enabled():
-    return config.code.oauth_callback and len(get_configured_oauth_providers()) > 0
-
-
-def require_login():
-    return bool(os.environ.get("CHAINLIT_AUTH_SECRET"))
-
-
-def get_configuration():
-    return {
-        "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 []
-        ),
-        "default_theme": config.ui.default_theme,
-        "ui": {
-            "login_page_image": config.ui.login_page_image,
-            "login_page_image_filter": config.ui.login_page_image_filter,
-            "login_page_image_dark_filter": config.ui.login_page_image_dark_filter,
-        },
-    }
-
-
-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
-
-    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)
-            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
-
-
-async def get_current_user(token: str = Depends(reuseable_oauth)):
-    if not require_login():
-        return None
-
-    return await authenticate_user(token)
-
-
-__all__ = [
-    "clear_auth_cookie",
-    "create_jwt",
-    "get_configuration",
-    "get_current_user",
-    "get_token_from_cookies",
-    "set_auth_cookie",
-]

chainlit-2.7.0/chainlit/auth/cookie.py

@@ -1,197 +0,0 @@
-import os
-from typing import Literal, Optional, cast
-
-from fastapi import Request, Response
-from fastapi.exceptions import HTTPException
-from fastapi.security.base import SecurityBase
-from fastapi.security.utils import get_authorization_scheme_param
-from starlette.status import HTTP_401_UNAUTHORIZED
-
-from chainlit.config import config
-
-""" Module level cookie settings. """
-_cookie_samesite = cast(
-    Literal["lax", "strict", "none"],
-    os.environ.get("CHAINLIT_COOKIE_SAMESITE", "lax"),
-)
-
-assert _cookie_samesite in [
-    "lax",
-    "strict",
-    "none",
-], (
-    "Invalid value for CHAINLIT_COOKIE_SAMESITE. Must be one of 'lax', 'strict' or 'none'."
-)
-_cookie_secure = _cookie_samesite == "none"
-if _cookie_root_path := os.environ.get("CHAINLIT_ROOT_PATH", None):
-    _cookie_path = os.environ.get(_cookie_root_path, "/")
-else:
-    _cookie_path = os.environ.get("CHAINLIT_AUTH_COOKIE_PATH", "/")
-_state_cookie_lifetime = 3 * 60  # 3m
-_auth_cookie_name = os.environ.get("CHAINLIT_AUTH_COOKIE_NAME", "access_token")
-_state_cookie_name = "oauth_state"
-
-
-class OAuth2PasswordBearerWithCookie(SecurityBase):
-    """
-    OAuth2 password flow with cookie support with fallback to bearer token.
-    """
-
-    def __init__(
-        self,
-        tokenUrl: str,
-        scheme_name: Optional[str] = None,
-        auto_error: bool = True,
-    ):
-        self.tokenUrl = tokenUrl
-        self.scheme_name = scheme_name or self.__class__.__name__
-        self.auto_error = auto_error
-
-    async def __call__(self, request: Request) -> Optional[str]:
-        # First try to get the token from the cookie
-        token = get_token_from_cookies(request.cookies)
-
-        # If no cookie, try the Authorization header as fallback
-        if not token:
-            # TODO: Only bother to check if cookie auth is explicitly disabled.
-            authorization = request.headers.get("Authorization")
-            if authorization:
-                scheme, token = get_authorization_scheme_param(authorization)
-                if scheme.lower() != "bearer":
-                    if self.auto_error:
-                        raise HTTPException(
-                            status_code=HTTP_401_UNAUTHORIZED,
-                            detail="Invalid authentication credentials",
-                            headers={"WWW-Authenticate": "Bearer"},
-                        )
-                    else:
-                        return None
-            else:
-                if self.auto_error:
-                    raise HTTPException(
-                        status_code=HTTP_401_UNAUTHORIZED,
-                        detail="Not authenticated",
-                        headers={"WWW-Authenticate": "Bearer"},
-                    )
-                else:
-                    return None
-
-        return token
-
-
-def _get_chunked_cookie(cookies: dict[str, str], name: str) -> Optional[str]:
-    # Gather all auth_chunk_i cookies, sorted by their index
-    chunk_parts = []
-
-    i = 0
-    while True:
-        cookie_key = f"{_auth_cookie_name}_{i}"
-        if cookie_key not in cookies:
-            break
-
-        chunk_parts.append(cookies[cookie_key])
-        i += 1
-
-    joined = "".join(chunk_parts)
-
-    return joined if joined != "" else None
-
-
-def get_token_from_cookies(cookies: dict[str, str]) -> Optional[str]:
-    """
-    Read all chunk cookies and reconstruct the token
-    """
-
-    # Default/unchunked cookies
-    if value := cookies.get(_auth_cookie_name):
-        return value
-
-    return _get_chunked_cookie(cookies, _auth_cookie_name)
-
-
-def set_auth_cookie(request: Request, response: Response, token: str):
-    """
-    Helper function to set the authentication cookie with secure parameters
-    and remove any leftover chunks from a previously larger token.
-    """
-
-    _chunk_size = 3000
-
-    existing_cookies = {
-        k for k in request.cookies.keys() if k.startswith(_auth_cookie_name)
-    }
-
-    if len(token) > _chunk_size:
-        chunks = [token[i : i + _chunk_size] for i in range(0, len(token), _chunk_size)]
-
-        for i, chunk in enumerate(chunks):
-            k = f"{_auth_cookie_name}_{i}"
-
-            response.set_cookie(
-                key=k,
-                value=chunk,
-                httponly=True,
-                secure=_cookie_secure,
-                samesite=_cookie_samesite,
-                max_age=config.project.user_session_timeout,
-            )
-
-            existing_cookies.discard(k)
-    else:
-        # Default (shorter cookies)
-        response.set_cookie(
-            key=_auth_cookie_name,
-            value=token,
-            httponly=True,
-            secure=_cookie_secure,
-            samesite=_cookie_samesite,
-            max_age=config.project.user_session_timeout,
-        )
-
-        existing_cookies.discard(_auth_cookie_name)
-
-    # Delete remaining prior cookies/cookie chunks
-    for k in existing_cookies:
-        response.delete_cookie(
-            key=k, path=_cookie_path, secure=_cookie_secure, samesite=_cookie_samesite
-        )
-
-
-def clear_auth_cookie(request: Request, response: Response):
-    """
-    Helper function to clear the authentication cookie
-    """
-
-    existing_cookies = {
-        k for k in request.cookies.keys() if k.startswith(_auth_cookie_name)
-    }
-
-    for k in existing_cookies:
-        response.delete_cookie(
-            key=k, path=_cookie_path, secure=_cookie_secure, samesite=_cookie_samesite
-        )
-
-
-def set_oauth_state_cookie(response: Response, token: str):
-    response.set_cookie(
-        _state_cookie_name,
-        token,
-        httponly=True,
-        samesite=_cookie_samesite,
-        secure=_cookie_secure,
-        max_age=_state_cookie_lifetime,
-    )
-
-
-def validate_oauth_state_cookie(request: Request, state: str):
-    """Check the state from the oauth provider against the browser cookie."""
-
-    oauth_state = request.cookies.get(_state_cookie_name)
-
-    if oauth_state != state:
-        raise Exception("oauth state does not correspond")
-
-
-def clear_oauth_state_cookie(response: Response):
-    """Oauth complete, delete state token."""
-    response.delete_cookie(_state_cookie_name)  # Do we set path here?