chainlit 0.7.700__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

chainlit/client/cloud.py

@@ -1,502 +0,0 @@
-import uuid
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import httpx
-from chainlit.logger import logger
-
-from .base import (
-    AppUser,
-    ChainlitGraphQLClient,
-    ConversationDict,
-    ConversationFilter,
-    ElementDict,
-    MessageDict,
-    PageInfo,
-    PaginatedResponse,
-    Pagination,
-    PersistedAppUser,
-)
-
-
-class ChainlitCloudClient(ChainlitGraphQLClient):
-    chainlit_server: str
-
-    def __init__(self, api_key: str, chainlit_server="https://cloud.chainlit.io"):
-        # Remove trailing slash
-        chainlit_server = chainlit_server.rstrip("/")
-        super().__init__(api_key=api_key, chainlit_server=chainlit_server)
-        self.chainlit_server = chainlit_server
-
-    async def create_app_user(self, app_user: AppUser) -> Optional[PersistedAppUser]:
-        mutation = """
-            mutation ($username: String!, $role: Role!, $tags: [String!], $provider: String, $image: String) {
-                createAppUser(username: $username, role: $role, tags: $tags, provider: $provider, image: $image) {
-                    id,
-                    username,
-                    role,
-                    tags,
-                    provider,
-                    image,
-                    createdAt
-                }
-            }
-            """
-        variables = app_user.to_dict()
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not create app user.")
-            return None
-
-        return PersistedAppUser.from_dict(res["data"]["createAppUser"])
-
-    async def update_app_user(self, app_user: AppUser) -> Optional[PersistedAppUser]:
-        mutation = """
-            mutation ($username: String!, $role: Role!, $tags: [String!], $provider: String, $image: String) {
-                updateAppUser(username: $username, role: $role, tags: $tags, provider: $provider, image: $image) {
-                    id,
-                    username,
-                    role,
-                    tags,
-                    provider,
-                    image,
-                    createdAt
-                }
-            }
-            """
-        variables = app_user.to_dict()
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not update app user.")
-            return None
-
-        return PersistedAppUser.from_dict(res["data"]["updateAppUser"])
-
-    async def get_app_user(self, username: str) -> Optional[PersistedAppUser]:
-        query = """
-             query ($username: String!) {
-                getAppUser(username: $username) {
-                    id,
-                    username,
-                    role,
-                    tags,
-                    provider,
-                    image,
-                    createdAt
-                }
-            }
-            """
-        variables = {"username": username}
-        res = await self.query(query, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not get app user.")
-            return None
-
-        return PersistedAppUser.from_dict(res["data"]["getAppUser"])
-
-    async def delete_app_user(self, username: str) -> bool:
-        mutation = """
-                mutation ($username: String!) {
-                    deleteAppUser(username: $username) {
-                        id,
-                    }
-                }
-                """
-        variables = {"username": username}
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not delete app user.")
-            return False
-
-        return True
-
-    async def create_conversation(
-        self, app_user_id: Optional[str], tags: Optional[List[str]]
-    ) -> Optional[str]:
-        mutation = """
-        mutation ($appUserId: String, $tags: [String!]) {
-            createConversation (appUserId: $appUserId, tags: $tags) {
-                id
-            }
-        }
-        """
-        variables = {}  # type: Dict[str, Any]
-        if app_user_id is not None:
-            variables["appUserId"] = app_user_id
-
-        if tags:
-            variables["tags"] = tags
-
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not create conversation.")
-            return None
-
-        return res["data"]["createConversation"]["id"]
-
-    async def delete_conversation(self, conversation_id: str) -> bool:
-        mutation = """
-        mutation ($id: ID!) {
-            deleteConversation(id: $id) {
-                id
-            }
-        }
-        """
-        variables = {"id": conversation_id}
-        res = await self.mutation(mutation, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        return True
-
-    async def get_conversation_author(self, conversation_id: str) -> Optional[str]:
-        query = """
-        query ($id: ID!) {
-            conversation(id: $id) {
-               appUser {
-                   username
-               }
-            }
-        }
-        """
-        variables = {
-            "id": conversation_id,
-        }
-        res = await self.query(query, variables)
-        self.check_for_errors(res, raise_error=True)
-        data = res.get("data")
-        conversation = data.get("conversation") if data else None
-        if not conversation:
-            return None
-        return (
-            conversation["appUser"].get("username") if conversation["appUser"] else None
-        )
-
-    async def get_conversation(self, conversation_id: str) -> ConversationDict:
-        query = """
-        query ($id: ID!) {
-            conversation(id: $id) {
-                id
-                createdAt
-                tags
-                metadata
-                appUser {
-                    id
-                    username
-                }
-                messages {
-                    id
-                    isError
-                    parentId
-                    indent
-                    author
-                    content
-                    waitForAnswer
-                    humanFeedback
-                    humanFeedbackComment
-                    disableHumanFeedback
-                    language
-                    prompt
-                    authorIsUser
-                    createdAt
-                }
-                elements {
-                    id
-                    conversationId
-                    type
-                    name
-                    mime
-                    url
-                    display
-                    language
-                    size
-                    forIds
-                }
-            }
-        }
-        """
-        variables = {
-            "id": conversation_id,
-        }
-        res = await self.query(query, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        return res["data"]["conversation"]
-
-    async def update_conversation_metadata(self, conversation_id: str, metadata: Dict):
-        mutation = """mutation ($conversationId: ID!, $metadata: Json!) {
-                    updateConversationMetadata(conversationId: $conversationId, metadata: $metadata) {
-                            id
-                    }
-                }"""
-        variables = {
-            "conversationId": conversation_id,
-            "metadata": metadata,
-        }
-
-        res = await self.mutation(mutation, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        return True
-
-    async def get_conversations(
-        self, pagination: Pagination, filter: ConversationFilter
-    ):
-        query = """query (
-        $first: Int
-        $cursor: String
-        $withFeedback: Int
-        $username: String
-        $search: String
-    ) {
-        conversations(
-        first: $first
-        cursor: $cursor
-        withFeedback: $withFeedback
-        username: $username
-        search: $search
-        ) {
-        pageInfo {
-            endCursor
-            hasNextPage
-        }
-        edges {
-            cursor
-            node {
-            id
-            createdAt
-            tags
-            appUser {
-                username
-            }
-            messages {
-                content
-            }
-            }
-        }
-        }
-    }"""
-
-        variables = {
-            "first": pagination.first,
-            "cursor": pagination.cursor,
-            "withFeedback": filter.feedback,
-            "username": filter.username,
-            "search": filter.search,
-        }
-        res = await self.query(query, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        conversations = []
-
-        for edge in res["data"]["conversations"]["edges"]:
-            node = edge["node"]
-            conversations.append(node)
-
-        page_info = res["data"]["conversations"]["pageInfo"]
-
-        return PaginatedResponse(
-            pageInfo=PageInfo(
-                hasNextPage=page_info["hasNextPage"],
-                endCursor=page_info["endCursor"],
-            ),
-            data=conversations,
-        )
-
-    async def set_human_feedback(
-        self, message_id: str, feedback: int, feedbackComment: Optional[str]
-    ) -> bool:
-        mutation = """mutation ($messageId: ID!, $humanFeedback: Int!, $humanFeedbackComment: String) {
-                    setHumanFeedback(messageId: $messageId, humanFeedback: $humanFeedback, humanFeedbackComment: $humanFeedbackComment) {
-                            id
-                            humanFeedback
-                            humanFeedbackComment
-                    }
-                }"""
-        variables = {
-            "messageId": message_id,
-            "humanFeedback": feedback,
-        }
-        if feedbackComment:
-            variables["humanFeedbackComment"] = feedbackComment
-        res = await self.mutation(mutation, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        return True
-
-    async def get_message(self):
-        raise NotImplementedError
-
-    async def create_message(self, variables: MessageDict) -> Optional[str]:
-        mutation = """
-        mutation ($id: ID!, $conversationId: ID!, $author: String!, $content: String!, $language: String, $prompt: Json, $isError: Boolean, $parentId: String, $indent: Int, $authorIsUser: Boolean, $disableHumanFeedback: Boolean, $waitForAnswer: Boolean, $createdAt: StringOrFloat) {
-            createMessage(id: $id, conversationId: $conversationId, author: $author, content: $content, language: $language, prompt: $prompt, isError: $isError, parentId: $parentId, indent: $indent, authorIsUser: $authorIsUser, disableHumanFeedback: $disableHumanFeedback, waitForAnswer: $waitForAnswer, createdAt: $createdAt) {
-                id
-            }
-        }
-        """
-        res = await self.mutation(mutation, variables)
-        if self.check_for_errors(res):
-            logger.warning("Could not create message.")
-            return None
-
-        return res["data"]["createMessage"]["id"]
-
-    async def update_message(self, message_id: str, variables: MessageDict) -> bool:
-        mutation = """
-        mutation ($messageId: ID!, $author: String!, $content: String!, $parentId: String, $language: String, $prompt: Json, $disableHumanFeedback: Boolean) {
-            updateMessage(messageId: $messageId, author: $author, content: $content, parentId: $parentId, language: $language,  prompt: $prompt, disableHumanFeedback: $disableHumanFeedback) {
-                id
-            }
-        }
-        """
-        res = await self.mutation(mutation, dict(messageId=message_id, **variables))
-
-        if self.check_for_errors(res):
-            logger.warning("Could not update message.")
-            return False
-
-        return True
-
-    async def delete_message(self, message_id: str) -> bool:
-        mutation = """
-        mutation ($messageId: ID!) {
-            deleteMessage(messageId: $messageId) {
-                id
-            }
-        }
-        """
-        res = await self.mutation(mutation, {"messageId": message_id})
-
-        if self.check_for_errors(res):
-            logger.warning("Could not delete message.")
-            return False
-
-        return True
-
-    async def get_element(
-        self, conversation_id: str, element_id: str
-    ) -> Optional[ElementDict]:
-        query = """query (
-        $conversationId: ID!
-        $id: ID!
-    ) {
-        element(
-        conversationId: $conversationId,
-        id: $id
-        ) {
-        id
-        conversationId
-        type
-        name
-        mime
-        url
-        display
-        language
-        size
-        forIds
-        }
-    }"""
-
-        variables = {
-            "conversationId": conversation_id,
-            "id": element_id,
-        }
-        res = await self.query(query, variables)
-        self.check_for_errors(res, raise_error=True)
-
-        return res["data"]["element"]
-
-    async def create_element(self, variables: ElementDict) -> Optional[ElementDict]:
-        mutation = """
-        mutation ($conversationId: ID!, $type: String!, $name: String!, $display: String!, $forIds: [String!]!, $url: String, $objectKey: String, $size: String, $language: String, $mime: String) {
-            createElement(conversationId: $conversationId, type: $type, url: $url, objectKey: $objectKey, name: $name, display: $display, size: $size, language: $language, forIds: $forIds, mime: $mime) {
-                id,
-                type,
-                url,
-                objectKey,
-                name,
-                display,
-                size,
-                language,
-                forIds,
-                mime
-            }
-        }
-        """
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not create element.")
-            return None
-
-        return res["data"]["createElement"]
-
-    async def update_element(self, variables: ElementDict) -> Optional[ElementDict]:
-        mutation = """
-        mutation ($conversationId: ID!, $id: ID!, $forIds: [String!]!) {
-            updateElement(conversationId: $conversationId, id: $id, forIds: $forIds) {
-                id,
-            }
-        }
-        """
-
-        res = await self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not update element.")
-            return None
-
-        return res["data"]["updateElement"]
-
-    async def upload_element(
-        self, content: Union[bytes, str], mime: str, conversation_id: Optional[str]
-    ) -> Dict:
-        id = str(uuid.uuid4())
-        body = {"fileName": id, "contentType": mime}
-
-        if conversation_id:
-            body["conversationId"] = conversation_id
-
-        path = "/api/upload/file"
-
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.chainlit_server}{path}",
-                json=body,
-                headers=self.headers,
-            )
-            if response.status_code != 200:
-                reason = response.text
-                logger.error(f"Failed to sign upload url: {reason}")
-                return {"object_key": None, "url": None}
-            json_res = response.json()
-
-        upload_details = json_res["post"]
-        object_key = upload_details["fields"]["key"]
-        signed_url = json_res["signedUrl"]
-
-        # Prepare form data
-        form_data = {}  # type: Dict[str, Tuple[Union[str, None], Any]]
-        for field_name, field_value in upload_details["fields"].items():
-            form_data[field_name] = (None, field_value)
-
-        # Add file to the form_data
-        # Note: The content_type parameter is not needed here, as the correct MIME type should be set in the 'Content-Type' field from upload_details
-        form_data["file"] = (id, content)
-
-        async with httpx.AsyncClient() as client:
-            upload_response = await client.post(
-                upload_details["url"],
-                files=form_data,
-            )
-            try:
-                upload_response.raise_for_status()
-                url = f'{upload_details["url"]}/{object_key}'
-                return {"object_key": object_key, "url": signed_url}
-            except Exception as e:
-                logger.error(f"Failed to upload file: {str(e)}")
-                return {"object_key": None, "url": None}

chainlit/prompt.py

@@ -1,40 +0,0 @@
-from typing import Any, Dict, List, Literal, Optional
-
-from dataclasses_json import DataClassJsonMixin
-from pydantic.dataclasses import dataclass
-
-
-@dataclass
-class BaseTemplate(DataClassJsonMixin):
-    template: Optional[str] = None
-    formatted: Optional[str] = None
-    template_format: Optional[str] = "f-string"
-
-
-@dataclass
-class PromptMessage(BaseTemplate):
-    # This is used for Langchain's MessagesPlaceholder
-    placeholder_size: Optional[int] = None
-    # This is used for OpenAI's function message
-    name: Optional[str] = None
-    role: Optional[Literal["system", "assistant", "user", "function"]] = None
-
-    def to_openai(self):
-        msg_dict = {"role": self.role, "content": self.formatted}
-        if self.role == "function":
-            msg_dict["name"] = self.name or ""
-        return msg_dict
-
-    def to_string(self):
-        return f"{self.role}: {self.formatted}"
-
-
-@dataclass
-class Prompt(BaseTemplate):
-    provider: Optional[str] = None
-    id: Optional[str] = None
-    inputs: Optional[Dict[str, str]] = None
-    completion: Optional[str] = None
-    settings: Optional[Dict[str, Any]] = None
-    messages: Optional[List[PromptMessage]] = None
-    functions: Optional[List[Dict]] = None

chainlit-0.7.700.dist-info/RECORD

@@ -1,61 +0,0 @@
-chainlit/__init__.py,sha256=e215uKlKg0rvx3EIcwn1j9WSJoQwzbwRQx-bP2HI6go,8840
-chainlit/__main__.py,sha256=7Vg3w3T3qDuz4KDu5lQhLH6lQ3cYdume7gHH7Z1V97U,87
-chainlit/action.py,sha256=k-GsblVHI4DnDWFyF-RZgq3KfdfAFICFh2OBeU4w8N8,1410
-chainlit/auth.py,sha256=kA9S1aTv7kPFfAzOmwkTlsyE4f17NEwvUCXo49vbUjY,2716
-chainlit/cache.py,sha256=Bv3dT4eHhE6Fq3c6Do0ZTpiyoXgXYewdxTgpYghEd9g,1361
-chainlit/chat_settings.py,sha256=2ByenmwS8O6jQjDVJjhhbLrBPGA5aY2F7R3VvQQxXPk,877
-chainlit/cli/__init__.py,sha256=HpEonQCHdgYnNB0tBq8DXUO4S3MegHHuIn5YOvLLgY4,4793
-chainlit/cli/utils.py,sha256=mE2d9oOk-B2b9ZvDV1zENoDWxjfMriGP7bVwEFduZP4,717
-chainlit/client/base.py,sha256=7hzMJJJK10CQ13dIVgg93vDBy3Y6saDTMftjSF3FaPw,4365
-chainlit/client/cloud.py,sha256=EXBYtEzt04KcnlGzzkPCx8sjSByNQQ21GB4ekXL81TI,16349
-chainlit/config.py,sha256=zfpNwqD1Iob2CjqEjAazpqoWLCFTX3gF1wLADi6BITo,10646
-chainlit/context.py,sha256=3hrRRB_joQjR8fjKRwpWZqUQNFxS3oXVmXuec7n6pj0,2195
-chainlit/data/__init__.py,sha256=KHS56Bbh1Vx1BfNipO8jC-lTrY8gWSTgJSZK-OHotuQ,373
-chainlit/data/acl.py,sha256=WNp4ytwRmLWLfcSsjAQSbbSwhV3Acbhx1F1gy5qLgMk,474
-chainlit/element.py,sha256=1m-iK90aCAY8kK6nKim4TtKtzFz3hvYnjQW3iDOmtDo,11714
-chainlit/emitter.py,sha256=SmIPoXNExhAIn3wSG0-tcKKyd9HZ3FXXA9S9qYiUEUs,8067
-chainlit/frontend/dist/assets/index-71698725.js,sha256=SgMDc3pdA6Ae_CVniFSUlq7aTB6rx2bAOAlQsj0oebk,3084418
-chainlit/frontend/dist/assets/index-8942cb2d.css,sha256=iULLLdx-rywLKpSdrJuSZwAF22WLkNdLKypNpaN5PQY,6557
-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/assets/react-plotly-2c0acdf0.js,sha256=acCLmJDbRgiv7mxSHC8_xofgCAIFPcrGDXIRH5231Ko,3739251
-chainlit/frontend/dist/favicon.svg,sha256=0Cy8x28obT5eWW3nxZRhsEvu6_zMqrqbg0y6hT3D0Q0,6455
-chainlit/frontend/dist/index.html,sha256=q8QL3ovB9FvmXo5wZjOQaiKdy7XzjeQWeafSBVSU1uo,959
-chainlit/haystack/__init__.py,sha256=uZ77YiPy-qleSTi3dQCDO9HE6S6F6GpJWmh7jO4cxXA,217
-chainlit/haystack/callbacks.py,sha256=VCy7v2zlRV9pSSrEfSsd8-dTcAIbIxINdBnJg8zjYXQ,3910
-chainlit/hello.py,sha256=bqKP00i0FKHnZ9fdyVW1a2xDAA1g7IWT0EVzUNky7rA,417
-chainlit/input_widget.py,sha256=1Z1qn3YwaZ7upqqxZXtbfDxBlVobDjbZ3HtlNOj-U3E,4880
-chainlit/langchain/__init__.py,sha256=zErMw0_3ufSGeF9ye7X0ZX3wDat4mTOx97T40ePDO2g,217
-chainlit/langchain/callbacks.py,sha256=bA9_QMuJHK40CLe4QN2fa1iyWSOXcif2hIdZu45QGYI,23191
-chainlit/langflow/__init__.py,sha256=wxhxdsl1yxdsRyNTgZticxFF_8VFtJJ4OdIy3tnEIyM,817
-chainlit/llama_index/__init__.py,sha256=c7wIUZmKTtZPU9zpdGpKTHctQaBWTuRGqTN0kkIkBcg,218
-chainlit/llama_index/callbacks.py,sha256=2wIADRsy6njqPDyObW9NKZ5FXc-bBkgu5eWmVE03Dc4,4849
-chainlit/logger.py,sha256=wTwRSZsLfXwWy6U4351IgWAm4KCMThgxm9EZpjGUEr4,373
-chainlit/markdown.py,sha256=L2IPPWxIlrhJZcKPfO1akomHdN3sgC2EvC2ilxR8MQs,1624
-chainlit/message.py,sha256=dPcVnJJ6hRIrU_Dlm66YuDReU_tr5Fizjyrtsayk_XY,19124
-chainlit/oauth_providers.py,sha256=I8yF2tFBsGdGGtUo6GZtiwo6fEx6yxPrzF2F-Fdl6WY,14901
-chainlit/playground/__init__.py,sha256=igNRcBgqLKPTjOQtTNhhGNJFmZn-Dl1fHRQzQSjDGTQ,80
-chainlit/playground/config.py,sha256=a6fnIU2IrYQDKU6zHF8qUD3ssUBD9UiTEN10pMxgnGY,998
-chainlit/playground/provider.py,sha256=NVg1OTdriSfMOqfRUcymIaiasNfGNzLjo6GM5K34z8U,4424
-chainlit/playground/providers/__init__.py,sha256=L4Y7Udpexm769Jnf-mIeN-YGh6xaaMjF3rPxSfReiN4,225
-chainlit/playground/providers/anthropic.py,sha256=9j13gtnA6_Y1MjXMLsp17MJwniZlUgqfMUEzE166FFk,3431
-chainlit/playground/providers/huggingface.py,sha256=HQC14D8l0-JOJIP8YYsHrslZQf0d0gDpBOktQkZZLlA,2122
-chainlit/playground/providers/langchain.py,sha256=1hh00W8M1aTr9O5D13zkEcCFdTMGVjLuQFZylxmDmzE,2776
-chainlit/playground/providers/openai.py,sha256=-TMNUaYmj8Hw68JKuTCjLJXPbeoQtCI4gXRH7HShYyo,12428
-chainlit/playground/providers/vertexai.py,sha256=TwFyhNmbStUso0ShvoRzOQ5b4l8ErG1szxqjv4IRXE0,3678
-chainlit/prompt.py,sha256=GssulrgQdpkHGXBDFWCbTFWtrT2voorTXcHvjQj4SD4,1221
-chainlit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chainlit/secret.py,sha256=0MXq8YxTeL93K8IyAew5UgZmIIw9_yJ_Kg4iML6cdVM,296
-chainlit/server.py,sha256=J6yQdbvmWwst2mPgzEkBaDfO4nYr5kYOsXyYemgBTXY,19241
-chainlit/session.py,sha256=WOwyPZuqu73GcULkGTjV_Coal1d2cRgEZCmRuHydSyc,6424
-chainlit/socket.py,sha256=Icz3ZlaaZHLTrG2H4g1KF8Uu2BlWfFUAI6rHn3RjFtc,8560
-chainlit/sync.py,sha256=G1n-7-3WgXsN8y1bJkEyws_YwmHZIyDZoZUwhprigag,1235
-chainlit/telemetry.py,sha256=sIZzYk0YEmtWbOS8B5tf6aQfW-uKzwvVtajpbj8bLMw,3210
-chainlit/types.py,sha256=PLWsBVRyCRYeBshLgg3MpVSAT6rf_eAQ17M6v9Dnik0,2180
-chainlit/user_session.py,sha256=-GjXsuyhx7bvRlCHOqRHh-r6PkCm8fCPJMX6-kTch64,1534
-chainlit/utils.py,sha256=3HzhfZ4XJhBIe9sJ_3Lxv3lMH4mFXsi6nLBGqm8Gtdw,2571
-chainlit/version.py,sha256=iosXhlXclBwBqlADFKEilxAC2wWKbtuBKi87AmPi7s8,196
-chainlit-0.7.700.dist-info/METADATA,sha256=CGHGNtpTqdRXmPIyWpvY8gFsJkip1UYe5h9Hg36u9vY,6312
-chainlit-0.7.700.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-chainlit-0.7.700.dist-info/entry_points.txt,sha256=FrkqdjrFl8juSnvBndniyX7XuKojmUwO4ghRh-CFMQc,45
-chainlit-0.7.700.dist-info/RECORD,,