chainlit 1.1.404__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

chainlit/__init__.py

@@ -1,33 +1,26 @@
-import inspect
 import os
 
 from dotenv import load_dotenv
 
+# ruff: noqa: E402
+# Keep this here to ensure imports have environment available.
 env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
 
-import asyncio
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from chainlit.logger import logger
 
-from fastapi import Request, Response
-from pydantic.dataclasses import dataclass
-from starlette.datastructures import Headers
+if env_found:
+    logger.info("Loaded .env file")
 
-if TYPE_CHECKING:
-    from chainlit.haystack.callbacks import HaystackAgentCallbackHandler
-    from chainlit.langchain.callbacks import (
-        LangchainCallbackHandler,
-        AsyncLangchainCallbackHandler,
-    )
-    from chainlit.llama_index.callbacks import LlamaIndexCallbackHandler
-    from chainlit.openai import instrument_openai
-    from chainlit.mistralai import instrument_mistralai
+import asyncio
+from typing import TYPE_CHECKING, Any, Dict
 
 import chainlit.input_widget as input_widget
 from chainlit.action import Action
+from chainlit.assistant import Assistant
+from chainlit.assistant_settings import AssistantSettings
 from chainlit.cache import cache
 from chainlit.chat_context import chat_context
 from chainlit.chat_settings import ChatSettings
-from chainlit.config import config
 from chainlit.context import context
 from chainlit.element import (
     Audio,
@@ -43,7 +36,6 @@ from chainlit.element import (
     Text,
     Video,
 )
-from chainlit.logger import logger
 from chainlit.message import (
     AskActionMessage,
     AskFileMessage,
@@ -51,303 +43,46 @@ from chainlit.message import (
     ErrorMessage,
     Message,
 )
-from chainlit.oauth_providers import get_configured_oauth_providers
 from chainlit.step import Step, step
 from chainlit.sync import make_async, run_sync
-from chainlit.telemetry import trace
-from chainlit.types import AudioChunk, ChatProfile, Starter, ThreadDict
+from chainlit.types import AudioChunk, ChatProfile, Starter
 from chainlit.user import PersistedUser, User
 from chainlit.user_session import user_session
-from chainlit.utils import make_module_getattr, wrap_user_function
+from chainlit.utils import make_module_getattr
 from chainlit.version import __version__
 from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
+from pydantic.dataclasses import dataclass
 
-if env_found:
-    logger.info("Loaded .env file")
-
-
-@trace
-def password_auth_callback(func: Callable[[str, str], Optional[User]]) -> Callable:
-    """
-    Framework agnostic decorator to authenticate the user.
-
-    Args:
-        func (Callable[[str, str], Optional[User]]): The authentication callback to execute. Takes the email and password as parameters.
-
-    Example:
-        @cl.password_auth_callback
-        async def password_auth_callback(username: str, password: str) -> Optional[User]:
-
-    Returns:
-        Callable[[str, str], Optional[User]]: The decorated authentication callback.
-    """
-
-    config.code.password_auth_callback = wrap_user_function(func)
-    return func
-
-
-@trace
-def header_auth_callback(func: Callable[[Headers], Optional[User]]) -> Callable:
-    """
-    Framework agnostic decorator to authenticate the user via a header
-
-    Args:
-        func (Callable[[Headers], Optional[User]]): The authentication callback to execute.
-
-    Example:
-        @cl.header_auth_callback
-        async def header_auth_callback(headers: Headers) -> Optional[User]:
-
-    Returns:
-        Callable[[Headers], Optional[User]]: The decorated authentication callback.
-    """
-
-    config.code.header_auth_callback = wrap_user_function(func)
-    return func
-
-
-@trace
-def oauth_callback(
-    func: Callable[[str, str, Dict[str, str], User], Optional[User]]
-) -> Callable:
-    """
-    Framework agnostic decorator to authenticate the user via oauth
-
-    Args:
-        func (Callable[[str, str, Dict[str, str], User], Optional[User]]): The authentication callback to execute.
-
-    Example:
-        @cl.oauth_callback
-        async def oauth_callback(provider_id: str, token: str, raw_user_data: Dict[str, str], default_app_user: User, id_token: Optional[str]) -> Optional[User]:
-
-    Returns:
-        Callable[[str, str, Dict[str, str], User], Optional[User]]: The decorated authentication callback.
-    """
-
-    if len(get_configured_oauth_providers()) == 0:
-        raise ValueError(
-            "You must set the environment variable for at least one oauth provider to use oauth authentication."
-        )
-
-    config.code.oauth_callback = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_logout(func: Callable[[Request, Response], Any]) -> Callable:
-    """
-    Function called when the user logs out.
-    Takes the FastAPI request and response as parameters.
-    """
-
-    config.code.on_logout = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_message(func: Callable) -> Callable:
-    """
-    Framework agnostic decorator to react to messages coming from the UI.
-    The decorated function is called every time a new message is received.
-
-    Args:
-        func (Callable[[Message], Any]): The function to be called when a new message is received. Takes a cl.Message.
-
-    Returns:
-        Callable[[str], Any]: The decorated on_message function.
-    """
-
-    async def with_parent_id(message: Message):
-        async with Step(name="on_message", type="run", parent_id=message.id) as s:
-            s.input = message.content
-            if len(inspect.signature(func).parameters) > 0:
-                await func(message)
-            else:
-                await func()
-
-    config.code.on_message = wrap_user_function(with_parent_id)
-    return func
-
-
-@trace
-def on_chat_start(func: Callable) -> Callable:
-    """
-    Hook to react to the user websocket connection event.
-
-    Args:
-        func (Callable[], Any]): The connection hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_start = wrap_user_function(
-        step(func, name="on_chat_start", type="run"), with_task=True
-    )
-    return func
-
-
-@trace
-def on_chat_resume(func: Callable[[ThreadDict], Any]) -> Callable:
-    """
-    Hook to react to resume websocket connection event.
-
-    Args:
-        func (Callable[], Any]): The connection hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_resume = wrap_user_function(func, with_task=True)
-    return func
-
-
-@trace
-def set_chat_profiles(
-    func: Callable[[Optional["User"]], List["ChatProfile"]]
-) -> Callable:
-    """
-    Programmatic declaration of the available chat profiles (can depend on the User from the session if authentication is setup).
-
-    Args:
-        func (Callable[[Optional["User"]], List["ChatProfile"]]): The function declaring the chat profiles.
-
-    Returns:
-        Callable[[Optional["User"]], List["ChatProfile"]]: The decorated function.
-    """
-
-    config.code.set_chat_profiles = wrap_user_function(func)
-    return func
-
-
-@trace
-def set_starters(func: Callable[[Optional["User"]], List["Starter"]]) -> Callable:
-    """
-    Programmatic declaration of the available starter (can depend on the User from the session if authentication is setup).
-
-    Args:
-        func (Callable[[Optional["User"]], List["Starter"]]): The function declaring the starters.
-
-    Returns:
-        Callable[[Optional["User"]], List["Starter"]]: The decorated function.
-    """
-
-    config.code.set_starters = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_chat_end(func: Callable) -> Callable:
-    """
-    Hook to react to the user websocket disconnect event.
-
-    Args:
-        func (Callable[], Any]): The disconnect hook to execute.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_chat_end = wrap_user_function(func, with_task=True)
-    return func
-
-
-@trace
-def on_audio_chunk(func: Callable) -> Callable:
-    """
-    Hook to react to the audio chunks being sent.
-
-    Args:
-        chunk (AudioChunk): The audio chunk being sent.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_audio_chunk = wrap_user_function(func, with_task=False)
-    return func
-
-
-@trace
-def on_audio_end(func: Callable) -> Callable:
-    """
-    Hook to react to the audio stream ending. This is called after the last audio chunk is sent.
-
-    Args:
-    elements ([List[Element]): The files that were uploaded before starting the audio stream (if any).
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
+from .callbacks import (
+    action_callback,
+    author_rename,
+    header_auth_callback,
+    oauth_callback,
+    on_audio_chunk,
+    on_audio_end,
+    on_chat_end,
+    on_chat_resume,
+    on_chat_start,
+    on_create_assistant,
+    on_list_assistants,
+    on_logout,
+    on_message,
+    on_settings_update,
+    on_stop,
+    password_auth_callback,
+    set_chat_profiles,
+    set_starters,
+)
 
-    config.code.on_audio_end = wrap_user_function(
-        step(func, name="on_audio_end", type="run"), with_task=True
+if TYPE_CHECKING:
+    from chainlit.haystack.callbacks import HaystackAgentCallbackHandler
+    from chainlit.langchain.callbacks import (
+        AsyncLangchainCallbackHandler,
+        LangchainCallbackHandler,
     )
-    return func
-
-
-@trace
-def author_rename(func: Callable[[str], str]) -> Callable[[str], str]:
-    """
-    Useful to rename the author of message to display more friendly author names in the UI.
-    Args:
-        func (Callable[[str], str]): The function to be called to rename an author. Takes the original author name as parameter.
-
-    Returns:
-        Callable[[Any, str], Any]: The decorated function.
-    """
-
-    config.code.author_rename = wrap_user_function(func)
-    return func
-
-
-@trace
-def on_stop(func: Callable) -> Callable:
-    """
-    Hook to react to the user stopping a thread.
-
-    Args:
-        func (Callable[[], Any]): The stop hook to execute.
-
-    Returns:
-        Callable[[], Any]: The decorated stop hook.
-    """
-
-    config.code.on_stop = wrap_user_function(func)
-    return func
-
-
-def action_callback(name: str) -> Callable:
-    """
-    Callback to call when an action is clicked in the UI.
-
-    Args:
-        func (Callable[[Action], Any]): The action callback to execute. First parameter is the action.
-    """
-
-    def decorator(func: Callable[[Action], Any]):
-        config.code.action_callbacks[name] = wrap_user_function(func, with_task=True)
-        return func
-
-    return decorator
-
-
-def on_settings_update(
-    func: Callable[[Dict[str, Any]], Any]
-) -> Callable[[Dict[str, Any]], Any]:
-    """
-    Hook to react to the user changing any settings.
-
-    Args:
-        func (Callable[], Any]): The hook to execute after settings were changed.
-
-    Returns:
-        Callable[], Any]: The decorated hook.
-    """
-
-    config.code.on_settings_update = wrap_user_function(func, with_task=True)
-    return func
+    from chainlit.llama_index.callbacks import LlamaIndexCallbackHandler
+    from chainlit.mistralai import instrument_mistralai
+    from chainlit.openai import instrument_openai
 
 
 def sleep(duration: int):
@@ -380,6 +115,7 @@ __getattr__ = make_module_getattr(
 )
 
 __all__ = [
+    "__version__",
     "ChatProfile",
     "Starter",
     "user_session",
@@ -402,6 +138,10 @@ __all__ = [
     "TaskStatus",
     "Video",
     "ChatSettings",
+    # Experimental
+    "AssistantSettings",
+    # Experimental
+    "Assistant",
     "input_widget",
     "Message",
     "ErrorMessage",
@@ -421,6 +161,8 @@ __all__ = [
     "action_callback",
     "author_rename",
     "on_settings_update",
+    "on_create_assistant",
+    "on_list_assistants",
     "password_auth_callback",
     "header_auth_callback",
     "sleep",
@@ -434,6 +176,22 @@ __all__ = [
     "HaystackAgentCallbackHandler",
     "instrument_openai",
     "instrument_mistralai",
+    "password_auth_callback",
+    "header_auth_callback",
+    "oauth_callback",
+    "on_logout",
+    "on_message",
+    "on_chat_start",
+    "on_chat_resume",
+    "set_chat_profiles",
+    "set_starters",
+    "on_chat_end",
+    "on_audio_chunk",
+    "on_audio_end",
+    "author_rename",
+    "on_stop",
+    "action_callback",
+    "on_settings_update",
 ]
 
 

chainlit/_utils.py

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

@@ -0,0 +1,16 @@
+from typing import List, Dict
+from chainlit.input_widget import InputWidget
+
+class Assistant:
+    input_widgets: List[InputWidget] = []
+    settings_values: Dict = {}
+
+    def __init__(self, input_widgets: List[InputWidget], settings_values: Dict):
+        self.input_widgets = input_widgets
+        self.settings_values = settings_values
+    
+    def to_dict(self):
+        return {
+            "input_widgets": [widget.__repr__() for widget in self.input_widgets],
+            "settings_values": self.settings_values
+        }

chainlit/assistant_settings.py

@@ -0,0 +1,35 @@
+import logging
+from typing import List
+
+from chainlit.context import context
+from chainlit.input_widget import InputWidget
+from pydantic.dataclasses import Field, dataclass
+
+
+@dataclass
+class AssistantSettings:
+    """Useful to create chat settings that the user can change."""
+
+    inputs: List[InputWidget] = Field(default_factory=list, exclude=True)
+
+    def __init__(
+        self,
+        inputs: List[InputWidget],
+    ) -> None:
+        self.inputs = inputs
+
+    def settings(self):
+        return dict(
+            [(input_widget.id, input_widget.initial) for input_widget in self.inputs]
+        )
+
+    async def send(self):
+        settings = self.settings()
+        context.emitter.set_assistant_settings(settings)
+
+        inputs_content = [input_widget.to_dict() for input_widget in self.inputs]
+        # logging.info(f"Sending assistant settings: {inputs_content}")
+        await context.emitter.emit("assistant_settings", inputs_content)
+
+        # logging.info(f"Assistant settings sent: {settings}")
+        return settings