nicegui 3.0.2__tar.gz → 3.0.4__tar.gz

{nicegui-3.0.2 → nicegui-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nicegui
-Version: 3.0.2
+Version: 3.0.4
 Summary: Create web-based user interfaces with Python. The nice way.
 License: MIT
 License-File: LICENSE
@@ -41,13 +41,12 @@ Requires-Dist: orjson (>=3.9.15) ; platform_machine != "i386" and platform_machi
 Requires-Dist: plotly (>=5.13,<7.0) ; extra == "plotly"
 Requires-Dist: python-engineio (>=4.12.0)
 Requires-Dist: python-multipart (>=0.0.18)
-Requires-Dist: python-socketio[asyncio-client] (>=5.10.0)
+Requires-Dist: python-socketio[asyncio-client] (>=5.14.0)
 Requires-Dist: pywebview (>=5.0.1,<6.0.0) ; extra == "native"
 Requires-Dist: redis (>=4.0.0) ; extra == "redis"
 Requires-Dist: starlette (>=0.45.3)
 Requires-Dist: typing-extensions (>=4.0.0)
 Requires-Dist: uvicorn[standard] (>=0.22.0)
-Requires-Dist: vbuild (>=0.8.2)
 Requires-Dist: watchfiles (>=0.18.1)
 Project-URL: Repository, https://github.com/zauberzeug/nicegui
 Description-Content-Type: text/markdown

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/core.py

@@ -17,3 +17,8 @@ air: Air | None = None
 root: Callable | None = None
 script_mode: bool = False
 script_client: Client | None = None
+
+
+def is_script_mode_preflight() -> bool:
+    """Return whether this is the preflight run of the script mode."""
+    return script_mode and not app.is_started  # pylint: disable=undefined-variable # noqa: F821

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/dependencies.py

@@ -6,10 +6,9 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Callable
 
-import vbuild
-
 from .dataclasses import KWONLY_SLOTS
 from .helpers import hash_file_path
+from .vbuild import VBuild
 from .version import __version__
 
 if TYPE_CHECKING:
@@ -86,7 +85,7 @@ def register_vue_component(path: Path, *, max_time: float | None) -> Component:
         if key in vue_components and vue_components[key].path == path:
             return vue_components[key]
         assert key not in vue_components, f'Duplicate VUE component {key}'
-        v = vbuild.VBuild(path.name, path.read_text(encoding='utf-8'))
+        v = VBuild(path)
         vue_components[key] = VueComponent(key=key, name=name, path=path, html=v.html, script=v.script, style=v.style)
         return vue_components[key]
     if path.suffix == '.js':

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/elements/table.py

@@ -43,6 +43,12 @@ class Table(FilterElement, component='table.js'):
 
         A table based on Quasar's `QTable <https://quasar.dev/vue-components/table>`_ component.
 
+        If ``selection`` is "single" or "multiple", then a ``selected`` property is accessible containing the selected rows.
+
+        Note:
+        Cells in ``rows`` must not contain lists because they can cause the browser to crash.
+        To display complex data structures, convert them to strings first (e.g., using ``str()`` or custom formatting).
+
         :param rows: list of row objects
         :param columns: list of column objects (defaults to the columns of the first row *since version 2.0.0*)
         :param column_defaults: optional default column properties, *added in version 2.0.0*
@@ -52,8 +58,6 @@ class Table(FilterElement, component='table.js'):
         :param pagination: a dictionary correlating to a pagination object or number of rows per page (`None` hides the pagination, 0 means "infinite"; default: `None`).
         :param on_select: callback which is invoked when the selection changes
         :param on_pagination_change: callback which is invoked when the pagination changes
-
-        If selection is 'single' or 'multiple', then a `selected` property is accessible containing the selected rows.
         """
         super().__init__()
 

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/event.py

@@ -7,6 +7,7 @@ from collections.abc import Awaitable, Callable
 from contextlib import nullcontext
 from dataclasses import dataclass
 from typing import Any, ClassVar, Generic
+from weakref import WeakSet
 
 from typing_extensions import ParamSpec
 
@@ -32,6 +33,10 @@ class Callback(Generic[P]):
         """Run the callback."""
         with (self.slot and self.slot()) or nullcontext():
             expect_args = helpers.expects_arguments(self.func)
+            expect_args |= (
+                isinstance(getattr(self.func, '__self__', None), Event) and
+                getattr(self.func, '__name__', None) in {'emit', 'call'}
+            )
             return self.func(*args, **kwargs) if expect_args else self.func()  # type: ignore[call-arg]
 
     async def await_result(self, result: Awaitable | AwaitableResponse | asyncio.Task) -> Any:
@@ -41,13 +46,13 @@ class Callback(Generic[P]):
 
 
 class Event(Generic[P]):
-    instances: ClassVar[list[Event]] = []
+    instances: ClassVar[WeakSet[Event]] = WeakSet()
 
     def __init__(self) -> None:
         """Event
 
-        Events are a powerful tool distribute information between different parts of your code.
-        The following demo shows how to define an event, subscribe a callback and emit it.
+        Events are a powerful tool distribute information between different parts of your code,
+        especially from long-living objects like data models to the short-living UI.
 
         Handlers can be synchronous or asynchronous.
         They can also take arguments if the event contains arguments.
@@ -55,19 +60,19 @@ class Event(Generic[P]):
         *Added in version 3.0.0*
         """
         self.callbacks: list[Callback[P]] = []
-        self.instances.append(self)
+        self.instances.add(self)
 
     def subscribe(self, callback: Callable[P, Any] | Callable[[], Any], *,
-                  unsubscribe_on_disconnect: bool | None = None) -> None:
+                  unsubscribe_on_delete: bool | None = None) -> None:
         """Subscribe to the event.
 
-        The ``unsubscribe_on_disconnect`` can be used to explicitly define
-        whether the callback should be automatically unsubscribed when the client disconnects.
+        The ``unsubscribe_on_delete`` can be used to explicitly define
+        whether the callback should be automatically unsubscribed when the current client is deleted.
         By default, the callback is automatically unsubscribed if subscribed from within a UI context
         to prevent memory leaks.
 
         :param callback: the callback which will be called when the event is fired
-        :param unsubscribe_on_disconnect: whether to unsubscribe the callback when the client disconnects
+        :param unsubscribe_on_delete: whether to unsubscribe the callback when the current client is deleted
             (default: ``None`` meaning the callback is automatically unsubscribed if subscribed from within a UI context)
         """
         frame = inspect.currentframe()
@@ -75,26 +80,25 @@ class Event(Generic[P]):
         frame = frame.f_back
         assert frame is not None
         callback_ = Callback[P](func=callback, filepath=frame.f_code.co_filename, line=frame.f_lineno)
-        try:
+        client: Client | None = None
+        if Slot.get_stack():  # NOTE: additional check before accessing `context.slot` which would enter script mode
             callback_.slot = weakref.ref(context.slot)
-            client: Client | None = context.client
-        except RuntimeError:
-            client = None
-        if callback_.slot is None and unsubscribe_on_disconnect is True:
-            raise RuntimeError('Calling `subscribe` with `unsubscribe_on_disconnect=True` outside of a UI context '
+            client = context.client
+        if callback_.slot is None and unsubscribe_on_delete is True:
+            raise RuntimeError('Calling `subscribe` with `unsubscribe_on_delete=True` outside of a UI context '
                                'is not supported.')
-        if client is not None and unsubscribe_on_disconnect is not False:
-            async def register_disconnect() -> None:
+        if client is not None and unsubscribe_on_delete is not False and not core.is_script_mode_preflight():
+            async def register_unsubscribe() -> None:
                 try:
                     await client.connected()
-                    client.on_disconnect(lambda: self.unsubscribe(callback))
+                    client.on_delete(lambda: self.unsubscribe(callback))
                 except ClientConnectionTimeout:
                     log.debug('Could not register a disconnect handler for callback %s', callback)
                     self.unsubscribe(callback)
             if core.loop and core.loop.is_running():
-                background_tasks.create(register_disconnect())
+                background_tasks.create(register_unsubscribe())
             else:
-                core.app.on_startup(register_disconnect())
+                core.app.on_startup(register_unsubscribe())
         self.callbacks.append(callback_)
 
     def unsubscribe(self, callback: Callable[P, Any] | Callable[[], Any]) -> None:
@@ -144,18 +148,15 @@ def _invoke_and_forget(callback: Callback[P], *args: P.args, **kwargs: P.kwargs)
                 background_tasks.create(callback.await_result(result), name=f'{callback.filepath}:{callback.line}')
             else:
                 core.app.on_startup(callback.await_result(result))
-    except Exception:
-        log.exception('Could not emit callback %s', callback)
+    except Exception as e:
+        core.app.handle_exception(e)
 
 
 async def _invoke_and_await(callback: Callback[P], *args: P.args, **kwargs: P.kwargs) -> Any:
-    try:
-        result = callback.run(*args, **kwargs)
-        if _should_await(result):
-            result = await callback.await_result(result)
-        return result
-    except Exception as e:
-        core.app.handle_exception(e)
+    result = callback.run(*args, **kwargs)
+    if _should_await(result):
+        result = await callback.await_result(result)
+    return result
 
 
 def _should_await(result: Any) -> bool:

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/helpers.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import asyncio
 import functools
 import hashlib
 import os
 import socket
 import struct
+import sys
 import threading
 import time
 import webbrowser
@@ -22,6 +22,11 @@ if TYPE_CHECKING:
 
 _shown_warnings: set[str] = set()
 
+if sys.version_info < (3, 13):
+    from asyncio import iscoroutinefunction
+else:
+    from inspect import iscoroutinefunction
+
 
 def warn_once(message: str, *, stack_info: bool = False) -> None:
     """Print a warning message only once."""
@@ -48,7 +53,7 @@ def is_coroutine_function(obj: Any) -> bool:
     """
     while isinstance(obj, functools.partial):
         obj = obj.func
-    return asyncio.iscoroutinefunction(obj)
+    return iscoroutinefunction(obj)
 
 
 def expects_arguments(func: Callable) -> bool:

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/persistence/redis_persistent_dict.py

@@ -17,13 +17,13 @@ class RedisPersistentDict(PersistentDict):
         if not optional_features.has('redis'):
             raise ImportError('Redis is not installed. Please run "pip install nicegui[redis]".')
         self.url = url
-        self.redis_client = redis.from_url(
-            url,
-            health_check_interval=10,
-            socket_connect_timeout=5,
-            retry_on_timeout=True,
-            socket_keepalive=True,
-        )
+        self._redis_client_params = {
+            'health_check_interval': 10,
+            'socket_connect_timeout': 5,
+            'retry_on_timeout': True,
+            **({'socket_keepalive': True} if not url.startswith('unix://') else {}),
+        }
+        self.redis_client = redis.from_url(self.url, **self._redis_client_params)
         self.pubsub = self.redis_client.pubsub()
         self.key = key_prefix + id
         self._should_listen = True
@@ -40,13 +40,7 @@ class RedisPersistentDict(PersistentDict):
 
     def initialize_sync(self) -> None:
         """Load initial data from Redis and start listening for changes in a synchronous context."""
-        with redis_sync.from_url(
-            self.url,
-            health_check_interval=10,
-            socket_connect_timeout=5,
-            retry_on_timeout=True,
-            socket_keepalive=True,
-        ) as redis_client_sync:
+        with redis_sync.from_url(self.url, **self._redis_client_params) as redis_client_sync:
             try:
                 data = redis_client_sync.get(self.key)
                 self.update(json.loads(data) if data else {})

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/storage.py

@@ -82,7 +82,7 @@ class Storage:
         Therefore it is normally better to use `app.storage.user` instead,
         which can be modified anytime, reduces overall payload, improves security and has larger storage capacity.
         """
-        if core.script_mode and not core.app.is_started:
+        if core.is_script_mode_preflight():
             return {}
         request: Optional[Request] = request_contextvar.get()
         if request is None:
@@ -103,7 +103,7 @@ class Storage:
         The data is stored on the server.
         It is shared between all browser tabs by identifying the user via session cookie ID.
         """
-        if core.script_mode and not core.app.is_started:
+        if core.is_script_mode_preflight():
             return PseudoPersistentDict()
         request: Optional[Request] = request_contextvar.get()
         if request is None:

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/testing/plugin.py

@@ -1,4 +1,10 @@
 # pylint: disable=unused-import
 from .general_fixtures import nicegui_reset_globals, pytest_addoption  # noqa: F401
-from .screen_plugin import nicegui_chrome_options, nicegui_driver, nicegui_remove_all_screenshots, screen  # noqa: F401
+from .screen_plugin import (  # noqa: F401
+    nicegui_chrome_options,
+    nicegui_driver,
+    nicegui_remove_all_screenshots,
+    pytest_runtest_makereport,
+    screen,
+)
 from .user_plugin import create_user, user  # noqa: F401

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/testing/screen.py

@@ -1,4 +1,3 @@
-import os
 import re
 import runpy
 import threading
@@ -247,10 +246,12 @@ class Screen:
         """Wait for the given number of seconds."""
         time.sleep(t)
 
-    def shot(self, name: str) -> None:
+    def shot(self, name: str, *, failed: bool) -> None:
         """Take a screenshot and store it in the screenshots directory."""
-        os.makedirs(self.SCREENSHOT_DIR, exist_ok=True)
-        filename = f'{self.SCREENSHOT_DIR}/{name}.png'
+        self.SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
+        if failed:
+            name = f'{name}.failed'
+        filename = self.SCREENSHOT_DIR / f'{name}.png'
         print(f'Storing screenshot to {filename}')
         self.selenium.get_screenshot_as_file(filename)
 

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/testing/screen_plugin.py

@@ -18,6 +18,14 @@ from .screen import Screen
 DOWNLOAD_DIR = Path(__file__).parent / 'download'
 
 
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):  # pylint: disable=unused-argument
+    """Store test outcome in the node for fixture access."""
+    outcome = yield
+    rep = outcome.get_result()
+    setattr(item, f'rep_{rep.when}', rep)
+
+
 @pytest.fixture
 def nicegui_chrome_options(chrome_options: webdriver.ChromeOptions) -> webdriver.ChromeOptions:
     """Configure the Chrome options for the NiceGUI tests."""
@@ -47,9 +55,8 @@ def capabilities(capabilities: dict) -> dict:
 @pytest.fixture(scope='session')
 def nicegui_remove_all_screenshots() -> None:
     """Remove all screenshots from the screenshot directory before the test session."""
-    if os.path.exists(Screen.SCREENSHOT_DIR):
-        for name in os.listdir(Screen.SCREENSHOT_DIR):
-            os.remove(os.path.join(Screen.SCREENSHOT_DIR, name))
+    for name in Screen.SCREENSHOT_DIR.glob('*.png'):
+        name.unlink()
 
 
 @pytest.fixture()
@@ -77,7 +84,8 @@ def screen(nicegui_reset_globals,  # noqa: F811, pylint: disable=unused-argument
     os.environ.pop('NICEGUI_SCREEN_TEST_PORT', None)
     logs = [record for record in screen_.caplog.get_records('call') if record.levelname == 'ERROR']
     if screen_.is_open:
-        screen_.shot(request.node.name)
+        test_failed = hasattr(request.node, 'rep_call') and request.node.rep_call.failed
+        screen_.shot(request.node.name, failed=test_failed or bool(logs))
     screen_.stop_server()
     if DOWNLOAD_DIR.exists():
         shutil.rmtree(DOWNLOAD_DIR)

{nicegui-3.0.2 → nicegui-3.0.4}/nicegui/timer.py

@@ -41,7 +41,7 @@ class Timer:
         self._current_invocation: Optional[asyncio.Task] = None
 
         coroutine = self._run_once if once else self._run_in_loop
-        if core.script_mode and not core.app.is_started:
+        if core.is_script_mode_preflight():
             return
         if core.app.is_started:
             background_tasks.create(coroutine(), name=str(callback))
@@ -105,14 +105,14 @@ class Timer:
             self._cleanup()
 
     async def _invoke_callback(self) -> None:
-        try:
-            assert self.callback is not None
-            with self._get_context():
+        with self._get_context():
+            try:
+                assert self.callback is not None
                 result = self.callback()
                 if isinstance(result, Awaitable) and not isinstance(result, AwaitableResponse):
                     await result
-        except Exception as e:
-            core.app.handle_exception(e)
+            except Exception as e:
+                core.app.handle_exception(e)
 
     async def _can_start(self) -> bool:
         return True

nicegui-3.0.4/nicegui/vbuild.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+from pathlib import Path
+
+VOID_TAGS = 'area base br col embed hr img input link meta param source track wbr'.split()
+
+
+class VBuild:
+
+    def __init__(self, filepath: Path) -> None:
+        parser = VueParser(filepath)
+        if parser.html is None:
+            raise ValueError(f'{filepath} has no template')
+
+        name = filepath.stem.replace('/', '-').replace('\\', '-').replace(':', '-').replace('.', '-')
+        html = re.sub(r'^<([\w-]+)', rf'<\1 data-{name}', parser.html)
+        self.html = f'<script type="text/x-template" id="tpl-{name}">{html}</script>'
+        self.style = '\n'.join(add_css_prefix(style, '') for style in parser.styles) + '\n'
+        self.style += '\n'.join(add_css_prefix(style, f'*[data-{name}]') for style in parser.scopedStyles)
+        self.script = create_vue_component(filepath.stem, f'#tpl-{name}', parser.script)
+
+
+class VueParser(HTMLParser):  # pylint: disable=abstract-method  # pylint assumes there is an abstract ``error`` method
+
+    def __init__(self, filepath: Path):
+        HTMLParser.__init__(self)
+        self.rootTag: str | None = None
+        self.html: str | None = None
+        self.script: str | None = None
+        self.styles: list[str] = []
+        self.scopedStyles: list[str] = []
+        self._p1: int | None = None
+        self._level = 0
+        self._tag = ''
+        self.feed(filepath.read_text(encoding='utf-8').strip('\n\r\t '))
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self._tag = tag
+
+        if tag in VOID_TAGS:
+            return  # don't manage if it's a void element
+
+        self._level += 1
+        if self._level == 1 and tag == 'template':
+            if self._p1 is not None:
+                raise ValueError('File contains more than one template')
+            self._p1 = self._get_offset() + len(self._start_tag_text)
+        if self._level == 2 and self._p1:  # test p1, to be sure to be in a template
+            if self.rootTag is not None:
+                raise ValueError('File has more than one top level tag')
+            self.rootTag = tag
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag not in VOID_TAGS:
+            if tag == 'template' and self._p1:  # don't watch the level (so it can accept malformed HTML)
+                self.html = self.rawdata[self._p1:self._get_offset()].strip()
+            self._level -= 1
+
+    def handle_data(self, data: str) -> None:
+        if self._level == 1:
+            if self._tag == 'script':
+                self.script = data
+            if self._tag == 'style':
+                if 'scoped' in self._start_tag_text.lower():
+                    self.scopedStyles.append(data)
+                else:
+                    self.styles.append(data)
+
+    def _get_offset(self) -> int:
+        pos = 0
+        for _ in range(self.lineno - 1):
+            pos = self.rawdata.find('\n', pos) + 1
+        return pos + self.offset
+
+    @property
+    def _start_tag_text(self) -> str:
+        text = self.get_starttag_text()
+        assert text is not None
+        return text
+
+
+def create_vue_component(name: str, template: str, code: str | None) -> str:
+    """Create a Vue component."""
+    if code is None:
+        js = '{}'
+    else:
+        p1 = code.find('{')
+        p2 = code.rfind('}')
+        if not 0 <= p1 <= p2:
+            raise ValueError('Cannot find valid content inside "{" and "}"')
+        js = code[p1:p2 + 1]
+    js = js.replace('{', f'{{template:"{template}",', 1)
+    return f'''var {name} = Vue.component('{name}', {js});'''
+
+
+def add_css_prefix(css: str, prefix: str) -> str:
+    """Add the prefix (CSS selector) to all rules in ``css``."""
+    medias: list[tuple[str, str]] = []
+    while '@media' in css:
+        p1 = css.find('@media', 0)
+        p2 = css.find('{', p1) + 1
+        level = 1
+        while level > 0:
+            level += 1 if css[p2] == '{' else -1 if css[p2] == '}' else 0
+            p2 += 1
+        block = css[p1:p2]
+        media_def = block[:block.find('{')].strip()
+        media_css = block[block.find('{') + 1:block.rfind('}')].strip()
+        css = css.replace(block, '')
+        medias.append((media_def, add_css_prefix(media_css, prefix)))
+
+    lines: list[str] = []
+    css = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', css)
+    css = re.sub(re.compile(r'[ \t\n]+', re.DOTALL), ' ', css)
+    for rule in re.findall(r'[^}]+{[^}]+}', css):
+        selectors, declarations = rule.split('{', 1)
+        if prefix:
+            line = [(prefix + ' ' + i.replace(':scope', '').strip()).strip() for i in selectors.split(',')]
+        else:
+            line = [i.strip() for i in selectors.split(',')]
+        lines.append(', '.join(line) + ' {' + declarations.strip())
+    lines.extend(f'{d} {{ {c} }}' for d, c in medias)
+    return '\n'.join(lines).strip()

{nicegui-3.0.2 → nicegui-3.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nicegui"
-version = "v3.0.2"
+version = "v3.0.4"
 description = "Create web-based user interfaces with Python. The nice way."
 authors = ["Zauberzeug GmbH <info@zauberzeug.com>"]
 license = "MIT"
@@ -16,8 +16,7 @@ Pygments = ">=2.15.1,<3.0.0"
 starlette = ">=0.45.3"
 uvicorn = {extras = ["standard"], version = ">=0.22.0"}
 fastapi = ">=0.109.1"
-python-socketio = {extras = ["asyncio-client"], version = ">=5.10.0"} # version min: see https://github.com/zauberzeug/nicegui/issues/1809
-vbuild = ">=0.8.2"
+python-socketio = {extras = ["asyncio-client"], version = ">=5.14.0"} # https://github.com/zauberzeug/nicegui/security/dependabot/52
 jinja2 = "^3.1.6" # https://github.com/zauberzeug/nicegui/security/dependabot/44
 python-multipart = ">=0.0.18"
 orjson = {version = ">=3.9.15", markers = "platform_machine != 'i386' and platform_machine != 'i686'"} # https://github.com/zauberzeug/nicegui/security/dependabot/29, orjson does not support 32bit
@@ -37,6 +36,7 @@ h11 = ">=0.16.0" # transitive, pinned to https://github.com/zauberzeug/nicegui/s
 python-engineio = ">=4.12.0"  # transitive, pinned to address https://github.com/zauberzeug/nicegui/issues/4602
 aiohttp = ">=3.10.2" # transitive, pinned to address https://github.com/zauberzeug/nicegui/security/dependabot/36
 certifi = ">=2024.07.04" # transitive, pinned to address https://github.com/zauberzeug/nicegui/security/dependabot/35
+pydantic-core = {version = ">=2.35.0", optional = true} # Optional to not force Pydantic V2
 
 [tool.poetry.extras]
 native = ["pywebview"]
@@ -58,7 +58,8 @@ urllib3 = ">=1.26.18,!=2.0.0,!=2.0.1,!=2.0.2,!=2.0.3,!=2.0.4,!=2.0.5,!=2.0.6,!=2
 itsdangerous = "^2.1.2" # required by SessionMiddleware (see https://fastapi.tiangolo.com/?h=itsdangerous#optional-dependencies)
 pandas = [
     {version = "^2.0.0", python = "<3.13"},
-    {version = "^2.2.3", python = ">=3.13,<3.14"}
+    {version = "^2.2.3", python = ">=3.13,<3.14"},
+    {version = "^2.3.3", python = ">=3.14"}
 ]
 secure = ">=0.3.0"
 webdriver-manager = ">=3.8.6,<5.0.0"
@@ -94,9 +95,9 @@ main_file = ""
 testpaths = ["tests"]
 filterwarnings = [
   'error',
-  'ignore::DeprecationWarning:^vbuild(\.|$)',
   'ignore::DeprecationWarning:^websockets\.legacy(\.|$)',
   'ignore::DeprecationWarning:^uvicorn\.protocols\.websockets(\.|$)',
+  "ignore:'asyncio\\.iscoroutinefunction' is deprecated and slated for removal:DeprecationWarning",
 ]
 
 [tool.mypy]
@@ -114,7 +115,6 @@ module = [
     "pyecharts.*",
     "sass",
     "socketio.*",
-    "vbuild",
     "webview.*", # can be removed with next pywebview release
 ]
 ignore_missing_imports = true