chainlit 0.2.110__tar.gz → 0.3.0__tar.gz

{chainlit-0.2.110 → chainlit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 0.2.110
+Version: 0.3.0
 Summary: A faster way to build chatbot UIs.
 Home-page: https://github.com/Chainlit/chainlit
 License: Apache-2.0 license
@@ -13,23 +13,24 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: aiofiles (>=23.1.0,<24.0.0)
+Requires-Dist: aiohttp (>=3.8.4,<4.0.0)
+Requires-Dist: asyncer (>=0.0.2,<0.0.3)
 Requires-Dist: auth0-python (>=4.1.1,<5.0.0)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: dataclasses_json (>=0.5.7,<0.6.0)
-Requires-Dist: flask_cors (>=3.0.10,<4.0.0)
-Requires-Dist: flask_socketio (>=5.3.3,<6.0.0)
-Requires-Dist: gevent (>=22.10.2,<23.0.0)
-Requires-Dist: gevent_websocket (>=0.10.1,<0.11.0)
-Requires-Dist: openai (>=0.27.2,<0.28.0)
-Requires-Dist: pydantic (>=1.10.6,<2.0.0)
+Requires-Dist: fastapi (>=0.96.0,<0.97.0)
+Requires-Dist: fastapi-socketio (>=0.0.10,<0.0.11)
+Requires-Dist: nest-asyncio (>=1.5.6,<2.0.0)
+Requires-Dist: openai (>=0.27.7,<0.28.0)
+Requires-Dist: pydantic (>=1.10.8,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-graphql-client (>=0.4.3,<0.5.0)
+Requires-Dist: syncer (>=2.0.3,<3.0.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
-Requires-Dist: typing-inspect (==0.8.0)
-Requires-Dist: typing_extensions (==4.5.0)
 Requires-Dist: uptrace (>=1.18.0,<2.0.0)
-Requires-Dist: watchdog (>=3.0.0,<4.0.0)
-Requires-Dist: watchdog_gevent (>=0.1.1,<0.2.0)
+Requires-Dist: uvicorn (>=0.22.0,<0.23.0)
+Requires-Dist: watchfiles (>=0.19.0,<0.20.0)
 Project-URL: Repository, https://github.com/Chainlit/chainlit
 Description-Content-Type: text/markdown
 
@@ -72,12 +73,12 @@ import chainlit as cl
 
 
 @cl.on_message  # this function will be called every time a user inputs a message in the UI
-def main(message: str):
+async def main(message: str):
     # this is an intermediate step
-    cl.Message(author="Tool 1", content=f"Response from tool1", indent=1).send()
+    await cl.Message(author="Tool 1", content=f"Response from tool1", indent=1).send()
 
     # send back the final answer
-    cl.Message(content=f"This is the final answer").send()
+    await cl.Message(content=f"This is the final answer").send()
 ```
 
 Now run it!

{chainlit-0.2.110 → chainlit-0.3.0}/README.md

@@ -37,12 +37,12 @@ import chainlit as cl
 
 
 @cl.on_message  # this function will be called every time a user inputs a message in the UI
-def main(message: str):
+async def main(message: str):
     # this is an intermediate step
-    cl.Message(author="Tool 1", content=f"Response from tool1", indent=1).send()
+    await cl.Message(author="Tool 1", content=f"Response from tool1", indent=1).send()
 
     # send back the final answer
-    cl.Message(content=f"This is the final answer").send()
+    await cl.Message(content=f"This is the final answer").send()
 ```
 
 Now run it!

{chainlit-0.2.110 → chainlit-0.3.0}/chainlit/__init__.py

@@ -1,28 +1,28 @@
-import gevent
-from gevent import monkey
-
-monkey.patch_all()
-
-from chainlit.lc import monkey
-
-monkey.patch()
+from dotenv import load_dotenv
+from typing import Callable, Any
+import inspect
+import os
+import asyncio
 
+from chainlit.lc import LANGCHAIN_INSTALLED
 from chainlit.config import config
 from chainlit.telemetry import trace
 from chainlit.version import __version__
 from chainlit.logger import logger
-from chainlit.server import socketio
-from chainlit.sdk import get_sdk
+from chainlit.emitter import ChainlitEmitter
 from chainlit.types import LLMSettings
 from chainlit.message import ErrorMessage
 from chainlit.action import Action
-from chainlit.element import LocalImage, RemoteImage, Text, Pdf
+from chainlit.element import Image, Text, Pdf, Avatar
 from chainlit.message import Message, ErrorMessage, AskUserMessage, AskFileMessage
 from chainlit.user_session import user_session
-from typing import Callable, Any
-from dotenv import load_dotenv
-import inspect
-import os
+from chainlit.sync import run_sync, make_async
+
+if LANGCHAIN_INSTALLED:
+    from chainlit.lc.callbacks import (
+        ChainlitCallbackHandler,
+        AsyncChainlitCallbackHandler,
+    )
 
 
 env_found = load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
@@ -42,8 +42,7 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
         Callable: The wrapped function.
     """
 
-    def wrapper(*args):
-        sdk = get_sdk()
+    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())
 
@@ -52,25 +51,29 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
             param_name: arg for param_name, arg in zip(user_function_params, args)
         }
 
-        if with_task and sdk:
-            sdk.task_start()
+        if with_task:
+            await __chainlit_emitter__.task_start()
 
         try:
             # Call the user-defined function with the arguments
-            return user_function(**params_values)
+            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)
-            if sdk:
-                ErrorMessage(content=str(e), author="Error").send()
+            await ErrorMessage(content=str(e), author="Error").send()
         finally:
-            if with_task and sdk:
-                sdk.task_end()
+            if with_task:
+                await __chainlit_emitter__.task_end()
 
     return wrapper
 
 
 @trace
-def langchain_factory(func: Callable) -> Callable:
+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...).
@@ -78,14 +81,24 @@ def langchain_factory(func: Callable) -> Callable:
     The per user instance is called every time a new message is received.
 
     Args:
-        func (Callable[[], Any]): The factory function to create a new LangChain instance.
+        use_async bool: Whether to call the the agent asynchronously or not. Defaults to False.
 
     Returns:
         Callable[[], Any]: The decorated factory function.
     """
 
-    config.lc_factory = wrap_user_function(func, with_task=True)
-    return func
+    # 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.lc_factory = wrap_user_function(func, with_task=True)
+        return func
+
+    config.lc_agent_is_async = use_async
+
+    return decorator
 
 
 @trace
@@ -136,7 +149,6 @@ def langchain_run(func: Callable[[Any, str], str]) -> Callable:
     Returns:
         Callable[[Any, str], Any]: The decorated function.
     """
-
     config.lc_run = wrap_user_function(func)
     return func
 
@@ -209,7 +221,7 @@ def sleep(duration: int):
     Args:
         duration (int): The duration in seconds.
     """
-    return socketio.sleep(duration)
+    return asyncio.sleep(duration)
 
 
 __all__ = [
@@ -217,9 +229,9 @@ __all__ = [
     "LLMSettings",
     "Action",
     "Pdf",
-    "LocalImage",
-    "RemoteImage",
+    "Image",
     "Text",
+    "Avatar",
     "Message",
     "ErrorMessage",
     "AskUserMessage",
@@ -232,4 +244,8 @@ __all__ = [
     "on_stop",
     "action_callback",
     "sleep",
+    "ChainlitCallbackHandler",
+    "AsyncChainlitCallbackHandler",
+    "run_sync",
+    "make_async",
 ]

{chainlit-0.2.110 → chainlit-0.3.0}/chainlit/action.py

@@ -1,6 +1,7 @@
 from pydantic.dataclasses import dataclass
 from dataclasses_json import dataclass_json
-from chainlit.sdk import get_emit
+
+from chainlit.emitter import get_emit_fn
 from chainlit.telemetry import trace_event
 
 
@@ -20,16 +21,15 @@ 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")
 
-    def send(self, for_id: str):
-        emit = get_emit()
-        if emit:
-            trace_event(f"send {self.__class__.__name__}")
-            self.forId = for_id
-            emit("action", self.to_dict())
+    async def send(self, for_id: str):
+        trace_event(f"send {self.__class__.__name__}")
+        self.forId = for_id
+        await self.emit("action", self.to_dict())
 
-    def remove(self):
-        emit = get_emit()
-        if emit:
-            trace_event(f"remove {self.__class__.__name__}")
-            emit("remove_action", self.to_dict())
+    async def remove(self):
+        trace_event(f"remove {self.__class__.__name__}")
+        await self.emit("remove_action", self.to_dict())

chainlit-0.3.0/chainlit/cache.py

@@ -0,0 +1,20 @@
+import os
+
+from chainlit.config import config
+from chainlit.logger import logger
+from chainlit.lc import LANGCHAIN_INSTALLED
+
+
+def init_lc_cache():
+    use_cache = (
+        config.run_settings.no_cache is False and config.run_settings.ci is False
+    )
+
+    if LANGCHAIN_INSTALLED and use_cache:
+        import langchain
+        from langchain.cache import SQLiteCache
+
+        if config.lc_cache_path:
+            langchain.llm_cache = SQLiteCache(database_path=config.lc_cache_path)
+            if not os.path.exists(config.lc_cache_path):
+                logger.info(f"LangChain cache enabled: {config.lc_cache_path}")

{chainlit-0.2.110 → chainlit-0.3.0}/chainlit/cli/__init__.py

@@ -1,15 +1,28 @@
 import click
 import os
 import sys
-import webbrowser
-from chainlit.config import config, init_config, load_module
-from chainlit.watch import watch_directory
+import uvicorn
+import asyncio
+import nest_asyncio
+
+nest_asyncio.apply()
+
+from chainlit.config import (
+    config,
+    init_config,
+    load_module,
+    PACKAGE_ROOT,
+    DEFAULT_HOST,
+    DEFAULT_PORT,
+)
 from chainlit.markdown import init_markdown
 from chainlit.cli.auth import login, logout
 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.logger import logger
+from chainlit.server import app
 
 
 # Create the main command group for Chainlit CLI
@@ -20,11 +33,11 @@ def cli():
 
 
 # Define the function to run Chainlit with provided options
-def run_chainlit(target: str, watch=False, headless=False, debug=False):
-    DEFAULT_HOST = "0.0.0.0"
-    DEFAULT_PORT = 8000
+def run_chainlit(target: str):
     host = os.environ.get("CHAINLIT_HOST", DEFAULT_HOST)
     port = int(os.environ.get("CHAINLIT_PORT", DEFAULT_PORT))
+    config.run_settings.host = host
+    config.run_settings.port = port
 
     check_file(target)
     # Load the module provided by the user
@@ -34,28 +47,20 @@ def run_chainlit(target: str, watch=False, headless=False, debug=False):
     # Create the chainlit.md file if it doesn't exist
     init_markdown(config.root)
 
-    # Enable file watching if the user specified it
-    if watch:
-        watch_directory()
+    # Initialize the LangChain cache if installed and enabled
+    init_lc_cache()
 
-    from chainlit.server import socketio, app
+    log_level = "debug" if config.run_settings.debug else "error"
 
-    # Open the browser if in development mode
-    def open_browser(headless: bool):
-        if not headless:
-            if host == DEFAULT_HOST:
-                url = f"http://localhost:{port}"
-            else:
-                url = f"http://{host}:{port}"
-            # Wait two seconds to allow the server to start
-            socketio.sleep(2)
-
-            logger.info(f"Your app is available at {url}")
-            webbrowser.open(url)
-
-    socketio.start_background_task(open_browser, headless)
     # Start the server
-    socketio.run(app, host=host, port=port, debug=debug, use_reloader=False)
+    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)
 
 
 # Define the "run" command for Chainlit CLI
@@ -65,9 +70,10 @@ def run_chainlit(target: str, watch=False, headless=False, debug=False):
 @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, host, port):
+def chainlit_run(target, watch, headless, debug, ci, no_cache, host, port):
     if host:
         os.environ["CHAINLIT_HOST"] = host
     if port:
@@ -75,10 +81,21 @@ def chainlit_run(target, watch, headless, debug, ci, host, port):
     if ci:
         logger.info("Running in CI mode")
         config.enable_telemetry = False
+        no_cache = True
+        from chainlit.cli.mock import mock_openai
+
+        mock_openai()
+
     else:
         trace_event("chainlit run")
 
-    run_chainlit(target, watch, headless, debug)
+    config.run_settings.headless = headless
+    config.run_settings.debug = debug
+    config.run_settings.no_cache = no_cache
+    config.run_settings.ci = ci
+    config.run_settings.watch = watch
+
+    run_chainlit(target)
 
 
 @cli.command("deploy")
@@ -94,8 +111,7 @@ def chainlit_deploy(target, args=None, **kwargs):
 @click.argument("args", nargs=-1)
 def chainlit_hello(args=None, **kwargs):
     trace_event("chainlit hello")
-    dir_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-    hello_path = os.path.join(dir_path, "hello.py")
+    hello_path = os.path.join(PACKAGE_ROOT, "hello.py")
     run_chainlit(hello_path)
 
 

chainlit-0.3.0/chainlit/cli/mock.py

@@ -0,0 +1,48 @@
+def mock_openai():
+    import os
+    from aioresponses import aioresponses
+    import responses
+
+    # Mock the openai api key
+    os.environ["OPENAI_API_KEY"] = "sk-FAKE-OPENAI-API-KEY"
+
+    mocked_json_reply = {
+        "id": "cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7",
+        "object": "text_completion",
+        "created": 1589478378,
+        "model": "text-davinci-003",
+        "choices": [
+            {
+                "text": "\n\n```text\n3*3\n```",
+                "index": 0,
+                "logprobs": None,
+                "finish_reason": "length",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": 5,
+            "completion_tokens": 7,
+            "total_tokens": 12,
+        },
+    }
+
+    # Mock the sync openai api
+
+    responses.start()
+
+    responses.add(
+        responses.POST,
+        "https://api.openai.com/v1/completions",
+        json=mocked_json_reply,
+    )
+
+    # Mock the async openai api
+    aioresponses_obj = aioresponses()
+
+    aioresponses_obj.start()
+
+    aioresponses_obj.add(
+        url="https://api.openai.com/v1/completions",
+        method="POST",
+        payload=mocked_json_reply,
+    )