Allow awaiting the result of detector.detect()

[falkoschindler]

If the RoSys detector is busy, the detect() method simply puts the new image into a queue and returns immediately. This can be confusing if the caller expects the detection to be done when the method returns.

Here is a sketch how such a lazy processing can be implemented without returning too early. Using a generic Worker class we should be able to integrate it quite easily:

import asyncio
import time
import uuid
from typing import Awaitable, Callable, Generic, ParamSpec, TypeVar

from nicegui import ui

_T = TypeVar('_T')
_P = ParamSpec('_P')


class LazyWorker(Generic[_P, _T]):

    def __init__(self, func: Callable[_P, Awaitable[_T]]) -> None:
        self.func = func
        self.waiting: uuid.UUID | None = None
        self.is_free = asyncio.Event()
        self.is_free.set()

    async def compute(self, *args: _P.args, **kwargs: _P.kwargs) -> _T | None:
        id_ = uuid.uuid4()
        self.waiting = id_
        while True:
            if self.waiting != id_:
                return None
            try:
                await asyncio.wait_for(self.is_free.wait(), timeout=0.1)
            except asyncio.TimeoutError:
                continue
            if self.waiting == id_:
                break

        self.is_free.clear()
        self.waiting = None
        result = await self.func(*args, **kwargs)
        self.is_free.set()
        return result


async def add(x: float, y: float) -> float:
    await asyncio.sleep(1)
    return x + y

worker = LazyWorker(add)


async def handle_click():
    notification = ui.notification('Running...', spinner=True)
    result = await worker.compute(time.time(), 2)
    notification.message = f'Done {result}'
    notification.spinner = False

ui.button('Click me', on_click=handle_click)

ui.run()

[rodja]

This is implemented and merged in #94.