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

chainlit/server.py

@@ -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.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,18 +49,25 @@ 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()
 
@@ -92,6 +109,8 @@ async def lifespan(app: FastAPI):
     try:
         yield
     finally:
+        if config.project.database == "local":
+            await client.disconnect()
         if watch_task:
             try:
                 stop_event.set()
@@ -206,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."""
@@ -236,7 +329,7 @@ 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
+    client = None
 
     # Check authorization
     if not config.project.public and not authorization:
@@ -244,17 +337,22 @@ async def connect(sid, environ):
         trace_event("no_access_token")
         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("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:
@@ -293,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
 
@@ -308,15 +405,21 @@ 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.on_chat_start:
+        """Call the on_chat_start function provided by the developer."""
+        await config.code.on_chat_start()
+
     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__)
+    if config.code.llama_index_factory:
+        llama_instance = await config.code.llama_index_factory()
+        session["llama_instance"] = llama_instance
 
 
 @socket.on("disconnect")
@@ -336,7 +439,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()
 
@@ -350,8 +454,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
@@ -364,6 +471,8 @@ async def process_message(session: Session, author: str, input_str: str):
             )
 
         langchain_agent = session.get("agent")
+        llama_instance = session.get("llama_instance")
+
         if langchain_agent:
             from chainlit.lc.agent import run_langchain_agent
 
@@ -373,7 +482,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:
@@ -384,9 +492,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
@@ -397,18 +503,23 @@ async def process_message(session: Session, author: str, input_str: str):
             # Finally, send the response to the user
             await Message(author=config.ui.name, content=res).send()
 
+        elif llama_instance:
+            from chainlit.llama_index.run import run_llama
+
+            await run_llama(llama_instance, input_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")
@@ -423,11 +534,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)
 
@@ -436,8 +546,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

@@ -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,8 @@ 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
+    # Optional llama instance
+    llama_instance: Any
     # Whether the current task should be stopped
     should_stop: bool
     # Optional client to persist messages and files

chainlit/sync.py

@@ -1,37 +1,30 @@
-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 threading
 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:
+    if threading.current_thread() == threading.main_thread():
+        return sync(co)
+    else:
+        loop = get_loop()
+        result = asyncio.run_coroutine_threadsafe(co, loop=loop)
+        return result.result()

chainlit/types.py

@@ -1,4 +1,4 @@
-from typing import List, TypedDict, Optional, Literal, Dict, Union
+from typing import List, Any, TypedDict, Optional, Literal, Dict, Union
 from pydantic import BaseModel
 from pydantic.dataclasses import dataclass
 from dataclasses_json import dataclass_json
@@ -66,3 +66,28 @@ class CompletionRequest(BaseModel):
     prompt: str
     userEnv: Dict[str, str]
     settings: LLMSettings
+
+
+class UpdateFeedbackRequest(BaseModel):
+    messageId: int
+    feedback: int
+
+
+class DeleteConversationRequest(BaseModel):
+    conversationId: int
+
+
+class Pagination(BaseModel):
+    first: int
+    cursor: Any
+
+
+class ConversationFilter(BaseModel):
+    feedback: Optional[Literal[-1, 0, 1]]
+    authorEmail: Optional[str]
+    search: Optional[str]
+
+
+class GetConversationsRequest(BaseModel):
+    pagination: Pagination
+    filter: ConversationFilter

chainlit/user_session.py

@@ -1,5 +1,5 @@
 from typing import Dict
-from chainlit.emitter import get_emitter
+from chainlit.context import get_emitter
 
 user_sessions: Dict[str, Dict] = {}
 

chainlit/utils.py

@@ -0,0 +1,51 @@
+from typing import Callable
+import inspect
+
+from chainlit.context import get_emitter
+from chainlit.logger import logger
+from chainlit.message import ErrorMessage
+
+
+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

{chainlit-0.4.1.dist-info → chainlit-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 0.4.1
+Version: 0.4.3
 Summary: A faster way to build chatbot UIs.
 Home-page: https://github.com/Chainlit/chainlit
 License: Apache-2.0 license
@@ -19,10 +19,11 @@ 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: fastapi (>=0.96.0,<0.97.0)
+Requires-Dist: fastapi (>=0.97.0,<0.98.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: prisma (>=0.9.0,<0.10.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)
@@ -92,7 +93,10 @@ $ chainlit run demo.py -w
 
 ### 🔗 With LangChain
 
-Checkout our plug and play [integration](https://docs.chainlit.io/langchain) with LangChain!
+Check out our plug-and-play [integration](https://docs.chainlit.io/langchain) with LangChain!
+
+### 📚 More Examples - Cookbook
+You can find various examples of Chainlit apps [here](https://github.com/Chainlit/cookbook) that leverage tools and services such as OpenAI, Anthropiс, LangChain, LlamaIndex, ChromaDB, Pinecone and more.
 
 ## 🛣 Roadmap
 - [ ] New UI elements (spreadsheet, video, carousel...)

chainlit-0.4.3.dist-info/RECORD

@@ -0,0 +1,49 @@
+chainlit/__init__.py,sha256=KJjPLSjatqlNVjWDpYy6XzHWKZeIjH3cJ0Q3WhKDp_A,4078
+chainlit/__main__.py,sha256=7Vg3w3T3qDuz4KDu5lQhLH6lQ3cYdume7gHH7Z1V97U,87
+chainlit/action.py,sha256=dk-ymZXZPQlHjh77ivwmdzhAp3QN7ihPZVVVhoh2jMc,1209
+chainlit/cache.py,sha256=HFieoVnhsJf36AT7nRL8wcEJ1jTgeTLju23WW2-vgp4,1343
+chainlit/cli/__init__.py,sha256=DMeygqozPGYgMcM9oRPXRV1RVdhorCe0W-sOyTmjhCU,4888
+chainlit/cli/auth.py,sha256=G437UK4BvLA4wWPz_KPDwN6_6dnchMtHWr4tqu5XN-M,4093
+chainlit/cli/deploy.py,sha256=RyIzpjS3yuVjQpllDO2PzXb6VZAtTcOyuAfF75WKVJE,2594
+chainlit/cli/mock.py,sha256=hfcd62F0Bw6Bc2sj56gBYrxhujeCbQ2BzU8KZyTqG0Q,67012
+chainlit/cli/utils.py,sha256=Pn6ANnw9GgdUduiMphnb8RiGUPRbzDafkCHM2rOPBj4,716
+chainlit/client/base.py,sha256=HtVS6mGm_Ik6W08nLdUPtdVxzxK6Au1K6QKz-HdBz2Q,3284
+chainlit/client/cloud.py,sha256=OEUVVnvJK0ofQRoOkjxNniuyPtxZfVLqYXi8_0o6fS0,14109
+chainlit/client/local.py,sha256=JTSBHVArt7aA-rkuFJrGvlKUGin-PO2VXoWd_AQUko0,7324
+chainlit/client/utils.py,sha256=YARrA5XMpOpKhNjvIpve5H5CH2YekNP46aEYFvBjXlk,682
+chainlit/config.py,sha256=zd-vakyf06v-93g1JJ4aaHGJcQ3O-VoMJU71HqUIMUY,8493
+chainlit/context.py,sha256=m639AAk-bt7DWTStuW8s9FotohVonuW7veg5UwiKdKA,709
+chainlit/db/__init__.py,sha256=kFk5a6SoDrq1U6X4EjvJLd-3YsuVV4cl9r8BFHUExlM,982
+chainlit/db/prisma/schema.prisma,sha256=ZvhefSK_9D2Vck9SORaG9o-jQr6_BRpKNo-2YTlmgmg,1373
+chainlit/element.py,sha256=15nfoeQYF-hkOC8eFWmUWUsLT-vhyyacmG3GkOE_QDk,6317
+chainlit/emitter.py,sha256=SVgD6f9evY2IzanZ_ZHLd3qK_keDO20E_2fqv1Ka5JI,4142
+chainlit/frontend/dist/assets/index-37b5009c.js,sha256=rm7EbF7bDLQgCTyTHTVj9qQ9bjyAis7ZOzjU8yd-PHE,614554
+chainlit/frontend/dist/assets/index-51393291.js,sha256=asduyAfPksSjLfrXf7gdIuy03MbpTCMfgBeEj2J_4ys,1334161
+chainlit/frontend/dist/assets/index-f93cc942.css,sha256=-TzJQmhWdpIg94Jv25YHMi9h-jSQmeERggrrlmYIflg,5697
+chainlit/frontend/dist/assets/logo_dark-bc7401f6.svg,sha256=vHQB9g-n5OqOmuH3Fduuc7ZMg0EmMsGyO9cEnYwLbHg,8889
+chainlit/frontend/dist/assets/logo_light-f19fc2ea.svg,sha256=8Z_C6t-0V9QL9ldmLjaLfp2REcGDuaTeNynj6-6muNI,8891
+chainlit/frontend/dist/favicon.svg,sha256=0Cy8x28obT5eWW3nxZRhsEvu6_zMqrqbg0y6hT3D0Q0,6455
+chainlit/frontend/dist/index.html,sha256=7CUGF4qj4bXEsryZy4prJbz4scyBPQlt5RQioKKAJQE,793
+chainlit/hello.py,sha256=bqKP00i0FKHnZ9fdyVW1a2xDAA1g7IWT0EVzUNky7rA,417
+chainlit/langflow/__init__.py,sha256=spuypuoC0mVDVsxUbPJk2dKOfAtDv3IePuSe2a_L23U,2339
+chainlit/lc/__init__.py,sha256=mEtyfyGNDieIysKsWOrlvUvqVCqVnhYZqZprlZ1CBso,3281
+chainlit/lc/agent.py,sha256=tSR6TxZlMh91rmh95h2b-6bSGugak9lNpwaioDfiz1c,1140
+chainlit/lc/callbacks.py,sha256=wZLpWKnQCmYBk_LPFvL25U5KdXV50UuKzDtRrPjkUWs,12788
+chainlit/llama_index/__init__.py,sha256=X_Ydtrw62YzOQ1Dpe0BHXnX3akz5HbGrM5NNXZczNnQ,953
+chainlit/llama_index/callbacks.py,sha256=8WiHAxirhTXzGFk2rKBRQ9u_wKRg_yHntuRh6yGA_mo,2994
+chainlit/llama_index/run.py,sha256=NCYoMr-PJKjCENYuBJvE8W4MnH3VKvonxBmEMfQdZ78,1230
+chainlit/logger.py,sha256=VFl6D0UbY7PH7gCl0HBXM_vfk7lK_bMEqiUxQBq_Vnw,374
+chainlit/markdown.py,sha256=JRhaKb0BB1G2S1XEaGj95DH75y7jqWdeIPx4u0oDaxw,1623
+chainlit/message.py,sha256=zCagR3TEhdzf39p4LEcloNaSYpVttwBiMdRtNmPTeo4,12216
+chainlit/server.py,sha256=8oGPuRQV9QrrhGdEuSQmBnX_it_XkgyZ-BM2go__wQQ,17625
+chainlit/session.py,sha256=V1cKSi1REHy3zJSk1szLPL59MuGuwjg_HECfqD7VdsU,866
+chainlit/sync.py,sha256=g5BC-DA34BMhhB16fZ4QwKTda4oC2MYoAnLS-WoKRRI,688
+chainlit/telemetry.py,sha256=yaRnmjjwLPbUa_wLQ--sp1VKPAKIHgTQP-MZo_W8AM8,2358
+chainlit/types.py,sha256=py6vLmm_w43v7X_NNBvWtfi5rUc9owGNPdBO7L8Pto4,1981
+chainlit/user_session.py,sha256=U4F1e9DBUhFoXvEdReRTq7Bu0Str4qsvSgAOeMobUzA,1213
+chainlit/utils.py,sha256=2yoBX7W6vNxnIefHvrbspXggVwGrtYzAO9xJtTJT61M,1561
+chainlit/version.py,sha256=iosXhlXclBwBqlADFKEilxAC2wWKbtuBKi87AmPi7s8,196
+chainlit-0.4.3.dist-info/METADATA,sha256=aeKV9Cp0pRbcS0XeQykUVQTKYKLivr2QuvewIl7TQAE,4325
+chainlit-0.4.3.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+chainlit-0.4.3.dist-info/entry_points.txt,sha256=FrkqdjrFl8juSnvBndniyX7XuKojmUwO4ghRh-CFMQc,45
+chainlit-0.4.3.dist-info/RECORD,,