nicegui 2.0.1__tar.gz → 2.2.0__tar.gz

{nicegui-2.0.1 → nicegui-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nicegui
-Version: 2.0.1
+Version: 2.2.0
 Summary: Create web-based user interfaces with Python. The nice way.
 Home-page: https://github.com/zauberzeug/nicegui
 License: MIT

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/air.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import gzip
 import json
+import logging
 import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, Optional
@@ -34,6 +35,7 @@ class Air:
     def __init__(self, token: str) -> None:
         import httpx  # pylint: disable=import-outside-toplevel
 
+        self.log = logging.getLogger('nicegui.air')
         self.token = token
         self.relay = socketio.AsyncClient()
         self.client = httpx.AsyncClient(app=core.app)
@@ -172,28 +174,35 @@ class Air:
 
     async def connect(self) -> None:
         """Connect to the NiceGUI On Air server."""
-        if self.connecting or self.relay.connected:
+        if self.connecting:
+            self.log.debug('Already connecting.')
             return
+        if self.relay.connected:
+            return
+        self.log.debug('Going to connect...')
         self.connecting = True
         backoff_time = 1
         try:
             while True:
                 try:
                     if self.relay.connected:
-                        await self.relay.disconnect()
+                        await asyncio.wait_for(self.disconnect(), timeout=5)
+                    self.log.debug('Connecting...')
                     await self.relay.connect(
                         f'{RELAY_HOST}?device_token={self.token}',
                         socketio_path='/on_air/socket.io',
                         transports=['websocket', 'polling'],  # favor websocket over polling
                     )
+                    self.log.debug('Connected.')
                     break
                 except socketio.exceptions.ConnectionError:
-                    pass
+                    self.log.debug('Connection error.', stack_info=True)
                 except ValueError:  # NOTE this sometimes happens when the internal socketio client is not yet ready
-                    pass
+                    self.log.debug('ValueError while connecting.', stack_info=True)
                 except Exception:
                     log.exception('Could not connect to NiceGUI On Air server.')
 
+                self.log.debug(f'Retrying in {backoff_time} seconds...')
                 await asyncio.sleep(backoff_time)
                 backoff_time = min(backoff_time * 2, 32)
         finally:
@@ -201,11 +210,13 @@ class Air:
 
     async def disconnect(self) -> None:
         """Disconnect from the NiceGUI On Air server."""
+        self.log.debug('Disconnecting...')
         if self.relay.connected:
             await self.relay.disconnect()
         for stream in self.streams.values():
             await stream.response.aclose()
         self.streams.clear()
+        self.log.debug('Disconnected.')
 
     async def emit(self, message_type: str, data: Dict[str, Any], room: str) -> None:
         """Emit a message to the NiceGUI On Air server."""

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/element.py

@@ -518,7 +518,7 @@ class Element(Visibility):
             additions.append(f'text={shorten(self._text)}')
         if hasattr(self, 'content') and self.content:  # pylint: disable=no-member
             additions.append(f'content={shorten(self.content)}')  # pylint: disable=no-member
-        IGNORED_PROPS = {'loopback', 'color', 'view', 'innerHTML', 'codehilite_css'}
+        IGNORED_PROPS = {'loopback', 'color', 'view', 'innerHTML', 'codehilite_css_url'}
         additions += [
             f'{key}={shorten(value)}'
             for key, value in self._props.items()

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/element_filter.py

@@ -10,7 +10,9 @@ from .elements.mixins.content_element import ContentElement
 from .elements.mixins.source_element import SourceElement
 from .elements.mixins.text_element import TextElement
 from .elements.notification import Notification
+from .elements.radio import Radio
 from .elements.select import Select
+from .elements.toggle import Toggle
 
 T = TypeVar('T', bound=Element)
 
@@ -109,16 +111,17 @@ class ElementFilter(Generic[T]):
                     element.props.get('icon'),
                     element.props.get('placeholder'),
                     element.props.get('value'),
+                    element.props.get('error-message'),
                     element.text if isinstance(element, TextElement) else None,
                     element.content if isinstance(element, ContentElement) else None,
                     element.source if isinstance(element, SourceElement) else None,
                 ) if content]
                 if isinstance(element, Notification):
                     element_contents.append(element.message)
-                if isinstance(element, Select):
+                if isinstance(element, (Select, Radio, Toggle)):
                     options = {option['value']: option['label'] for option in element.props.get('options', [])}
                     element_contents.append(options.get(element.value, ''))
-                    if element.is_showing_popup:
+                    if not isinstance(element, Select) or element.is_showing_popup:
                         element_contents.extend(options.values())
                 if any(all(needle not in str(haystack) for haystack in element_contents) for needle in self._contents):
                     continue

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/choice_element.py

@@ -41,7 +41,6 @@ class ChoiceElement(ValueElement):
         :param value: The new value. If not given, the current value is kept.
         """
         self.options = options
-        self.update()
         if value is not ...:
             self.value = value
-            self.update()
+        self.update()

nicegui-2.2.0/nicegui/elements/colors.js

@@ -0,0 +1,35 @@
+export default {
+  mounted() {
+    for (let name in this.$props) {
+      if (name === "customColors") continue;
+      document.body.style.setProperty("--q-" + name.replace("_", "-"), this.$props[name]);
+    }
+    if (this.customColors) {
+      let customCSS = "";
+      for (let customColor in this.customColors) {
+        const colorName = customColor.replaceAll("_", "-");
+        const colorVar = "--q-" + colorName;
+        document.body.style.setProperty(colorVar, this.customColors[customColor]);
+        customCSS += `.text-${colorName} { color: var(${colorVar}) !important; }\n`;
+        customCSS += `.bg-${colorName} { background-color: var(${colorVar}) !important; }\n`;
+      }
+      const style = document.createElement("style");
+      style.innerHTML = customCSS;
+      style.dataset.niceguiCustomColors = "";
+      document.head.querySelectorAll("[data-nicegui-custom-colors]").forEach((el) => el.remove());
+      document.getElementsByTagName("head")[0].appendChild(style);
+    }
+  },
+  props: {
+    primary: String,
+    secondary: String,
+    accent: String,
+    dark: String,
+    dark_page: String,
+    positive: String,
+    negative: String,
+    info: String,
+    warning: String,
+    customColors: Object,
+  },
+};

nicegui-2.2.0/nicegui/elements/colors.py

@@ -0,0 +1,45 @@
+from ..element import Element
+from .mixins.color_elements import QUASAR_COLORS
+
+
+class Colors(Element, component='colors.js'):
+
+    def __init__(self, *,
+                 primary: str = '#5898d4',
+                 secondary: str = '#26a69a',
+                 accent: str = '#9c27b0',
+                 dark: str = '#1d1d1d',
+                 dark_page: str = '#121212',
+                 positive: str = '#21ba45',
+                 negative: str = '#c10015',
+                 info: str = '#31ccec',
+                 warning: str = '#f2c037',
+                 **custom_colors: str) -> None:
+        """Color Theming
+
+        Sets the main colors (primary, secondary, accent, ...) used by `Quasar <https://quasar.dev/style/theme-builder>`_.
+
+        :param primary: Primary color (default: "#5898d4")
+        :param secondary: Secondary color (default: "#26a69a")
+        :param accent: Accent color (default: "#9c27b0")
+        :param dark: Dark color (default: "#1d1d1d")
+        :param dark_page: Dark page color (default: "#121212")
+        :param positive: Positive color (default: "#21ba45")
+        :param negative: Negative color (default: "#c10015")
+        :param info: Info color (default: "#31ccec")
+        :param warning: Warning color (default: "#f2c037")
+        :param custom_colors: Custom color definitions for branding (needs ``ui.colors`` to be called before custom color is ever used)
+        """
+        super().__init__()
+        self._props['primary'] = primary
+        self._props['secondary'] = secondary
+        self._props['accent'] = accent
+        self._props['dark'] = dark
+        self._props['dark_page'] = dark_page
+        self._props['positive'] = positive
+        self._props['negative'] = negative
+        self._props['info'] = info
+        self._props['warning'] = warning
+        self._props['customColors'] = custom_colors
+        QUASAR_COLORS.update({name.replace('_', '-') for name in custom_colors})
+        self.update()

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/echart.py

@@ -100,7 +100,7 @@ class EChart(Element, component='echart.js', dependencies=['lib/echarts/echarts.
         self.run_method('update_chart')
 
     def run_chart_method(self, name: str, *args, timeout: float = 1) -> AwaitableResponse:
-        """Run a method of the JSONEditor instance.
+        """Run a method of the EChart instance.
 
         See the `ECharts documentation <https://echarts.apache.org/en/api.html#echartsInstance>`_ for a list of methods.
 

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/lib/three/modules/DragControls.js

@@ -334,7 +334,7 @@ function onPointerDown( event ) {
 
 			// look for the outermost group in the object's upper hierarchy
 
-			_selected = findGroup( _intersections[ 0 ].object );
+			_selected = findGroup( _intersections[ 0 ].object ) || _intersections[ 0 ].object;
 
 		} else {
 

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/markdown.js

@@ -1,7 +1,10 @@
+import { loadResource } from "../../static/utils/resources.js";
+
 export default {
   template: `<div></div>`,
   async mounted() {
-    this.ensure_codehilite_css();
+    await this.$nextTick(); // NOTE: wait for window.path_prefix to be set
+    await loadResource(window.path_prefix + this.codehilite_css_url);
     if (this.use_mermaid) {
       this.mermaid = (await import("mermaid")).default;
       this.renderMermaid();
@@ -21,17 +24,9 @@ export default {
         await this.mermaid.run({ nodes: [pre.children[0]] });
       });
     },
-    ensure_codehilite_css() {
-      if (!document.querySelector(`style[data-codehilite-css]`)) {
-        const style = document.createElement("style");
-        style.setAttribute("data-codehilite-css", "");
-        style.innerHTML = this.codehilite_css;
-        document.head.appendChild(style);
-      }
-    },
   },
   props: {
-    codehilite_css: String,
+    codehilite_css_url: String,
     use_mermaid: {
       required: false,
       default: false,

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/markdown.py

@@ -3,11 +3,16 @@ from functools import lru_cache
 from typing import List
 
 import markdown2
+from fastapi.responses import PlainTextResponse
 from pygments.formatters import HtmlFormatter  # pylint: disable=no-name-in-module
 
+from .. import core
+from ..version import __version__
 from .mermaid import Mermaid
 from .mixins.content_element import ContentElement
 
+CODEHILITE_CSS_URL = f'/_nicegui/{__version__}/codehilite.css'
+
 
 class Markdown(ContentElement, component='markdown.js'):
 
@@ -25,14 +30,18 @@ class Markdown(ContentElement, component='markdown.js'):
         self.extras = extras[:]
         super().__init__(content=content)
         self._classes.append('nicegui-markdown')
-        self._props['codehilite_css'] = (
-            HtmlFormatter(nobackground=True).get_style_defs('.codehilite') +
-            HtmlFormatter(nobackground=True, style='github-dark').get_style_defs('.body--dark .codehilite')
-        )
         if 'mermaid' in extras:
             self._props['use_mermaid'] = True
             self.libraries.append(Mermaid.exposed_libraries[0])
 
+        self._props['codehilite_css_url'] = CODEHILITE_CSS_URL
+        if not any(r for r in core.app.routes if getattr(r, 'path', None) == CODEHILITE_CSS_URL):
+            core.app.get(CODEHILITE_CSS_URL)(lambda: PlainTextResponse(
+                HtmlFormatter(nobackground=True).get_style_defs('.codehilite') +
+                HtmlFormatter(nobackground=True, style='github-dark').get_style_defs('.body--dark .codehilite'),
+                media_type='text/css',
+            ))
+
     def _handle_content_change(self, content: str) -> None:
         html = prepare_content(content, extras=' '.join(self.extras))
         if self._props.get('innerHTML') != html:

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/notification.py

@@ -196,3 +196,6 @@ class Notification(Element, component='notification.js'):
     def dismiss(self) -> None:
         """Dismiss the notification."""
         self.run_method('dismiss')
+
+    def set_visibility(self, visible: bool) -> None:
+        raise NotImplementedError('Use `dismiss()` to remove the notification. See #3670 for more information.')

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/plotly.vue

@@ -13,6 +13,12 @@ export default {
   },
   methods: {
     update() {
+      // wait for plotly to be loaded
+      if (typeof Plotly === "undefined") {
+        setTimeout(this.update, 10);
+        return;
+      }
+
       // default responsive to true
       const options = this.options;
       if (options.config === undefined) options.config = { responsive: true };

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/scene.js

@@ -145,6 +145,7 @@ export default {
     }
     this.controls = new OrbitControls(this.camera, this.renderer.domElement);
     this.drag_controls = new DragControls(this.draggable_objects, this.camera, this.renderer.domElement);
+    this.drag_controls.transformGroup = true;
     const applyConstraint = (constraint, position) => {
       if (!constraint) return;
       const [variable, expression] = constraint.split("=").map((s) => s.trim());
@@ -278,6 +279,9 @@ export default {
           undefined,
           (error) => console.error(error)
         );
+      } else if (type == "axes_helper") {
+        mesh = new THREE.AxesHelper(args[0]);
+        mesh.material.transparent = true;
       } else {
         let geometry;
         const wireframe = args.pop();
@@ -400,6 +404,7 @@ export default {
     },
     move_camera(x, y, z, look_at_x, look_at_y, look_at_z, up_x, up_y, up_z, duration) {
       if (this.camera_tween) this.camera_tween.stop();
+      const camera_up_changed = up_x !== null || up_y !== null || up_z !== null;
       this.camera_tween = new TWEEN.Tween([
         this.camera.position.x,
         this.camera.position.y,
@@ -432,6 +437,12 @@ export default {
           this.camera.lookAt(p[6], p[7], p[8]);
           this.controls.target.set(p[6], p[7], p[8]);
         })
+        .onComplete(() => {
+          if (camera_up_changed) {
+            this.controls.dispose();
+            this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+          }
+        })
         .start();
     },
     get_camera() {

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/scene.py

@@ -51,6 +51,7 @@ class Scene(Element,
                 'lib/tween/tween.umd.js',
             ]):
     # pylint: disable=import-outside-toplevel
+    from .scene_objects import AxesHelper as axes_helper
     from .scene_objects import Box as box
     from .scene_objects import Curve as curve
     from .scene_objects import Cylinder as cylinder

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/scene_objects.py

@@ -335,3 +335,21 @@ class PointCloud(Object3D):
         self.args[0] = points
         self.args[1] = colors
         self.scene.run_method('set_points', self.id, points, colors)
+
+
+class AxesHelper(Object3D):
+
+    def __init__(self,
+                 length: float = 1.0,
+                 ) -> None:
+        """Axes Helper
+
+        This element is based on Three.js' `AxesHelper <https://threejs.org/docs/#api/en/helpers/AxesHelper>`_ object.
+        It is used to visualize the XYZ axes:
+        The X axis is red.
+        The Y axis is green.
+        The Z axis is blue.
+
+        :param length: length of the the axes (default: 1.0)
+        """
+        super().__init__('axes_helper', length)

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/elements/timer.py

@@ -125,6 +125,9 @@ class Timer(Element, component='timer.js'):
 
     def _cleanup(self) -> None:
         self.callback = None
-        if not self.client._deleted:  # pylint: disable=protected-access
+        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.0.1 → nicegui-2.2.0}/nicegui/functions/navigate.py

@@ -60,6 +60,8 @@ class Navigate:
             path = f'#c{target.id}'
         elif callable(target):
             path = Client.page_routes[target]
+        else:
+            raise TypeError(f'Invalid target type: {type(target)}')
         context.client.open(path, new_tab)
 
 

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/page_layout.py

@@ -265,18 +265,26 @@ class Footer(ValueElement):
 
 class PageSticky(Element):
 
-    def __init__(self, position: PageStickyPositions = 'bottom-right', x_offset: float = 0, y_offset: float = 0) -> None:
+    def __init__(self,
+                 position: PageStickyPositions = 'bottom-right',
+                 x_offset: float = 0,
+                 y_offset: float = 0,
+                 *,
+                 expand: bool = False) -> None:
         """Page sticky
 
-        A sticky element that is always visible at the bottom of the page.
+        This element is based on Quasar's `QPageSticky <https://quasar.dev/layout/page-sticky>`_ component.
 
-        :param position: position of the sticky element (default: `'bottom-right'`)
-        :param x_offset: horizontal offset of the sticky element (default: `0`)
-        :param y_offset: vertical offset of the sticky element (default: `0`)
+        :param position: position on the screen (default: "bottom-right")
+        :param x_offset: horizontal offset (default: 0)
+        :param y_offset: vertical offset (default: 0)
+        :param expand: whether to fully expand instead of shrinking to fit the content (default: ``False``)
         """
         super().__init__('q-page-sticky')
         self._props['position'] = position
         self._props['offset'] = [x_offset, y_offset]
+        if expand:
+            self._props['expand'] = True
 
 
 def _check_current_slot(element: Element) -> None:

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/static/nicegui.js

@@ -158,7 +158,11 @@ function renderRecursively(elements, id) {
   Object.entries(props).forEach(([key, value]) => {
     if (key.startsWith(":")) {
       try {
-        props[key.substring(1)] = eval(value);
+        try {
+          props[key.substring(1)] = new Function(`return (${value})`)();
+        } catch (e) {
+          props[key.substring(1)] = eval(value);
+        }
         delete props[key];
       } catch (e) {
         console.error(`Error while converting ${key} attribute to function:`, e);

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/static/utils/dynamic_properties.js

@@ -11,7 +11,11 @@ export function convertDynamicProperties(obj, recursive) {
   for (const [attr, value] of Object.entries(obj)) {
     if (attr.startsWith(":")) {
       try {
-        obj[attr.slice(1)] = new Function(`return (${value})`)();
+        try {
+          obj[attr.slice(1)] = new Function(`return (${value})`)();
+        } catch (e) {
+          obj[attr.slice(1)] = eval(value);
+        }
         delete obj[attr];
       } catch (e) {
         console.error(`Error while converting ${attr} attribute to function:`, e);

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/storage.py

@@ -212,3 +212,5 @@ class Storage:
         self._tabs.clear()
         for filepath in self.path.glob('storage-*.json'):
             filepath.unlink()
+        if self.path.exists():
+            self.path.rmdir()

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/testing/general_fixtures.py

@@ -52,6 +52,7 @@ def nicegui_reset_globals() -> Generator[None, None, None]:
     app.get('/')(Client.auto_index_client.build_response)
     binding.reset()
     yield
+    app.reset()
 
 
 def prepare_simulation(request: pytest.FixtureRequest) -> None:

{nicegui-2.0.1 → nicegui-2.2.0}/nicegui/testing/user.py

@@ -12,6 +12,7 @@ from nicegui import Client, ElementFilter, ui
 from nicegui.element import Element
 from nicegui.nicegui import _on_handshake
 
+from .user_download import UserDownload
 from .user_interaction import UserInteraction
 from .user_navigate import UserNavigate
 from .user_notify import UserNotify
@@ -33,14 +34,22 @@ class User:
         self.forward_history: List[str] = []
         self.navigate = UserNavigate(self)
         self.notify = UserNotify()
+        self.download = UserDownload(self)
+
+    @property
+    def _client(self) -> Client:
+        if self.client is None:
+            raise ValueError('This user has not opened a page yet. Did you forgot to call .open()?')
+        return self.client
 
     def __getattribute__(self, name: str) -> Any:
-        if name not in {'notify', 'navigate'}:  # NOTE: avoid infinite recursion
+        if name not in {'notify', 'navigate', 'download'}:  # NOTE: avoid infinite recursion
             ui.navigate = self.navigate
             ui.notify = self.notify
+            ui.download = self.download
         return super().__getattribute__(name)
 
-    async def open(self, path: str, *, clear_forward_history: bool = True) -> None:
+    async def open(self, path: str, *, clear_forward_history: bool = True) -> Client:
         """Open the given path."""
         response = await self.http_client.get(path, follow_redirects=True)
         assert response.status_code == 200, f'Expected status code 200, got {response.status_code}'
@@ -56,6 +65,7 @@ class User:
         self.back_history.append(path)
         if clear_forward_history:
             self.forward_history.clear()
+        return self.client
 
     @overload
     async def should_see(self,
@@ -91,9 +101,8 @@ class User:
         By default `should_see` makes three attempts to find the element before failing.
         This can be adjusted with the `retries` parameter.
         """
-        assert self.client
         for _ in range(retries):
-            with self.client:
+            with self._client:
                 if self.notify.contains(target) or self._gather_elements(target, kind, marker, content):
                     return
                 await asyncio.sleep(0.1)
@@ -126,9 +135,8 @@ class User:
                              retries: int = 3,
                              ) -> None:
         """Assert that the page does not contain an input with the given value."""
-        assert self.client
         for _ in range(retries):
-            with self.client:
+            with self._client:
                 if not self.notify.contains(target) and not self._gather_elements(target, kind, marker, content):
                     return
                 await asyncio.sleep(0.05)
@@ -171,8 +179,7 @@ class User:
              content: Union[str, List[str], None] = None,
              ) -> UserInteraction[T]:
         """Select elements for interaction."""
-        assert self.client
-        with self.client:
+        with self._client:
             elements = self._gather_elements(target, kind, marker, content)
             if not elements:
                 raise AssertionError('expected to find at least one ' +
@@ -182,8 +189,7 @@ class User:
     @property
     def current_layout(self) -> Element:
         """Return the root layout element of the current page."""
-        assert self.client
-        return self.client.layout
+        return self._client.layout
 
     def _gather_elements(self,
                          target: Union[str, Type[T], None] = None,

nicegui-2.2.0/nicegui/testing/user_download.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, List, Optional, Union
+
+import httpx
+
+from .. import background_tasks
+
+if TYPE_CHECKING:
+    from .user import User
+
+
+class UserDownload:
+
+    def __init__(self, user: User) -> None:
+        self.http_responses: List[httpx.Response] = []
+        self.user = user
+
+    def __call__(self, src: Union[str, Path, bytes], filename: Optional[str] = None, media_type: str = '') -> Any:
+        background_tasks.create(self._get(src))
+
+    async def _get(self,  src: Union[str, Path, bytes]) -> None:
+        if isinstance(src, bytes):
+            await asyncio.sleep(0)
+            response = httpx.Response(httpx.codes.OK, content=src)
+        else:
+            response = await self.user.http_client.get(str(src))
+        self.http_responses.append(response)
+
+    async def next(self, *, timeout: float = 1.0) -> httpx.Response:
+        """Wait for a new download to happen.
+
+        :param timeout: the maximum time to wait (default: 1.0)
+        :returns: the HTTP response
+        """
+        assert self.user.client
+        downloads = len(self.http_responses)
+        deadline = time.time() + timeout
+        while len(self.http_responses) < downloads + 1:
+            await asyncio.sleep(0.1)
+            if time.time() > deadline:
+                raise TimeoutError('Download did not happen')
+        return self.http_responses[-1]

{nicegui-2.0.1 → nicegui-2.2.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.value_element import ValueElement
 
 if TYPE_CHECKING:
     from .user import User
@@ -43,7 +44,10 @@ class UserInteraction(Generic[T]):
         return self
 
     def type(self, text: str) -> Self:
-        """Type the given text into the selected elements."""
+        """Type the given text into the selected elements.
+
+        Note: All elements must have a ``value`` attribute.
+        """
         assert self.user.client
         with self.user.client:
             for element in self.elements:
@@ -75,3 +79,15 @@ class UserInteraction(Generic[T]):
                     event_arguments = events.GenericEventArguments(sender=element, client=self.user.client, args=args)
                     events.handle_event(listener.handler, event_arguments)
         return self
+
+    def clear(self) -> Self:
+        """Clear the selected elements.
+
+        Note: All elements must have a ``value`` attribute).
+        """
+        assert self.user.client
+        with self.user.client:
+            for element in self.elements:
+                assert isinstance(element, ValueElement)
+                element.value = None
+        return self