Add background reaper for stalled DLC worker

Introduce STOP_WORKER_TIMEOUT and a background reaper to handle worker threads that don't terminate within the stop timeout. Increase join timeout to STOP_WORKER_TIMEOUT, set _pending_reset when a reset is requested while the worker is alive, and schedule _schedule_reap to join the thread in the background instead of immediately marking the processor as FAULTED. The reaper performs final cleanup (clearing thread, queue, state, stop event) and applies a pending DLCLive reset once the thread is reaped, with guards to ensure only one reaper runs at a time.

Author: C-Achard

dlclivegui/services/dlc_processor.py

@@ -21,6 +21,7 @@
 from dlclivegui.temp import Engine  # type: ignore # TODO use main package enum when released
 
 logger = logging.getLogger(__name__)
+STOP_WORKER_TIMEOUT = 10.0  # seconds to wait for worker thread to stop before marking as faulted
 
 try:  # pragma: no cover - optional dependency
     from dlclive import (
@@ -155,6 +156,9 @@ def __init__(self) -> None:
         self._lifecycle_lock = threading.Lock()
         self._stop_event = threading.Event()
         self._initialized = False
+        ## Worker cleanup
+        self._reaping = False
+        self._pending_reset = False
 
         # Statistics tracking
         self._frames_enqueued = 0
@@ -184,6 +188,8 @@ def reset(self) -> None:
         """Stop the worker thread and drop the current DLCLive instance."""
         stopped = self._stop_worker()
         if not stopped:
+            with self._lifecycle_lock:
+                self._pending_reset = True
             logger.warning(
                 "Reset requested but worker thread is still alive; skipping DLCLive reset to avoid potential issues."
             )
@@ -330,21 +336,50 @@ def _stop_worker(self) -> bool:
             self._state = WorkerState.STOPPING
             self._stop_event.set()
 
-        t.join(timeout=2.0)
+        t.join(timeout=STOP_WORKER_TIMEOUT)
         if t.is_alive():
             qsize = self._queue.qsize() if self._queue is not None else -1
             logger.warning("DLC worker thread did not terminate cleanly (qsize=%s)", qsize)
-            with self._lifecycle_lock:
-                self._state = WorkerState.FAULTED
+            self._schedule_reap(t)
             return False
 
+        # Normal cleanup
         with self._lifecycle_lock:
             self._worker_thread = None
             self._queue = None
             self._state = WorkerState.STOPPED
             self._stop_event.clear()
         return True
 
+    def _schedule_reap(self, t: threading.Thread) -> None:
+        with self._lifecycle_lock:
+            if self._reaping:
+                return
+            self._reaping = True
+
+        # ensure only one reaper
+        def reap():
+            try:
+                t.join()  # wait without timeout in background
+                with self._lifecycle_lock:
+                    # only clean if we're still stopping this thread
+                    if self._worker_thread is t:
+                        self._worker_thread = None
+                        self._queue = None
+                        self._state = WorkerState.STOPPED
+                        self._stop_event.clear()
+
+                        if self._pending_reset:
+                            self._dlc = None
+                            self._initialized = False
+                            self._pending_reset = False
+            finally:
+                with self._lifecycle_lock:
+                    self._reaping = False
+            logger.debug("[Stop worker] DLC worker thread reaped; processor is STOPPED again")
+
+        threading.Thread(target=reap, name="DLCLiveReaper", daemon=True).start()
+
     @contextmanager
     def _timed_processor(self):
         """