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

chainlit/types.py

@@ -1,334 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generic,
-    List,
-    Literal,
-    Optional,
-    Protocol,
-    TypedDict,
-    TypeVar,
-    Union,
-)
-
-if TYPE_CHECKING:
-    from chainlit.element import ElementDict
-    from chainlit.step import StepDict
-
-from dataclasses_json import DataClassJsonMixin
-from pydantic import BaseModel
-from pydantic.dataclasses import dataclass
-
-InputWidgetType = Literal[
-    "switch", "slider", "select", "textinput", "tags", "numberinput"
-]
-ToastType = Literal["info", "success", "warning", "error"]
-
-
-class ThreadDict(TypedDict):
-    id: str
-    createdAt: str
-    name: Optional[str]
-    userId: Optional[str]
-    userIdentifier: Optional[str]
-    tags: Optional[List[str]]
-    metadata: Optional[Dict]
-    steps: List[StepDict]
-    elements: Optional[List[ElementDict]]
-
-
-class Pagination(BaseModel):
-    first: int
-    cursor: Optional[str] = None
-
-
-class ThreadFilter(BaseModel):
-    feedback: Literal[0, 1] | None = None
-    userId: str | None = None
-    search: str | None = None
-
-
-@dataclass
-class PageInfo:
-    hasNextPage: bool
-    startCursor: Optional[str]
-    endCursor: Optional[str]
-
-    def to_dict(self):
-        return {
-            "hasNextPage": self.hasNextPage,
-            "startCursor": self.startCursor,
-            "endCursor": self.endCursor,
-        }
-
-    @classmethod
-    def from_dict(cls, page_info_dict: Dict) -> PageInfo:
-        hasNextPage = page_info_dict.get("hasNextPage", False)
-        startCursor = page_info_dict.get("startCursor", None)
-        endCursor = page_info_dict.get("endCursor", None)
-        return cls(
-            hasNextPage=hasNextPage, startCursor=startCursor, endCursor=endCursor
-        )
-
-
-T = TypeVar("T", covariant=True)
-
-
-class HasFromDict(Protocol[T]):
-    @classmethod
-    def from_dict(cls, obj_dict: Any) -> T:
-        raise NotImplementedError
-
-
-@dataclass
-class PaginatedResponse(Generic[T]):
-    pageInfo: PageInfo
-    data: List[T]
-
-    def to_dict(self):
-        return {
-            "pageInfo": self.pageInfo.to_dict(),
-            "data": [
-                (d.to_dict() if hasattr(d, "to_dict") and callable(d.to_dict) else d)
-                for d in self.data
-            ],
-        }
-
-    @classmethod
-    def from_dict(
-        cls, paginated_response_dict: Dict, the_class: HasFromDict[T]
-    ) -> PaginatedResponse[T]:
-        pageInfo = PageInfo.from_dict(paginated_response_dict.get("pageInfo", {}))
-
-        data = [the_class.from_dict(d) for d in paginated_response_dict.get("data", [])]
-
-        return cls(pageInfo=pageInfo, data=data)
-
-
-@dataclass
-class FileSpec(DataClassJsonMixin):
-    accept: Union[List[str], Dict[str, List[str]]]
-    max_files: int
-    max_size_mb: int
-
-
-@dataclass
-class ActionSpec(DataClassJsonMixin):
-    keys: List[str]
-
-
-@dataclass
-class AskSpec(DataClassJsonMixin):
-    """Specification for asking the user."""
-
-    timeout: int
-    type: Literal["text", "file", "action", "element"]
-    step_id: str
-
-
-@dataclass
-class AskFileSpec(FileSpec, AskSpec, DataClassJsonMixin):
-    """Specification for asking the user a file."""
-
-
-@dataclass
-class AskActionSpec(ActionSpec, AskSpec, DataClassJsonMixin):
-    """Specification for asking the user an action"""
-
-
-@dataclass
-class AskElementSpec(AskSpec, DataClassJsonMixin):
-    """Specification for asking the user a custom element"""
-
-    element_id: str
-
-
-class FileReference(TypedDict):
-    id: str
-
-
-class FileDict(TypedDict):
-    id: str
-    name: str
-    path: Path
-    size: int
-    type: str
-
-
-class MessagePayload(TypedDict):
-    message: StepDict
-    fileReferences: Optional[List[FileReference]]
-
-
-class InputAudioChunkPayload(TypedDict):
-    isStart: bool
-    mimeType: str
-    elapsedTime: float
-    data: bytes
-
-
-@dataclass
-class InputAudioChunk:
-    isStart: bool
-    mimeType: str
-    elapsedTime: float
-    data: bytes
-
-
-class OutputAudioChunk(TypedDict):
-    track: str
-    mimeType: str
-    data: bytes
-
-
-@dataclass
-class AskFileResponse:
-    id: str
-    name: str
-    path: str
-    size: int
-    type: str
-
-
-class AskActionResponse(TypedDict):
-    name: str
-    payload: Dict
-    label: str
-    tooltip: str
-    forId: str
-    id: str
-
-
-class AskElementResponse(TypedDict, total=False):
-    submitted: bool
-
-
-class UpdateThreadRequest(BaseModel):
-    threadId: str
-    name: str
-
-
-class DeleteThreadRequest(BaseModel):
-    threadId: str
-
-
-class DeleteFeedbackRequest(BaseModel):
-    feedbackId: str
-
-
-class GetThreadsRequest(BaseModel):
-    pagination: Pagination
-    filter: ThreadFilter
-
-
-class CallActionRequest(BaseModel):
-    action: Dict
-    sessionId: str
-
-
-class ConnectStdioMCPRequest(BaseModel):
-    sessionId: str
-    clientType: Literal["stdio"]
-    name: str
-    fullCommand: str
-
-
-class ConnectSseMCPRequest(BaseModel):
-    sessionId: str
-    clientType: Literal["sse"]
-    name: str
-    url: str
-    # Optional HTTP headers to forward to the MCP transport (e.g. Authorization)
-    headers: Optional[Dict[str, str]] = None
-
-
-class ConnectStreamableHttpMCPRequest(BaseModel):
-    sessionId: str
-    clientType: Literal["streamable-http"]
-    name: str
-    url: str
-    # Optional HTTP headers to forward to the MCP transport (e.g. Authorization)
-    headers: Dict[str, str] | None = None
-
-
-ConnectMCPRequest = Union[
-    ConnectStdioMCPRequest, ConnectSseMCPRequest, ConnectStreamableHttpMCPRequest
-]
-
-
-class DisconnectMCPRequest(BaseModel):
-    sessionId: str
-    name: str
-
-
-class ElementRequest(BaseModel):
-    element: Dict
-    sessionId: str
-
-
-class Theme(str, Enum):
-    light = "light"
-    dark = "dark"
-
-
-@dataclass
-class Starter(DataClassJsonMixin):
-    """Specification for a starter that can be chosen by the user at the thread start."""
-
-    label: str
-    message: str
-    command: Optional[str] = None
-    icon: Optional[str] = None
-
-
-@dataclass
-class ChatProfile(DataClassJsonMixin):
-    """Specification for a chat profile that can be chosen by the user at the thread start."""
-
-    name: str
-    markdown_description: str
-    icon: Optional[str] = None
-    default: bool = False
-    starters: Optional[List[Starter]] = None
-    config_overrides: Any = None
-
-
-FeedbackStrategy = Literal["BINARY"]
-
-
-class CommandDict(TypedDict):
-    # The identifier of the command, will be displayed in the UI
-    id: str
-    # The description of the command, will be displayed in the UI
-    description: str
-    # The lucide icon name
-    icon: str
-    # Display the command as a button in the composer
-    button: Optional[bool]
-    # Whether the command will be persistent unless the user toggles it
-    persistent: Optional[bool]
-
-
-class FeedbackDict(TypedDict):
-    forId: str
-    id: Optional[str]
-    value: Literal[0, 1]
-    comment: Optional[str]
-
-
-@dataclass
-class Feedback:
-    forId: str
-    value: Literal[0, 1]
-    threadId: Optional[str] = None
-    id: Optional[str] = None
-    comment: Optional[str] = None
-
-
-class UpdateFeedbackRequest(BaseModel):
-    feedback: Feedback

chainlit/user.py

@@ -1,43 +0,0 @@
-from typing import Dict, Literal, Optional, TypedDict
-
-from dataclasses_json import DataClassJsonMixin
-from pydantic import Field
-from pydantic.dataclasses import dataclass
-
-Provider = Literal[
-    "credentials",
-    "header",
-    "github",
-    "google",
-    "azure-ad",
-    "azure-ad-hybrid",
-    "okta",
-    "auth0",
-    "descope",
-]
-
-
-class UserDict(TypedDict):
-    id: str
-    identifier: str
-    display_name: Optional[str]
-    metadata: Dict
-
-
-# Used when logging-in a user
-@dataclass
-class User(DataClassJsonMixin):
-    identifier: str
-    display_name: Optional[str] = None
-    metadata: Dict = Field(default_factory=dict)
-
-
-@dataclass
-class PersistedUserFields:
-    id: str
-    createdAt: str
-
-
-@dataclass
-class PersistedUser(User, PersistedUserFields):
-    pass

chainlit/user_session.py

@@ -1,153 +0,0 @@
-from typing import Callable, Dict, Generic, Optional, TypeVar
-
-from chainlit.context import context
-
-user_sessions: Dict[str, Dict] = {}
-
-T = TypeVar("T")
-
-
-class UserSession:
-    """
-    Developer facing user session class.
-    Useful for the developer to store user specific data between calls.
-    """
-
-    def get(self, key, default=None):
-        if not context.session:
-            return default
-
-        if context.session.id not in user_sessions:
-            # Create a new user session
-            user_sessions[context.session.id] = {}
-
-        user_session = user_sessions[context.session.id]
-
-        # Copy important fields from the session
-        user_session["id"] = context.session.id
-        user_session["env"] = context.session.user_env
-        user_session["chat_settings"] = context.session.chat_settings
-        user_session["user"] = context.session.user
-        user_session["chat_profile"] = context.session.chat_profile
-        user_session["client_type"] = context.session.client_type
-
-        return user_session.get(key, default)
-
-    def set(self, key, value):
-        if not context.session:
-            return None
-
-        if context.session.id not in user_sessions:
-            user_sessions[context.session.id] = {}
-
-        user_session = user_sessions[context.session.id]
-        user_session[key] = value
-
-    def create_accessor(
-        self, key: str, default: T, *, apply_fn: Optional[Callable[[T], T]] = None
-    ) -> "SessionAccessor[T]":
-        """
-        Create a typed session accessor object for the given key and default value.
-
-        #### Note: Creates the accessor configuration. The session value itself is only stored/updated when `.set()`, `.reset()`, or `.apply()` are called.
-
-        Parameters
-        ----------
-        key : str
-            The session dictionary key to store the value under
-        default : T
-            Default value to return when key is not present in session
-        apply_fn : Optional[Callable[[T], T]], default None
-            Optional function to transform the value when apply() is called
-
-        Returns
-        -------
-        SessionAccessor[T]
-            A typed accessor object bound to the specified session key
-
-        Examples
-        --------
-
-        ```python
-        count = cl.user_session.create_accessor("count", 0)
-        count.get() # returns 0
-        count.set(5)  # type-safe setter
-        count.get() # returns 5
-
-        # With transform function
-        counter = cl.user_session.create_accessor("counter", 0, apply_fn=lambda x: x + 1)
-        counter.apply() # increments value and returns new value (1)
-
-        @cl.on_message
-        async def on_message(message: cl.Message):
-            await cl.Message(content=f"You sent {counter.apply()} messages").send() # You sent 2 messages
-        ```
-        """
-        return SessionAccessor(key, default, apply_fn=apply_fn)
-
-
-user_session = UserSession()
-
-
-class SessionAccessor(Generic[T]):
-    """
-    Extended session accessor class to store user specific data between calls with type safety.
-
-    Provides a typed wrapper around user_session dictionary access with default values
-    and optional transform functions. The session value is only stored in memory when
-    explicitly modified through `.set()`, `.reset()`, or `.apply()` methods.
-
-    Examples
-    --------
-    ```python
-    count = cl.user_session.create_accessor("count", 0)
-    count.get() # returns 0
-    count.set(5)  # type-safe setter
-    count.get() # returns 5
-
-    # With transform function
-    counter = cl.user_session.create_accessor("counter", 0, apply_fn=lambda x: x + 1)
-    counter.apply() # increments value and returns new value (1)
-
-    @cl.on_message
-    async def on_message(message: cl.Message):
-        await cl.Message(content=f"You sent {counter.apply()} messages").send() # You sent 2 messages
-    ```
-    """
-
-    def __init__(
-        self, key: str, default: T, *, apply_fn: Optional[Callable[[T], T]] = None
-    ):
-        self._key = key
-        self._default = default
-        self._apply_fn = apply_fn
-
-    def get(self) -> T:
-        """
-        Get the current value of the accessor.
-        """
-        return user_session.get(self._key, self._default)
-
-    def set(self, value: T) -> None:
-        """
-        Set the value of the accessor.
-        """
-        return user_session.set(self._key, value)
-
-    def reset(self) -> None:
-        """
-        Reset the value to the default.
-        """
-        return self.set(self._default)
-
-    def apply(self) -> T:
-        """
-        Apply the transform function to the current value, store the result, and return it.
-
-        Returns the current value if no transform function is provided.
-        """
-        value = self.get()
-        if self._apply_fn:
-            value = self._apply_fn(value)
-        self.set(value)
-        return value

chainlit/utils.py

@@ -1,173 +0,0 @@
-import functools
-import importlib
-import inspect
-import os
-from asyncio import CancelledError
-from datetime import datetime, timezone
-from typing import Callable
-
-import click
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-from packaging import version
-from starlette.middleware.base import BaseHTTPMiddleware
-
-from chainlit.auth import ensure_jwt_secret
-from chainlit.context import context
-from chainlit.logger import logger
-
-
-def utc_now():
-    dt = datetime.now(timezone.utc).replace(tzinfo=None)
-    return dt.isoformat() + "Z"
-
-
-def timestamp_utc(timestamp: float):
-    dt = datetime.fromtimestamp(timestamp, timezone.utc).replace(tzinfo=None)
-    return dt.isoformat() + "Z"
-
-
-def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
-    """
-    Wraps a user-defined function to accept arguments as a dictionary.
-
-    Args:
-        user_function (Callable): The user-defined function to wrap.
-
-    Returns:
-        Callable: The wrapped function.
-    """
-
-    @functools.wraps(user_function)
-    async def wrapper(*args):
-        # Get the parameter names of the user-defined function
-        user_function_params = list(inspect.signature(user_function).parameters.keys())
-
-        # Create a dictionary of parameter names and their corresponding values from *args
-        params_values = {
-            param_name: arg for param_name, arg in zip(user_function_params, args)
-        }
-
-        if with_task:
-            await context.emitter.task_start()
-
-        try:
-            # Call the user-defined function with the arguments
-            if inspect.iscoroutinefunction(user_function):
-                return await user_function(**params_values)
-            else:
-                return user_function(**params_values)
-        except CancelledError:
-            pass
-        except Exception as e:
-            logger.exception(e)
-            if with_task:
-                from chainlit.message import ErrorMessage
-
-                await ErrorMessage(
-                    content=str(e) or e.__class__.__name__, author="Error"
-                ).send()
-        finally:
-            if with_task:
-                await context.emitter.task_end()
-
-    return wrapper
-
-
-def make_module_getattr(registry):
-    """Leverage PEP 562 to make imports lazy in an __init__.py
-
-    The registry must be a dictionary with the items to import as keys and the
-    modules they belong to as a value.
-    """
-
-    def __getattr__(name):
-        module_path = registry[name]
-        module = importlib.import_module(module_path, __package__)
-        return getattr(module, name)
-
-    return __getattr__
-
-
-def check_module_version(name, required_version):
-    """
-    Check the version of a module.
-
-    Args:
-        name (str): A module name.
-        version (str): Minimum version.
-
-    Returns:
-        (bool): Return True if the module is installed and the version
-            match the minimum required version.
-    """
-    try:
-        module = importlib.import_module(name)
-    except ModuleNotFoundError:
-        return False
-    return version.parse(module.__version__) >= version.parse(required_version)
-
-
-def check_file(target: str):
-    # Define accepted file extensions for Chainlit
-    ACCEPTED_FILE_EXTENSIONS = ("py", "py3")
-
-    _, extension = os.path.splitext(target)
-
-    # Check file extension
-    if extension[1:] not in ACCEPTED_FILE_EXTENSIONS:
-        if extension[1:] == "":
-            raise click.BadArgumentUsage(
-                "Chainlit requires raw Python (.py) files, but the provided file has no extension."
-            )
-        else:
-            raise click.BadArgumentUsage(
-                f"Chainlit requires raw Python (.py) files, not {extension}."
-            )
-
-    if not os.path.exists(target):
-        raise click.BadParameter(f"File does not exist: {target}")
-
-
-def mount_chainlit(app: FastAPI, target: str, path="/chainlit"):
-    from chainlit.config import config, load_module
-    from chainlit.server import app as chainlit_app
-
-    config.run.debug = os.environ.get("CHAINLIT_DEBUG", False)
-    os.environ["CHAINLIT_ROOT_PATH"] = path
-
-    api_full_path = path
-
-    if app.root_path:
-        parent_root_path = app.root_path.rstrip("/")
-        api_full_path = parent_root_path + path
-        os.environ["CHAINLIT_PARENT_ROOT_PATH"] = parent_root_path
-
-    check_file(target)
-    # Load the module provided by the user
-    config.run.module_name = target
-    load_module(config.run.module_name)
-
-    ensure_jwt_secret()
-
-    class ChainlitMiddleware(BaseHTTPMiddleware):
-        """Middleware to handle path routing for submounted Chainlit applications.
-
-        When Chainlit is submounted within a larger FastAPI application, its default route
-        `@router.get("/{full_path:path}")` can conflict with the main app's routing. This
-        middleware ensures requests are only forwarded to Chainlit if they match the
-        designated subpath, preventing routing collisions.
-
-        If a request's path doesn't start with the configured subpath, the middleware
-        returns a 404 response instead of forwarding to Chainlit's default route.
-        """
-
-        async def dispatch(self, request: Request, call_next):
-            if not request.url.path.startswith(api_full_path):
-                return JSONResponse(status_code=404, content={"detail": "Not found"})
-
-            return await call_next(request)
-
-    chainlit_app.add_middleware(ChainlitMiddleware)
-
-    app.mount(path, chainlit_app)

chainlit/version.py

@@ -1,8 +0,0 @@
-from importlib import metadata
-
-try:
-    __version__ = metadata.version(__package__)
-except metadata.PackageNotFoundError:
-    # Case where package metadata is not available, default to a 'non-outdated' version.
-    # Ref: config.py::load_settings()
-    __version__ = "2.7.0"