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

chainlit/__init__.py

@@ -1,15 +1,17 @@
 from dotenv import load_dotenv
-from typing import Callable, Any
+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.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
@@ -17,6 +19,8 @@ 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 (
@@ -42,7 +46,7 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
         Callable: The wrapped function.
     """
 
-    async def wrapper(*args, __chainlit_emitter__: ChainlitEmitter):
+    async def wrapper(*args):
         # Get the parameter names of the user-defined function
         user_function_params = list(inspect.signature(user_function).parameters.keys())
 
@@ -51,8 +55,10 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
             param_name: arg for param_name, arg in zip(user_function_params, args)
         }
 
+        emitter = get_emitter()
+
         if with_task:
-            await __chainlit_emitter__.task_start()
+            await emitter.task_start()
 
         try:
             # Call the user-defined function with the arguments
@@ -64,10 +70,12 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
             pass
         except Exception as e:
             logger.exception(e)
-            await ErrorMessage(content=str(e), author="Error").send()
+            await ErrorMessage(
+                content=str(e) or e.__class__.__name__, author="Error"
+            ).send()
         finally:
             if with_task:
-                await __chainlit_emitter__.task_end()
+                await emitter.task_end()
 
     return wrapper
 
@@ -205,7 +213,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]):
@@ -215,6 +223,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.
@@ -247,6 +268,8 @@ __all__ = [
     "sleep",
     "ChainlitCallbackHandler",
     "AsyncChainlitCallbackHandler",
+    "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/cache.py

@@ -1,4 +1,5 @@
 import os
+import threading
 
 from chainlit.config import config
 from chainlit.logger import logger
@@ -12,7 +13,7 @@ def init_lc_cache():
         import langchain
         from langchain.cache import SQLiteCache
 
-        if config.project.lc_cache_path is None:
+        if config.project.lc_cache_path is not None:
             langchain.llm_cache = SQLiteCache(
                 database_path=config.project.lc_cache_path
             )
@@ -20,3 +21,25 @@ def init_lc_cache():
                 logger.info(
                     f"LangChain cache created at: {config.project.lc_cache_path}"
                 )
+
+
+_cache = {}
+_cache_lock = threading.Lock()
+
+
+def cache(func):
+    def wrapper(*args, **kwargs):
+        # Create a cache key based on the function name, arguments, and keyword arguments
+        cache_key = (
+            (func.__name__,) + args + tuple((k, v) for k, v in sorted(kwargs.items()))
+        )
+
+        with _cache_lock:
+            # Check if the result is already in the cache
+            if cache_key not in _cache:
+                # If not, call the function and store the result in the cache
+                _cache[cache_key] = func(*args, **kwargs)
+
+        return _cache[cache_key]
+
+    return wrapper

chainlit/cli/__init__.py

@@ -2,10 +2,6 @@ import click
 import os
 import sys
 import uvicorn
-import asyncio
-import nest_asyncio
-
-nest_asyncio.apply()
 
 from chainlit.config import (
     config,
@@ -21,6 +17,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,36 +47,74 @@ def run_chainlit(target: str):
     # Initialize the LangChain cache if installed and enabled
     init_lc_cache()
 
-    log_level = "debug" if config.run.debug else "error"
+    # Initialize the local database if configured to use it
+    init_local_db()
 
-    # 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()
+    log_level = "debug" if config.run.debug else "error"
 
-    # 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 +166,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):

chainlit/client/base.py

@@ -0,0 +1,152 @@
+from typing import (
+    Dict,
+    Any,
+    List,
+    TypedDict,
+    Optional,
+    Union,
+    Literal,
+    TypeVar,
+    Generic,
+)
+
+from abc import ABC, abstractmethod
+from pydantic.dataclasses import dataclass
+from dataclasses_json import dataclass_json
+
+from chainlit.types import (
+    Pagination,
+    ConversationFilter,
+    ElementType,
+    ElementSize,
+    ElementDisplay,
+)
+
+
+class MessageDict(TypedDict):
+    conversationId: Optional[str]
+    id: Optional[int]
+    tempId: Optional[str]
+    createdAt: Optional[int]
+    content: str
+    author: str
+    prompt: Optional[str]
+    llmSettings: Dict
+    language: Optional[str]
+    indent: Optional[int]
+    authorIsUser: Optional[bool]
+    waitForAnswer: Optional[bool]
+    isError: Optional[bool]
+    humanFeedback: Optional[int]
+
+
+class UserDict(TypedDict):
+    name: str
+    email: str
+    role: str
+
+
+class ElementDict(TypedDict):
+    id: Optional[int]
+    conversationId: Optional[int]
+    type: ElementType
+    url: str
+    name: str
+    display: ElementDisplay
+    size: ElementSize
+    language: str
+    forIds: Optional[List[Union[str, int]]]
+
+
+class ConversationDict(TypedDict):
+    id: Optional[int]
+    createdAt: Optional[int]
+    elementCount: Optional[int]
+    messageCount: Optional[int]
+    author: Optional[UserDict]
+    messages: List[MessageDict]
+    elements: Optional[List[ElementDict]]
+
+
+@dataclass
+class PageInfo:
+    hasNextPage: bool
+    endCursor: Any
+
+
+T = TypeVar("T")
+
+
+@dataclass_json
+@dataclass
+class PaginatedResponse(Generic[T]):
+    pageInfo: PageInfo
+    data: List[T]
+
+
+class BaseClient(ABC):
+    project_id: str
+
+    @abstractmethod
+    async def is_project_member(self, access_token: str) -> bool:
+        pass
+
+    @abstractmethod
+    async def get_member_role(self, access_token: str) -> str:
+        pass
+
+    @abstractmethod
+    async def get_project_members(self) -> List[UserDict]:
+        pass
+
+    @abstractmethod
+    async def create_conversation(self) -> int:
+        pass
+
+    @abstractmethod
+    async def delete_conversation(self, conversation_id: int) -> bool:
+        pass
+
+    @abstractmethod
+    async def get_conversation(self, conversation_id: int) -> ConversationDict:
+        pass
+
+    @abstractmethod
+    async def get_conversations(
+        self, pagination: "Pagination", filter: "ConversationFilter"
+    ) -> PaginatedResponse[ConversationDict]:
+        pass
+
+    @abstractmethod
+    async def get_message(self, conversation_id: str, message_id: str) -> Dict:
+        pass
+
+    @abstractmethod
+    async def create_message(self, variables: MessageDict) -> int:
+        pass
+
+    @abstractmethod
+    async def update_message(self, message_id: int, variables: MessageDict) -> bool:
+        pass
+
+    @abstractmethod
+    async def delete_message(self, message_id: int) -> bool:
+        pass
+
+    @abstractmethod
+    async def upload_element(self, content: bytes, mime: str) -> str:
+        pass
+
+    @abstractmethod
+    async def upsert_element(self, variables: ElementDict) -> ElementDict:
+        pass
+
+    @abstractmethod
+    async def get_element(self, conversation_id: int, element_id: int) -> ElementDict:
+        pass
+
+    @abstractmethod
+    async def set_human_feedback(
+        self, message_id: int, feedback: Literal[-1, 0, 1]
+    ) -> bool:
+        pass