chainlit 1.1.300rc4__py3-none-any.whl → 1.1.301__py3-none-any.whl

chainlit/step.py

@@ -295,7 +295,10 @@ class Step:
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and (self.parent_id or "message" not in self.type):
+        if config.ui.hide_cot and self.type not in [
+            "user_message",
+            "assistant_message",
+        ]:
             return True
 
         await context.emitter.update_step(step_dict)
@@ -349,7 +352,10 @@ class Step:
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and (self.parent_id or "message" not in self.type):
+        if config.ui.hide_cot and self.type not in [
+            "user_message",
+            "assistant_message",
+        ]:
             return self
 
         await context.emitter.send_step(step_dict)
@@ -374,7 +380,10 @@ class Step:
 
         assert self.id
 
-        if config.ui.hide_cot and (self.parent_id or "message" not in self.type):
+        if config.ui.hide_cot and self.type not in [
+            "user_message",
+            "assistant_message",
+        ]:
             return
 
         if not self.streaming:

chainlit/teams/__init__.py

@@ -0,0 +1,6 @@
+try:
+    import botbuilder
+except ModuleNotFoundError:
+    raise ValueError(
+        "The botbuilder-core package is required to integrate Chainlit with a Slack app. Run `pip install botbuilder-core --upgrade`"
+    )

chainlit/teams/app.py

@@ -0,0 +1,332 @@
+import asyncio
+import base64
+import mimetypes
+import os
+import uuid
+from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Union
+
+import filetype
+
+if TYPE_CHECKING:
+    from botbuilder.core import TurnContext
+    from botbuilder.schema import Activity
+
+import httpx
+from botbuilder.core import (
+    BotFrameworkAdapter,
+    BotFrameworkAdapterSettings,
+    MessageFactory,
+    TurnContext,
+)
+from botbuilder.schema import (
+    ActionTypes,
+    Activity,
+    ActivityTypes,
+    Attachment,
+    CardAction,
+    ChannelAccount,
+    HeroCard,
+)
+from chainlit.config import config
+from chainlit.context import ChainlitContext, HTTPSession, context_var
+from chainlit.data import get_data_layer
+from chainlit.element import Element, ElementDict
+from chainlit.emitter import BaseChainlitEmitter
+from chainlit.logger import logger
+from chainlit.message import Message, StepDict
+from chainlit.telemetry import trace
+from chainlit.types import Feedback
+from chainlit.user import PersistedUser, User
+from chainlit.user_session import user_session
+
+
+class TeamsEmitter(BaseChainlitEmitter):
+    def __init__(self, session: HTTPSession, turn_context: TurnContext, enabled=False):
+        super().__init__(session)
+        self.turn_context = turn_context
+        self.enabled = enabled
+
+    async def send_element(self, element_dict: ElementDict):
+        if not self.enabled or element_dict.get("display") != "inline":
+            return
+
+        persisted_file = self.session.files.get(element_dict.get("chainlitKey") or "")
+        attachment: Optional[Attachment] = None
+        mime: Optional[str] = None
+
+        element_name: str = element_dict.get("name", "Untitled")
+
+        if mime:
+            file_extension = mimetypes.guess_extension(mime)
+            if file_extension:
+                element_name += file_extension
+
+        if persisted_file:
+            mime = element_dict.get("mime")
+            with open(persisted_file["path"], "rb") as file:
+                dencoded_string = base64.b64encode(file.read()).decode()
+                content_url = f"data:{mime};base64,{dencoded_string}"
+                attachment = Attachment(
+                    content_type=mime, content_url=content_url, name=element_name
+                )
+
+        elif url := element_dict.get("url"):
+            attachment = Attachment(
+                content_type=mime, content_url=url, name=element_name
+            )
+
+        if not attachment:
+            return
+
+        await self.turn_context.send_activity(Activity(attachments=[attachment]))
+
+    async def send_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+
+        step_type = step_dict.get("type")
+        is_message = step_type in [
+            "user_message",
+            "assistant_message",
+        ]
+        is_chain_of_thought = bool(step_dict.get("parentId"))
+        is_empty_output = not step_dict.get("output")
+
+        if is_chain_of_thought or is_empty_output or not is_message:
+            return
+        else:
+            reply = MessageFactory.text(step_dict["output"])
+            enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+            if enable_feedback:
+                like_button = CardAction(
+                    type=ActionTypes.message_back,
+                    title="👍",
+                    text="like",
+                    value={"feedback": "like", "step_id": step_dict["id"]},
+                )
+                dislike_button = CardAction(
+                    type=ActionTypes.message_back,
+                    title="👎",
+                    text="dislike",
+                    value={"feedback": "dislike", "step_id": step_dict["id"]},
+                )
+                card = HeroCard(buttons=[like_button, dislike_button])
+                attachment = Attachment(
+                    content_type="application/vnd.microsoft.card.hero", content=card
+                )
+                reply.attachments = [attachment]
+
+            await self.turn_context.send_activity(reply)
+
+    async def update_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+
+        await self.send_step(step_dict)
+
+
+adapter_settings = BotFrameworkAdapterSettings(
+    app_id=os.environ.get("TEAMS_APP_ID"),
+    app_password=os.environ.get("TEAMS_APP_PASSWORD"),
+)
+adapter = BotFrameworkAdapter(adapter_settings)
+
+
+@trace
+def init_teams_context(
+    session: HTTPSession,
+    turn_context: TurnContext,
+) -> ChainlitContext:
+    emitter = TeamsEmitter(session=session, turn_context=turn_context)
+    context = ChainlitContext(session=session, emitter=emitter)
+    context_var.set(context)
+    user_session.set("teams_turn_context", turn_context)
+    return context
+
+
+users_by_teams_id: Dict[str, Union[User, PersistedUser]] = {}
+
+USER_PREFIX = "teams_"
+
+
+async def get_user(teams_user: ChannelAccount):
+    if teams_user.id in users_by_teams_id:
+        return users_by_teams_id[teams_user.id]
+
+    metadata = {
+        "name": teams_user.name,
+        "id": teams_user.id,
+    }
+    user = User(identifier=USER_PREFIX + str(teams_user.name), metadata=metadata)
+
+    users_by_teams_id[teams_user.id] = user
+
+    if data_layer := get_data_layer():
+        try:
+            persisted_user = await data_layer.create_user(user)
+            if persisted_user:
+                users_by_teams_id[teams_user.id] = persisted_user
+        except Exception as e:
+            logger.error(f"Error creating user: {e}")
+
+    return users_by_teams_id[teams_user.id]
+
+
+async def download_teams_file(url: str):
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+        if response.status_code == 200:
+            return response.content
+        else:
+            return None
+
+
+async def download_teams_files(
+    session: HTTPSession, attachments: Optional[List[Attachment]] = None
+):
+    if not attachments:
+        return []
+
+    attachments = [
+        attachment for attachment in attachments if isinstance(attachment.content, dict)
+    ]
+    download_coros = [
+        download_teams_file(attachment.content.get("downloadUrl"))
+        for attachment in attachments
+    ]
+    file_bytes_list = await asyncio.gather(*download_coros)
+    file_refs = []
+    for idx, file_bytes in enumerate(file_bytes_list):
+        if file_bytes:
+            name = attachments[idx].name
+            mime_type = filetype.guess_mime(file_bytes) or "application/octet-stream"
+            file_ref = await session.persist_file(
+                name=name, mime=mime_type, content=file_bytes
+            )
+            file_refs.append(file_ref)
+
+    files_dicts = [
+        session.files[file["id"]] for file in file_refs if file["id"] in session.files
+    ]
+
+    file_elements = [Element.from_dict(file_dict) for file_dict in files_dicts]
+
+    return file_elements
+
+
+def clean_content(activity: Activity):
+    return activity.text.strip()
+
+
+async def process_teams_message(
+    turn_context: TurnContext,
+    thread_name: str,
+):
+    user = await get_user(turn_context.activity.from_property)
+
+    thread_id = str(
+        uuid.uuid5(uuid.NAMESPACE_DNS, str(turn_context.activity.conversation.id))
+    )
+
+    text = clean_content(turn_context.activity)
+    teams_files = turn_context.activity.attachments
+
+    session_id = str(uuid.uuid4())
+
+    session = HTTPSession(
+        id=session_id,
+        thread_id=thread_id,
+        user=user,
+        client_type="teams",
+    )
+
+    ctx = init_teams_context(
+        session=session,
+        turn_context=turn_context,
+    )
+
+    file_elements = await download_teams_files(session, teams_files)
+
+    msg = Message(
+        content=text,
+        elements=file_elements,
+        type="user_message",
+        author=user.metadata.get("name"),
+    )
+
+    await msg.send()
+
+    ctx.emitter.enabled = True
+
+    if on_chat_start := config.code.on_chat_start:
+        await on_chat_start()
+
+    if on_message := config.code.on_message:
+        await on_message(msg)
+
+    if on_chat_end := config.code.on_chat_end:
+        await on_chat_end()
+
+    if data_layer := get_data_layer():
+        if isinstance(user, PersistedUser):
+            try:
+                await data_layer.update_thread(
+                    thread_id=thread_id,
+                    name=thread_name,
+                    metadata=ctx.session.to_persistable(),
+                    user_id=user.id,
+                )
+            except Exception as e:
+                logger.error(f"Error updating thread: {e}")
+
+    ctx.session.delete()
+
+
+async def handle_message(turn_context: TurnContext):
+    if turn_context.activity.type == ActivityTypes.message:
+        if (
+            turn_context.activity.text == "like"
+            or turn_context.activity.text == "dislike"
+        ):
+            feedback_value: Literal[0, 1] = (
+                0 if turn_context.activity.text == "dislike" else 1
+            )
+            step_id = turn_context.activity.value.get("step_id")
+            if data_layer := get_data_layer():
+                await data_layer.upsert_feedback(
+                    Feedback(forId=step_id, value=feedback_value)
+                )
+            updated_text = "👍" if turn_context.activity.text == "like" else "👎"
+            # Update the existing message to remove the buttons
+            updated_message = Activity(
+                type=ActivityTypes.message,
+                id=turn_context.activity.reply_to_id,
+                text=updated_text,
+                attachments=[],
+            )
+            await turn_context.update_activity(updated_message)
+        else:
+            # Send typing activity
+            typing_activity = Activity(
+                type=ActivityTypes.typing,
+                from_property=turn_context.activity.recipient,
+                recipient=turn_context.activity.from_property,
+                conversation=turn_context.activity.conversation,
+            )
+            await turn_context.send_activity(typing_activity)
+            thread_name = f"{turn_context.activity.from_property.name} Teams DM"
+            await process_teams_message(turn_context, thread_name)
+
+
+async def on_turn(turn_context: TurnContext):
+    await handle_message(turn_context)
+
+
+# Create the main bot class
+class TeamsBot:
+    async def on_turn(self, turn_context: TurnContext):
+        await on_turn(turn_context)
+
+
+# Create the bot instance
+bot = TeamsBot()

chainlit/translations/en-US.json

@@ -20,7 +20,7 @@
         "TaskList": {
           "title": "🗒️ Task List",
           "loading": "Loading...",
-          "error": "An error occured"
+          "error": "An error occurred"
         }
       },
       "attachments": {

chainlit/types.py

@@ -150,11 +150,16 @@ class FileDict(TypedDict):
     type: str
 
 
-class UIMessagePayload(TypedDict):
+class MessagePayload(TypedDict):
     message: "StepDict"
     fileReferences: Optional[List[FileReference]]
 
 
+class SystemMessagePayload(TypedDict):
+    content: str
+    metadata: Optional[Dict[str, Any]]
+
+
 class AudioChunkPayload(TypedDict):
     isStart: bool
     mimeType: str
@@ -193,21 +198,6 @@ class AskActionResponse(TypedDict):
     collapsed: bool
 
 
-class GenerationRequest(BaseModel):
-    chatGeneration: Optional[ChatGeneration] = None
-    completionGeneration: Optional[CompletionGeneration] = None
-    userEnv: Dict[str, str]
-
-    @property
-    def generation(self):
-        if self.chatGeneration:
-            return self.chatGeneration
-        return self.completionGeneration
-
-    def is_chat(self):
-        return self.chatGeneration is not None
-
-
 class DeleteThreadRequest(BaseModel):
     threadId: str
 
@@ -259,8 +249,8 @@ class FeedbackDict(TypedDict):
 @dataclass
 class Feedback:
     forId: str
-    threadId: Optional[str]
     value: Literal[0, 1]
+    threadId: Optional[str] = None
     id: Optional[str] = None
     comment: Optional[str] = None
 

chainlit/user.py

@@ -4,7 +4,15 @@ from dataclasses_json import DataClassJsonMixin
 from pydantic.dataclasses import Field, dataclass
 
 Provider = Literal[
-    "credentials", "header", "github", "google", "azure-ad", "okta", "auth0", "descope"
+    "credentials",
+    "header",
+    "github",
+    "google",
+    "azure-ad",
+    "azure-ad-hybrid",
+    "okta",
+    "auth0",
+    "descope",
 ]
 
 

chainlit/utils.py

@@ -1,12 +1,16 @@
 import functools
 import importlib
 import inspect
+import os
 from asyncio import CancelledError
 from typing import Callable
 
+import click
+from chainlit.auth import ensure_jwt_secret
 from chainlit.context import context
 from chainlit.logger import logger
 from chainlit.message import ErrorMessage
+from fastapi import FastAPI
 from packaging import version
 
 
@@ -87,3 +91,42 @@ def check_module_version(name, required_version):
     except ModuleNotFoundError:
         return False
     return version.parse(module.__version__) >= version.parse(required_version)
+
+
+def check_file(target: str):
+    # Define accepted file extensions for Chainlit
+    ACCEPTED_FILE_EXTENSIONS = ("py", "py3")
+
+    _, extension = os.path.splitext(target)
+
+    # Check file extension
+    if extension[1:] not in ACCEPTED_FILE_EXTENSIONS:
+        if extension[1:] == "":
+            raise click.BadArgumentUsage(
+                "Chainlit requires raw Python (.py) files, but the provided file has no extension."
+            )
+        else:
+            raise click.BadArgumentUsage(
+                f"Chainlit requires raw Python (.py) files, not {extension}."
+            )
+
+    if not os.path.exists(target):
+        raise click.BadParameter(f"File does not exist: {target}")
+
+
+def mount_chainlit(app: FastAPI, target: str, path="/chainlit"):
+    os.environ["CHAINLIT_ROOT_PATH"] = path
+    os.environ["CHAINLIT_SUBMOUNT"] = "true"
+    from chainlit.config import config, load_module
+    from chainlit.server import combined_asgi_app as chainlit_app
+
+    config.run.root_path = path
+
+    check_file(target)
+    # Load the module provided by the user
+    config.run.module_name = target
+    load_module(config.run.module_name)
+
+    ensure_jwt_secret()
+
+    app.mount("/", chainlit_app)

{chainlit-1.1.300rc4.dist-info → chainlit-1.1.301.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 1.1.300rc4
+Version: 1.1.301
 Summary: Build Conversational AI.
 Home-page: https://github.com/Chainlit/chainlit
 License: Apache-2.0 license
@@ -18,7 +18,6 @@ Requires-Dist: asyncer (>=0.0.2,<0.0.3)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: dataclasses_json (>=0.5.7,<0.6.0)
 Requires-Dist: fastapi (>=0.110.1,<0.111.0)
-Requires-Dist: fastapi-socketio (>=0.0.10,<0.0.11)
 Requires-Dist: filetype (>=1.2.0,<2.0.0)
 Requires-Dist: httpx (>=0.23.0)
 Requires-Dist: lazify (>=0.4.0,<0.5.0)
@@ -31,6 +30,7 @@ Requires-Dist: pydantic (>=1,<3)
 Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
+Requires-Dist: python-socketio (>=5.11.0,<6.0.0)
 Requires-Dist: starlette (>=0.37.2,<0.38.0)
 Requires-Dist: syncer (>=2.0.3,<3.0.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)

chainlit-1.1.301.dist-info/RECORD

@@ -0,0 +1,79 @@
+chainlit/__init__.py,sha256=g6MbN4Vuf8PbJTpTE2XNqVt-GklWQCk8g5_JZGbrB8M,11052
+chainlit/__main__.py,sha256=7Vg3w3T3qDuz4KDu5lQhLH6lQ3cYdume7gHH7Z1V97U,87
+chainlit/action.py,sha256=k-GsblVHI4DnDWFyF-RZgq3KfdfAFICFh2OBeU4w8N8,1410
+chainlit/auth.py,sha256=lLHePwmwKzX0LiWqpTAtKTdSecrDLqCMSY9Yw4c-TD8,2681
+chainlit/cache.py,sha256=Bv3dT4eHhE6Fq3c6Do0ZTpiyoXgXYewdxTgpYghEd9g,1361
+chainlit/chat_settings.py,sha256=2ByenmwS8O6jQjDVJjhhbLrBPGA5aY2F7R3VvQQxXPk,877
+chainlit/cli/__init__.py,sha256=iLyxU_9db-2n_MaSr6V0VNoQDxhwRIT10-OGlENlq7o,6163
+chainlit/config.py,sha256=o2eF5q6O2xSYXAryW8xljuj98HH8u_AFWpTq6bHbrqM,16712
+chainlit/context.py,sha256=wVtOHIAS9NufvnIW8e4VPHgD7W7pyrstEQGt29FtILc,3075
+chainlit/copilot/dist/assets/logo_dark-2a3cf740.svg,sha256=Kjz3QMh-oh-ag4YatjU0YCPqGF7F8nHh8VUQoJIs01E,8887
+chainlit/copilot/dist/assets/logo_light-b078e7bc.svg,sha256=sHjnvEq1rfqh3bcexJNYUY7WEDdTQZq3aKZYpi4w4ck,8889
+chainlit/copilot/dist/index.js,sha256=nnRtMY1HcLmpOTmwk9ah8tLwgp8_dpDSUJb1voFRW7w,6752568
+chainlit/data/__init__.py,sha256=cUT49s5AhIm5WDlESQEpahSl7k6nzlMAYSJgO_00kO0,17092
+chainlit/data/acl.py,sha256=5EwZuKVcZediw77L661MohGce3JzGIaYmw6NutmMTw0,578
+chainlit/data/dynamodb.py,sha256=u5L9xqp0FG6J2VuGqUjMiJmIddL5jXs4MUcoZb4mXsM,19420
+chainlit/data/sql_alchemy.py,sha256=OFjNnNcswZOgYZfnc7sH2_lJQQDQF6olw2xW8-JMqsg,26805
+chainlit/data/storage_clients.py,sha256=D9KY1XKDjZh2uuh01ECxeoEtjw-JlrCR-WCuOuePVQI,3007
+chainlit/discord/__init__.py,sha256=kZ_AAMaCToqO-1FdeQ8_IHS2pqNT0QJ-yyd8bCMaHHs,198
+chainlit/discord/app.py,sha256=KvBS-bL89tKzzz2-lqCQVaI2hb4qYTyhl_TzCdhMfHQ,10540
+chainlit/element.py,sha256=sjOgHjDaTuQ-t663dmBT-iBOgSVTn3mTlbSGjE42LjE,10990
+chainlit/emitter.py,sha256=BbZ0GwEY9DQu7cN2khgMqT7GzRK3dShPIJMRRwnGuag,13082
+chainlit/frontend/dist/assets/DailyMotion-578b63e6.js,sha256=FljqIxuYhDmbN82fvg-_8c_mlTZPj_G_DefTX4TKuUk,2961
+chainlit/frontend/dist/assets/Facebook-b825e5bb.js,sha256=SML0392XsEaiAX-umB3X4P1VxMmeyNGKSwNrf16504A,3216
+chainlit/frontend/dist/assets/FilePlayer-bcba3b4e.js,sha256=YxE74TiGD3kSs4tUhlyV39d2axLSOZ7ogfzsZq1MQdo,9041
+chainlit/frontend/dist/assets/Kaltura-fc1c9497.js,sha256=6GrAMBk1kETlbpFzcPMOOYkbjk_CUQem-nuiD2FimTw,2790
+chainlit/frontend/dist/assets/Mixcloud-4cfb2724.js,sha256=DLVwQ7RLYm4dvfClyoSFDB6rjG7vCFv8hiNbSN-vNYY,2638
+chainlit/frontend/dist/assets/Mux-aa92055c.js,sha256=unvszOgiIQfmZhFtEeIXJE5eiSr6w8Jx1sRpGZX4VlQ,5360
+chainlit/frontend/dist/assets/Preview-9f55905a.js,sha256=RXuDNVigADyu5lGUk-y5QrhiPp1RHqcE5-RylFprdBo,3011
+chainlit/frontend/dist/assets/SoundCloud-f991fe03.js,sha256=z8XVOBBfaskYyC-bRCsXb6qDFTH4mebmR5jsR5IiH44,2923
+chainlit/frontend/dist/assets/Streamable-53128f49.js,sha256=7WZSefvfRi_qnIS9LTa3PFrs-pgr48YiXM1DXplb1LI,2935
+chainlit/frontend/dist/assets/Twitch-fce8b9f5.js,sha256=H3rQ8YEW6AcejSWtvaVAcfjzQdYgdULPye5mTZ_nc_4,3083
+chainlit/frontend/dist/assets/Vidyard-e35c6102.js,sha256=UW5ad17Jlo5U1BjQG6sFEHvAp8ic6en2Uvb-4DuVb04,2857
+chainlit/frontend/dist/assets/Vimeo-fff35f8e.js,sha256=brWSILraomEKxRDGFR56wwZl81gvxvAvSVbGMCbHvB0,3627
+chainlit/frontend/dist/assets/Wistia-ec07dc64.js,sha256=VU557IGXuda6KYDPVrohXQWDoyIX385ooBt2eIn6LZA,3514
+chainlit/frontend/dist/assets/YouTube-ad068e2a.js,sha256=h-dP39j7ZP7AeqCrJLKlv_ZMD20GSc8nQeMJSaEiMLI,4448
+chainlit/frontend/dist/assets/index-aaf974a9.css,sha256=qvl0qUmR5u0JcmJAfkzaZpN-0ZKdQjzqCSE9cnrQpZQ,2559
+chainlit/frontend/dist/assets/index-d40d41cc.js,sha256=q548b7K04T5yFuuKXr3Z7_y24V5iM7ti_BNfLkRNgoQ,2753963
+chainlit/frontend/dist/assets/logo_dark-2a3cf740.svg,sha256=Kjz3QMh-oh-ag4YatjU0YCPqGF7F8nHh8VUQoJIs01E,8887
+chainlit/frontend/dist/assets/logo_light-b078e7bc.svg,sha256=sHjnvEq1rfqh3bcexJNYUY7WEDdTQZq3aKZYpi4w4ck,8889
+chainlit/frontend/dist/assets/react-plotly-b2c6442b.js,sha256=zOhmPUI82UBQWmBpKFKuAQF_bQT-sXGbG3-kigjMQQ4,3739251
+chainlit/frontend/dist/favicon.svg,sha256=0Cy8x28obT5eWW3nxZRhsEvu6_zMqrqbg0y6hT3D0Q0,6455
+chainlit/frontend/dist/index.html,sha256=cIwIROqkmnFNLWkOz4N_7S91qPJA6r9SuYe4pNguwS8,965
+chainlit/haystack/__init__.py,sha256=uZ77YiPy-qleSTi3dQCDO9HE6S6F6GpJWmh7jO4cxXA,217
+chainlit/haystack/callbacks.py,sha256=tItLc6OmskPeDEJH2Qjtg7KgAgIy1TuYQYHTZm9cr3U,5209
+chainlit/hello.py,sha256=LwENQWo5s5r8nNDn4iKSV77vX60Ky5r_qGjQhyi7qlY,416
+chainlit/input_widget.py,sha256=KmOn1nPTBvnld3iIBHR0Vih0KsCxVnTbo2t_xBNANzo,4949
+chainlit/langchain/__init__.py,sha256=zErMw0_3ufSGeF9ye7X0ZX3wDat4mTOx97T40ePDO2g,217
+chainlit/langchain/callbacks.py,sha256=MHl_m6FYZmCzn0e2KOlZpd6ld0rSP1LzuCKs4Eh_N_8,20517
+chainlit/langflow/__init__.py,sha256=wxhxdsl1yxdsRyNTgZticxFF_8VFtJJ4OdIy3tnEIyM,817
+chainlit/llama_index/__init__.py,sha256=weRoIWCaRBGvA1LczCEfsqhWsltQSVlhtRnTovtdo8w,227
+chainlit/llama_index/callbacks.py,sha256=THFmwotSF_ibqFuaQgxGvEjgKmmzoGJKNlVI75SI2ig,7267
+chainlit/logger.py,sha256=wTwRSZsLfXwWy6U4351IgWAm4KCMThgxm9EZpjGUEr4,373
+chainlit/markdown.py,sha256=VUpqW7MqgjiPIQYHU4funwqC4GmHZBu_TGZTjTI4B0k,2025
+chainlit/message.py,sha256=aEw2VNZ0-4mAC3PSG-0j5ZjO1qZ9MaUFDnfiAXLM_q8,17997
+chainlit/oauth_providers.py,sha256=Mv31biQ84EBJfQGBxqhFfnbpl-jfQ_Zn6IxKY3XZg6Q,22972
+chainlit/openai/__init__.py,sha256=DJP_ptclLUM5Zylr4RO1Vk0lCufo3yDqXyH5J9izYS8,1814
+chainlit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chainlit/secret.py,sha256=cQvIFGTQ7r2heC8EOGdgifSZZYqslh-qQxhUhKhD8vU,295
+chainlit/server.py,sha256=H8Oj4rEqY9OulwbNoZzcTc53U0vuYXUPREhYUNKLqpM,28626
+chainlit/session.py,sha256=SOX2zFct3apiSNcIzCDWgDRsUFgUG_6hewqWU8gfIZE,9694
+chainlit/slack/__init__.py,sha256=Q41ztJHeVmpoXVgVqAcwGOufQp_bjf7dDT7eEXDdhPI,207
+chainlit/slack/app.py,sha256=FgrlaupsCo-_1m8FiFcS5s-wFg_28bCjfKnawvlVbEM,11646
+chainlit/socket.py,sha256=0xUoHRQXqhTb9IB9k7rMM7gYIoLQgZed6jV337KtL54,11824
+chainlit/step.py,sha256=rLlK_dhZNKidK5Q7FtP_sNmlm-zUyjF4gHLPxl3PHA8,14213
+chainlit/sync.py,sha256=G1n-7-3WgXsN8y1bJkEyws_YwmHZIyDZoZUwhprigag,1235
+chainlit/teams/__init__.py,sha256=ZSEbsRJHT_mKfGn6yuzM5NX-xItleSDS0af7vt8Z1OA,217
+chainlit/teams/app.py,sha256=i4uu5BizcPH_h824ZFBNbpqM0weCfpPt3zb8YpQ-5po,10378
+chainlit/telemetry.py,sha256=Rk4dnZv0OnGOgV4kD-VHdhgl4i7i3ypqhSE_R-LZceM,3060
+chainlit/translations/en-US.json,sha256=J46wpkc01XLnytWNLSziillMvfmwXsc-mIUeYDIy59M,7741
+chainlit/translations.py,sha256=WG_r7HzxBYns-zk9tVvoGdoofv71okTZx8k1RlcoTIg,2034
+chainlit/types.py,sha256=1W_IexztYW5ewOfxXtdL6qJHWYLWJ5qC9JG0iu6Rnv4,5329
+chainlit/user.py,sha256=8PgRJvv59b7BKTNguObo68gyFoOGNJfVkT3WW-fvhAM,671
+chainlit/user_session.py,sha256=G1amgs1_h2tVn4mtAXZmunm9nlBHQ_rCYvJQh3nsVwQ,1645
+chainlit/utils.py,sha256=w3UIzvaQ72y5VrycFoWaqS_NocS40No7mzPWqkelzCE,3939
+chainlit/version.py,sha256=iosXhlXclBwBqlADFKEilxAC2wWKbtuBKi87AmPi7s8,196
+chainlit-1.1.301.dist-info/METADATA,sha256=Kh2rf0xg4Cm4O8G67VjEVp7a2h1OaHLW6ukJ4bLsY7w,6315
+chainlit-1.1.301.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+chainlit-1.1.301.dist-info/entry_points.txt,sha256=FrkqdjrFl8juSnvBndniyX7XuKojmUwO4ghRh-CFMQc,45
+chainlit-1.1.301.dist-info/RECORD,,

chainlit/cli/utils.py

@@ -1,24 +0,0 @@
-import os
-
-import click
-
-
-def check_file(target: str):
-    # Define accepted file extensions for Chainlit
-    ACCEPTED_FILE_EXTENSIONS = ("py", "py3")
-
-    _, extension = os.path.splitext(target)
-
-    # Check file extension
-    if extension[1:] not in ACCEPTED_FILE_EXTENSIONS:
-        if extension[1:] == "":
-            raise click.BadArgumentUsage(
-                "Chainlit requires raw Python (.py) files, but the provided file has no extension."
-            )
-        else:
-            raise click.BadArgumentUsage(
-                f"Chainlit requires raw Python (.py) files, not {extension}."
-            )
-
-    if not os.path.exists(target):
-        raise click.BadParameter(f"File does not exist: {target}")