chainlit 2.0.dev2__py3-none-any.whl → 2.0rc1__py3-none-any.whl

chainlit/socket.py

@@ -1,29 +1,29 @@
 import asyncio
 import json
 import time
-import uuid
-from typing import Any, Dict, Literal
+from typing import Any, Dict, Literal, Optional, Tuple, Union
 from urllib.parse import unquote
 
+from starlette.requests import cookie_parser
+from typing_extensions import TypeAlias
+
 from chainlit.action import Action
 from chainlit.auth import get_current_user, require_login
 from chainlit.chat_context import chat_context
 from chainlit.config import config
 from chainlit.context import init_ws_context
 from chainlit.data import get_data_layer
-from chainlit.element import Element
 from chainlit.logger import logger
 from chainlit.message import ErrorMessage, Message
 from chainlit.server import sio
 from chainlit.session import WebsocketSession
 from chainlit.telemetry import trace_event
-from chainlit.types import (
-    InputAudioChunk,
-    InputAudioChunkPayload,
-    MessagePayload,
-)
+from chainlit.types import InputAudioChunk, InputAudioChunkPayload, MessagePayload
+from chainlit.user import PersistedUser, User
 from chainlit.user_session import user_sessions
 
+WSGIEnvironment: TypeAlias = dict[str, Any]
+
 
 def restore_existing_session(sid, session_id, emit_fn, emit_call_fn):
     """Restore a session from the sessionId provided by the client."""
@@ -82,45 +82,57 @@ def load_user_env(user_env):
     return user_env
 
 
-def build_anon_user_identifier(environ):
-    scope = environ.get("asgi.scope", {})
-    client_ip, _ = scope.get("client")
-    ip = environ.get("HTTP_X_FORWARDED_FOR", client_ip)
+def _get_token_from_auth(auth: dict) -> Optional[str]:
+    # Not using cookie auth, return token.
+    token = auth.get("token")
+    if token:
+        return token.split(" ")[1]
 
-    try:
-        headers = scope.get("headers", {})
-        user_agent = next(
-            (v.decode("utf-8") for k, v in headers if k.decode("utf-8") == "user-agent")
-        )
-        return str(uuid.uuid5(uuid.NAMESPACE_DNS, user_agent + ip))
+    return None
 
-    except StopIteration:
-        return str(uuid.uuid5(uuid.NAMESPACE_DNS, ip))
 
+def _get_token_from_cookie(environ: WSGIEnvironment) -> Optional[str]:
+    if cookie_header := environ.get("HTTP_COOKIE", None):
+        cookies = cookie_parser(cookie_header)
+        return cookies.get("access_token", None)
 
-@sio.on("connect")
-async def connect(sid, environ):
-    if (
-        not config.code.on_chat_start
-        and not config.code.on_message
-        and not config.code.on_audio_chunk
-    ):
-        logger.warning(
-            "You need to configure at least one of on_chat_start, on_message or on_audio_chunk callback"
-        )
-        return False
-    user = None
-    token = None
-    login_required = require_login()
-    try:
-        # Check if the authentication is required
-        if login_required:
-            authorization_header = environ.get("HTTP_AUTHORIZATION")
-            token = authorization_header.split(" ")[1] if authorization_header else None
-            user = await get_current_user(token=token)
-    except Exception:
-        logger.info("Authentication failed")
-        return False
+    return None
+
+
+def _get_token(environ: WSGIEnvironment, auth: dict) -> Optional[str]:
+    """Take WSGI environ, return access token."""
+
+    if not config.project.cookie_auth:
+        return _get_token_from_auth(auth)
+
+    return _get_token_from_cookie(environ)
+
+
+async def _authenticate_connection(
+    environ,
+    auth,
+) -> Union[Tuple[Union[User, PersistedUser], str], Tuple[None, None]]:
+    if token := _get_token(environ, auth):
+        user = await get_current_user(token=token)
+        if user:
+            return user, token
+
+    return None, None
+
+
+@sio.on("connect")  # pyright: ignore [reportOptionalCall]
+async def connect(sid, environ, auth):
+    user = token = None
+
+    if require_login():
+        try:
+            user, token = await _authenticate_connection(environ, auth)
+        except Exception as e:
+            logger.exception("Exception authenticating connection: %s", e)
+
+        if not user:
+            logger.error("Authentication failed in websocket connect.")
+            raise ConnectionRefusedError("authentication failed")
 
     # Session scoped function to emit to the client
     def emit_fn(event, data):
@@ -130,16 +142,16 @@ async def connect(sid, environ):
     def emit_call_fn(event: Literal["ask", "call_fn"], data, timeout):
         return sio.call(event, data, timeout=timeout, to=sid)
 
-    session_id = environ.get("HTTP_X_CHAINLIT_SESSION_ID")
+    session_id = auth.get("sessionId")
     if restore_existing_session(sid, session_id, emit_fn, emit_call_fn):
         return True
 
-    user_env_string = environ.get("HTTP_USER_ENV")
+    user_env_string = auth.get("userEnv")
     user_env = load_user_env(user_env_string)
 
-    client_type = environ.get("HTTP_X_CHAINLIT_CLIENT_TYPE")
+    client_type = auth.get("clientType")
     http_referer = environ.get("HTTP_REFERER")
-    url_encoded_chat_profile = environ.get("HTTP_X_CHAINLIT_CHAT_PROFILE")
+    url_encoded_chat_profile = auth.get("chatProfile")
     chat_profile = (
         unquote(url_encoded_chat_profile) if url_encoded_chat_profile else None
     )
@@ -154,7 +166,7 @@ async def connect(sid, environ):
         user=user,
         token=token,
         chat_profile=chat_profile,
-        thread_id=environ.get("HTTP_X_CHAINLIT_THREAD_ID"),
+        thread_id=auth.get("threadId"),
         languages=environ.get("HTTP_ACCEPT_LANGUAGE"),
         http_referer=http_referer,
     )
@@ -163,17 +175,17 @@ async def connect(sid, environ):
     return True
 
 
-@sio.on("connection_successful")
+@sio.on("connection_successful")  # pyright: ignore [reportOptionalCall]
 async def connection_successful(sid):
     context = init_ws_context(sid)
 
-    if context.session.restored:
-        return
-
     await context.emitter.task_end()
     await context.emitter.clear("clear_ask")
     await context.emitter.clear("clear_call_fn")
 
+    if context.session.restored:
+        return
+
     if context.session.thread_id_to_resume and config.code.on_chat_resume:
         thread = await resume_thread(context.session)
         if thread:
@@ -196,14 +208,14 @@ async def connection_successful(sid):
         context.session.current_task = task
 
 
-@sio.on("clear_session")
+@sio.on("clear_session")  # pyright: ignore [reportOptionalCall]
 async def clean_session(sid):
     session = WebsocketSession.get(sid)
     if session:
         session.to_clear = True
 
 
-@sio.on("disconnect")
+@sio.on("disconnect")  # pyright: ignore [reportOptionalCall]
 async def disconnect(sid):
     session = WebsocketSession.get(sid)
 
@@ -237,7 +249,7 @@ async def disconnect(sid):
         asyncio.ensure_future(clear_on_timeout(sid))
 
 
-@sio.on("stop")
+@sio.on("stop")  # pyright: ignore [reportOptionalCall]
 async def stop(sid):
     if session := WebsocketSession.get(sid):
         trace_event("stop_task")
@@ -274,7 +286,7 @@ async def process_message(session: WebsocketSession, payload: MessagePayload):
         await context.emitter.task_end()
 
 
-@sio.on("edit_message")
+@sio.on("edit_message")  # pyright: ignore [reportOptionalCall]
 async def edit_message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
@@ -304,7 +316,7 @@ async def edit_message(sid, payload: MessagePayload):
             await context.emitter.task_end()
 
 
-@sio.on("client_message")
+@sio.on("client_message")  # pyright: ignore [reportOptionalCall]
 async def message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
@@ -313,17 +325,30 @@ async def message(sid, payload: MessagePayload):
     session.current_task = task
 
 
-@sio.on("audio_start")
+@sio.on("window_message")  # pyright: ignore [reportOptionalCall]
+async def window_message(sid, data):
+    """Handle a message send by the host window."""
+    session = WebsocketSession.require(sid)
+    init_ws_context(session)
+
+    if config.code.on_window_message:
+        try:
+            await config.code.on_window_message(data)
+        except asyncio.CancelledError:
+            pass
+
+
+@sio.on("audio_start")  # pyright: ignore [reportOptionalCall]
 async def audio_start(sid):
     """Handle audio init."""
     session = WebsocketSession.require(sid)
 
     context = init_ws_context(session)
     if config.code.on_audio_start:
-       connected = bool(await config.code.on_audio_start())
-       connection_state = "on" if connected else "off"
-       await context.emitter.update_audio_connection(connection_state)
-        
+        connected = bool(await config.code.on_audio_start())
+        connection_state = "on" if connected else "off"
+        await context.emitter.update_audio_connection(connection_state)
+
 
 @sio.on("audio_chunk")
 async def audio_chunk(sid, payload: InputAudioChunkPayload):
@@ -350,7 +375,7 @@ async def audio_end(sid):
 
         if config.code.on_audio_end:
             await config.code.on_audio_end()
-            
+
     except asyncio.CancelledError:
         pass
     except Exception as e:

chainlit/step.py

@@ -7,6 +7,10 @@ from copy import deepcopy
 from functools import wraps
 from typing import Callable, Dict, List, Optional, TypedDict, Union
 
+from literalai import BaseGeneration
+from literalai.helper import utc_now
+from literalai.observability.step import StepType, TrueStepType
+
 from chainlit.config import config
 from chainlit.context import CL_RUN_NAMES, context, local_steps
 from chainlit.data import get_data_layer
@@ -14,9 +18,6 @@ from chainlit.element import Element
 from chainlit.logger import logger
 from chainlit.telemetry import trace_event
 from chainlit.types import FeedbackDict
-from literalai import BaseGeneration
-from literalai.helper import utc_now
-from literalai.observability.step import StepType, TrueStepType
 
 
 def check_add_step_in_cot(step: "Step"):
@@ -107,8 +108,8 @@ def step(
                 ) as step:
                     try:
                         step.input = flatten_args_kwargs(func, args, kwargs)
-                    except:
-                        pass
+                    except Exception as e:
+                        logger.exception(e)
                     result = await func(*args, **kwargs)
                     try:
                         if result and not step.output:
@@ -134,8 +135,8 @@ def step(
                 ) as step:
                     try:
                         step.input = flatten_args_kwargs(func, args, kwargs)
-                    except:
-                        pass
+                    except Exception as e:
+                        logger.exception(e)
                     result = func(*args, **kwargs)
                     try:
                         if result and not step.output:
@@ -317,7 +318,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step update: {str(e)}")
+                logger.error(f"Failed to persist step update: {e!s}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
@@ -344,7 +345,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step deletion: {str(e)}")
+                logger.error(f"Failed to persist step deletion: {e!s}")
 
         await context.emitter.delete_step(step_dict)
 
@@ -371,7 +372,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step creation: {str(e)}")
+                logger.error(f"Failed to persist step creation: {e!s}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)

chainlit/sync.py

@@ -10,9 +10,10 @@ import asyncio
 import threading
 
 from asyncer import asyncify
-from chainlit.context import context_var
 from syncer import sync
 
+from chainlit.context import context_var
+
 make_async = asyncify
 
 T_Retval = TypeVar("T_Retval")

chainlit/teams/app.py

@@ -28,6 +28,7 @@ from botbuilder.schema import (
     ChannelAccount,
     HeroCard,
 )
+
 from chainlit.config import config
 from chainlit.context import ChainlitContext, HTTPSession, context, context_var
 from chainlit.data import get_data_layer

chainlit/translations/nl-NL.json

@@ -0,0 +1,229 @@
+{
+    "components": {
+        "atoms": {
+            "buttons": {
+                "userButton": {
+                    "menu": {
+                        "settings": "Instellingen",
+                        "settingsKey": "I",
+                        "APIKeys": "API-sleutels",
+                        "logout": "Uitloggen"
+                    }
+                }
+            }
+        },
+        "molecules": {
+            "newChatButton": {
+                "newChat": "Nieuwe Chat"
+            },
+            "tasklist": {
+                "TaskList": {
+                    "title": "\ud83d\uddd2\ufe0f Takenlijst",
+                    "loading": "Laden...",
+                    "error": "Er is een fout opgetreden"
+                }
+            },
+            "attachments": {
+                "cancelUpload": "Upload annuleren",
+                "removeAttachment": "Bijlage verwijderen"
+            },
+            "newChatDialog": {
+                "createNewChat": "Nieuwe chat maken?",
+                "clearChat": "Dit zal de huidige berichten wissen en een nieuwe chat starten.",
+                "cancel": "Annuleren",
+                "confirm": "Bevestigen"
+            },
+            "settingsModal": {
+                "settings": "Instellingen",
+                "expandMessages": "Berichten uitbreiden",
+                "hideChainOfThought": "Gedachtenketen verbergen",
+                "darkMode": "Donkere modus"
+            },
+            "detailsButton": {
+                "using": "Gebruikt",
+                "used": "Gebruikt"
+            },
+            "auth": {
+                "authLogin": {
+                    "title": "Log in om toegang te krijgen tot de app.",
+                    "form": {
+                        "email": "E-mailadres",
+                        "password": "Wachtwoord",
+                        "noAccount": "Nog geen account?",
+                        "alreadyHaveAccount": "Al een account?",
+                        "signup": "Registreren",
+                        "signin": "Inloggen",
+                        "or": "OF",
+                        "continue": "Doorgaan",
+                        "forgotPassword": "Wachtwoord vergeten?",
+                        "passwordMustContain": "Uw wachtwoord moet bevatten:",
+                        "emailRequired": "e-mail is een verplicht veld",
+                        "passwordRequired": "wachtwoord is een verplicht veld"
+                    },
+                    "error": {
+                        "default": "Inloggen niet mogelijk.",
+                        "signin": "Probeer in te loggen met een ander account.",
+                        "oauthsignin": "Probeer in te loggen met een ander account.",
+                        "redirect_uri_mismatch": "De omleidings-URI komt niet overeen met de oauth-appconfiguratie.",
+                        "oauthcallbackerror": "Probeer in te loggen met een ander account.",
+                        "oauthcreateaccount": "Probeer in te loggen met een ander account.",
+                        "emailcreateaccount": "Probeer in te loggen met een ander account.",
+                        "callback": "Probeer in te loggen met een ander account.",
+                        "oauthaccountnotlinked": "Om uw identiteit te bevestigen, log in met hetzelfde account dat u oorspronkelijk gebruikte.",
+                        "emailsignin": "De e-mail kon niet worden verzonden.",
+                        "emailverify": "Verifieer uw e-mail, een nieuwe e-mail is verzonden.",
+                        "credentialssignin": "Inloggen mislukt. Controleer of de verstrekte gegevens correct zijn.",
+                        "sessionrequired": "Log in om toegang te krijgen tot deze pagina."
+                    }
+                },
+                "authVerifyEmail": {
+                    "almostThere": "Bijna daar! We hebben een e-mail gestuurd naar ",
+                    "verifyEmailLink": "Klik op de link in die e-mail om uw registratie te voltooien.",
+                    "didNotReceive": "Kun je de e-mail niet vinden?",
+                    "resendEmail": "E-mail opnieuw verzenden",
+                    "goBack": "Ga terug",
+                    "emailSent": "E-mail succesvol verzonden.",
+                    "verifyEmail": "Verifieer uw e-mailadres"
+                },
+                "providerButton": {
+                    "continue": "Doorgaan met {{provider}}",
+                    "signup": "Aanmelden met {{provider}}"
+                },
+                "authResetPassword": {
+                    "newPasswordRequired": "Nieuw wachtwoord is een verplicht veld",
+                    "passwordsMustMatch": "Wachtwoorden moeten overeenkomen",
+                    "confirmPasswordRequired": "Bevestig wachtwoord is een verplicht veld",
+                    "newPassword": "Nieuw wachtwoord",
+                    "confirmPassword": "Bevestig wachtwoord",
+                    "resetPassword": "Wachtwoord resetten"
+                },
+                "authForgotPassword": {
+                    "email": "E-mailadres",
+                    "emailRequired": "e-mail is een verplicht veld",
+                    "emailSent": "Controleer het e-mailadres {{email}} voor instructies om uw wachtwoord te resetten.",
+                    "enterEmail": "Voer uw e-mailadres in en we sturen u instructies om uw wachtwoord te resetten.",
+                    "resendEmail": "E-mail opnieuw verzenden",
+                    "continue": "Doorgaan",
+                    "goBack": "Ga terug"
+                }
+            }
+        },
+        "organisms": {
+            "chat": {
+                "history": {
+                    "index": {
+                        "showHistory": "Geschiedenis tonen",
+                        "lastInputs": "Laatste invoer",
+                        "noInputs": "Zo leeg...",
+                        "loading": "Laden..."
+                    }
+                },
+                "inputBox": {
+                    "input": {
+                        "placeholder": "Typ uw bericht hier..."
+                    },
+                    "speechButton": {
+                        "start": "Opname starten",
+                        "stop": "Opname stoppen"
+                    },
+                    "SubmitButton": {
+                        "sendMessage": "Bericht verzenden",
+                        "stopTask": "Taak stoppen"
+                    },
+                    "UploadButton": {
+                        "attachFiles": "Bestanden toevoegen"
+                    },
+                    "waterMark": {
+                        "text": "Gebouwd met"
+                    }
+                },
+                "Messages": {
+                    "index": {
+                        "running": "Bezig",
+                        "executedSuccessfully": "succesvol uitgevoerd",
+                        "failed": "mislukt",
+                        "feedbackUpdated": "Feedback bijgewerkt",
+                        "updating": "Bijwerken"
+                    }
+                },
+                "dropScreen": {
+                    "dropYourFilesHere": "Sleep uw bestanden hierheen"
+                },
+                "index": {
+                    "failedToUpload": "Uploaden mislukt",
+                    "cancelledUploadOf": "Upload geannuleerd van",
+                    "couldNotReachServer": "Server niet bereikbaar",
+                    "continuingChat": "Vervolg van eerdere chat"
+                },
+                "settings": {
+                    "settingsPanel": "Instellingenpaneel",
+                    "reset": "Resetten",
+                    "cancel": "Annuleren",
+                    "confirm": "Bevestigen"
+                }
+            },
+            "threadHistory": {
+                "sidebar": {
+                    "filters": {
+                        "FeedbackSelect": {
+                            "feedbackAll": "Feedback: Alles",
+                            "feedbackPositive": "Feedback: Positief",
+                            "feedbackNegative": "Feedback: Negatief"
+                        },
+                        "SearchBar": {
+                            "search": "Zoeken"
+                        }
+                    },
+                    "DeleteThreadButton": {
+                        "confirmMessage": "Dit verwijdert de thread evenals de berichten en elementen.",
+                        "cancel": "Annuleren",
+                        "confirm": "Bevestigen",
+                        "deletingChat": "Chat verwijderen",
+                        "chatDeleted": "Chat verwijderd"
+                    },
+                    "index": {
+                        "pastChats": "Vorige Chats"
+                    },
+                    "ThreadList": {
+                        "empty": "Leeg...",
+                        "today": "Vandaag",
+                        "yesterday": "Gisteren",
+                        "previous7days": "Afgelopen 7 dagen",
+                        "previous30days": "Afgelopen 30 dagen"
+                    },
+                    "TriggerButton": {
+                        "closeSidebar": "Zijbalk sluiten",
+                        "openSidebar": "Zijbalk openen"
+                    }
+                },
+                "Thread": {
+                    "backToChat": "Terug naar chat",
+                    "chatCreatedOn": "Deze chat is aangemaakt op"
+                }
+            },
+            "header": {
+                "chat": "Chat",
+                "readme": "Readme"
+            }
+        }
+    },
+    "hooks": {
+        "useLLMProviders": {
+            "failedToFetchProviders": "Kan providers niet ophalen:"
+        }
+    },
+    "pages": {
+        "Design": {},
+        "Env": {
+            "savedSuccessfully": "Succesvol opgeslagen",
+            "requiredApiKeys": "Vereiste API-sleutels",
+            "requiredApiKeysInfo": "Om deze app te gebruiken, zijn de volgende API-sleutels vereist. De sleutels worden opgeslagen in de lokale opslag van uw apparaat."
+        },
+        "Page": {
+            "notPartOfProject": "U maakt geen deel uit van dit project."
+        },
+        "ResumeButton": {
+            "resumeChat": "Chat hervatten"
+        }
+    }
+}

chainlit/types.py

@@ -79,7 +79,7 @@ T = TypeVar("T", covariant=True)
 class HasFromDict(Protocol[T]):
     @classmethod
     def from_dict(cls, obj_dict: Any) -> T:
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 @dataclass
@@ -168,11 +168,13 @@ class InputAudioChunk:
     elapsedTime: float
     data: bytes
 
+
 class OutputAudioChunk(TypedDict):
     track: str
     mimeType: str
     data: bytes
 
+
 @dataclass
 class AskFileResponse:
     id: str

chainlit/user.py

@@ -1,7 +1,8 @@
 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",

chainlit/utils.py

@@ -6,12 +6,13 @@ 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 fastapi import FastAPI
-from packaging import version
 
 
 def wrap_user_function(user_function: Callable, with_task=False) -> Callable:

{chainlit-2.0.dev2.dist-info → chainlit-2.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chainlit
-Version: 2.0.dev2
+Version: 2.0rc1
 Summary: Build Conversational AI.
 Home-page: https://chainlit.io/
 License: Apache-2.0
@@ -24,7 +24,7 @@ Requires-Dist: aiofiles (>=23.1.0,<24.0.0)
 Requires-Dist: asyncer (>=0.0.7,<0.0.8)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: dataclasses_json (>=0.6.7,<0.7.0)
-Requires-Dist: fastapi (>=0.110.1,<0.113)
+Requires-Dist: fastapi (>=0.115.3,<0.116)
 Requires-Dist: filetype (>=1.2.0,<2.0.0)
 Requires-Dist: httpx (>=0.23.0)
 Requires-Dist: lazify (>=0.4.0,<0.5.0)
@@ -37,7 +37,7 @@ 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: starlette (>=0.41.2,<0.42.0)
 Requires-Dist: syncer (>=2.0.3,<3.0.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Requires-Dist: uptrace (>=1.22.0,<2.0.0)