chainlit 0.2.110__py3-none-any.whl → 0.3.0__py3-none-any.whl

chainlit/client.py

@@ -1,8 +1,11 @@
 from typing import Dict, Any, Optional
-from python_graphql_client import GraphqlClient
 from abc import ABC, abstractmethod
 import uuid
-import requests
+
+import asyncio
+import aiohttp
+from python_graphql_client import GraphqlClient
+
 from chainlit.types import ElementType, ElementSize
 from chainlit.logger import logger
 from chainlit.config import config
@@ -13,31 +16,31 @@ class BaseClient(ABC):
     session_id: str
 
     @abstractmethod
-    def is_project_member(self, access_token: str) -> bool:
+    async def is_project_member(self, access_token: str) -> bool:
         pass
 
     @abstractmethod
-    def create_conversation(self, session_id: str) -> int:
+    async def create_conversation(self, session_id: str) -> int:
         pass
 
     @abstractmethod
-    def create_message(self, variables: Dict[str, Any]) -> int:
+    async def create_message(self, variables: Dict[str, Any]) -> int:
         pass
 
     @abstractmethod
-    def update_message(self, message_id: int, variables: Dict[str, Any]) -> bool:
+    async def update_message(self, message_id: int, variables: Dict[str, Any]) -> bool:
         pass
 
     @abstractmethod
-    def delete_message(self, message_id: int) -> bool:
+    async def delete_message(self, message_id: int) -> bool:
         pass
 
     @abstractmethod
-    def upload_element(self, content: bytes, mime: str) -> int:
+    async def upload_element(self, content: bytes, mime: str) -> str:
         pass
 
     @abstractmethod
-    def create_element(
+    async def create_element(
         self,
         type: ElementType,
         url: str,
@@ -50,16 +53,23 @@ class BaseClient(ABC):
         pass
 
 
+conversation_lock = asyncio.Lock()
+
+
 class CloudClient(BaseClient):
     conversation_id: Optional[str] = None
 
-    def __init__(self, project_id: str, session_id: str, access_token: str, url: str):
+    def __init__(self, project_id: str, session_id: str, access_token: str):
         self.project_id = project_id
         self.session_id = session_id
-        self.url = url
-        self.headers = {"Authorization": access_token}
-        graphql_endpoint = f"{url}/api/graphql"
-        self.client = GraphqlClient(endpoint=graphql_endpoint, headers=self.headers)
+        self.headers = {
+            "Authorization": access_token,
+            "content-type": "application/json",
+        }
+        graphql_endpoint = f"{config.chainlit_server}/api/graphql"
+        self.graphql_client = GraphqlClient(
+            endpoint=graphql_endpoint, headers=self.headers
+        )
 
     def query(self, query: str, variables: Dict[str, Any] = {}) -> Dict[str, Any]:
         """
@@ -69,7 +79,7 @@ class CloudClient(BaseClient):
         :param variables: A dictionary of variables for the query.
         :return: The response data as a dictionary.
         """
-        return self.client.execute(query=query, variables=variables)
+        return self.graphql_client.execute_async(query=query, variables=variables)
 
     def check_for_errors(self, response: Dict[str, Any]):
         if "errors" in response:
@@ -85,50 +95,53 @@ class CloudClient(BaseClient):
         :param variables: A dictionary of variables for the mutation.
         :return: The response data as a dictionary.
         """
-        return self.client.execute(query=mutation, variables=variables)
-
-    def is_project_member(self) -> bool:
-        try:
-            headers = {
-                "content-type": "application/json",
-                "Authorization": self.headers["Authorization"],
+        return self.graphql_client.execute_async(query=mutation, variables=variables)
+
+    async def is_project_member(self) -> bool:
+        data = {"projectId": self.project_id}
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{config.chainlit_server}/api/role",
+                json=data,
+                headers=self.headers,
+            ) as r:
+                if not r.ok:
+                    reason = await r.text()
+                    logger.error(f"Failed to get user role. {r.status}: {reason}")
+                    return False
+                json = await r.json()
+                role = json.get("role", "ANONYMOUS")
+                return role != "ANONYMOUS"
+
+    async def create_conversation(self, session_id: str) -> int:
+        # If we run multiple send concurrently, we need to make sure we don't create multiple conversations.
+        async with conversation_lock:
+            if self.conversation_id:
+                return self.conversation_id
+
+            mutation = """
+            mutation ($projectId: String!, $sessionId: String!) {
+                createConversation(projectId: $projectId, sessionId: $sessionId) {
+                    id
+                }
             }
-            data = {"projectId": self.project_id}
-            response = requests.post(
-                f"{config.chainlit_server}/api/role", headers=headers, json=data
-            )
-
-            role = response.json().get("role", "ANONYMOUS")
-            return role != "ANONYMOUS"
-        except Exception as e:
-            logger.exception(e)
-            return False
+            """
+            variables = {"projectId": self.project_id, "sessionId": session_id}
+            res = await self.mutation(mutation, variables)
 
-    def create_conversation(self, session_id: str) -> int:
-        mutation = """
-        mutation ($projectId: String!, $sessionId: String!) {
-            createConversation(projectId: $projectId, sessionId: $sessionId) {
-                id
-            }
-        }
-        """
-        variables = {"projectId": self.project_id, "sessionId": session_id}
-        res = self.mutation(mutation, variables)
-
-        if self.check_for_errors(res):
-            logger.warning("Could not create conversation.")
-            return None
+            if self.check_for_errors(res):
+                logger.warning("Could not create conversation.")
+                return None
 
-        return int(res["data"]["createConversation"]["id"])
+            return int(res["data"]["createConversation"]["id"])
 
-    def get_conversation_id(self):
-        if not self.conversation_id:
-            self.conversation_id = self.create_conversation(self.session_id)
+    async def get_conversation_id(self):
+        self.conversation_id = await self.create_conversation(self.session_id)
 
         return self.conversation_id
 
-    def create_message(self, variables: Dict[str, Any]) -> int:
-        c_id = self.get_conversation_id()
+    async def create_message(self, variables: Dict[str, Any]) -> int:
+        c_id = await self.get_conversation_id()
 
         if not c_id:
             logger.warning("Missing conversation ID, could not persist the message.")
@@ -137,21 +150,20 @@ class CloudClient(BaseClient):
         variables["conversationId"] = c_id
 
         mutation = """
-        mutation ($conversationId: ID!, $author: String!, $content: String!, $language: String, $prompt: String, $llmSettings: Json, $isError: Boolean, $indent: Int, $authorIsUser: Boolean, $waitForAnswer: Boolean) {
-            createMessage(conversationId: $conversationId, author: $author, content: $content, language: $language, prompt: $prompt, llmSettings: $llmSettings, isError: $isError, indent: $indent, authorIsUser: $authorIsUser, waitForAnswer: $waitForAnswer) {
+        mutation ($conversationId: ID!, $author: String!, $content: String!, $language: String, $prompt: String, $llmSettings: Json, $isError: Boolean, $indent: Int, $authorIsUser: Boolean, $waitForAnswer: Boolean, $createdAt: Float) {
+            createMessage(conversationId: $conversationId, author: $author, content: $content, language: $language, prompt: $prompt, llmSettings: $llmSettings, isError: $isError, indent: $indent, authorIsUser: $authorIsUser, waitForAnswer: $waitForAnswer, createdAt: $createdAt) {
                 id
             }
         }
         """
-        res = self.mutation(mutation, variables)
-
+        res = await self.mutation(mutation, variables)
         if self.check_for_errors(res):
             logger.warning("Could not create message.")
             return None
 
         return int(res["data"]["createMessage"]["id"])
 
-    def update_message(self, message_id: int, variables: Dict[str, Any]) -> bool:
+    async def update_message(self, message_id: int, variables: Dict[str, Any]) -> bool:
         mutation = """
         mutation ($messageId: ID!, $author: String!, $content: String!, $language: String, $prompt: String, $llmSettings: Json) {
             updateMessage(messageId: $messageId, author: $author, content: $content, language: $language, prompt: $prompt, llmSettings: $llmSettings) {
@@ -160,7 +172,7 @@ class CloudClient(BaseClient):
         }
         """
         variables["messageId"] = message_id
-        res = self.mutation(mutation, variables)
+        res = await self.mutation(mutation, variables)
 
         if self.check_for_errors(res):
             logger.warning("Could not update message.")
@@ -168,7 +180,7 @@ class CloudClient(BaseClient):
 
         return True
 
-    def delete_message(self, message_id: int) -> bool:
+    async def delete_message(self, message_id: int) -> bool:
         mutation = """
         mutation ($messageId: ID!) {
             deleteMessage(messageId: $messageId) {
@@ -176,7 +188,7 @@ class CloudClient(BaseClient):
             }
         }
         """
-        res = self.mutation(mutation, {"messageId": message_id})
+        res = await self.mutation(mutation, {"messageId": message_id})
 
         if self.check_for_errors(res):
             logger.warning("Could not delete message.")
@@ -184,7 +196,7 @@ class CloudClient(BaseClient):
 
         return True
 
-    def create_element(
+    async def create_element(
         self,
         type: ElementType,
         url: str,
@@ -194,7 +206,7 @@ class CloudClient(BaseClient):
         language: str = None,
         for_id: str = None,
     ) -> Dict[str, Any]:
-        c_id = self.get_conversation_id()
+        c_id = await self.get_conversation_id()
 
         if not c_id:
             logger.warning("Missing conversation ID, could not persist the element.")
@@ -224,7 +236,7 @@ class CloudClient(BaseClient):
             "language": language,
             "forId": for_id,
         }
-        res = self.mutation(mutation, variables)
+        res = await self.mutation(mutation, variables)
 
         if self.check_for_errors(res):
             logger.warning("Could not persist element.")
@@ -232,34 +244,44 @@ class CloudClient(BaseClient):
 
         return res["data"]["createElement"]
 
-    def upload_element(self, content: bytes, mime: str) -> str:
+    async def upload_element(self, content: bytes, mime: str) -> str:
         id = f"{uuid.uuid4()}"
-        url = f"{self.url}/api/upload/file"
-        body = {"projectId": self.project_id, "fileName": id}
-        if mime:
-            body["contentType"] = mime
+        body = {"projectId": self.project_id, "fileName": id, "contentType": mime}
+
+        path = f"/api/upload/file"
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{config.chainlit_server}{path}",
+                json=body,
+                headers=self.headers,
+            ) as r:
+                if not r.ok:
+                    reason = await r.text()
+                    logger.error(f"Failed to upload file: {reason}")
+                    return ""
+                json_res = await r.json()
 
-        res = requests.post(url, json=body, headers=self.headers)
-
-        if not res.ok:
-            logger.error(f"Failed to upload file: {res.text}")
-            return ""
-
-        json_res = res.json()
         upload_details = json_res["post"]
         permanent_url = json_res["permanentUrl"]
 
-        files = {"file": content}
-
-        upload_response = requests.post(
-            upload_details["url"],
-            data=upload_details["fields"],
-            files=files,
-        )
-
-        if not upload_response.ok:
-            logger.error(f"Failed to upload file: {upload_response.text}")
-            return ""
-
-        url = f'{upload_details["url"]}/{upload_details["fields"]["key"]}'
-        return permanent_url
+        form_data = aiohttp.FormData()
+
+        # Add fields to the form_data
+        for field_name, field_value in upload_details["fields"].items():
+            form_data.add_field(field_name, field_value)
+
+        # Add file to the form_data
+        form_data.add_field("file", content, content_type="multipart/form-data")
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                upload_details["url"],
+                data=form_data,
+            ) as upload_response:
+                if not upload_response.ok:
+                    reason = await upload_response.text()
+                    logger.error(f"Failed to upload file: {reason}")
+                    return ""
+
+                url = f'{upload_details["url"]}/{upload_details["fields"]["key"]}'
+                return permanent_url

chainlit/config.py

@@ -9,11 +9,12 @@ from chainlit.logger import logger
 if TYPE_CHECKING:
     from chainlit.action import Action
 
+PACKAGE_ROOT = os.path.dirname(__file__)
 
 # Get the directory the script is running from
-root = os.getcwd()
+APP_ROOT = os.getcwd()
 
-config_dir = os.path.join(root, ".chainlit")
+config_dir = os.path.join(APP_ROOT, ".chainlit")
 config_file = os.path.join(config_dir, "config.toml")
 
 # Default config file created if none exists
@@ -53,8 +54,24 @@ chainlit_prod_url = os.environ.get("CHAINLIT_PROD_URL")
 chainlit_server = "https://cloud.chainlit.io"
 
 
+DEFAULT_HOST = "0.0.0.0"
+DEFAULT_PORT = 8000
+
+
+@dataclass()
+class RunSettings:
+    host: str = DEFAULT_HOST
+    port: int = DEFAULT_PORT
+    headless: bool = False
+    watch: bool = False
+    no_cache: bool = False
+    debug: bool = False
+    ci: bool = False
+
+
 @dataclass()
 class ChainlitConfig:
+    run_settings: RunSettings
     # Chainlit server URL. Used only for cloud features
     chainlit_server: str
     # Name of the app and chatbot. Used as the default message author.
@@ -74,7 +91,7 @@ class ChainlitConfig:
     # Developer defined callbacks for each action. Key is the action name, value is the callback function.
     action_callbacks: Dict[str, Callable[["Action"], Any]]
     # Directory where the Chainlit project is located
-    root = root
+    root = APP_ROOT
     # The url of the deployed app. Only set if the app is deployed.
     chainlit_prod_url = chainlit_prod_url
     # Link to your github repo. This will add a github button in the UI's header.
@@ -91,6 +108,7 @@ class ChainlitConfig:
     on_stop: Optional[Callable[[], Any]] = None
     on_chat_start: Optional[Callable[[], Any]] = None
     on_message: Optional[Callable[[str], Any]] = None
+    lc_agent_is_async: Optional[bool] = None
     lc_run: Optional[Callable[[Any, str], str]] = None
     lc_postprocess: Optional[Callable[[Any], str]] = None
     lc_factory: Optional[Callable[[], Any]] = None
@@ -174,6 +192,7 @@ def load_config():
         lc_cache_path = os.path.join(config_dir, ".langchain.db")
 
         config = ChainlitConfig(
+            run_settings=RunSettings(),
             action_callbacks={},
             github=github,
             request_limit=request_limit,

chainlit/element.py

@@ -1,97 +1,75 @@
 from pydantic.dataclasses import dataclass
 from dataclasses_json import dataclass_json
-from typing import Dict
+from typing import Dict, Union
 import uuid
-from abc import ABC, abstractmethod
-from chainlit.sdk import get_sdk, BaseClient
+import aiofiles
+
+from chainlit.emitter import get_emitter, BaseClient
 from chainlit.telemetry import trace_event
 from chainlit.types import ElementType, ElementDisplay, ElementSize
-from base64 import b64encode, b64decode
-from urllib import parse as urlparse
+
+type_to_mime = {
+    "image": "binary/octet-stream",
+    "text": "text/plain",
+    "pdf": "application/pdf",
+}
 
 
 @dataclass_json
 @dataclass
-class Element(ABC):
+class Element:
+    # Name of the element, this will be used to reference the element in the UI.
     name: str
+    # The type of the element. This will be used to determine how to display the element in the UI.
     type: ElementType
+    # Controls how the image element should be displayed in the UI. Choices are “side” (default), “inline”, or “page”.
     display: ElementDisplay = "side"
+    # The URL of the element if already hosted somehwere else.
+    url: str = None
+    # The local path of the element.
+    path: str = None
+    # The byte content of the element.
+    content: bytes = None
+    # The ID of the element. This is set automatically when the element is sent to the UI if cloud is enabled.
     id: int = None
+    # The ID of the element if cloud is disabled.
     tempId: str = None
+    # The ID of the message this element is associated with.
     forId: str = None
 
     def __post_init__(self) -> None:
         trace_event(f"init {self.__class__.__name__}")
+        self.emitter = get_emitter()
+        if not self.emitter:
+            raise RuntimeError("Element should be instantiated in a Chainlit context")
 
-    @abstractmethod
-    def persist(self, client: BaseClient, for_id: str = None) -> Dict:
-        pass
-
-    def before_emit(self, element: Dict) -> Dict:
-        return element
+        if not self.url and not self.path and not self.content:
+            raise ValueError("Must provide url, path or content to instantiate element")
 
-    def send(self, for_id: str = None):
-        sdk = get_sdk()
-
-        element = None
-
-        # Cloud is enabled, upload the element to S3
-        if sdk.client:
-            element = self.persist(sdk.client, for_id)
-            self.id = element["id"]
-
-        if not element:
-            self.tempId = uuid.uuid4().hex
-            element = self.to_dict()
-            if for_id:
-                element["forId"] = for_id
-
-        if sdk.emit and element:
-            trace_event(f"send {self.__class__.__name__}")
-            element = self.before_emit(element)
-            sdk.emit("element", element)
+        self.tempId = uuid.uuid4().hex
 
+    async def preprocess_content(self):
+        pass
 
-@dataclass
-class LocalElement(Element):
-    content: bytes = None
+    async def load(self):
+        if self.path:
+            async with aiofiles.open(self.path, "rb") as f:
+                self.content = await f.read()
+                await self.preprocess_content()
+        elif self.content:
+            await self.preprocess_content()
+        else:
+            raise ValueError("Must provide path or content to load element")
 
-    def persist(self, client: BaseClient, for_id: str = None):
-        if not self.content:
-            raise ValueError("Must provide content")
-        url = client.upload_element(content=self.content, mime=None)
-        if url:
-            size = getattr(self, "size", None)
-            language = getattr(self, "language", None)
-            element = client.create_element(
-                name=self.name,
-                url=url,
-                type=self.type,
-                display=self.display,
-                size=size,
-                language=language,
-                for_id=for_id,
+    async def persist(self, client: BaseClient, for_id: str = None):
+        if not self.url and self.content:
+            self.url = await client.upload_element(
+                content=self.content, mime=type_to_mime[self.type]
             )
-            return element
-
-
-@dataclass
-class RemoteElementBase:
-    url: str
 
-
-@dataclass
-class ImageBase:
-    type: ElementType = "image"
-    size: ElementSize = "medium"
-
-
-@dataclass
-class RemoteElement(Element, RemoteElementBase):
-    def persist(self, client: BaseClient, for_id: str = None):
         size = getattr(self, "size", None)
         language = getattr(self, "language", None)
-        element = client.create_element(
+        element = await client.create_element(
             name=self.name,
             url=self.url,
             type=self.type,
@@ -102,47 +80,73 @@ class RemoteElement(Element, RemoteElementBase):
         )
         return element
 
+    async def before_emit(self, element: Dict) -> Dict:
+        return element
 
-@dataclass
-class LocalImage(ImageBase, LocalElement):
-    """Useful to send an image living on the local filesystem to the UI."""
+    async def send(self, for_id: str = None):
+        element = None
 
-    path: str = None
+        if not self.content and not self.url and self.path:
+            await self.load()
 
-    def __post_init__(self):
-        if self.path:
-            with open(self.path, "rb") as f:
-                self.content = f.read()
-        elif self.content:
-            self.content = self.content
-        else:
-            raise ValueError("Must provide either path or content")
+        # Cloud is enabled, upload the element to S3
+        if self.emitter.client and not self.id:
+            element = await self.persist(self.emitter.client, for_id)
+            self.id = element["id"]
 
+        elif not self.url and not self.content:
+            raise ValueError("Must provide url or content to send element")
+
+        element = self.to_dict()
+        if for_id:
+            element["forId"] = for_id
+
+        if self.emitter.emit and element:
+            trace_event(f"send {self.__class__.__name__}")
+            element = await self.before_emit(element)
+            await self.emitter.emit("element", element)
 
-@dataclass
-class RemoteImage(ImageBase, RemoteElement):
-    """Useful to send an image based on an URL to the UI."""
 
-    pass
+@dataclass
+class Image(Element):
+    type: ElementType = "image"
+    size: ElementSize = "medium"
 
 
 @dataclass
-class TextBase:
-    text: str
+class Avatar(Element):
+    type: ElementType = "avatar"
+
+    async def send(self):
+        element = None
+
+        if not self.content and not self.url and self.path:
+            await self.load()
+
+        if not self.url and not self.content:
+            raise ValueError("Must provide url or content to send element")
+
+        element = self.to_dict()
+
+        if self.emitter.emit and element:
+            trace_event(f"send {self.__class__.__name__}")
+            element = await self.before_emit(element)
+            await self.emitter.emit("element", element)
 
 
 @dataclass
-class Text(LocalElement, TextBase):
+class Text(Element):
     """Useful to send a text (not a message) to the UI."""
 
+    content: Union[str, bytes] = None
     type: ElementType = "text"
-    content = bytes("", "utf-8")
     language: str = None
 
-    def __post_init__(self):
-        self.content = bytes(self.text, "utf-8")
+    async def preprocess_content(self):
+        if isinstance(self.content, str):
+            self.content = self.content.encode("utf-8")
 
-    def before_emit(self, text_element):
+    async def before_emit(self, text_element):
         if "content" in text_element and isinstance(text_element["content"], bytes):
             text_element["content"] = text_element["content"].decode("utf-8")
         return text_element
@@ -150,39 +154,6 @@ class Text(LocalElement, TextBase):
 
 @dataclass
 class Pdf(Element):
-    """Useful to send a pdf (remote or local) to the UI."""
+    """Useful to send a pdf to the UI."""
 
     type: ElementType = "pdf"
-    url: str = None
-    path: str = None
-    content: bytes = None
-
-    def persist(self, client: BaseClient, for_id: str = None):
-        if not self.content and not self.url:
-            raise ValueError("Must provide content or url")
-
-        # Either upload the content or use the url
-        url = None
-        if self.content:
-            url = client.upload_element(content=self.content, mime="application/pdf")
-        else:
-            url = self.url
-
-        if url:
-            element = client.create_element(
-                name=self.name,
-                url=url,
-                type=self.type,
-                display=self.display,
-                for_id=for_id,
-            )
-            return element
-
-    def __post_init__(self):
-        if self.path:
-            with open(self.path, "rb") as f:
-                self.content = f.read()
-        elif self.content or self.url:
-            pass  # do nothing here
-        else:
-            raise ValueError("Must provide either path, content or url")