refactors task runner

Author: WolfgangFahl

ngwidgets/__init__.py

@@ -1 +1 @@
-__version__ = "0.29.1"
+__version__ = "0.29.2"

ngwidgets/task_runner.py

@@ -6,15 +6,15 @@
 
 import asyncio
 import inspect
+import time
 from typing import Callable, Optional
 
 from basemkit.persistent_log import Log
+from ngwidgets.progress import Progressbar
 from nicegui import background_tasks
+from nicegui import run
 
 # optional generic Progressbar tqdm or nicegui.ui
-from ngwidgets.progress import Progressbar
-
-
 class TaskRunner:
     """
     A robust background task runner that supports:
@@ -29,12 +29,50 @@ def __init__(self, timeout: float = 20.0, progress: Optional[Progressbar] = None
         self.timeout = timeout
         self.progress = progress
         self.log = Log()
+        self.start_time = None
+        self.stop_time = None
+        self.task_name = "?"
+
+    def set_name(self, func: Callable):
+        """Set task name from function"""
+        self.task_name = getattr(func, '__name__', '?')
+
+    def get_status(self) -> str:
+        """Get formatted status string with timing information"""
+        if not self.start_time:
+            status = 'Ready'
+        else:
+            elapsed = self.get_elapsed_time()
+            start_str = time.strftime('%H:%M:%S', time.localtime(self.start_time))
+
+            if self.is_running():
+                status = f'Running "{self.task_name}" for {elapsed:.1f}s since {start_str}'
+            elif self.stop_time:
+                stop_str = time.strftime('%H:%M:%S', time.localtime(self.stop_time))
+                status = f'Completed "{self.task_name}" in {elapsed:.1f}s ({start_str}-{stop_str})'
+            else:
+                status = f'Interrupted "{self.task_name}" after {elapsed:.1f}s from {start_str}'
+
+        return status
+
+    def get_elapsed_time(self) -> float:
+        """Get elapsed time in seconds since task started"""
+        elapsed = 0.0
+        if self.start_time:
+            if self.is_running():
+                elapsed = time.time() - self.start_time
+            elif self.stop_time:
+                elapsed = self.stop_time - self.start_time
+        return elapsed
 
     def cancel_running(self):
         if self.task and not self.task.done():
             self.task.cancel()
-            if self.progress:
-                self.progress.reset()
+        if self.progress:
+            self.progress.reset()
+        # Reset timing when cancelled
+        self.start_time = None
+        self.stop_time = None
 
     def is_running(self) -> bool:
         running = self.task and not self.task.done()
@@ -65,9 +103,12 @@ def run_blocking(self, blocking_func: Callable, *args, **kwargs):
             blocking_func
         ):
             raise TypeError("run_blocking expects a sync function, not async.")
-
+        self.set_name(blocking_func)
         async def wrapper():
-            await asyncio.to_thread(blocking_func, *args, **kwargs)
+            # this would be the native asyncio call
+            # await asyncio.to_thread(blocking_func, *args, **kwargs)
+            # we use nicegui managed threads
+            await run.io_bound(blocking_func, *args, **kwargs)
 
         self._start(wrapper)
 
@@ -82,6 +123,7 @@ def run_async_wrapping_blocking(self, coro_func: Callable[[], asyncio.Future]):
             raise TypeError(
                 "run_async_wrapping_blocking expects an async def function."
             )
+        self.set_name(coro_func)
         self._start(coro_func)
 
     def run_async(self, coro_func: Callable[..., asyncio.Future], *args, **kwargs):
@@ -94,10 +136,12 @@ def run_async(self, coro_func: Callable[..., asyncio.Future], *args, **kwargs):
         """
         if not inspect.iscoroutinefunction(coro_func):
             raise TypeError("run_async expects an async def function (not called yet).")
+        self.set_name(coro_func)
         self._start(coro_func, *args, **kwargs)
 
     def _start(self, coro_func: Callable[..., asyncio.Future], *args, **kwargs):
         self.cancel_running()
+        self.start_time = time.time()
 
         async def wrapped():
             try:
@@ -116,5 +160,6 @@ async def wrapped():
             finally:
                 if self.progress:
                     self.progress.update_value(self.progress.total)
+                self.stop_time = time.time()
 
         self.task = background_tasks.create(wrapped())

ngwidgets/version.py

@@ -18,7 +18,7 @@ class Version:
     name = "ngwidgets"
     version = ngwidgets.__version__
     date = "2023-09-10"
-    updated = "2025-07-22"
+    updated = "2025-07-23"
     description = "NiceGUI widgets"
 
     authors = "Wolfgang Fahl"

ngwidgets/widgets_demo.py

@@ -7,6 +7,7 @@
 import asyncio
 import logging
 import random
+import time
 from dataclasses import dataclass
 from datetime import datetime
 
@@ -587,52 +588,83 @@ async def show_taskrunner_demo(self):
         """
         Demonstrate the TaskRunner with timeout, progress, and cancellation
         """
-
         def show():
-            task_runner = TaskRunner(timeout=10.0)
+            # Create progress bar for TaskRunner
+            progress_bar = NiceguiProgressbar(total=100, desc="Task", unit="step")
+            task_runner = TaskRunner(timeout=8.0, progress=progress_bar)
 
-            async def load_data():
-                await asyncio.sleep(3)  # Simulate data loading
-                content.clear()
+            async def hint(title:str,done:bool=False,marker:str="✅"):
                 with content:
-                    ui.markdown("✅ Data loaded successfully!")
-
-            async def slow_load():
-                await asyncio.sleep(15)  # Will timeout
-                content.clear()
+                    content.clear()
                 with content:
-                    ui.markdown("This should timeout!")
+                    if not done:
+                        ui.spinner()
+                        marker=""
+                    ui.markdown(title+marker)
+
+            async def load_data_5secs():
+                title='Loading data ... for 5 secs'
+                await hint(title)
+
+                # Simulate work with progress updates
+                for _i in range(50):
+                    await asyncio.sleep(0.1)  # 5 seconds total
+                    progress_bar.update(2)  # 2% per step
+
+                await hint(title,True)
+
+            async def slow_load_10secs():
+                title='Loading 10 secs (this will timeout after 8 secs)...'
+                await hint(title)
+
+                # This will timeout at 8 seconds
+                for _i in range(100):
+                    await asyncio.sleep(0.1)  # 10 seconds total - will timeout
+                    progress_bar.update(1)
+
+                await hint('This should timeout!',True,marker="❌")
+
+            def blocking_task(secs:float=5):
+                time.sleep(secs)
+                return f"Blocking task  {secs} secs completed"
 
-            def blocking_task():
-                import time
+            async def blocking_task_5secs():
+                title = 'Running blocking task for 5 secs'
+                await hint(title)
+                result = blocking_task(5)
+                await hint(result, True)
 
-                time.sleep(2)  # Blocking operation
-                return "Blocking task completed"
+            async def quick_task_1sec():
+                title='Quick task 1sec'
+                await hint(title)
 
-            async def handle_blocking():
-                result = await run.io_bound(blocking_task)
-                content.clear()
+                await asyncio.sleep(1)  # 1 second for quick demo
+                await hint(title,True)
+
+            def cancel_task():
+                task_runner.cancel_running()
                 with content:
-                    ui.markdown(f"✅ {result}")
+                    content.clear()
+                    ui.markdown('⚠️ Task cancelled')
 
             with ui.card() as content:
-                ui.spinner()
-                ui.markdown("Ready to run tasks...")
+                ui.markdown('Ready to run tasks...')
+
+            # Show progress bar
+            progress_bar.progress.visible = True
 
             with ui.row():
-                ui.button("Load Data (3s)", on_click=lambda: task_runner.run(load_data))
-                ui.button(
-                    "Timeout Test (15s)", on_click=lambda: task_runner.run(slow_load)
-                )
-                ui.button(
-                    "Blocking Task", on_click=lambda: task_runner.run(handle_blocking)
-                )
-                ui.button("Cancel", on_click=task_runner.cancel_running)
+                ui.button('Load Data (5s)', on_click=lambda: task_runner.run(load_data_5secs))
+                ui.button('Quick Task (1s)', on_click=lambda: task_runner.run(quick_task_1sec))
+                ui.button('Blocking Task (5s)', on_click=lambda: task_runner.run(blocking_task_5secs))
+                ui.button('Timeout Test (8s+)', on_click=lambda: task_runner.run(slow_load_10secs))
+                ui.button('Cancel', on_click=cancel_task)
 
             with ui.row():
-                ui.label().bind_text_from(
-                    task_runner, "is_running", lambda running: f"Running: {running}"
-                )
+                status_label = ui.label('')
+
+                # Update status every 100ms using timer
+                ui.timer(0.1, lambda: status_label.set_text(task_runner.get_status()))
 
         await self.setup_content_div(show)