chainlit 2.7.0__py3-none-any.whl → 2.7.1__py3-none-any.whl

chainlit/context.py

@@ -1,112 +0,0 @@
-import asyncio
-import uuid
-from contextvars import ContextVar
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
-
-from lazify import LazyProxy
-
-from chainlit.session import ClientType, HTTPSession, WebsocketSession
-
-if TYPE_CHECKING:
-    from chainlit.emitter import BaseChainlitEmitter
-    from chainlit.step import Step
-    from chainlit.user import PersistedUser, User
-
-CL_RUN_NAMES = ["on_chat_start", "on_message", "on_audio_end"]
-
-
-class ChainlitContextException(Exception):
-    def __init__(self, msg="Chainlit context not found", *args, **kwargs):
-        super().__init__(msg, *args, **kwargs)
-
-
-class ChainlitContext:
-    loop: asyncio.AbstractEventLoop
-    emitter: "BaseChainlitEmitter"
-    session: Union["HTTPSession", "WebsocketSession"]
-
-    @property
-    def current_step(self):
-        if previous_steps := local_steps.get():
-            return previous_steps[-1]
-
-    @property
-    def current_run(self):
-        if previous_steps := local_steps.get():
-            return next(
-                (step for step in previous_steps if step.name in CL_RUN_NAMES), None
-            )
-
-    def __init__(
-        self,
-        session: Union["HTTPSession", "WebsocketSession"],
-        emitter: Optional["BaseChainlitEmitter"] = None,
-    ):
-        from chainlit.emitter import BaseChainlitEmitter, ChainlitEmitter
-
-        self.loop = asyncio.get_running_loop()
-        self.session = session
-
-        if emitter:
-            self.emitter = emitter
-        elif isinstance(self.session, HTTPSession):
-            self.emitter = BaseChainlitEmitter(self.session)
-        elif isinstance(self.session, WebsocketSession):
-            self.emitter = ChainlitEmitter(self.session)
-
-
-context_var: ContextVar[ChainlitContext] = ContextVar("chainlit")
-local_steps: ContextVar[Optional[List["Step"]]] = ContextVar(
-    "local_steps", default=None
-)
-
-
-def init_ws_context(session_or_sid: Union[WebsocketSession, str]) -> ChainlitContext:
-    if not isinstance(session_or_sid, WebsocketSession):
-        session = WebsocketSession.require(session_or_sid)
-    else:
-        session = session_or_sid
-    context = ChainlitContext(session)
-    context_var.set(context)
-    return context
-
-
-def init_http_context(
-    thread_id: Optional[str] = None,
-    user: Optional[Union["User", "PersistedUser"]] = None,
-    auth_token: Optional[str] = None,
-    user_env: Optional[Dict[str, str]] = None,
-    client_type: ClientType = "webapp",
-) -> ChainlitContext:
-    from chainlit.data import get_data_layer
-
-    session_id = str(uuid.uuid4())
-    thread_id = thread_id or str(uuid.uuid4())
-    session = HTTPSession(
-        id=session_id,
-        thread_id=thread_id,
-        token=auth_token,
-        user=user,
-        client_type=client_type,
-        user_env=user_env,
-    )
-    context = ChainlitContext(session)
-    context_var.set(context)
-
-    if data_layer := get_data_layer():
-        if user_id := getattr(user, "id", None):
-            asyncio.create_task(
-                data_layer.update_thread(thread_id=thread_id, user_id=user_id)
-            )
-
-    return context
-
-
-def get_context() -> ChainlitContext:
-    try:
-        return context_var.get()
-    except LookupError as e:
-        raise ChainlitContextException from e
-
-
-context: ChainlitContext = LazyProxy(get_context, enable_cache=False)

chainlit/data/__init__.py

@@ -1,111 +0,0 @@
-import os
-import warnings
-from typing import Optional
-
-from .base import BaseDataLayer
-from .utils import (
-    queue_until_user_message as queue_until_user_message,  # TODO: Consider deprecating re-export.; Redundant alias tells type checkers to STFU.
-)
-
-_data_layer: Optional[BaseDataLayer] = None
-_data_layer_initialized = False
-
-
-def get_data_layer():
-    global _data_layer, _data_layer_initialized
-
-    if not _data_layer_initialized:
-        if _data_layer:
-            # Data layer manually set, warn user that this is deprecated.
-
-            warnings.warn(
-                "Setting data layer manually is deprecated. Use @data_layer instead.",
-                DeprecationWarning,
-            )
-
-        else:
-            from chainlit.config import config
-
-            if config.code.data_layer:
-                # When @data_layer is configured, call it to get data layer.
-                _data_layer = config.code.data_layer()
-            elif database_url := os.environ.get("DATABASE_URL"):
-                from .chainlit_data_layer import ChainlitDataLayer
-
-                if os.environ.get("LITERAL_API_KEY"):
-                    warnings.warn(
-                        "Both LITERAL_API_KEY and DATABASE_URL specified. Ignoring Literal AI data layer and relying on data layer pointing to DATABASE_URL."
-                    )
-
-                bucket_name = os.environ.get("BUCKET_NAME")
-
-                # AWS S3
-                aws_region = os.getenv("APP_AWS_REGION")
-                aws_access_key = os.getenv("APP_AWS_ACCESS_KEY")
-                aws_secret_key = os.getenv("APP_AWS_SECRET_KEY")
-                dev_aws_endpoint = os.getenv("DEV_AWS_ENDPOINT")
-                is_using_s3 = bool(aws_access_key and aws_secret_key and aws_region)
-
-                # Google Cloud Storage
-                gcs_project_id = os.getenv("APP_GCS_PROJECT_ID")
-                gcs_client_email = os.getenv("APP_GCS_CLIENT_EMAIL")
-                gcs_private_key = os.getenv("APP_GCS_PRIVATE_KEY")
-                is_using_gcs = bool(gcs_project_id)
-
-                # Azure Storage
-                azure_storage_account = os.getenv("APP_AZURE_STORAGE_ACCOUNT")
-                azure_storage_key = os.getenv("APP_AZURE_STORAGE_ACCESS_KEY")
-                is_using_azure = bool(azure_storage_account and azure_storage_key)
-
-                storage_client = None
-
-                if sum([is_using_s3, is_using_gcs, is_using_azure]) > 1:
-                    warnings.warn(
-                        "Multiple storage configurations detected. Please use only one."
-                    )
-                elif is_using_s3:
-                    from chainlit.data.storage_clients.s3 import S3StorageClient
-
-                    storage_client = S3StorageClient(
-                        bucket=bucket_name,
-                        region_name=aws_region,
-                        aws_access_key_id=aws_access_key,
-                        aws_secret_access_key=aws_secret_key,
-                        endpoint_url=dev_aws_endpoint,
-                    )
-                elif is_using_gcs:
-                    from chainlit.data.storage_clients.gcs import GCSStorageClient
-
-                    storage_client = GCSStorageClient(
-                        project_id=gcs_project_id,
-                        client_email=gcs_client_email,
-                        private_key=gcs_private_key,
-                        bucket_name=bucket_name,
-                    )
-                elif is_using_azure:
-                    from chainlit.data.storage_clients.azure_blob import (
-                        AzureBlobStorageClient,
-                    )
-
-                    storage_client = AzureBlobStorageClient(
-                        container_name=bucket_name,
-                        storage_account=azure_storage_account,
-                        storage_key=azure_storage_key,
-                    )
-
-                _data_layer = ChainlitDataLayer(
-                    database_url=database_url, storage_client=storage_client
-                )
-            elif api_key := os.environ.get("LITERAL_API_KEY"):
-                # When LITERAL_API_KEY is defined, use Literal AI data layer
-                from .literalai import LiteralDataLayer
-
-                # support legacy LITERAL_SERVER variable as fallback
-                server = os.environ.get("LITERAL_API_URL") or os.environ.get(
-                    "LITERAL_SERVER"
-                )
-                _data_layer = LiteralDataLayer(api_key=api_key, server=server)
-
-        _data_layer_initialized = True
-
-    return _data_layer

chainlit/data/acl.py

@@ -1,19 +0,0 @@
-from fastapi import HTTPException
-
-from chainlit.data import get_data_layer
-
-
-async def is_thread_author(username: str, thread_id: str):
-    data_layer = get_data_layer()
-    if not data_layer:
-        raise HTTPException(status_code=400, detail="Data layer not initialized")
-
-    thread_author = await data_layer.get_thread_author(thread_id)
-
-    if not thread_author:
-        raise HTTPException(status_code=404, detail="Thread not found")
-
-    if thread_author != username:
-        raise HTTPException(status_code=401, detail="Unauthorized")
-    else:
-        return True

chainlit/data/base.py

@@ -1,107 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Dict, List, Optional
-
-from chainlit.types import (
-    Feedback,
-    PaginatedResponse,
-    Pagination,
-    ThreadDict,
-    ThreadFilter,
-)
-
-from .utils import queue_until_user_message
-
-if TYPE_CHECKING:
-    from chainlit.element import Element, ElementDict
-    from chainlit.step import StepDict
-    from chainlit.user import PersistedUser, User
-
-
-class BaseDataLayer(ABC):
-    """Base class for data persistence."""
-
-    @abstractmethod
-    async def get_user(self, identifier: str) -> Optional["PersistedUser"]:
-        pass
-
-    @abstractmethod
-    async def create_user(self, user: "User") -> Optional["PersistedUser"]:
-        pass
-
-    @abstractmethod
-    async def delete_feedback(
-        self,
-        feedback_id: str,
-    ) -> bool:
-        pass
-
-    @abstractmethod
-    async def upsert_feedback(
-        self,
-        feedback: Feedback,
-    ) -> str:
-        pass
-
-    @queue_until_user_message()
-    @abstractmethod
-    async def create_element(self, element: "Element"):
-        pass
-
-    @abstractmethod
-    async def get_element(
-        self, thread_id: str, element_id: str
-    ) -> Optional["ElementDict"]:
-        pass
-
-    @queue_until_user_message()
-    @abstractmethod
-    async def delete_element(self, element_id: str, thread_id: Optional[str] = None):
-        pass
-
-    @queue_until_user_message()
-    @abstractmethod
-    async def create_step(self, step_dict: "StepDict"):
-        pass
-
-    @queue_until_user_message()
-    @abstractmethod
-    async def update_step(self, step_dict: "StepDict"):
-        pass
-
-    @queue_until_user_message()
-    @abstractmethod
-    async def delete_step(self, step_id: str):
-        pass
-
-    @abstractmethod
-    async def get_thread_author(self, thread_id: str) -> str:
-        return ""
-
-    @abstractmethod
-    async def delete_thread(self, thread_id: str):
-        pass
-
-    @abstractmethod
-    async def list_threads(
-        self, pagination: "Pagination", filters: "ThreadFilter"
-    ) -> "PaginatedResponse[ThreadDict]":
-        pass
-
-    @abstractmethod
-    async def get_thread(self, thread_id: str) -> "Optional[ThreadDict]":
-        pass
-
-    @abstractmethod
-    async def update_thread(
-        self,
-        thread_id: str,
-        name: Optional[str] = None,
-        user_id: Optional[str] = None,
-        metadata: Optional[Dict] = None,
-        tags: Optional[List[str]] = None,
-    ):
-        pass
-
-    @abstractmethod
-    async def build_debug_url(self) -> str:
-        pass