chainlit 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

chainlit/__init__.py

@@ -1,17 +1,26 @@
 from dotenv import load_dotenv
-from typing import Callable, Any
-import inspect
+from typing import Callable, Any, TYPE_CHECKING
 import os
 import asyncio
 
-from chainlit.lc import LANGCHAIN_INSTALLED
+if TYPE_CHECKING:
+    from chainlit.client.base import BaseClient
+
+from chainlit.lc import (
+    LANGCHAIN_INSTALLED,
+    langchain_factory,
+    langchain_postprocess,
+    langchain_run,
+    langchain_rename,
+)
+from chainlit.llama_index import LLAMA_INDEX_INSTALLED, llama_index_factory
+from chainlit.langflow import langflow_factory
+from chainlit.utils import wrap_user_function
 from chainlit.config import config
 from chainlit.telemetry import trace
 from chainlit.version import __version__
 from chainlit.logger import logger
-from chainlit.emitter import ChainlitEmitter
 from chainlit.types import LLMSettings
-from chainlit.message import ErrorMessage
 from chainlit.action import Action
 from chainlit.element import Image, Text, Pdf, Avatar, Pyplot
 from chainlit.message import Message, ErrorMessage, AskUserMessage, AskFileMessage
@@ -21,8 +30,13 @@ from chainlit.cache import cache
 
 if LANGCHAIN_INSTALLED:
     from chainlit.lc.callbacks import (
-        ChainlitCallbackHandler,
-        AsyncChainlitCallbackHandler,
+        LangchainCallbackHandler,
+        AsyncLangchainCallbackHandler,
+    )
+
+if LLAMA_INDEX_INSTALLED:
+    from chainlit.llama_index.callbacks import (
+        LlamaIndexCallbackHandler,
     )
 
 
@@ -32,94 +46,6 @@ if env_found:
     logger.info("Loaded .env file")
 
 
-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.
-    """
-
-    async def wrapper(*args, __chainlit_emitter__: ChainlitEmitter):
-        # 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 __chainlit_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 InterruptedError:
-            pass
-        except Exception as e:
-            logger.exception(e)
-            await ErrorMessage(content=str(e), author="Error").send()
-        finally:
-            if with_task:
-                await __chainlit_emitter__.task_end()
-
-    return wrapper
-
-
-@trace
-def langchain_factory(use_async: bool) -> Callable:
-    """
-    Plug and play decorator for the LangChain library.
-    The decorated function should instantiate a new LangChain instance (Chain, Agent...).
-    One instance per user session is created and cached.
-    The per user instance is called every time a new message is received.
-
-    Args:
-        use_async bool: Whether to call the the agent asynchronously or not. Defaults to False.
-
-    Returns:
-        Callable[[], Any]: The decorated factory function.
-    """
-
-    # Check if the factory is called with the correct parameter
-    if type(use_async) != bool:
-        error_message = "langchain_factory use_async parameter is required"
-        raise ValueError(error_message)
-
-    def decorator(func: Callable) -> Callable:
-        config.code.lc_factory = wrap_user_function(func, with_task=True)
-        return func
-
-    config.code.lc_agent_is_async = use_async
-
-    return decorator
-
-
-@trace
-def langchain_postprocess(func: Callable[[Any], str]) -> Callable:
-    """
-    Useful to post process the response a LangChain object instantiated with @langchain_factory.
-    The decorated function takes the raw output of the LangChain object as input.
-    The response will NOT be automatically sent to the UI, you need to send a Message.
-
-    Args:
-        func (Callable[[Any], str]): The post-processing function to apply after generating a response. Takes the response as parameter.
-
-    Returns:
-        Callable[[Any], str]: The decorated post-processing function.
-    """
-
-    config.code.lc_postprocess = wrap_user_function(func)
-    return func
-
-
 @trace
 def on_message(func: Callable) -> Callable:
     """
@@ -137,38 +63,6 @@ def on_message(func: Callable) -> Callable:
     return func
 
 
-@trace
-def langchain_run(func: Callable[[Any, str], str]) -> Callable:
-    """
-    Useful to override the default behavior of the LangChain object instantiated with @langchain_factory.
-    Use when your agent run method has custom parameters.
-    Takes the LangChain agent and the user input as parameters.
-    The response will NOT be automatically sent to the UI, you need to send a Message.
-    Args:
-        func (Callable[[Any, str], str]): The function to be called when a new message is received. Takes the agent and user input as parameters and returns the output string.
-
-    Returns:
-        Callable[[Any, str], Any]: The decorated function.
-    """
-    config.code.lc_run = wrap_user_function(func)
-    return func
-
-
-@trace
-def langchain_rename(func: Callable[[str], str]) -> Callable[[str], str]:
-    """
-    Useful to rename the LangChain tools/chains used in the agent and display more friendly author names in the UI.
-    Args:
-        func (Callable[[str], str]): The function to be called to rename a tool/chain. Takes the original tool/chain name as parameter.
-
-    Returns:
-        Callable[[Any, str], Any]: The decorated function.
-    """
-
-    config.code.lc_rename = wrap_user_function(func)
-    return func
-
-
 @trace
 def on_chat_start(func: Callable) -> Callable:
     """
@@ -206,7 +100,7 @@ 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 exexute. First parameter is the action.
+        func (Callable[[Action], Any]): The action callback to execute. First parameter is the action.
     """
 
     def decorator(func: Callable[[Action], Any]):
@@ -216,6 +110,19 @@ def action_callback(name: str) -> Callable:
     return decorator
 
 
+@trace
+def client_factory(func: Callable[[], "BaseClient"]) -> Callable[[], "BaseClient"]:
+    """
+    Callback to call when to initialize the custom client.
+
+    Args:
+        func (Callable[[str], BaseClient]): The action callback to execute. First parameter is the session id.
+    """
+
+    config.code.client_factory = func
+    return func
+
+
 def sleep(duration: int):
     """
     Sleep for a given duration.
@@ -242,12 +149,16 @@ __all__ = [
     "langchain_postprocess",
     "langchain_run",
     "langchain_rename",
+    "llama_index_factory",
+    "langflow_factory",
     "on_chat_start",
     "on_stop",
     "action_callback",
     "sleep",
-    "ChainlitCallbackHandler",
-    "AsyncChainlitCallbackHandler",
+    "LangchainCallbackHandler",
+    "AsyncLangchainCallbackHandler",
+    "LlamaIndexCallbackHandler",
+    "client_factory",
     "run_sync",
     "make_async",
     "cache",

chainlit/action.py

@@ -1,7 +1,7 @@
 from pydantic.dataclasses import dataclass
 from dataclasses_json import dataclass_json
 
-from chainlit.emitter import get_emit_fn
+from chainlit.context import get_emitter
 from chainlit.telemetry import trace_event
 
 
@@ -21,9 +21,7 @@ class Action:
 
     def __post_init__(self) -> None:
         trace_event(f"init {self.__class__.__name__}")
-        self.emit = get_emit_fn()
-        if not self.emit:
-            raise RuntimeError("Action should be instantiated in a Chainlit context")
+        self.emit = get_emitter().emit
 
     async def send(self, for_id: str):
         trace_event(f"send {self.__class__.__name__}")

chainlit/cli/__init__.py

@@ -21,6 +21,7 @@ from chainlit.cli.deploy import deploy
 from chainlit.cli.utils import check_file
 from chainlit.telemetry import trace_event
 from chainlit.cache import init_lc_cache
+from chainlit.db import init_local_db, migrate_local_db
 from chainlit.logger import logger
 from chainlit.server import app
 
@@ -50,6 +51,9 @@ def run_chainlit(target: str):
     # Initialize the LangChain cache if installed and enabled
     init_lc_cache()
 
+    # Initialize the local database if configured to use it
+    init_local_db()
+
     log_level = "debug" if config.run.debug else "error"
 
     # Start the server
@@ -60,26 +64,69 @@ def run_chainlit(target: str):
 
     # Run the asyncio event loop instead of uvloop to enable re entrance
     asyncio.run(start())
-    # uvicorn.run(app, host=host, port=port)
+    # uvicorn.run(app, host=host, port=port, log_level=log_level)
 
 
 # Define the "run" command for Chainlit CLI
 @cli.command("run")
 @click.argument("target", required=True, envvar="RUN_TARGET")
-@click.option("-w", "--watch", default=False, is_flag=True, envvar="WATCH")
-@click.option("-h", "--headless", default=False, is_flag=True, envvar="HEADLESS")
-@click.option("-d", "--debug", default=False, is_flag=True, envvar="DEBUG")
-@click.option("-c", "--ci", default=False, is_flag=True, envvar="CI")
-@click.option("--no-cache", default=False, is_flag=True, envvar="NO_CACHE")
-@click.option("--host")
-@click.option("--port")
-def chainlit_run(target, watch, headless, debug, ci, no_cache, host, port):
+@click.option(
+    "-w",
+    "--watch",
+    default=False,
+    is_flag=True,
+    envvar="WATCH",
+    help="Reload the app when the module changes",
+)
+@click.option(
+    "-h",
+    "--headless",
+    default=False,
+    is_flag=True,
+    envvar="HEADLESS",
+    help="Will prevent to auto open the app in the browser",
+)
+@click.option(
+    "-d",
+    "--debug",
+    default=False,
+    is_flag=True,
+    envvar="DEBUG",
+    help="Set the log level to debug",
+)
+@click.option(
+    "-c",
+    "--ci",
+    default=False,
+    is_flag=True,
+    envvar="CI",
+    help="Flag to run in CI mode",
+)
+@click.option(
+    "--no-cache",
+    default=False,
+    is_flag=True,
+    envvar="NO_CACHE",
+    help="Useful to disable third parties cache, such as langchain.",
+)
+@click.option(
+    "--db",
+    type=click.Choice(["cloud", "local"]),
+    help="Useful to control database mode when running CI.",
+)
+@click.option("--host", help="Specify a different host to run the server on")
+@click.option("--port", help="Specify a different port to run the server on")
+def chainlit_run(target, watch, headless, debug, ci, no_cache, db, host, port):
     if host:
         os.environ["CHAINLIT_HOST"] = host
     if port:
         os.environ["CHAINLIT_PORT"] = port
     if ci:
         logger.info("Running in CI mode")
+
+        if db:
+            config.project.database = db
+
         config.project.enable_telemetry = False
         no_cache = True
         from chainlit.cli.mock import mock_openai
@@ -131,6 +178,14 @@ def chainlit_logout(args=None, **kwargs):
     sys.exit(0)
 
 
+@cli.command("migrate")
+@click.argument("args", nargs=-1)
+def chainlit_migrate(args=None, **kwargs):
+    trace_event("chainlit migrate")
+    migrate_local_db()
+    sys.exit(0)
+
+
 @cli.command("init")
 @click.argument("args", nargs=-1)
 def chainlit_init(args=None, **kwargs):