chainlit 1.1.404__tar.gz → 1.2.0__tar.gz

{chainlit-1.1.404 → chainlit-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 1.1.404
+Version: 1.2.0
 Summary: Build Conversational AI.
 Home-page: https://github.com/Chainlit/chainlit
 License: Apache-2.0 license
@@ -16,8 +16,8 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: aiofiles (>=23.1.0,<24.0.0)
 Requires-Dist: asyncer (>=0.0.7,<0.0.8)
 Requires-Dist: click (>=8.1.3,<9.0.0)
-Requires-Dist: dataclasses_json (>=0.5.7,<0.6.0)
-Requires-Dist: fastapi (>=0.110.1,<0.111.0)
+Requires-Dist: dataclasses_json (>=0.6.7,<0.7.0)
+Requires-Dist: fastapi (>=0.110.1,<0.113)
 Requires-Dist: filetype (>=1.2.0,<2.0.0)
 Requires-Dist: httpx (>=0.23.0)
 Requires-Dist: lazify (>=0.4.0,<0.5.0)

chainlit-1.2.0/chainlit/__init__.py

@@ -0,0 +1,189 @@
+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"))
+
+from chainlit.logger import logger
+
+if env_found:
+    logger.info("Loaded .env file")
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Dict
+
+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,
+    Component,
+    File,
+    Image,
+    Pdf,
+    Plotly,
+    Pyplot,
+    Task,
+    TaskList,
+    TaskStatus,
+    Text,
+    Video,
+)
+from chainlit.message import (
+    AskActionMessage,
+    AskFileMessage,
+    AskUserMessage,
+    ErrorMessage,
+    Message,
+)
+from chainlit.step import Step, step
+from chainlit.sync import make_async, run_sync
+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
+from chainlit.version import __version__
+from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
+from pydantic.dataclasses import dataclass
+
+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_logout,
+    on_message,
+    on_settings_update,
+    on_stop,
+    password_auth_callback,
+    set_chat_profiles,
+    set_starters,
+)
+
+if TYPE_CHECKING:
+    from chainlit.haystack.callbacks import HaystackAgentCallbackHandler
+    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
+
+
+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",
+        "HaystackAgentCallbackHandler": "chainlit.haystack.callbacks",
+        "instrument_openai": "chainlit.openai",
+        "instrument_mistralai": "chainlit.mistralai",
+    }
+)
+
+__all__ = [
+    "__version__",
+    "ChatProfile",
+    "Starter",
+    "user_session",
+    "chat_context",
+    "CopilotFunction",
+    "AudioChunk",
+    "Action",
+    "User",
+    "PersistedUser",
+    "Audio",
+    "Pdf",
+    "Plotly",
+    "Image",
+    "Text",
+    "Component",
+    "Pyplot",
+    "File",
+    "Task",
+    "TaskList",
+    "TaskStatus",
+    "Video",
+    "ChatSettings",
+    "input_widget",
+    "Message",
+    "ErrorMessage",
+    "AskUserMessage",
+    "AskActionMessage",
+    "AskFileMessage",
+    "Step",
+    "step",
+    "ChatGeneration",
+    "CompletionGeneration",
+    "GenerationMessage",
+    "on_logout",
+    "on_chat_start",
+    "on_chat_end",
+    "on_chat_resume",
+    "on_stop",
+    "action_callback",
+    "author_rename",
+    "on_settings_update",
+    "password_auth_callback",
+    "header_auth_callback",
+    "sleep",
+    "run_sync",
+    "make_async",
+    "cache",
+    "context",
+    "LangchainCallbackHandler",
+    "AsyncLangchainCallbackHandler",
+    "LlamaIndexCallbackHandler",
+    "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",
+]
+
+
+def __dir__():
+    return __all__

chainlit-1.2.0/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-1.1.404/chainlit/__init__.py → chainlit-1.2.0/chainlit/callbacks.py

@@ -1,85 +1,35 @@
 import inspect
-import os
+from typing import Any, Awaitable, Callable, Dict, List, Optional
 
-from dotenv import load_dotenv
-
-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 fastapi import Request, Response
-from pydantic.dataclasses import dataclass
-from starlette.datastructures import Headers
-
-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 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.config import config
-from chainlit.context import context
-from chainlit.element import (
-    Audio,
-    Component,
-    File,
-    Image,
-    Pdf,
-    Plotly,
-    Pyplot,
-    Task,
-    TaskList,
-    TaskStatus,
-    Text,
-    Video,
-)
-from chainlit.logger import logger
-from chainlit.message import (
-    AskActionMessage,
-    AskFileMessage,
-    AskUserMessage,
-    ErrorMessage,
-    Message,
-)
+from chainlit.message import 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.user import PersistedUser, User
-from chainlit.user_session import user_session
-from chainlit.utils import make_module_getattr, wrap_user_function
-from chainlit.version import __version__
-from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
-
-if env_found:
-    logger.info("Loaded .env file")
+from chainlit.types import ChatProfile, Starter, ThreadDict
+from chainlit.user import User
+from chainlit.utils import wrap_user_function
+from fastapi import Request, Response
+from starlette.datastructures import Headers
 
 
 @trace
-def password_auth_callback(func: Callable[[str, str], Optional[User]]) -> Callable:
+def password_auth_callback(
+    func: Callable[[str, str], Awaitable[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.
+        func (Callable[[str, str], Awaitable[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.
+        Callable[[str, str], Awaitable[Optional[User]]]: The decorated authentication callback.
     """
 
     config.code.password_auth_callback = wrap_user_function(func)
@@ -87,19 +37,21 @@ def password_auth_callback(func: Callable[[str, str], Optional[User]]) -> Callab
 
 
 @trace
-def header_auth_callback(func: Callable[[Headers], Optional[User]]) -> Callable:
+def header_auth_callback(
+    func: Callable[[Headers], Awaitable[Optional[User]]]
+) -> Callable:
     """
     Framework agnostic decorator to authenticate the user via a header
 
     Args:
-        func (Callable[[Headers], Optional[User]]): The authentication callback to execute.
+        func (Callable[[Headers], Awaitable[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.
+        Callable[[Headers], Awaitable[Optional[User]]]: The decorated authentication callback.
     """
 
     config.code.header_auth_callback = wrap_user_function(func)
@@ -108,20 +60,22 @@ def header_auth_callback(func: Callable[[Headers], Optional[User]]) -> Callable:
 
 @trace
 def oauth_callback(
-    func: Callable[[str, str, Dict[str, str], User], Optional[User]]
+    func: Callable[
+        [str, str, Dict[str, str], User, Optional[str]], Awaitable[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.
+        func (Callable[[str, str, Dict[str, str], User, Optional[str]], Awaitable[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.
+        Callable[[str, str, Dict[str, str], User, Optional[str]], Awaitable[Optional[User]]]: The decorated authentication callback.
     """
 
     if len(get_configured_oauth_providers()) == 0:
@@ -205,16 +159,16 @@ def on_chat_resume(func: Callable[[ThreadDict], Any]) -> Callable:
 
 @trace
 def set_chat_profiles(
-    func: Callable[[Optional["User"]], List["ChatProfile"]]
+    func: Callable[[Optional["User"]], Awaitable[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.
+        func (Callable[[Optional["User"]], Awaitable[List["ChatProfile"]]]): The function declaring the chat profiles.
 
     Returns:
-        Callable[[Optional["User"]], List["ChatProfile"]]: The decorated function.
+        Callable[[Optional["User"]], Awaitable[List["ChatProfile"]]]: The decorated function.
     """
 
     config.code.set_chat_profiles = wrap_user_function(func)
@@ -222,15 +176,17 @@ def set_chat_profiles(
 
 
 @trace
-def set_starters(func: Callable[[Optional["User"]], List["Starter"]]) -> Callable:
+def set_starters(
+    func: Callable[[Optional["User"]], Awaitable[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.
+        func (Callable[[Optional["User"]], Awaitable[List["Starter"]]]): The function declaring the starters.
 
     Returns:
-        Callable[[Optional["User"]], List["Starter"]]: The decorated function.
+        Callable[[Optional["User"]], Awaitable[List["Starter"]]]: The decorated function.
     """
 
     config.code.set_starters = wrap_user_function(func)
@@ -288,14 +244,16 @@ def on_audio_end(func: Callable) -> Callable:
 
 
 @trace
-def author_rename(func: Callable[[str], str]) -> Callable[[str], str]:
+def author_rename(
+    func: Callable[[str], Awaitable[str]]
+) -> Callable[[str], Awaitable[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.
+        func (Callable[[str], Awaitable[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.
+        Callable[[Any, str], Awaitable[Any]]: The decorated function.
     """
 
     config.code.author_rename = wrap_user_function(func)
@@ -334,7 +292,7 @@ def action_callback(name: str) -> Callable:
 
 
 def on_settings_update(
-    func: Callable[[Dict[str, Any]], Any]
+    func: Callable[[Dict[str, Any]], Any],
 ) -> Callable[[Dict[str, Any]], Any]:
     """
     Hook to react to the user changing any settings.
@@ -348,94 +306,3 @@ def on_settings_update(
 
     config.code.on_settings_update = wrap_user_function(func, with_task=True)
     return func
-
-
-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",
-        "HaystackAgentCallbackHandler": "chainlit.haystack.callbacks",
-        "instrument_openai": "chainlit.openai",
-        "instrument_mistralai": "chainlit.mistralai",
-    }
-)
-
-__all__ = [
-    "ChatProfile",
-    "Starter",
-    "user_session",
-    "chat_context",
-    "CopilotFunction",
-    "AudioChunk",
-    "Action",
-    "User",
-    "PersistedUser",
-    "Audio",
-    "Pdf",
-    "Plotly",
-    "Image",
-    "Text",
-    "Component",
-    "Pyplot",
-    "File",
-    "Task",
-    "TaskList",
-    "TaskStatus",
-    "Video",
-    "ChatSettings",
-    "input_widget",
-    "Message",
-    "ErrorMessage",
-    "AskUserMessage",
-    "AskActionMessage",
-    "AskFileMessage",
-    "Step",
-    "step",
-    "ChatGeneration",
-    "CompletionGeneration",
-    "GenerationMessage",
-    "on_logout",
-    "on_chat_start",
-    "on_chat_end",
-    "on_chat_resume",
-    "on_stop",
-    "action_callback",
-    "author_rename",
-    "on_settings_update",
-    "password_auth_callback",
-    "header_auth_callback",
-    "sleep",
-    "run_sync",
-    "make_async",
-    "cache",
-    "context",
-    "LangchainCallbackHandler",
-    "AsyncLangchainCallbackHandler",
-    "LlamaIndexCallbackHandler",
-    "HaystackAgentCallbackHandler",
-    "instrument_openai",
-    "instrument_mistralai",
-]
-
-
-def __dir__():
-    return __all__

{chainlit-1.1.404 → chainlit-1.2.0}/chainlit/config.py

@@ -4,7 +4,17 @@ import site
 import sys
 from importlib import util
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+)
 
 import tomli
 from chainlit.logger import logger
@@ -14,6 +24,8 @@ from dataclasses_json import DataClassJsonMixin
 from pydantic.dataclasses import Field, dataclass
 from starlette.datastructures import Headers
 
+from ._utils import is_path_inside
+
 if TYPE_CHECKING:
     from chainlit.action import Action
     from chainlit.element import ElementBased
@@ -270,10 +282,14 @@ 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
@@ -284,12 +300,14 @@ class CodeSettings:
     on_audio_chunk: Optional[Callable[["AudioChunk"], Any]] = None
     on_audio_end: Optional[Callable[[List["ElementBased"]], Any]] = None
 
-    author_rename: Optional[Callable[[str], str]] = 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"]]] = (
-        None
-    )
-    set_starters: Optional[Callable[[Optional["User"]], List["Starter"]]] = None
+    set_chat_profiles: Optional[
+        Callable[[Optional["User"]], Awaitable[List["ChatProfile"]]]
+    ] = None
+    set_starters: Optional[
+        Callable[[Optional["User"]], Awaitable[List["Starter"]]]
+    ] = None
 
 
 @dataclass()
@@ -327,33 +345,41 @@ class ChainlitConfig:
         # 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"
-        )
-        translation_lib_parent_language_file_path = os.path.join(
-            config_translation_dir, f"{parent_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(translation_lib_parent_language_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}."
             )
-            with open(
-                translation_lib_parent_language_file_path, "r", encoding="utf-8"
-            ) as f:
-                translation = json.load(f)
-        elif os.path.exists(default_translation_lib_file_path):
+            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