chainlit 0.1.103__tar.gz → 0.2.1__tar.gz

{chainlit-0.1.103 → chainlit-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 0.1.103
+Version: 0.2.1
 Summary: A faster way to build chatbot UIs.
 Home-page: https://github.com/Chainlit/chainlit
 License: Apache-2.0 license
@@ -37,7 +37,7 @@ Description-Content-Type: text/markdown
 
 **A faster way to build chatbot UIs.**
 
-Chainlit lets you create chatbot UIs on top of any Python code in minutes. It’s all Python, open-source, and free!
+Chainlit lets you create chatbot UIs on top of any Python code in minutes. It’s all Python, open-source, and free! Some of the key features include intermediary steps visualisation, element management & display (images, text, carousel, etc.) as well as cloud deployment.
 
 [![](https://dcbadge.vercel.app/api/server/ZThrUxbAYw?style=flat)](https://discord.gg/ZThrUxbAYw)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/chainlit_io.svg?style=social&label=Follow%20%40chainlit_io)](https://twitter.com/chainlit_io)

{chainlit-0.1.103 → chainlit-0.2.1}/README.md

@@ -2,7 +2,7 @@
 
 **A faster way to build chatbot UIs.**
 
-Chainlit lets you create chatbot UIs on top of any Python code in minutes. It’s all Python, open-source, and free!
+Chainlit lets you create chatbot UIs on top of any Python code in minutes. It’s all Python, open-source, and free! Some of the key features include intermediary steps visualisation, element management & display (images, text, carousel, etc.) as well as cloud deployment.
 
 [![](https://dcbadge.vercel.app/api/server/ZThrUxbAYw?style=flat)](https://discord.gg/ZThrUxbAYw)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/chainlit_io.svg?style=social&label=Follow%20%40chainlit_io)](https://twitter.com/chainlit_io)

{chainlit-0.1.103 → chainlit-0.2.1}/chainlit/__init__.py

@@ -8,21 +8,21 @@ from chainlit.lc import monkey
 monkey.patch()
 
 from chainlit.sdk import get_sdk
-from chainlit.user_session import user_session
 from chainlit.config import config
 from chainlit.types import (
-    ElementDisplay,
     LLMSettings,
     AskSpec,
     AskFileSpec,
     AskFileResponse,
     AskResponse,
-    Action,
 )
 from chainlit.telemetry import trace
 from chainlit.version import __version__
 from chainlit.logger import logger
 from chainlit.server import socketio
+from chainlit.action import Action
+from chainlit.element import LocalImage, RemoteImage, Text
+from chainlit.user_session import user_session
 from typing import Callable, Any, List, Union
 from dotenv import load_dotenv
 import inspect
@@ -73,55 +73,6 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
     return wrapper
 
 
-@trace
-def send_text(text: str, name: str, display: ElementDisplay = "side"):
-    """
-    Send a text element to the chatbot UI.
-    If a project ID is configured, the element will be uploaded to the cloud storage.
-
-    Args:
-        text (str): The content of the text element.
-        name (str): The name of the text element to be displayed in the UI.
-        display (ElementDisplay, optional): Determines how the element should be displayed in the UI.
-            Choices are "side" (default) or "inline" or "page".
-    """
-    sdk = get_sdk()
-    if sdk:
-        sdk.send_text(text, name, display)
-
-
-@trace
-def send_local_image(path: str, name: str, display: ElementDisplay = "side"):
-    """
-    Send a local image to the chatbot UI.
-    If a project ID is configured, the image will be uploaded to the cloud storage.
-
-    Args:
-        path (str): The local file path of the image.
-        name (str): The name of the image to be displayed in the UI.
-        display (ElementDisplay, optional): Determines how the image should be displayed in the UI.
-            Choices are "side" (default) or "inline" or "page".
-    """
-    sdk = get_sdk()
-    if sdk:
-        sdk.send_local_image(path, name, display)
-
-
-@trace
-def send_image(url: str, name: str, display: ElementDisplay = "side"):
-    """
-    Send an image to the chatbot UI.
-    Args:
-        url (str): The URL of the image.
-        name (str): The name of the image to be displayed in the UI.
-        display (ElementDisplay, optional): Determines how the image should be displayed in the UI.
-            Choices are "side" (default) or "inline" or "page".
-    """
-    sdk = get_sdk()
-    if sdk:
-        sdk.send_image(url, name, display)
-
-
 @trace
 def send_message(
     content: str,
@@ -131,6 +82,8 @@ def send_message(
     indent=0,
     llm_settings: LLMSettings = None,
     end_stream=False,
+    actions: List[Action] = [],
+    elements: List[Union[LocalImage, RemoteImage, Text]] = [],
 ):
     """
     Send a message to the chatbot UI.
@@ -144,10 +97,13 @@ def send_message(
         indent (int, optional): If positive, the message will be nested in the UI.
         llm_settings (LLMSettings, optional): Settings of the LLM used to generate the prompt. This is useful for debug purposes in the prompt playground.
         end_stream (bool, optional): Pass True if this message was streamed.
+
+    Returns:
+        str: The message ID.
     """
     sdk = get_sdk()
     if sdk:
-        sdk.send_message(
+        msg_id = sdk.send_message(
             author=author,
             content=content,
             prompt=prompt,
@@ -157,6 +113,12 @@ def send_message(
             end_stream=end_stream,
         )
 
+        for action in actions:
+            action.send(for_id=msg_id)
+
+        for element in elements:
+            element.send(for_id=msg_id)
+
 
 @trace
 def send_error_message(content: str, author=config.chatbot_name, indent=0):
@@ -237,20 +199,6 @@ def ask_for_file(
             return None
 
 
-@trace
-def send_action(name: str, trigger: str, description=""):
-    """
-    Send an action to the chatbot UI.
-    Args:
-        name (str): The name of the action to send.
-        trigger (str): The text that should trigger the action when clicked.
-        description (str, optional): The description of the action. Defaults to "".
-    """
-    sdk = get_sdk()
-    if sdk:
-        sdk.send_action(name=name, trigger=trigger, description=description)
-
-
 @trace
 def start_stream(
     author=config.chatbot_name,
@@ -301,7 +249,6 @@ def langchain_factory(func: Callable) -> Callable:
     Returns:
         Callable[[], Any]: The decorated factory function.
     """
-    from chainlit.config import config
 
     config.lc_factory = wrap_user_function(func, with_task=True)
     return func
@@ -311,7 +258,8 @@ def langchain_factory(func: Callable) -> Callable:
 def langchain_postprocess(func: Callable[[Any], str]) -> Callable:
     """
     Useful to post process the response a LangChain object instantiated with @langchain_factory.
-    The decorated function takes the raw output of the LangChain object and return a string as the final response.
+    The decorated function takes the raw output of the LangChain object as input.
+    The response will NOT be automatically sent to the UI, you need to call send_message.
 
     Args:
         func (Callable[[Any], str]): The post-processing function to apply after generating a response. Takes the response as parameter.
@@ -319,7 +267,6 @@ def langchain_postprocess(func: Callable[[Any], str]) -> Callable:
     Returns:
         Callable[[Any], str]: The decorated post-processing function.
     """
-    from chainlit.config import config
 
     config.lc_postprocess = wrap_user_function(func)
     return func
@@ -337,7 +284,6 @@ def on_message(func: Callable) -> Callable:
     Returns:
         Callable[[str], Any]: The decorated on_message function.
     """
-    from chainlit.config import config
 
     config.on_message = wrap_user_function(func)
     return func
@@ -348,14 +294,14 @@ def langchain_run(func: Callable[[Any, str], str]) -> Callable:
     """
     Useful to override the default behavior of the LangChain object instantiated with @langchain_factory.
     Use when your agent run method has custom parameters.
-    This function should return a string as the final response.
+    Takes the LangChain agent and the user input as parameters.
+    The response will NOT be automatically sent to the UI, you need to call send_message.
     Args:
         func (Callable[[Any, str], str]): The function to be called when a new message is received. Takes the agent and user input as parameters and returns the output string.
 
     Returns:
         Callable[[Any, str], Any]: The decorated function.
     """
-    from chainlit.config import config
 
     config.lc_run = wrap_user_function(func)
     return func
@@ -371,7 +317,6 @@ def langchain_rename(func: Callable[[str], str]) -> Callable[[str], str]:
     Returns:
         Callable[[Any, str], Any]: The decorated function.
     """
-    from chainlit.config import config
 
     config.lc_rename = wrap_user_function(func)
     return func
@@ -388,7 +333,6 @@ def on_chat_start(func: Callable) -> Callable:
     Returns:
         Callable[], Any]: The decorated hook.
     """
-    from chainlit.config import config
 
     config.on_chat_start = wrap_user_function(func, with_task=True)
     return func
@@ -405,20 +349,20 @@ def on_stop(func: Callable) -> Callable:
     Returns:
         Callable[[], Any]: The decorated stop hook.
     """
-    from chainlit.config import config
 
     config.on_stop = wrap_user_function(func)
     return func
 
 
-def action(name: str) -> Callable:
+def action_callback(name: str) -> Callable:
     """
-    Callback to call when an action is triggered in the UI.
+    Callback to call when an action is clicked in the UI.
+
+    Args:
+        func (Callable[[Action], Any]): The action callback to exexute. First parameter is the action.
     """
 
     def decorator(func: Callable[[Action], Any]):
-        from chainlit.config import config
-
         config.action_callbacks[name] = wrap_user_function(func, with_task=True)
         return func
 
@@ -432,3 +376,26 @@ def sleep(duration: int):
         duration (int): The duration in seconds.
     """
     return socketio.sleep(duration)
+
+
+__all__ = [
+    "user_session",
+    "Action",
+    "LocalImage",
+    "RemoteImage",
+    "Text",
+    "send_message",
+    "send_error_message",
+    "ask_for_input",
+    "ask_for_file",
+    "start_stream",
+    "send_token",
+    "langchain_factory",
+    "langchain_postprocess",
+    "langchain_run",
+    "langchain_rename",
+    "on_chat_start",
+    "on_stop",
+    "action",
+    "sleep",
+]

chainlit-0.2.1/chainlit/action.py

@@ -0,0 +1,29 @@
+from pydantic.dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from chainlit.sdk import get_emit
+from chainlit.telemetry import trace_event
+
+
+@dataclass_json
+@dataclass
+class Action:
+    name: str
+    value: str
+    description: str = ""
+    forId: str = None
+
+    def __post_init__(self) -> None:
+        trace_event(f"init {self.__class__.__name__}")
+
+    def send(self, for_id: str):
+        emit = get_emit()
+        if emit:
+            trace_event(f"send {self.__class__.__name__}")
+            self.forId = for_id
+            emit("action", self.to_dict())
+
+    def remove(self):
+        emit = get_emit()
+        if emit:
+            trace_event(f"remove {self.__class__.__name__}")
+            emit("remove_action", self.to_dict())

{chainlit-0.1.103 → chainlit-0.2.1}/chainlit/client.py

@@ -20,13 +20,18 @@ class BaseClient(ABC):
         pass
 
     @abstractmethod
-    def upload_element(self, ext: str, content: bytes) -> int:
+    def upload_element(self, content: bytes) -> int:
         pass
 
     @abstractmethod
     def create_element(
-        self, conversation_id: str, type: ElementType, url: str, name: str, display: str
-    ) -> int:
+        self,
+        type: ElementType,
+        url: str,
+        name: str,
+        display: str,
+        for_id: str = None,
+    ) -> Dict[str, Any]:
         pass
 
 
@@ -95,18 +100,19 @@ class CloudClient(BaseClient):
         return int(res["data"]["createMessage"]["id"])
 
     def create_element(
-        self, type: ElementType, url: str, name: str, display: str
+        self, type: ElementType, url: str, name: str, display: str, for_id: str = None
     ) -> Dict[str, Any]:
         c_id = self.get_conversation_id()
 
         mutation = """
-        mutation ($conversationId: ID!, $type: String!, $url: String!, $name: String!, $display: String!) {
-            createElement(conversationId: $conversationId, type: $type, url: $url, name: $name, display: $display) {
+        mutation ($conversationId: ID!, $type: String!, $url: String!, $name: String!, $display: String!, $forId: String) {
+            createElement(conversationId: $conversationId, type: $type, url: $url, name: $name, display: $display, forId: $forId) {
                 id,
                 type,
                 url,
                 name,
-                display
+                display,
+                forId
             }
         }
         """
@@ -116,12 +122,13 @@ class CloudClient(BaseClient):
             "url": url,
             "name": name,
             "display": display,
+            "forId": for_id,
         }
         res = self.mutation(mutation, variables)
         return res["data"]["createElement"]
 
-    def upload_element(self, ext: str, content: bytes) -> str:
-        id = f"{uuid.uuid4()}{ext}"
+    def upload_element(self, content: bytes) -> str:
+        id = f"{uuid.uuid4()}"
         url = f"{self.url}/api/upload/file"
         body = {"projectId": self.project_id, "fileName": id}
 

{chainlit-0.1.103 → chainlit-0.2.1}/chainlit/config.py

@@ -1,12 +1,14 @@
 import os
 import sys
-from typing import Optional, Literal, Any, Callable, List, Dict
+from typing import Optional, Literal, Any, Callable, List, Dict, TYPE_CHECKING
 import tomli
-from chainlit.types import Action
 from pydantic.dataclasses import dataclass
 from importlib import machinery
 from chainlit.logger import logger
 
+if TYPE_CHECKING:
+    from chainlit.action import Action
+
 
 # Get the directory the script is running from
 root = os.getcwd()
@@ -71,7 +73,7 @@ class ChainlitConfig:
     # Path to the local langchain cache database
     lc_cache_path: str
     # Developer defined callbacks for each action. Key is the action name, value is the callback function.
-    action_callbacks: Dict[str, Callable[[Action], Any]]
+    action_callbacks: Dict[str, Callable[["Action"], Any]]
     # Directory where the Chainlit project is located
     root = root
     # Link to your github repo. This will add a github button in the UI's header.

chainlit-0.2.1/chainlit/element.py

@@ -0,0 +1,122 @@
+from pydantic.dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from typing import Dict
+from abc import ABC, abstractmethod
+from chainlit.sdk import get_sdk, BaseClient
+from chainlit.telemetry import trace_event
+from chainlit.types import ElementType, ElementDisplay
+
+
+@dataclass_json
+@dataclass
+class Element(ABC):
+    name: str
+    type: ElementType
+    display: ElementDisplay = "side"
+    forId: str = None
+
+    def __post_init__(self) -> None:
+        trace_event(f"init {self.__class__.__name__}")
+
+    @abstractmethod
+    def persist(self, client: BaseClient, for_id: str = None) -> Dict:
+        pass
+
+    def before_emit(self, element: Dict) -> Dict:
+        return element
+
+    def send(self, for_id: str = None):
+        sdk = get_sdk()
+
+        # Cloud is enabled, upload the element to S3
+        if sdk.client:
+            element = self.persist(sdk.client, for_id)
+        else:
+            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)
+
+
+@dataclass
+class LocalElementBase:
+    content: bytes
+
+
+@dataclass
+class LocalElement(Element, LocalElementBase):
+    def persist(self, client: BaseClient, for_id: str = None):
+        url = client.upload_element(content=self.content)
+        if url:
+            element = client.create_element(
+                name=self.name,
+                url=url,
+                type=self.type,
+                display=self.display,
+                for_id=for_id,
+            )
+            return element
+
+
+@dataclass
+class RemoteElementBase:
+    url: str
+
+
+@dataclass
+class RemoteElement(Element, RemoteElementBase):
+    def persist(self, client: BaseClient, for_id: str = None):
+        element = client.create_element(
+            name=self.name,
+            url=self.url,
+            type=self.type,
+            display=self.display,
+            for_id=for_id,
+        )
+        return element
+
+
+class LocalImage(LocalElement):
+    def __init__(
+        self,
+        name: str,
+        display: ElementDisplay = "side",
+        path: str = None,
+        content: bytes = None,
+    ):
+        if path:
+            with open(path, "rb") as f:
+                self.content = f.read()
+        elif content:
+            self.content = content
+        else:
+            raise ValueError("Must provide either path or content")
+
+        self.name = name
+        self.display = display
+        self.type = "image"
+
+
+class RemoteImage(RemoteElement):
+    def __init__(self, name: str, url: str, display: ElementDisplay = "side"):
+        self.name = name
+        self.display = display
+        self.type = "image"
+        self.url = url
+
+
+class Text(LocalElement):
+    def __init__(self, name: str, text: str, display: ElementDisplay = "side"):
+        self.name = name
+        self.display = display
+        self.type = "text"
+        self.content = bytes(text, "utf-8")
+
+    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