nicegui 2.8.0__tar.gz → 2.9.0__tar.gz

{nicegui-2.8.0 → nicegui-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nicegui
-Version: 2.8.0
+Version: 2.9.0
 Summary: Create web-based user interfaces with Python. The nice way.
 Home-page: https://github.com/zauberzeug/nicegui
 License: MIT
@@ -165,7 +165,6 @@ If you would like to support this project and have your avatar or company logo a
   <a href="https://github.com/lechler-gmbh"><img src="https://github.com/lechler-gmbh.png" width="50px" alt="Lechler GmbH" /></a>
   <a href="https://github.com/Zhifeng2019"><img src="https://github.com/Zhifeng2019.png" width="50px" alt="Zhifeng" /></a>
   <a href="https://github.com/sereneturtlefox"><img src="https://github.com/sereneturtlefox.png" width="50px" alt="None" /></a>
-  <a href="https://github.com/daviborges666"><img src="https://github.com/daviborges666.png" width="50px" alt="Davi Borges" /></a>
   <a href="https://github.com/whoulden"><img src="https://github.com/whoulden.png" width="50px" alt="Wayne Houlden" /></a>
   <a href="https://github.com/digiquip"><img src="https://github.com/digiquip.png" width="50px" alt="DigiQuip AS" /></a>
 </p>

{nicegui-2.8.0 → nicegui-2.9.0}/README.md

@@ -114,7 +114,6 @@ If you would like to support this project and have your avatar or company logo a
   <a href="https://github.com/lechler-gmbh"><img src="https://github.com/lechler-gmbh.png" width="50px" alt="Lechler GmbH" /></a>
   <a href="https://github.com/Zhifeng2019"><img src="https://github.com/Zhifeng2019.png" width="50px" alt="Zhifeng" /></a>
   <a href="https://github.com/sereneturtlefox"><img src="https://github.com/sereneturtlefox.png" width="50px" alt="None" /></a>
-  <a href="https://github.com/daviborges666"><img src="https://github.com/daviborges666.png" width="50px" alt="Davi Borges" /></a>
   <a href="https://github.com/whoulden"><img src="https://github.com/whoulden.png" width="50px" alt="Wayne Houlden" /></a>
   <a href="https://github.com/digiquip"><img src="https://github.com/digiquip.png" width="50px" alt="DigiQuip AS" /></a>
 </p>

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/air.py

@@ -134,7 +134,7 @@ class Air:
                 core.app.storage.copy_tab(data['old_tab_id'], data['tab_id'])
             client.tab_id = data['tab_id']
             client.on_air = True
-            client.handle_handshake()
+            client.handle_handshake(data.get('next_message_id'))
             return True
 
         @self.relay.on('client_disconnect')
@@ -178,6 +178,14 @@ class Air:
             client = Client.instances[client_id]
             client.handle_javascript_response(data['msg'])
 
+        @self.relay.on('ack')
+        def _handle_ack(data: Dict[str, Any]) -> None:
+            client_id = data['client_id']
+            if client_id not in Client.instances:
+                return
+            client = Client.instances[client_id]
+            client.outbox.prune_history(data['msg']['next_message_id'])
+
         @self.relay.on('out_of_time')
         async def _handle_out_of_time() -> None:
             print('Sorry, you have reached the time limit of this NiceGUI On Air preview.', flush=True)

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/app/app.py

@@ -30,6 +30,7 @@ class State(Enum):
 
 
 class App(FastAPI):
+    from ..timer import Timer as timer  # pylint: disable=import-outside-toplevel
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs, docs_url=None, redoc_url=None, openapi_url=None)

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/app/app_config.py

@@ -32,6 +32,7 @@ class AppConfig:
     language: Language = field(init=False)
     binding_refresh_interval: float = field(init=False)
     reconnect_timeout: float = field(init=False)
+    message_history_length: int = field(init=False)
     tailwind: bool = field(init=False)
     prod_js: bool = field(init=False)
     show_welcome_message: bool = field(init=False)
@@ -47,6 +48,7 @@ class AppConfig:
                        language: Language,
                        binding_refresh_interval: float,
                        reconnect_timeout: float,
+                       message_history_length: int,
                        tailwind: bool,
                        prod_js: bool,
                        show_welcome_message: bool,
@@ -60,6 +62,7 @@ class AppConfig:
         self.language = language
         self.binding_refresh_interval = binding_refresh_interval
         self.reconnect_timeout = reconnect_timeout
+        self.message_history_length = message_history_length
         self.tailwind = tailwind
         self.prod_js = prod_js
         self.show_welcome_message = show_welcome_message

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/client.py

@@ -63,6 +63,7 @@ class Client:
         self._deleted = False
         self.tab_id: Optional[str] = None
 
+        self.page = page
         self.outbox = Outbox(self)
 
         with Element('q-layout', _client=self).props('view="hhh lpr fff"').classes('nicegui-layout') as self.layout:
@@ -75,7 +76,6 @@ class Client:
         self._head_html = ''
         self._body_html = ''
 
-        self.page = page
         self.storage = ObservableDict()
 
         self.connect_handlers: List[Union[Callable[..., Any], Awaitable]] = []
@@ -123,7 +123,11 @@ class Client:
         elements = json.dumps({
             id: element._to_dict() for id, element in self.elements.items()  # pylint: disable=protected-access
         })
-        socket_io_js_query_params = {**core.app.config.socket_io_js_query_params, 'client_id': self.id}
+        socket_io_js_query_params = {
+            **core.app.config.socket_io_js_query_params,
+            'client_id': self.id,
+            'next_message_id': self.outbox.next_message_id,
+        }
         vue_html, vue_styles, vue_scripts, imports, js_imports = generate_resources(prefix, self.elements.values())
         return templates.TemplateResponse(
             request=request,
@@ -227,8 +231,10 @@ class Client:
         """Add a callback to be invoked when the client disconnects."""
         self.disconnect_handlers.append(handler)
 
-    def handle_handshake(self) -> None:
+    def handle_handshake(self, next_message_id: Optional[int]) -> None:
         """Cancel pending disconnect task and invoke connect handlers."""
+        if next_message_id is not None:
+            self.outbox.try_rewind(next_message_id)
         if self._disconnect_task:
             self._disconnect_task.cancel()
             self._disconnect_task = None
@@ -241,11 +247,7 @@ class Client:
     def handle_disconnect(self) -> None:
         """Wait for the browser to reconnect; invoke disconnect handlers if it doesn't."""
         async def handle_disconnect() -> None:
-            if self.page.reconnect_timeout is not None:
-                delay = self.page.reconnect_timeout
-            else:
-                delay = core.app.config.reconnect_timeout  # pylint: disable=protected-access
-            await asyncio.sleep(delay)
+            await asyncio.sleep(self.page.resolve_reconnect_timeout())
             for t in self.disconnect_handlers:
                 self.safe_invoke(t)
             for t in core.app._disconnect_handlers:  # pylint: disable=protected-access

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/elements/code.py

@@ -36,7 +36,7 @@ class Code(ContentElement, default_classes='nicegui-code'):
         timer(0.1, self._update_copy_button)
 
         self.client.on_connect(lambda: self.client.run_javascript(f'''
-            if (!navigator.clipboard) getElement({self.copy_button.id}).$el.style.display = 'none';
+            if (!navigator.clipboard) getHtmlElement({self.copy_button.id}).style.display = 'none';
         '''))
 
     async def show_checkmark(self) -> None:

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/elements/input.js

@@ -7,6 +7,7 @@ export default {
       :shadow-text="shadowText"
       @keydown.tab="perform_autocomplete"
       :list="id + '-datalist'"
+      :for="id"
     >
       <template v-for="(_, slot) in $slots" v-slot:[slot]="slotProps">
         <slot :name="slot" v-bind="slotProps || {}" />

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/elements/leaflet.js

@@ -64,8 +64,7 @@ export default {
       "preclick",
       "zoomanim",
     ]) {
-      this.map.on(type, async (e) => {
-        await this.$nextTick(); // NOTE: allow zoom and center to both be updated
+      this.map.on(type, (e) => {
         this.$emit(`map-${type}`, {
           ...e,
           originalEvent: undefined,

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/elements/leaflet.py

@@ -61,6 +61,8 @@ class Leaflet(Element, component='leaflet.js', default_classes='nicegui-leaflet'
             options={'attribution': '&copy; <a href="https://openstreetmap.org">OpenStreetMap</a> contributors'},
         )
 
+        self._send_update_on_value_change = True
+
     def __enter__(self) -> Self:
         Layer.current_leaflet = self
         return super().__enter__()
@@ -77,20 +79,25 @@ class Leaflet(Element, component='leaflet.js', default_classes='nicegui-leaflet'
             for layer in self.layers:
                 self.run_method('add_layer', layer.to_dict(), layer.id)
 
-    async def initialized(self) -> None:
-        """Wait until the map is initialized."""
+    async def initialized(self, timeout: float = 3.0) -> None:
+        """Wait until the map is initialized.
+
+        :param timeout: timeout in seconds (default: 3 seconds)
+        """
         event = asyncio.Event()
         self.on('init', event.set, [])
-        await self.client.connected()
+        await self.client.connected(timeout=timeout)
         await event.wait()
 
-    async def _handle_moveend(self, e: GenericEventArguments) -> None:
-        await asyncio.sleep(0.02)  # NOTE: wait for zoom to be updated as well
+    def _handle_moveend(self, e: GenericEventArguments) -> None:
+        self._send_update_on_value_change = False
         self.center = e.args['center']
+        self._send_update_on_value_change = True
 
-    async def _handle_zoomend(self, e: GenericEventArguments) -> None:
-        await asyncio.sleep(0.02)  # NOTE: wait for center to be updated as well
+    def _handle_zoomend(self, e: GenericEventArguments) -> None:
+        self._send_update_on_value_change = False
         self.zoom = e.args['zoom']
+        self._send_update_on_value_change = True
 
     def run_method(self, name: str, *args: Any, timeout: float = 1) -> AwaitableResponse:
         if not self.is_initialized:
@@ -102,14 +109,16 @@ class Leaflet(Element, component='leaflet.js', default_classes='nicegui-leaflet'
         if self._props['center'] == center:
             return
         self._props['center'] = center
-        self.update()
+        if self._send_update_on_value_change:
+            self.update()
 
     def set_zoom(self, zoom: int) -> None:
         """Set the zoom level of the map."""
         if self._props['zoom'] == zoom:
             return
         self._props['zoom'] = zoom
-        self.update()
+        if self._send_update_on_value_change:
+            self.update()
 
     def remove_layer(self, layer: Layer) -> None:
         """Remove a layer from the map."""

nicegui-2.9.0/nicegui/elements/timer.py

@@ -0,0 +1,47 @@
+from contextlib import nullcontext
+from typing import ContextManager
+
+from ..client import Client
+from ..element import Element
+from ..logging import log
+from ..timer import Timer as BaseTimer
+
+
+class Timer(BaseTimer, Element, component='timer.js'):
+
+    def _get_context(self) -> ContextManager:
+        return self.parent_slot or nullcontext()
+
+    async def _can_start(self) -> bool:
+        """Wait for the client connection before the timer callback can be allowed to manipulate the state.
+
+        See https://github.com/zauberzeug/nicegui/issues/206 for details.
+        Returns True if the client is connected, False if the client is not connected and the timer should be cancelled.
+        """
+        if self.client.shared:
+            return True
+
+        # ignore served pages which do not reconnect to backend (e.g. monitoring requests, scrapers etc.)
+        TIMEOUT = 60.0
+        try:
+            await self.client.connected(timeout=TIMEOUT)
+            return True
+        except TimeoutError:
+            log.error(f'Timer cancelled because client is not connected after {TIMEOUT} seconds')
+            return False
+
+    def _should_stop(self) -> bool:
+        return (
+            self.is_deleted or
+            self.client.id not in Client.instances or
+            super()._should_stop()
+        )
+
+    def _cleanup(self) -> None:
+        super()._cleanup()
+        if not self._deleted:
+            assert self.parent_slot
+            self.parent_slot.parent.remove(self)
+
+    def set_visibility(self, visible: bool) -> None:
+        raise NotImplementedError('Use `activate()`, `deactivate()` or `cancel()`. See #3670 for more information.')

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/functions/javascript.py

@@ -7,7 +7,8 @@ def run_javascript(code: str, *, timeout: float = 1.0) -> AwaitableResponse:
 
     This function runs arbitrary JavaScript code on a page that is executed in the browser.
     The client must be connected before this function is called.
-    To access a client-side object by ID, use the JavaScript function `getElement()`.
+    To access a client-side Vue component or HTML element by ID,
+    use the JavaScript functions `getElement()` or `getHtmlElement()`.
 
     If the function is awaited, the result of the JavaScript code is returned.
     Otherwise, the JavaScript code is executed without waiting for a response.

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/nicegui.py

@@ -3,7 +3,7 @@ import mimetypes
 import urllib.parse
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Dict
+from typing import Any, Dict
 
 import socketio
 from fastapi import HTTPException, Request
@@ -163,7 +163,7 @@ async def _exception_handler_500(request: Request, exception: Exception) -> Resp
 
 
 @sio.on('handshake')
-async def _on_handshake(sid: str, data: Dict[str, str]) -> bool:
+async def _on_handshake(sid: str, data: Dict[str, Any]) -> bool:
     client = Client.instances.get(data['client_id'])
     if not client:
         return False
@@ -175,7 +175,7 @@ async def _on_handshake(sid: str, data: Dict[str, str]) -> bool:
     else:
         client.environ = sio.get_environ(sid)
         await sio.enter_room(sid, client.id)
-    client.handle_handshake()
+    client.handle_handshake(data.get('next_message_id'))
     return True
 
 
@@ -203,3 +203,11 @@ def _on_javascript_response(_: str, msg: Dict) -> None:
     if not client:
         return
     client.handle_javascript_response(msg)
+
+
+@sio.on('ack')
+def _on_ack(_: str, msg: Dict) -> None:
+    client = Client.instances.get(msg['client_id'])
+    if not client:
+        return
+    client.outbox.prune_history(msg['next_message_id'])

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/outbox.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from collections import deque
 from typing import TYPE_CHECKING, Any, Deque, Dict, Optional, Tuple
 
@@ -10,10 +11,16 @@ if TYPE_CHECKING:
     from .client import Client
     from .element import Element
 
-ClientId = str
 ElementId = int
+
+ClientId = str
 MessageType = str
-Message = Tuple[ClientId, MessageType, Any]
+Payload = Any
+Message = Tuple[ClientId, MessageType, Payload]
+
+MessageId = int
+MessageTime = float
+HistoryEntry = Tuple[MessageId, MessageTime, Message]
 
 
 class Outbox:
@@ -22,8 +29,12 @@ class Outbox:
         self.client = client
         self.updates: Dict[ElementId, Optional[Element]] = {}
         self.messages: Deque[Message] = deque()
+        self.message_history: Deque[HistoryEntry] = deque()
+        self.next_message_id: int = 0
+
         self._should_stop = False
         self._enqueue_event: Optional[asyncio.Event] = None
+
         if core.app.is_started:
             background_tasks.create(self.loop(), name=f'outbox loop {client.id}')
         else:
@@ -46,7 +57,7 @@ class Outbox:
         self.updates[element.id] = None
         self._set_enqueue_event()
 
-    def enqueue_message(self, message_type: MessageType, data: Any, target_id: ClientId) -> None:
+    def enqueue_message(self, message_type: MessageType, data: Payload, target_id: ClientId) -> None:
         """Enqueue a message for the given client."""
         self.client.check_existence()
         self.messages.append((target_id, message_type, data))
@@ -77,12 +88,12 @@ class Outbox:
                         element_id: None if element is None else element._to_dict()  # pylint: disable=protected-access
                         for element_id, element in self.updates.items()
                     }
-                    coros.append(self._emit('update', data, self.client.id))
+                    coros.append(self._emit((self.client.id, 'update', data)))
                     self.updates.clear()
 
                 if self.messages:
-                    for target_id, message_type, data in self.messages:
-                        coros.append(self._emit(message_type, data, target_id))
+                    for message in self.messages:
+                        coros.append(self._emit(message))
                     self.messages.clear()
 
                 for coro in coros:
@@ -95,10 +106,47 @@ class Outbox:
                 core.app.handle_exception(e)
                 await asyncio.sleep(0.1)
 
-    async def _emit(self, message_type: MessageType, data: Any, target_id: ClientId) -> None:
-        await core.sio.emit(message_type, data, room=target_id)
-        if core.air is not None and core.air.is_air_target(target_id):
-            await core.air.emit(message_type, data, room=target_id)
+    async def _emit(self, message: Message) -> None:
+        client_id, message_type, data = message
+        data['_id'] = self.next_message_id
+
+        await core.sio.emit(message_type, data, room=client_id)
+        if core.air is not None and core.air.is_air_target(client_id):
+            await core.air.emit(message_type, data, room=client_id)
+
+        if not self.client.shared:
+            self.message_history.append((self.next_message_id, time.time(), message))
+            max_age = core.sio.eio.ping_interval + core.sio.eio.ping_timeout + self.client.page.resolve_reconnect_timeout()
+            while self.message_history and self.message_history[0][1] < time.time() - max_age:
+                self.message_history.popleft()
+            while len(self.message_history) > core.app.config.message_history_length:
+                self.message_history.popleft()
+
+        self.next_message_id += 1
+
+    def try_rewind(self, target_message_id: MessageId) -> None:
+        """Rewind to the given message ID and discard all messages before it."""
+        # nothing to do, the next message ID is already the target message ID
+        if self.next_message_id == target_message_id:
+            return
+
+        # rewind to the target message ID
+        while self.message_history:
+            self.next_message_id, _, message = self.message_history.pop()
+            self.messages.appendleft(message)
+            if self.next_message_id == target_message_id:
+                self.message_history.clear()
+                self._set_enqueue_event()
+                return
+
+        # target message ID not found, reload the page
+        if not self.client.shared:
+            self.client.run_javascript('window.location.reload()')
+
+    def prune_history(self, next_message_id: MessageId) -> None:
+        """Prune the message history up to the given message ID."""
+        while self.message_history and self.message_history[0][0] < next_message_id:
+            self.message_history.popleft()
 
     def stop(self) -> None:
         """Stop the outbox loop."""

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/page.py

@@ -56,7 +56,7 @@ class page:
         :param dark: whether to use Quasar's dark mode (defaults to `dark` argument of `run` command)
         :param language: language of the page (defaults to `language` argument of `run` command)
         :param response_timeout: maximum time for the decorated function to build the page (default: 3.0 seconds)
-        :param reconnect_timeout: maximum time the server waits for the browser to reconnect (default: 0.0 seconds)
+        :param reconnect_timeout: maximum time the server waits for the browser to reconnect (defaults to `reconnect_timeout` argument of `run` command))
         :param api_router: APIRouter instance to use, can be left `None` to use the default
         :param kwargs: additional keyword arguments passed to FastAPI's @app.get method
         """
@@ -94,6 +94,10 @@ class page:
         """Return the language of the page."""
         return self.language if self.language is not ... else core.app.config.language
 
+    def resolve_reconnect_timeout(self) -> float:
+        """Return the reconnect_timeout of the page."""
+        return self.reconnect_timeout if self.reconnect_timeout is not None else core.app.config.reconnect_timeout
+
     def __call__(self, func: Callable[..., Any]) -> Callable[..., Any]:
         core.app.remove_route(self.path)  # NOTE make sure only the latest route definition is used
         parameters_of_decorated_func = list(inspect.signature(func).parameters.keys())

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/page_layout.py

@@ -62,7 +62,7 @@ class Header(ValueElement, default_classes='nicegui-header'):
             add_body_html(f'''
                 <script>
                     window.onload = () => {{
-                        const header = getElement({self.id}).$el;
+                        const header = getHtmlElement({self.id});
                         new ResizeObserver(() => {{
                             document.documentElement.style.scrollPaddingTop = `${{header.offsetHeight}}px`;
                         }}).observe(header);

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/static/nicegui.js

@@ -43,6 +43,10 @@ function getElement(id) {
   return mounted_app.$refs["r" + _id];
 }
 
+function getHtmlElement(id) {
+  return document.getElementById(`c${id}`);
+}
+
 function runMethod(target, method_name, args) {
   if (typeof target === "object") {
     if (method_name in target) {
@@ -265,6 +269,15 @@ function download(src, filename, mediaType, prefix) {
   }
 }
 
+function ack() {
+  if (window.ackedMessageId >= window.nextMessageId) return;
+  window.socket.emit("ack", {
+    client_id: window.clientId,
+    next_message_id: window.nextMessageId,
+  });
+  window.ackedMessageId = window.nextMessageId;
+}
+
 async function loadDependencies(element, prefix, version) {
   if (element.component) {
     const { name, key, tag } = element.component;
@@ -306,6 +319,7 @@ window.onbeforeunload = function () {
 
 function createApp(elements, options) {
   replaceUndefinedAttributes(elements, 0);
+  setInterval(() => ack(), 3000);
   return (app = Vue.createApp({
     data() {
       return {
@@ -320,6 +334,8 @@ function createApp(elements, options) {
       window.clientId = options.query.client_id;
       const url = window.location.protocol === "https:" ? "wss://" : "ws://" + window.location.host;
       window.path_prefix = options.prefix;
+      window.nextMessageId = options.query.next_message_id;
+      window.ackedMessageId = -1;
       window.socket = io(url, {
         path: `${options.prefix}/_nicegui_ws/socket.io`,
         query: options.query,
@@ -333,6 +349,7 @@ function createApp(elements, options) {
             client_id: window.clientId,
             tab_id: TAB_ID,
             old_tab_id: OLD_TAB_ID,
+            next_message_id: window.nextMessageId,
           };
           window.socket.emit("handshake", args, (ok) => {
             if (!ok) {
@@ -371,7 +388,7 @@ function createApp(elements, options) {
             replaceUndefinedAttributes(this.elements, id);
           }
         },
-        run_javascript: (msg) => runJavascript(msg["code"], msg["request_id"]),
+        run_javascript: (msg) => runJavascript(msg.code, msg.request_id),
         open: (msg) => {
           const url = msg.path.startsWith("/") ? options.prefix + msg.path : msg.path;
           const target = msg.new_tab ? "_blank" : "_self";
@@ -384,6 +401,12 @@ function createApp(elements, options) {
       let isProcessingSocketMessage = false;
       for (const [event, handler] of Object.entries(messageHandlers)) {
         window.socket.on(event, async (...args) => {
+          if (args.length > 0 && args[0]._id !== undefined) {
+            const message_id = args[0]._id;
+            if (message_id < window.nextMessageId) return;
+            window.nextMessageId = message_id + 1;
+            delete args[0]._id;
+          }
           socketMessageQueue.push(() => handler(...args));
           if (!isProcessingSocketMessage) {
             while (socketMessageQueue.length > 0) {

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/testing/general_fixtures.py

@@ -91,6 +91,7 @@ def prepare_simulation(request: pytest.FixtureRequest) -> None:
         language='en-US',
         binding_refresh_interval=0.1,
         reconnect_timeout=3.0,
+        message_history_length=1000,
         tailwind=True,
         prod_js=True,
         show_welcome_message=False,

{nicegui-2.8.0 → nicegui-2.9.0}/nicegui/testing/user_interaction.py

@@ -6,6 +6,7 @@ from typing_extensions import Self
 
 from nicegui import background_tasks, events, ui
 from nicegui.element import Element
+from nicegui.elements.mixins.disableable_element import DisableableElement
 from nicegui.elements.mixins.value_element import ValueElement
 
 if TYPE_CHECKING:
@@ -58,6 +59,8 @@ class UserInteraction(Generic[T]):
         assert self.user.client
         with self.user.client:
             for element in self.elements:
+                if isinstance(element, DisableableElement) and not element.enabled:
+                    continue
                 assert isinstance(element, (ui.input, ui.editor, ui.codemirror))
                 element.value = (element.value or '') + text
         return self