nicegui 2.23.0__tar.gz → 2.23.2__tar.gz

{nicegui-2.23.0 → nicegui-2.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nicegui
-Version: 2.23.0
+Version: 2.23.2
 Summary: Create web-based user interfaces with Python. The nice way.
 License: MIT
 Keywords: gui,ui,web,interface,live

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/client.py

@@ -273,6 +273,7 @@ class Client:
         document_id = self._socket_to_document_id.pop(socket_id)
         self._cancel_delete_task(document_id)
         self._num_connections[document_id] -= 1
+        self.tab_id = None
 
         async def delete_content() -> None:
             await asyncio.sleep(self.page.resolve_reconnect_timeout())
@@ -370,21 +371,17 @@ class Client:
         self._temporary_socket_id = None
 
     @classmethod
-    async def prune_instances(cls) -> None:
-        """Prune stale clients in an endless loop."""
-        while True:
-            try:
-                stale_clients = [
-                    client
-                    for client in cls.instances.values()
-                    if not client.shared and not client.has_socket_connection and client.created < time.time() - 60.0
-                ]
-                for client in stale_clients:
-                    client.delete()
-            except Exception:
-                # NOTE: make sure the loop doesn't crash
-                log.exception('Error while pruning clients')
-            try:
-                await asyncio.sleep(10)
-            except asyncio.CancelledError:
-                break
+    def prune_instances(cls, *, client_age_threshold: float = 60.0) -> None:
+        """Prune stale clients."""
+        try:
+            stale_clients = [
+                client
+                for client in cls.instances.values()
+                if not client.shared and not client.has_socket_connection
+                and client.created <= time.time() - client_age_threshold
+            ]
+            for client in stale_clients:
+                client.delete()
+
+        except Exception:
+            log.exception('Error while pruning clients')

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/elements/plotly.vue

@@ -23,9 +23,9 @@ export default {
 
       // re-use plotly instance if config is the same
       if (JSON.stringify(options.config) == JSON.stringify(this.last_options.config)) {
-        Plotly.react(this.$el.id, this.options, options.config);
+        Plotly.react(this.$el, this.options, options.config);
       } else {
-        Plotly.newPlot(this.$el.id, this.options, options.config);
+        Plotly.newPlot(this.$el, this.options, options.config);
         this.set_handlers();
       }
 

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/functions/navigate.py

@@ -69,10 +69,12 @@ class Navigate:
         else:
             raise TypeError(f'Invalid target type: {type(target)}')
 
-        if not new_tab and isinstance(target, str) and not bool(urlparse(target).netloc) and \
-                any(isinstance(el, SubPages) for el in context.client.elements.values()):
-            context.client.sub_pages_router._handle_navigate(path)  # pylint: disable=protected-access
-            return
+        if not new_tab and isinstance(target, str):
+            parsed = urlparse(path)
+            if not parsed.scheme and not parsed.netloc and \
+                    any(isinstance(el, SubPages) for el in context.client.elements.values()):
+                context.client.sub_pages_router._handle_navigate(path)  # pylint: disable=protected-access
+                return
 
         context.client.open(path, new_tab)
 

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/nicegui.py

@@ -1,9 +1,10 @@
 import asyncio
 import mimetypes
+import time
 import urllib.parse
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 import socketio
 from fastapi import HTTPException, Request
@@ -17,6 +18,7 @@ from .error import error_content
 from .json import NiceGUIJSONResponse
 from .logging import log
 from .page import page
+from .persistence import PersistentDict
 from .slot import Slot
 from .staticfiles import CacheControlledStaticFiles
 from .version import __version__
@@ -132,9 +134,10 @@ async def _startup() -> None:
     run.setup()
     app.start()
     background_tasks.create(binding.refresh_loop(), name='refresh bindings')
-    background_tasks.create(Client.prune_instances(), name='prune clients')
-    background_tasks.create(Slot.prune_stacks(), name='prune slot stacks')
-    background_tasks.create(core.app.storage.prune_tab_storage(), name='prune tab storage')
+    app.timer(10, Client.prune_instances, immediate=False)
+    app.timer(10, Slot.prune_stacks, immediate=False)
+    app.timer(10, prune_tab_storage, immediate=False)
+    app.timer(10, prune_user_storage, immediate=False)
     air.connect()
 
 
@@ -214,3 +217,33 @@ def _on_ack(_: str, msg: Dict) -> None:
     if not client:
         return
     client.outbox.prune_history(msg['next_message_id'])
+
+
+async def prune_tab_storage(*, force: bool = False) -> None:
+    """Prune tab storage that is older than the configured ``max_tab_storage_age``."""
+    tab_storages = core.app.storage._tabs  # pylint: disable=protected-access
+    for tab_id, tab in list(tab_storages.items()):
+        if force or time.time() > tab.last_modified + core.app.storage.max_tab_storage_age:
+            tab.clear()
+            if isinstance(tab, PersistentDict):
+                await tab.close()
+            del tab_storages[tab_id]
+
+
+async def prune_user_storage(*, force: bool = False) -> None:
+    """Remove user storage objects without a client session."""
+    client_session_ids = {client.request.session['id']
+                          for client in Client.instances.values()
+                          if client.request is not None}
+    storages_to_close: List[PersistentDict] = []
+    now = time.time()
+    user_storages = core.app.storage._users  # pylint: disable=protected-access
+    for session_id in list(user_storages):
+        if session_id not in client_session_ids:
+            age = now - user_storages[session_id].last_modified
+            if force or age > 10.0:  # NOTE: do not remove storages created by middleware and still wait for client
+                storages_to_close.append(user_storages.pop(session_id))
+    results = await asyncio.gather(*[storage.close() for storage in storages_to_close], return_exceptions=True)
+    for result in results:
+        if isinstance(result, Exception):
+            log.exception(result)

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/slot.py

@@ -58,20 +58,14 @@ class Slot:
 
     @classmethod
     async def prune_stacks(cls) -> None:
-        """Remove stale slot stacks in an endless loop."""
-        while True:
-            try:
-                running = [id(task) for task in asyncio.tasks.all_tasks() if not task.done() and not task.cancelled()]
-                stale_ids = [task_id for task_id in cls.stacks if task_id not in running]
-                for task_id in stale_ids:
-                    del cls.stacks[task_id]
-            except Exception:
-                # NOTE: make sure the loop doesn't crash
-                log.exception('Error while pruning slot stacks')
-            try:
-                await asyncio.sleep(10)
-            except asyncio.CancelledError:
-                break
+        """Remove stale slot stacks."""
+        try:
+            running = [id(task) for task in asyncio.tasks.all_tasks() if not task.done() and not task.cancelled()]
+            stale_ids = [task_id for task_id in cls.stacks if task_id not in running]
+            for task_id in stale_ids:
+                del cls.stacks[task_id]
+        except Exception:
+            log.exception('Error while pruning slot stacks')
 
 
 def get_task_id() -> int:

{nicegui-2.23.0 → nicegui-2.23.2}/nicegui/storage.py

@@ -1,7 +1,5 @@
-import asyncio
 import contextvars
 import os
-import time
 import uuid
 from datetime import timedelta
 from pathlib import Path
@@ -20,8 +18,6 @@ from .persistence import FilePersistentDict, PersistentDict, ReadOnlyDict, Redis
 
 request_contextvar: contextvars.ContextVar[Optional[Request]] = contextvars.ContextVar('request_var', default=None)
 
-PURGE_INTERVAL = timedelta(minutes=5).total_seconds()
-
 
 class RequestTrackingMiddleware(BaseHTTPMiddleware):
 
@@ -30,10 +26,10 @@ class RequestTrackingMiddleware(BaseHTTPMiddleware):
         if 'id' not in request.session:
             request.session['id'] = str(uuid.uuid4())
         request.state.responded = False
-        await core.app.storage._create_user_storage(request.session['id'])  # pylint: disable=protected-access
+        session_id = request.session['id']
+        if session_id not in core.app.storage._users:  # pylint: disable=protected-access
+            await core.app.storage._create_user_storage(session_id)  # pylint: disable=protected-access
         response = await call_next(request)
-        if response.headers.get('X-NiceGUI-Content') != 'page':
-            await core.app.storage.user.close()
         request.state.responded = True
         return response
 
@@ -120,9 +116,8 @@ class Storage:
         return self._users[session_id]
 
     async def _create_user_storage(self, session_id: str) -> None:
-        if session_id not in self._users:
-            self._users[session_id] = Storage._create_persistent_dict(f'user-{session_id}')
-            await self._users[session_id].initialize()
+        self._users[session_id] = Storage._create_persistent_dict(f'user-{session_id}')
+        await self._users[session_id].initialize()
 
     @staticmethod
     def _is_in_auto_index_context() -> bool:
@@ -182,20 +177,6 @@ class Storage:
                 self._tabs[tab_id] = ObservableDict()
             self._tabs[tab_id].update(self._tabs[old_tab_id])
 
-    async def prune_tab_storage(self) -> None:
-        """Regularly prune tab storage that is older than the configured `max_tab_storage_age`."""
-        while True:
-            for tab_id, tab in list(self._tabs.items()):
-                if time.time() > tab.last_modified + self.max_tab_storage_age:
-                    tab.clear()
-                    if isinstance(tab, PersistentDict):
-                        await tab.close()
-                    del self._tabs[tab_id]
-            try:
-                await asyncio.sleep(PURGE_INTERVAL)
-            except asyncio.CancelledError:
-                break
-
     def clear(self) -> None:
         """Clears all storage."""
         self._general.clear()

{nicegui-2.23.0 → nicegui-2.23.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nicegui"
-version = "v2.23.0"
+version = "v2.23.2"
 description = "Create web-based user interfaces with Python. The nice way."
 authors = ["Zauberzeug GmbH <info@zauberzeug.com>"]
 license = "MIT"