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

chainlit/__init__.py

@@ -1,31 +1,42 @@
 from dotenv import load_dotenv
 from typing import Callable, Any, TYPE_CHECKING
-import inspect
 import os
 import asyncio
 
 if TYPE_CHECKING:
     from chainlit.client.base import BaseClient
 
-from chainlit.lc import LANGCHAIN_INSTALLED
+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.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
 from chainlit.user_session import user_session
 from chainlit.sync import run_sync, make_async
 from chainlit.cache import cache
-from chainlit.context import get_emitter
 
 if LANGCHAIN_INSTALLED:
     from chainlit.lc.callbacks import (
-        ChainlitCallbackHandler,
-        AsyncChainlitCallbackHandler,
+        LangchainCallbackHandler,
+        AsyncLangchainCallbackHandler,
+    )
+
+if LLAMA_INDEX_INSTALLED:
+    from chainlit.llama_index.callbacks import (
+        LlamaIndexCallbackHandler,
     )
 
 
@@ -35,98 +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):
-        # 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)
-        }
-
-        emitter = get_emitter()
-
-        if with_task:
-            await 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) or e.__class__.__name__, author="Error"
-            ).send()
-        finally:
-            if with_task:
-                await 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:
     """
@@ -144,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:
     """
@@ -262,12 +149,15 @@ __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",

chainlit/cli/__init__.py

@@ -2,6 +2,10 @@ import click
 import os
 import sys
 import uvicorn
+import asyncio
+import nest_asyncio
+
+nest_asyncio.apply()
 
 from chainlit.config import (
     config,
@@ -52,7 +56,15 @@ def run_chainlit(target: str):
 
     log_level = "debug" if config.run.debug else "error"
 
-    uvicorn.run(app, host=host, port=port, log_level=log_level)
+    # Start the server
+    async def start():
+        config = uvicorn.Config(app, host=host, port=port, log_level=log_level)
+        server = uvicorn.Server(config)
+        await server.serve()
+
+    # Run the asyncio event loop instead of uvloop to enable re entrance
+    asyncio.run(start())
+    # uvicorn.run(app, host=host, port=port, log_level=log_level)
 
 
 # Define the "run" command for Chainlit CLI