chainlit 2.7.0__py3-none-any.whl → 2.7.1__py3-none-any.whl

{chainlit-2.7.0.dist-info → chainlit-2.7.1.dist-info}/METADATA

@@ -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.1.dist-info/RECORD

@@ -0,0 +1,4 @@
+chainlit-2.7.1.dist-info/METADATA,sha256=jnq2rEhRbW3jO5LPp4OspbbHU17_j8s3Sk_Bwricewg,8008
+chainlit-2.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chainlit-2.7.1.dist-info/entry_points.txt,sha256=6bh2dHNg8oKZ_Vi97RjwoZQ1CMlI6Rcw4H5CSCnd_Lo,46
+chainlit-2.7.1.dist-info/RECORD,,

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/__main__.py

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

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/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/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/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?

chainlit/auth/jwt.py

@@ -1,42 +0,0 @@
-import os
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, Optional
-
-import jwt as pyjwt
-
-from chainlit.config import config
-from chainlit.user import User
-
-
-def get_jwt_secret() -> Optional[str]:
-    return os.environ.get("CHAINLIT_AUTH_SECRET")
-
-
-def create_jwt(data: User) -> str:
-    to_encode: Dict[str, Any] = data.to_dict()
-    to_encode.update(
-        {
-            "exp": datetime.now(timezone.utc)
-            + timedelta(seconds=config.project.user_session_timeout),
-            "iat": datetime.now(timezone.utc),  # Add issued at time
-        }
-    )
-
-    secret = get_jwt_secret()
-    assert secret
-    encoded_jwt = pyjwt.encode(to_encode, secret, algorithm="HS256")
-    return encoded_jwt
-
-
-def decode_jwt(token: str) -> User:
-    secret = get_jwt_secret()
-    assert secret
-
-    dict = pyjwt.decode(
-        token,
-        secret,
-        algorithms=["HS256"],
-        options={"verify_signature": True},
-    )
-    del dict["exp"]
-    return User(**dict)

chainlit/cache.py

@@ -1,45 +0,0 @@
-import importlib.util
-import os
-import threading
-from typing import Any
-
-from chainlit.config import config
-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:
-        from langchain.cache import SQLiteCache
-        from langchain.globals import set_llm_cache
-
-        if config.project.lc_cache_path is not None:
-            set_llm_cache(SQLiteCache(database_path=config.project.lc_cache_path))
-
-            if not os.path.exists(config.project.lc_cache_path):
-                logger.info(
-                    f"LangChain cache created at: {config.project.lc_cache_path}"
-                )
-
-
-_cache: dict[tuple, Any] = {}
-_cache_lock = threading.Lock()
-
-
-def cache(func):
-    def wrapper(*args, **kwargs):
-        # Create a cache key based on the function name, arguments, and keyword arguments
-        cache_key = (
-            (func.__name__,) + args + tuple((k, v) for k, v in sorted(kwargs.items()))
-        )
-
-        with _cache_lock:
-            # Check if the result is already in the cache
-            if cache_key not in _cache:
-                # If not, call the function and store the result in the cache
-                _cache[cache_key] = func(*args, **kwargs)
-
-        return _cache[cache_key]
-
-    return wrapper