PyPI - chainlit - Versions diffs - 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of chainlit might be problematic. Click here for more details.

Files changed (35) hide show

chainlit/__init__.py +30 -7
chainlit/action.py +2 -4
chainlit/cache.py +24 -1
chainlit/cli/__init__.py +64 -21
chainlit/client/base.py +152 -0
chainlit/client/cloud.py +440 -0
chainlit/client/local.py +257 -0
chainlit/client/utils.py +23 -0
chainlit/config.py +92 -29
chainlit/context.py +29 -0
chainlit/db/__init__.py +35 -0
chainlit/db/prisma/schema.prisma +48 -0
chainlit/element.py +54 -41
chainlit/emitter.py +1 -30
chainlit/frontend/dist/assets/index-995e21ad.js +11 -0
chainlit/frontend/dist/assets/index-f93cc942.css +1 -0
chainlit/frontend/dist/assets/index-fb1e167a.js +523 -0
chainlit/frontend/dist/index.html +2 -2
chainlit/lc/agent.py +1 -0
chainlit/lc/callbacks.py +6 -21
chainlit/logger.py +7 -2
chainlit/message.py +22 -16
chainlit/server.py +169 -59
chainlit/session.py +1 -3
chainlit/sync.py +16 -28
chainlit/types.py +26 -1
chainlit/user_session.py +1 -1
{chainlit-0.4.0.dist-info → chainlit-0.4.2.dist-info}/METADATA +8 -3
chainlit-0.4.2.dist-info/RECORD +44 -0
chainlit/client.py +0 -287
chainlit/frontend/dist/assets/index-0cc9e355.css +0 -1
chainlit/frontend/dist/assets/index-9e4bccd1.js +0 -717
chainlit-0.4.0.dist-info/RECORD +0 -37
{chainlit-0.4.0.dist-info → chainlit-0.4.2.dist-info}/WHEEL +0 -0
{chainlit-0.4.0.dist-info → chainlit-0.4.2.dist-info}/entry_points.txt +0 -0

chainlit/frontend/dist/index.html CHANGED Viewed

@@ -14,8 +14,8 @@
     <script>
       const global = globalThis;
     </script>
-    <script type="module" crossorigin src="/assets/index-9e4bccd1.js"></script>
-    <link rel="stylesheet" href="/assets/index-0cc9e355.css">
+    <script type="module" crossorigin src="/assets/index-fb1e167a.js"></script>
+    <link rel="stylesheet" href="/assets/index-f93cc942.css">
   </head>
   <body>
     <div id="root"></div>

chainlit/lc/agent.py CHANGED Viewed

@@ -1,6 +1,7 @@
 from typing import Any
 from chainlit.lc.callbacks import ChainlitCallbackHandler, AsyncChainlitCallbackHandler
 from chainlit.sync import make_async
+from chainlit.context import emitter_var
 async def run_langchain_agent(agent: Any, input_str: str, use_async: bool):

chainlit/lc/callbacks.py CHANGED Viewed

@@ -6,7 +6,8 @@ from langchain.schema import (
     BaseMessage,
     LLMResult,
 )
-from chainlit.emitter import get_emitter, ChainlitEmitter
+from chainlit.emitter import ChainlitEmitter
+from chainlit.context import get_emitter
 from chainlit.message import Message, ErrorMessage
 from chainlit.config import config
 from chainlit.types import LLMSettings
@@ -107,14 +108,10 @@ class ChainlitCallbackHandler(BaseChainlitCallbackHandler, BaseCallbackHandler):
             return
         if config.code.lc_rename:
-            author = run_sync(
-                config.code.lc_rename(author, __chainlit_emitter__=self.emitter)
-            )
+            author = run_sync(config.code.lc_rename(author))
         self.pop_prompt()
-        __chainlit_emitter__ = self.emitter
         streamed_message = Message(
             author=author,
             indent=indent,
@@ -135,11 +132,7 @@ class ChainlitCallbackHandler(BaseChainlitCallbackHandler, BaseCallbackHandler):
             return
         if config.code.lc_rename:
-            author = run_sync(
-                config.code.lc_rename(author, __chainlit_emitter__=self.emitter)
-            )
-        __chainlit_emitter__ = self.emitter
+            author = run_sync(config.code.lc_rename(author))
         if error:
             run_sync(ErrorMessage(author=author, content=message).send())
@@ -267,14 +260,10 @@ class AsyncChainlitCallbackHandler(BaseChainlitCallbackHandler, AsyncCallbackHan
             return
         if config.code.lc_rename:
-            author = await config.code.lc_rename(
-                author, __chainlit_emitter__=self.emitter
-            )
+            author = await config.code.lc_rename(author)
         self.pop_prompt()
-        __chainlit_emitter__ = self.emitter
         streamed_message = Message(
             author=author,
             indent=indent,
@@ -295,11 +284,7 @@ class AsyncChainlitCallbackHandler(BaseChainlitCallbackHandler, AsyncCallbackHan
             return
         if config.code.lc_rename:
-            author = await config.code.lc_rename(
-                author, __chainlit_emitter__=self.emitter
-            )
-        __chainlit_emitter__ = self.emitter
+            author = await config.code.lc_rename(author)
         if error:
             await ErrorMessage(author=author, content=message).send()

chainlit/logger.py CHANGED Viewed

@@ -1,12 +1,17 @@
 import logging
+import sys
 logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    level=logging.INFO,
+    stream=sys.stdout,
+    format="%(asctime)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
 )
 logging.getLogger("socketio").setLevel(logging.ERROR)
 logging.getLogger("engineio").setLevel(logging.ERROR)
-logging.getLogger("geventwebsocket.handler").setLevel(logging.ERROR)
 logging.getLogger("numexpr").setLevel(logging.ERROR)
 logger = logging.getLogger("chainlit")

chainlit/message.py CHANGED Viewed

@@ -1,11 +1,11 @@
 from typing import List, Dict, Union
 from abc import ABC, abstractmethod
 import uuid
-import time
 import asyncio
+from datetime import datetime, timezone
 from chainlit.telemetry import trace_event
-from chainlit.emitter import get_emitter
+from chainlit.context import get_emitter
 from chainlit.config import config
 from chainlit.types import (
     LLMSettings,
@@ -16,11 +16,7 @@ from chainlit.types import (
 )
 from chainlit.element import Element
 from chainlit.action import Action
-def current_milli_time():
-    """Get the current time in milliseconds."""
-    return round(time.time() * 1000)
+from chainlit.logger import logger
 class MessageBase(ABC):
@@ -28,14 +24,13 @@ class MessageBase(ABC):
     temp_id: str = None
     streaming = False
     created_at: int = None
+    fail_on_persist_error: bool = True
     def __post_init__(self) -> None:
         trace_event(f"init {self.__class__.__name__}")
         self.temp_id = uuid.uuid4().hex
-        self.created_at = current_milli_time()
+        self.created_at = datetime.now(timezone.utc).isoformat()
         self.emitter = get_emitter()
-        if not self.emitter:
-            raise RuntimeError("Message should be instantiated in a Chainlit context")
     @abstractmethod
     def to_dict(self):
@@ -44,9 +39,14 @@ class MessageBase(ABC):
     async def _create(self):
         msg_dict = self.to_dict()
         if self.emitter.client and not self.id:
-            self.id = await self.emitter.client.create_message(msg_dict)
-            if self.id:
-                msg_dict["id"] = self.id
+            try:
+                self.id = await self.emitter.client.create_message(msg_dict)
+                if self.id:
+                    msg_dict["id"] = self.id
+            except Exception as e:
+                if self.fail_on_persist_error:
+                    raise e
+                logger.error(f"Failed to persist message: {str(e)}")
         return msg_dict
@@ -77,8 +77,7 @@ class MessageBase(ABC):
         msg_dict = self.to_dict()
         if self.emitter.client and self.id:
-            self.emitter.client.update_message(self.id, msg_dict)
-            msg_dict["id"] = self.id
+            await self.emitter.client.update_message(self.id, msg_dict)
         await self.emitter.update_message(msg_dict)
@@ -171,7 +170,7 @@ class Message(MessageBase):
         super().__post_init__()
     def to_dict(self):
-        return {
+        _dict = {
             "tempId": self.temp_id,
             "createdAt": self.created_at,
             "content": self.content,
@@ -182,6 +181,11 @@ class Message(MessageBase):
             "indent": self.indent,
         }
+        if self.id:
+            _dict["id"] = self.id
+        return _dict
     async def send(self):
         """
         Send the message to the UI and persist it in the cloud if a project ID is configured.
@@ -214,10 +218,12 @@ class ErrorMessage(MessageBase):
         content: str,
         author: str = config.ui.name,
         indent: int = 0,
+        fail_on_persist_error: bool = False,
     ):
         self.content = content
         self.author = author
         self.indent = indent
+        self.fail_on_persist_error = fail_on_persist_error
         super().__post_init__()

chainlit/server.py CHANGED Viewed

@@ -6,11 +6,13 @@ mimetypes.add_type("text/css", ".css")
 import os
 import json
 import webbrowser
+from pathlib import Path
 from contextlib import asynccontextmanager
 from watchfiles import awatch
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.responses import (
     HTMLResponse,
     JSONResponse,
@@ -21,17 +23,25 @@ from fastapi_socketio import SocketManager
 from starlette.middleware.cors import CORSMiddleware
 import asyncio
-from chainlit.config import config, load_module, DEFAULT_HOST
+from chainlit.context import emitter_var, loop_var
+from chainlit.config import config, load_module, reload_config, DEFAULT_HOST
 from chainlit.session import Session, sessions
 from chainlit.user_session import user_sessions
-from chainlit.client import CloudClient
+from chainlit.client.cloud import CloudClient
+from chainlit.client.local import LocalClient
+from chainlit.client.utils import get_client
 from chainlit.emitter import ChainlitEmitter
 from chainlit.markdown import get_markdown_str
 from chainlit.action import Action
 from chainlit.message import Message, ErrorMessage
 from chainlit.telemetry import trace_event
 from chainlit.logger import logger
-from chainlit.types import CompletionRequest
+from chainlit.types import (
+    CompletionRequest,
+    UpdateFeedbackRequest,
+    GetConversationsRequest,
+    DeleteConversationRequest,
+)
 @asynccontextmanager
@@ -39,32 +49,56 @@ async def lifespan(app: FastAPI):
     host = config.run.host
     port = config.run.port
-    if not config.run.headless:
-        if host == DEFAULT_HOST:
-            url = f"http://localhost:{port}"
-        else:
-            url = f"http://{host}:{port}"
+    if host == DEFAULT_HOST:
+        url = f"http://localhost:{port}"
+    else:
+        url = f"http://{host}:{port}"
+    logger.info(f"Your app is available at {url}")
-        logger.info(f"Your app is available at {url}")
+    if not config.run.headless:
+        # Add a delay before opening the browser
+        await asyncio.sleep(1)
         webbrowser.open(url)
+    if config.project.database == "local":
+        from prisma import Client, register
+        client = Client()
+        register(client)
+        await client.connect()
     watch_task = None
     stop_event = asyncio.Event()
     if config.run.watch:
         async def watch_files_for_changes():
+            extensions = [".py"]
+            files = ["chainlit.md", "config.toml"]
             async for changes in awatch(config.root, stop_event=stop_event):
                 for change_type, file_path in changes:
                     file_name = os.path.basename(file_path)
                     file_ext = os.path.splitext(file_name)[1]
-                    if file_ext.lower() == ".py" or file_name.lower() == "chainlit.md":
-                        logger.info(f"File {change_type.name}: {file_name}")
+                    if file_ext.lower() in extensions or file_name.lower() in files:
+                        logger.info(
+                            f"File {change_type.name}: {file_name}. Reloading app..."
+                        )
+                        try:
+                            reload_config()
+                        except Exception as e:
+                            logger.error(f"Error reloading config: {e}")
+                            break
                         # Reload the module if the module name is specified in the config
                         if config.run.module_name:
-                            load_module(config.run.module_name)
+                            try:
+                                load_module(config.run.module_name)
+                            except Exception as e:
+                                logger.error(f"Error reloading module: {e}")
+                                break
                         await socket.emit("reload", {})
@@ -74,12 +108,16 @@ async def lifespan(app: FastAPI):
     try:
         yield
-    except KeyboardInterrupt:
-        logger.error("KeyboardInterrupt received, stopping the watch task...")
     finally:
+        if config.project.database == "local":
+            await client.disconnect()
         if watch_task:
-            stop_event.set()
-            await watch_task
+            try:
+                stop_event.set()
+                watch_task.cancel()
+                await watch_task
+            except asyncio.exceptions.CancelledError:
+                pass
 root_dir = os.path.dirname(os.path.abspath(__file__))
@@ -187,6 +225,80 @@ async def project_settings():
     )
+@app.put("/message/feedback")
+async def update_feedback(request: Request, update: UpdateFeedbackRequest):
+    """Update the human feedback for a particular message."""
+    client = await get_client(request)
+    await client.set_human_feedback(
+        message_id=update.messageId, feedback=update.feedback
+    )
+    return JSONResponse(content={"success": True})
+@app.get("/project/members")
+async def get_project_members(request: Request):
+    """Get all the members of a project."""
+    client = await get_client(request)
+    res = await client.get_project_members()
+    return JSONResponse(content=res)
+@app.get("/project/role")
+async def get_member_role(request: Request):
+    """Get the role of a member."""
+    client = await get_client(request)
+    res = await client.get_member_role()
+    return PlainTextResponse(content=res)
+@app.post("/project/conversations")
+async def get_project_conversations(request: Request, payload: GetConversationsRequest):
+    """Get the conversations page by page."""
+    client = await get_client(request)
+    res = await client.get_conversations(payload.pagination, payload.filter)
+    return JSONResponse(content=res.to_dict())
+@app.get("/project/conversation/{conversation_id}")
+async def get_conversation(request: Request, conversation_id: str):
+    """Get a specific conversation."""
+    client = await get_client(request)
+    res = await client.get_conversation(int(conversation_id))
+    return JSONResponse(content=res)
+@app.get("/project/conversation/{conversation_id}/element/{element_id}")
+async def get_conversation(request: Request, conversation_id: str, element_id: str):
+    """Get a specific conversation."""
+    client = await get_client(request)
+    res = await client.get_element(int(conversation_id), int(element_id))
+    return JSONResponse(content=res)
+@app.delete("/project/conversation")
+async def delete_conversation(request: Request, payload: DeleteConversationRequest):
+    """Delete a conversation."""
+    client = await get_client(request)
+    await client.delete_conversation(conversation_id=payload.conversationId)
+    return JSONResponse(content={"success": True})
+@app.get("/files/{filename:path}")
+async def serve_file(filename: str):
+    file_path = Path(config.project.local_fs_path) / filename
+    if file_path.is_file():
+        return FileResponse(file_path)
+    else:
+        return {"error": "File not found"}
 @app.get("/{path:path}")
 async def serve(path: str):
     """Serve the UI."""
@@ -217,36 +329,30 @@ def need_session(id: str):
 async def connect(sid, environ):
     user_env = environ.get("HTTP_USER_ENV")
     authorization = environ.get("HTTP_AUTHORIZATION")
-    cloud_client = None
-    # Check decorated functions
-    if (
-        not config.code.lc_factory
-        and not config.code.on_message
-        and not config.code.on_chat_start
-    ):
-        logger.error(
-            "Module should at least expose one of @langchain_factory, @on_message or @on_chat_start function"
-        )
-        return False
+    client = None
     # Check authorization
     if not config.project.public and not authorization:
         # Refuse connection if the app is private and no access token is provided
         trace_event("no_access_token")
-        logger.error("No access token provided")
+        logger.error("Connection refused: No access token provided")
         return False
-    elif authorization and config.project.id:
+    elif authorization and config.project.id and config.project.database == "cloud":
         # Create the cloud client
-        cloud_client = CloudClient(
+        client = CloudClient(
             project_id=config.project.id,
-            session_id=sid,
             access_token=authorization,
         )
-        is_project_member = await cloud_client.is_project_member()
+        is_project_member = await client.is_project_member()
         if not is_project_member:
-            logger.error("You are not a member of this project")
+            logger.error("Connection refused: You are not a member of this project")
             return False
+    elif config.project.database == "local":
+        client = LocalClient()
+    elif config.project.database == "custom":
+        if not config.code.client_factory:
+            raise ValueError("Client factory not provided")
+        client = await config.code.client_factory()
     # Check user env
     if config.project.user_env:
@@ -256,10 +362,12 @@ async def connect(sid, environ):
             for key in config.project.user_env:
                 if key not in user_env:
                     trace_event("missing_user_env")
-                    logger.error("Missing user environment variable: " + key)
+                    logger.error(
+                        "Connection refused: Missing user environment variable: " + key
+                    )
                     return False
         else:
-            logger.error("Missing user environment variables")
+            logger.error("Connection refused: Missing user environment variables")
             return False
     # Create the session
@@ -283,9 +391,8 @@ async def connect(sid, environ):
         "id": sid,
         "emit": emit_fn,
         "ask_user": ask_user_fn,
-        "client": cloud_client,
+        "client": client,
         "user_env": user_env,
-        "running_sync": False,
         "should_stop": False,
     }  # type: Session
@@ -298,15 +405,17 @@ async def connect(sid, environ):
 @socket.on("connection_successful")
 async def connection_successful(sid):
     session = need_session(sid)
-    __chainlit_emitter__ = ChainlitEmitter(session)
+    emitter_var.set(ChainlitEmitter(session))
+    loop_var.set(asyncio.get_event_loop())
     if config.code.lc_factory:
         """Instantiate the langchain agent and store it in the session."""
-        agent = await config.code.lc_factory(__chainlit_emitter__=__chainlit_emitter__)
+        agent = await config.code.lc_factory()
         session["agent"] = agent
     if config.code.on_chat_start:
         """Call the on_chat_start function provided by the developer."""
-        await config.code.on_chat_start(__chainlit_emitter__=__chainlit_emitter__)
+        await config.code.on_chat_start()
 @socket.on("disconnect")
@@ -326,7 +435,8 @@ async def stop(sid):
         trace_event("stop_task")
         session = sessions[sid]
-        __chainlit_emitter__ = ChainlitEmitter(session)
+        emitter_var.set(ChainlitEmitter(session))
+        loop_var.set(asyncio.get_event_loop())
         await Message(author="System", content="Task stopped by the user.").send()
@@ -340,8 +450,11 @@ async def process_message(session: Session, author: str, input_str: str):
     """Process a message from the user."""
     try:
-        __chainlit_emitter__ = ChainlitEmitter(session)
-        await __chainlit_emitter__.task_start()
+        emitter = ChainlitEmitter(session)
+        emitter_var.set(emitter)
+        loop_var.set(asyncio.get_event_loop())
+        await emitter.task_start()
         if session["client"]:
             # If cloud is enabled, persist the message
@@ -363,7 +476,6 @@ async def process_message(session: Session, author: str, input_str: str):
                 await config.code.lc_run(
                     langchain_agent,
                     input_str,
-                    __chainlit_emitter__=__chainlit_emitter__,
                 )
                 return
             else:
@@ -374,9 +486,7 @@ async def process_message(session: Session, author: str, input_str: str):
                 if config.code.lc_postprocess:
                     # If the developer provided a custom postprocess function, use it
-                    await config.code.lc_postprocess(
-                        raw_res, __chainlit_emitter__=__chainlit_emitter__
-                    )
+                    await config.code.lc_postprocess(raw_res)
                     return
                 elif output_key is not None:
                     # Use the output key if provided
@@ -389,16 +499,16 @@ async def process_message(session: Session, author: str, input_str: str):
         elif config.code.on_message:
             # If no langchain agent is available, call the on_message function provided by the developer
-            await config.code.on_message(
-                input_str, __chainlit_emitter__=__chainlit_emitter__
-            )
+            await config.code.on_message(input_str)
     except InterruptedError:
         pass
     except Exception as e:
         logger.exception(e)
-        await ErrorMessage(author="Error", content=str(e)).send()
+        await ErrorMessage(
+            author="Error", content=str(e) or e.__class__.__name__
+        ).send()
     finally:
-        await __chainlit_emitter__.task_end()
+        await emitter.task_end()
 @socket.on("ui_message")
@@ -413,11 +523,10 @@ async def message(sid, data):
     await process_message(session, author, input_str)
-async def process_action(session: Session, action: Action):
-    __chainlit_emitter__ = ChainlitEmitter(session)
+async def process_action(action: Action):
     callback = config.code.action_callbacks.get(action.name)
     if callback:
-        await callback(action, __chainlit_emitter__=__chainlit_emitter__)
+        await callback(action)
     else:
         logger.warning("No callback found for action %s", action.name)
@@ -426,8 +535,9 @@ async def process_action(session: Session, action: Action):
 async def call_action(sid, action):
     """Handle an action call from the UI."""
     session = need_session(sid)
+    emitter_var.set(ChainlitEmitter(session))
+    loop_var.set(asyncio.get_event_loop())
-    __chainlit_emitter__ = ChainlitEmitter(session)
     action = Action(**action)
-    await process_action(session, action)
+    await process_action(action)

chainlit/session.py CHANGED Viewed

@@ -1,5 +1,5 @@
 from typing import Dict, TypedDict, Optional, Callable, Any, Union
-from chainlit.client import BaseClient
+from chainlit.client.base import BaseClient
 from chainlit.types import AskResponse
@@ -16,8 +16,6 @@ class Session(TypedDict):
     user_env: Dict[str, str]
     # Optional langchain agent
     agent: Any
-    # If the session is currently running a sync task
-    running_sync: bool
     # Whether the current task should be stopped
     should_stop: bool
     # Optional client to persist messages and files

chainlit/sync.py CHANGED Viewed

@@ -1,37 +1,25 @@
-from typing import Any, Callable
+import sys
+from typing import Any, TypeVar, Coroutine
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
+else:
+    from typing_extensions import ParamSpec
 import asyncio
-from syncer import sync
 from asyncer import asyncify
-from chainlit.emitter import get_emitter
-def make_async(function: Callable):
-    emitter = get_emitter()
-    if not emitter:
-        raise RuntimeError(
-            "Emitter not found, please call make_async in a Chainlit context."
-        )
+from chainlit.context import get_loop
-    def wrapper(*args, **kwargs):
-        emitter.session["running_sync"] = True
-        __chainlit_emitter__ = emitter
-        res = function(*args, **kwargs)
-        emitter.session["running_sync"] = False
-        return res
-    return asyncify(wrapper, cancellable=True)
+make_async = asyncify
+T_Retval = TypeVar("T_Retval")
+T_ParamSpec = ParamSpec("T_ParamSpec")
+T = TypeVar("T")
-def run_sync(co: Any):
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError as e:
-        if "There is no current event loop" in str(e):
-            loop = None
-    if loop is None or not loop.is_running():
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    return sync(co)
+def run_sync(co: Coroutine[Any, Any, T_Retval]) -> T_Retval:
+    loop = get_loop()
+    result = asyncio.run_coroutine_threadsafe(co, loop=loop)
+    return result.result()

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

Potentially problematic release.

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