chainlit 1.0.401__py3-none-any.whl → 2.0.4__py3-none-any.whl

chainlit/translations/zh-CN.json

@@ -0,0 +1,243 @@
+{
+  "components": {
+    "atoms": {
+      "buttons": {
+        "userButton": {
+          "menu": {
+            "settings": "设置",
+            "settingsKey": "S",
+            "APIKeys": "API 密钥",
+            "logout": "登出"
+          }
+        }
+      }
+    },
+    "molecules": {
+      "newChatButton": {
+        "newChat": "新建对话"
+      },
+      "tasklist": {
+        "TaskList": {
+          "title": "\ud83d\uddd2\ufe0f 任务列表",
+          "loading": "加载中...",
+          "error": "发生错误"
+        }
+      },
+      "attachments": {
+        "cancelUpload": "取消上传",
+        "removeAttachment": "移除附件"
+      },
+      "newChatDialog": {
+        "createNewChat": "创建新对话？",
+        "clearChat": "这将清除当前消息并开始新的对话。",
+        "cancel": "取消",
+        "confirm": "确认"
+      },
+      "settingsModal": {
+        "settings": "设置",
+        "expandMessages": "展开消息",
+        "hideChainOfThought": "隐藏思考链",
+        "darkMode": "暗色模式"
+      },
+      "detailsButton": {
+        "using": "使用",
+        "used": "已用"
+      },
+      "auth": {
+        "authLogin": {
+          "title": "登录以访问应用。",
+          "form": {
+            "email": "电子邮箱地址",
+            "password": "密码",
+            "noAccount": "没有账户？",
+            "alreadyHaveAccount": "已有账户？",
+            "signup": "注册",
+            "signin": "登录",
+            "or": "或者",
+            "continue": "继续",
+            "forgotPassword": "忘记密码？",
+            "passwordMustContain": "您的密码必须包含：",
+            "emailRequired": "电子邮箱是必填项",
+            "passwordRequired": "密码是必填项"
+          },
+          "error": {
+            "default": "无法登录。",
+            "signin": "尝试使用不同的账户登录。",
+            "oauthsignin": "尝试使用不同的账户登录。",
+            "redirect_uri_mismatch": "重定向URI与OAuth应用配置不匹配。",
+            "oauthcallbackerror": "尝试使用不同的账户登录。",
+            "oauthcreateaccount": "尝试使用不同的账户登录。",
+            "emailcreateaccount": "尝试使用不同的账户登录。",
+            "callback": "尝试使用不同的账户登录。",
+            "oauthaccountnotlinked": "为了验证您的身份，请使用最初使用的同一账户登录。",
+            "emailsignin": "无法发送邮件。",
+            "emailverify": "请验证您的电子邮件，已发送一封新邮件。",
+            "credentialssignin": "登录失败。请检查您提供的详细信息是否正确。",
+            "sessionrequired": "请登录以访问此页面。"
+          }
+        },
+        "authVerifyEmail": {
+          "almostThere": "您快成功了！我们已向 ",
+          "verifyEmailLink": "请单击该邮件中的链接以完成注册。",
+          "didNotReceive": "没找到邮件？",
+          "resendEmail": "重新发送邮件",
+          "goBack": "返回",
+          "emailSent": "邮件已成功发送。",
+          "verifyEmail": "验证您的电子邮件地址"
+        },
+        "providerButton": {
+          "continue": "使用{{provider}}继续",
+          "signup": "使用{{provider}}注册"
+        },
+        "authResetPassword": {
+          "newPasswordRequired": "新密码是必填项",
+          "passwordsMustMatch": "密码必须一致",
+          "confirmPasswordRequired": "确认密码是必填项",
+          "newPassword": "新密码",
+          "confirmPassword": "确认密码",
+          "resetPassword": "重置密码"
+        },
+        "authForgotPassword": {
+          "email": "电子邮箱地址",
+          "emailRequired": "电子邮箱是必填项",
+          "emailSent": "请检查电子邮箱{{email}}以获取重置密码的指示。",
+          "enterEmail": "请输入您的电子邮箱地址，我们将发送重置密码的指示。",
+          "resendEmail": "重新发送邮件",
+          "continue": "继续",
+          "goBack": "返回"
+        }
+      }
+    },
+    "organisms": {
+      "chat": {
+        "history": {
+          "index": {
+            "showHistory": "显示历史",
+            "lastInputs": "最后输入",
+            "noInputs": "如此空旷...",
+            "loading": "加载中..."
+          }
+        },
+        "inputBox": {
+          "input": {
+            "placeholder": "在这里输入您的消息..."
+          },
+          "speechButton": {
+            "start": "开始录音",
+            "stop": "停止录音",
+            "loading": "连接中"
+          },
+          "SubmitButton": {
+            "sendMessage": "发送消息",
+            "stopTask": "停止任务"
+          },
+          "UploadButton": {
+            "attachFiles": "附加文件"
+          },
+          "waterMark": {
+            "text": "使用"
+          }
+        },
+        "Messages": {
+          "index": {
+            "running": "运行中",
+            "executedSuccessfully": "执行成功",
+            "failed": "失败",
+            "feedbackUpdated": "反馈更新",
+            "updating": "正在更新"
+          },
+          "copyButton": {
+            "copyToClipboard": "拷贝到剪贴板",
+            "copied": "已拷贝！"
+          },
+          "feedbackButton": {
+            "helpful": "Helpful",
+            "notHelpful": "Not helpful",
+            "editFeedback": "Edit feedback"
+          },
+          "feedbackDialog": {
+            "dialogTitle": "Add a comment",
+            "submitButton": "Submit feedback"
+          }
+        },
+        "dropScreen": {
+          "dropYourFilesHere": "在这里拖放您的文件"
+        },
+        "index": {
+          "failedToUpload": "上传失败",
+          "cancelledUploadOf": "取消上传",
+          "couldNotReachServer": "无法连接到服务器",
+          "continuingChat": "继续之前的对话"
+        },
+        "settings": {
+          "settingsPanel": "设置面板",
+          "reset": "重置",
+          "cancel": "取消",
+          "confirm": "确认"
+        }
+      },
+      "threadHistory": {
+        "sidebar": {
+          "filters": {
+            "FeedbackSelect": {
+              "feedbackAll": "反馈：全部",
+              "feedbackPositive": "反馈：正面",
+              "feedbackNegative": "反馈：负面"
+            },
+            "SearchBar": {
+              "search": "搜索"
+            }
+          },
+          "DeleteThreadButton": {
+            "confirmMessage": "这将删除线程及其消息和元素。",
+            "cancel": "取消",
+            "confirm": "确认",
+            "deletingChat": "删除对话",
+            "chatDeleted": "对话已删除"
+          },
+          "index": {
+            "pastChats": "过往对话"
+          },
+          "ThreadList": {
+            "empty": "空的...",
+            "today": "今天",
+            "yesterday": "昨天",
+            "previous7days": "前7天",
+            "previous30days": "前30天"
+          },
+          "TriggerButton": {
+            "closeSidebar": "关闭侧边栏",
+            "openSidebar": "打开侧边栏"
+          }
+        },
+        "Thread": {
+          "backToChat": "返回对话",
+          "chatCreatedOn": "此对话创建于"
+        }
+      },
+      "header": {
+        "chat": "对话",
+        "readme": "说明"
+      }
+    }
+  },
+  "hooks": {
+    "useLLMProviders": {
+      "failedToFetchProviders": "获取提供者失败:"
+    }
+  },
+  "pages": {
+    "Design": {},
+    "Env": {
+      "savedSuccessfully": "保存成功",
+      "requiredApiKeys": "必需的API密钥",
+      "requiredApiKeysInfo": "要使用此应用，需要以下API密钥。这些密钥存储在您的设备本地存储中。"
+    },
+    "Page": {
+      "notPartOfProject": "您不是此项目的一部分。"
+    },
+    "ResumeButton": {
+      "resumeChat": "恢复对话"
+    }
+  }
+}

chainlit/translations.py

@@ -0,0 +1,60 @@
+# TODO:
+# - Support linting plural
+# - Support interpolation
+
+
+def compare_json_structures(truth, to_compare, path=""):
+    """
+    Compare the structure of two deeply nested JSON objects.
+    Args:
+        truth (dict): The 'truth' JSON object.
+        to_compare (dict): The 'to_compare' JSON object.
+        path (str): The current path for error reporting (used internally).
+    Returns:
+        A list of differences found.
+    """
+    if not isinstance(truth, dict) or not isinstance(to_compare, dict):
+        raise ValueError("Both inputs must be dictionaries.")
+
+    errors = []
+
+    truth_keys = set(truth.keys())
+    to_compare_keys = set(to_compare.keys())
+
+    extra_keys = to_compare_keys - truth_keys
+    missing_keys = truth_keys - to_compare_keys
+
+    for key in extra_keys:
+        errors.append(f"⚠️ Extra key: '{path + '.' + key if path else key}'")
+
+    for key in missing_keys:
+        errors.append(f"❌ Missing key: '{path + '.' + key if path else key}'")
+
+    for key in truth_keys & to_compare_keys:
+        if isinstance(truth[key], dict) and isinstance(to_compare[key], dict):
+            # Recursive call to navigate through nested dictionaries
+            errors += compare_json_structures(
+                truth[key], to_compare[key], path + "." + key if path else key
+            )
+        elif not isinstance(truth[key], dict) and not isinstance(to_compare[key], dict):
+            # If both are not dicts, we are at leaf nodes and structure matches; skip value comparison
+            continue
+        else:
+            # Structure mismatch: one is a dict, the other is not
+            errors.append(
+                f"❌ Structure mismatch at: '{path + '.' + key if path else key}'"
+            )
+
+    return errors
+
+
+def lint_translation_json(file, truth, to_compare):
+    print(f"\nLinting {file}...")
+
+    errors = compare_json_structures(truth, to_compare)
+
+    if errors:
+        for error in errors:
+            print(f"{error}")
+    else:
+        print(f"✅ No errors found in {file}")

chainlit/types.py

@@ -1,13 +1,24 @@
 from enum import Enum
-from typing import TYPE_CHECKING, Dict, List, Literal, Optional, TypedDict, Union
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Protocol,
+    TypedDict,
+    TypeVar,
+    Union,
+)
 
 if TYPE_CHECKING:
     from chainlit.element import ElementDict
-    from chainlit.user import UserDict
     from chainlit.step import StepDict
 
 from dataclasses_json import DataClassJsonMixin
-from literalai import ChatGeneration, CompletionGeneration
 from pydantic import BaseModel
 from pydantic.dataclasses import dataclass
 
@@ -20,7 +31,8 @@ class ThreadDict(TypedDict):
     id: str
     createdAt: str
     name: Optional[str]
-    user: Optional["UserDict"]
+    userId: Optional[str]
+    userIdentifier: Optional[str]
     tags: Optional[List[str]]
     metadata: Optional[Dict]
     steps: List["StepDict"]
@@ -33,11 +45,68 @@ class Pagination(BaseModel):
 
 
 class ThreadFilter(BaseModel):
-    feedback: Optional[Literal[-1, 0, 1]] = None
-    userIdentifier: Optional[str] = None
+    feedback: Optional[Literal[0, 1]] = None
+    userId: Optional[str] = None
     search: Optional[str] = None
 
 
+@dataclass
+class PageInfo:
+    hasNextPage: bool
+    startCursor: Optional[str]
+    endCursor: Optional[str]
+
+    def to_dict(self):
+        return {
+            "hasNextPage": self.hasNextPage,
+            "startCursor": self.startCursor,
+            "endCursor": self.endCursor,
+        }
+
+    @classmethod
+    def from_dict(cls, page_info_dict: Dict) -> "PageInfo":
+        hasNextPage = page_info_dict.get("hasNextPage", False)
+        startCursor = page_info_dict.get("startCursor", None)
+        endCursor = page_info_dict.get("endCursor", None)
+        return cls(
+            hasNextPage=hasNextPage, startCursor=startCursor, endCursor=endCursor
+        )
+
+
+T = TypeVar("T", covariant=True)
+
+
+class HasFromDict(Protocol[T]):
+    @classmethod
+    def from_dict(cls, obj_dict: Any) -> T:
+        raise NotImplementedError
+
+
+@dataclass
+class PaginatedResponse(Generic[T]):
+    pageInfo: PageInfo
+    data: List[T]
+
+    def to_dict(self):
+        return {
+            "pageInfo": self.pageInfo.to_dict(),
+            "data": [
+                (d.to_dict() if hasattr(d, "to_dict") and callable(d.to_dict) else d)
+                for d in self.data
+            ],
+        }
+
+    @classmethod
+    def from_dict(
+        cls, paginated_response_dict: Dict, the_class: HasFromDict[T]
+    ) -> "PaginatedResponse[T]":
+        pageInfo = PageInfo.from_dict(paginated_response_dict.get("pageInfo", {}))
+
+        data = [the_class.from_dict(d) for d in paginated_response_dict.get("data", [])]
+
+        return cls(pageInfo=pageInfo, data=data)
+
+
 @dataclass
 class FileSpec(DataClassJsonMixin):
     accept: Union[List[str], Dict[str, List[str]]]
@@ -75,16 +144,37 @@ class FileReference(TypedDict):
 class FileDict(TypedDict):
     id: str
     name: str
-    path: str
+    path: Path
     size: int
     type: str
 
 
-class UIMessagePayload(TypedDict):
+class MessagePayload(TypedDict):
     message: "StepDict"
     fileReferences: Optional[List[FileReference]]
 
 
+class InputAudioChunkPayload(TypedDict):
+    isStart: bool
+    mimeType: str
+    elapsedTime: float
+    data: bytes
+
+
+@dataclass
+class InputAudioChunk:
+    isStart: bool
+    mimeType: str
+    elapsedTime: float
+    data: bytes
+
+
+class OutputAudioChunk(TypedDict):
+    track: str
+    mimeType: str
+    data: bytes
+
+
 @dataclass
 class AskFileResponse:
     id: str
@@ -96,43 +186,55 @@ class AskFileResponse:
 
 class AskActionResponse(TypedDict):
     name: str
-    value: str
+    payload: Dict
     label: str
-    description: str
+    tooltip: str
     forId: str
     id: str
-    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 UpdateThreadRequest(BaseModel):
+    threadId: str
+    name: str
 
 
 class DeleteThreadRequest(BaseModel):
     threadId: str
 
 
+class DeleteFeedbackRequest(BaseModel):
+    feedbackId: str
+
+
 class GetThreadsRequest(BaseModel):
     pagination: Pagination
     filter: ThreadFilter
 
 
+class CallActionRequest(BaseModel):
+    action: Dict
+    sessionId: str
+
+
+class ElementRequest(BaseModel):
+    element: Dict
+    sessionId: str
+
+
 class Theme(str, Enum):
     light = "light"
     dark = "dark"
 
 
+@dataclass
+class Starter(DataClassJsonMixin):
+    """Specification for a starter that can be chosen by the user at the thread start."""
+
+    label: str
+    message: str
+    icon: Optional[str] = None
+
+
 @dataclass
 class ChatProfile(DataClassJsonMixin):
     """Specification for a chat profile that can be chosen by the user at the thread start."""
@@ -140,22 +242,25 @@ class ChatProfile(DataClassJsonMixin):
     name: str
     markdown_description: str
     icon: Optional[str] = None
+    default: bool = False
+    starters: Optional[List[Starter]] = None
 
 
 FeedbackStrategy = Literal["BINARY"]
 
 
 class FeedbackDict(TypedDict):
-    value: Literal[-1, 0, 1]
-    strategy: FeedbackStrategy
+    forId: str
+    id: Optional[str]
+    value: Literal[0, 1]
     comment: Optional[str]
 
 
 @dataclass
 class Feedback:
     forId: str
-    value: Literal[-1, 0, 1]
-    strategy: FeedbackStrategy = "BINARY"
+    value: Literal[0, 1]
+    threadId: Optional[str] = None
     id: Optional[str] = None
     comment: Optional[str] = None
 

chainlit/user.py

@@ -1,16 +1,26 @@
-from typing import Dict, Literal, TypedDict
+from typing import Dict, Literal, Optional, TypedDict
 
 from dataclasses_json import DataClassJsonMixin
-from pydantic.dataclasses import Field, dataclass
+from pydantic import Field
+from pydantic.dataclasses import dataclass
 
 Provider = Literal[
-    "credentials", "header", "github", "google", "azure-ad", "okta", "auth0", "descope"
+    "credentials",
+    "header",
+    "github",
+    "google",
+    "azure-ad",
+    "azure-ad-hybrid",
+    "okta",
+    "auth0",
+    "descope",
 ]
 
 
 class UserDict(TypedDict):
     id: str
     identifier: str
+    display_name: Optional[str]
     metadata: Dict
 
 
@@ -18,6 +28,7 @@ class UserDict(TypedDict):
 @dataclass
 class User(DataClassJsonMixin):
     identifier: str
+    display_name: Optional[str] = None
     metadata: Dict = Field(default_factory=dict)
 
 

chainlit/user_session.py

@@ -1,6 +1,6 @@
 from typing import Dict
 
-from chainlit.context import context
+from chainlit.context import WebsocketSession, context
 
 user_sessions: Dict[str, Dict] = {}
 
@@ -27,9 +27,12 @@ class UserSession:
         user_session["chat_settings"] = context.session.chat_settings
         user_session["user"] = context.session.user
         user_session["chat_profile"] = context.session.chat_profile
+        user_session["http_referer"] = context.session.http_referer
+        user_session["client_type"] = context.session.client_type
+        user_session["http_cookie"] = context.session.http_cookie
 
-        if context.session.root_message:
-            user_session["root_message"] = context.session.root_message
+        if isinstance(context.session, WebsocketSession):
+            user_session["languages"] = context.session.languages
 
         return user_session.get(key, default)
 

chainlit/utils.py

@@ -1,12 +1,18 @@
 import functools
 import importlib
 import inspect
+import os
+from asyncio import CancelledError
 from typing import Callable
 
+import click
+from fastapi import FastAPI
+from packaging import version
+
+from chainlit.auth import ensure_jwt_secret
 from chainlit.context import context
 from chainlit.logger import logger
 from chainlit.message import ErrorMessage
-from packaging import version
 
 
 def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
@@ -39,13 +45,14 @@ def wrap_user_function(user_function: Callable, with_task=False) -> Callable:
                 return await user_function(**params_values)
             else:
                 return user_function(**params_values)
-        except InterruptedError:
+        except CancelledError:
             pass
         except Exception as e:
             logger.exception(e)
-            await ErrorMessage(
-                content=str(e) or e.__class__.__name__, author="Error"
-            ).send()
+            if with_task:
+                await ErrorMessage(
+                    content=str(e) or e.__class__.__name__, author="Error"
+                ).send()
         finally:
             if with_task:
                 await context.emitter.task_end()
@@ -85,3 +92,43 @@ 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 app as chainlit_app
+
+    config.run.root_path = path
+    config.run.debug = os.environ.get("CHAINLIT_DEBUG", False)
+
+    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(path, chainlit_app)