ok-script 2.0.2__tar.gz → 2.0.3__tar.gz

{ok_script-2.0.2/ok_script.egg-info → ok_script-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.2
+Version: 2.0.3
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 License: ok-script License

{ok_script-2.0.2 → ok_script-2.0.3}/ok/__init__.py

@@ -217,7 +217,6 @@ _OK_CONFIG_DEFAULTS = {
     'window_maximized': False,
     'navigation_expanded': True,
     'use_overlay': False,
-    'show_overlay_logs': True,
 }
 
 
@@ -226,24 +225,33 @@ def _create_ok_config(config):
     from ok.util.config import Config
 
     defaults = dict(_OK_CONFIG_DEFAULTS)
-    for key in ('use_overlay', 'show_overlay_logs'):
-        if key in config:
-            defaults[key] = bool(config[key])
+    if 'use_overlay' in config:
+        defaults['use_overlay'] = bool(config['use_overlay'])
     return Config('_ok', defaults)
 
 
 class _OverlayConfigMixin:
     def overlay_state(self):
-        return {
-            'boxes': bool(self.ok_config.get('use_overlay', False)),
-            'logs': bool(self.ok_config.get('show_overlay_logs', True)),
-        }
+        return {'boxes': bool(self.ok_config.get('use_overlay', False))}
 
     def initialize_overlay(self):
         """Apply persisted overlay state independently of the active UI."""
-        if self.ok_config.get('use_overlay', False) or callable(self.config.get('blur_area')):
+        if self.ok_config.get('use_overlay', False):
             overlay = self.get_overlay_view()
-            overlay.set_boxes_enabled(self.ok_config.get('use_overlay', False))
+            if overlay is not None:
+                overlay.set_boxes_enabled(True)
+
+    def _close_overlay(self, wait=True):
+        overlay = self.overlay_window
+        if overlay is None:
+            return
+        from ok.core.events import communicate
+        communicate.window.disconnect(overlay.update_overlay)
+        self.overlay_window = None
+        if wait:
+            overlay.close()
+        else:
+            overlay.close(wait=False)
 
     def sync_overlay_source(self, *_args):
         """Refresh a lazy overlay from the currently selected capture window."""
@@ -254,18 +262,18 @@ class _OverlayConfigMixin:
         overlay.sync_source_window(getattr(device_manager, 'hwnd_window', None))
 
     def set_overlay_setting(self, name, value):
-        key = {'boxes': 'use_overlay', 'logs': 'show_overlay_logs'}.get(name)
-        if key is None:
+        if name != 'boxes':
             raise ValueError(f'Unknown overlay setting: {name}')
 
-        self.ok_config[key] = bool(value)
+        self.ok_config['use_overlay'] = bool(value)
         overlay = self.overlay_window
         if name == 'boxes' and value:
             overlay = self.get_overlay_view()
+        elif name == 'boxes' and not value and overlay is not None:
+            self._close_overlay()
+            return self.overlay_state()
         if overlay is not None:
             self.sync_overlay_source()
-            # This also schedules a repaint so a changed log setting takes
-            # effect immediately in the native overlay.
             overlay.set_boxes_enabled(self.ok_config.get('use_overlay', False))
         return self.overlay_state()
 
@@ -333,9 +341,8 @@ class App(_OverlayConfigMixin):
         logger.debug('init app end')
 
     def quit(self):
-        if self.overlay_window is not None:
-            self.overlay_window.close()
         self.exit_event.set()
+        self._close_overlay(wait=False)
         self._close_device_manager()
         from PySide6.QtCore import QMetaObject, Qt
         QMetaObject.invokeMethod(self.app, "quit", Qt.QueuedConnection)
@@ -403,16 +410,28 @@ class App(_OverlayConfigMixin):
         self.show_message_window(title, content)
 
     def update_overlay(self, visible, x, y, window_width, window_height, width, height, scaling):
-        overlay_view = self.get_overlay_view()
+        if not self.ok_config.get('use_overlay', False):
+            # Treat the setting as an absolute lifecycle gate. In particular,
+            # a configured blur callback must not resurrect a disabled native
+            # window (and its input/expiry workers).
+            if self.overlay_window is not None:
+                self._close_overlay(wait=False)
+            return
+        overlay_view = self.overlay_window
+        if overlay_view is None:
+            overlay_view = self.get_overlay_view()
         if overlay_view:
             overlay_view.update_overlay(visible, x, y, window_width, window_height, width, height, scaling)
 
     def get_overlay_view(self):
         """Return the overlay widget exposed to tasks, custom tabs, and my_app."""
+        if not self.ok_config.get('use_overlay', False):
+            return None
         if self.overlay_window is None:
             from ok.core.events import communicate
             from ok.ui.overlay import Win32GdiOverlay
-            self.overlay_window = Win32GdiOverlay(og.device_manager.hwnd_window)
+            self.overlay_window = Win32GdiOverlay(
+                og.device_manager.hwnd_window, exit_event=self.exit_event)
             communicate.window.connect(self.overlay_window.update_overlay)
             self.overlay_window.set_boxes_enabled(self.ok_config.get('use_overlay', False))
         return self.overlay_window
@@ -462,7 +481,14 @@ class App(_OverlayConfigMixin):
         self.timer.start(1000)
         self.timer.timeout.connect(lambda: None)
 
-        sys.exit(self.app.exec())
+        exit_code = self.app.exec()
+        # QApplication has stopped, but a forgotten non-daemon worker can
+        # still keep the packaged process alive indefinitely. Normal cleanup
+        # gets a grace period; the daemon watchdog disappears by itself when
+        # Python exits normally.
+        from ok.util.process import start_exit_watchdog
+        start_exit_watchdog(exit_code=exit_code)
+        sys.exit(exit_code)
 
 
 class HeadlessApp(_OverlayConfigMixin):
@@ -536,10 +562,9 @@ class HeadlessApp(_OverlayConfigMixin):
         communicate.notification.disconnect(self.show_notification)
         if self.notification_manager is not None:
             self.notification_manager.stop()
-        if self.overlay_window is not None:
-            self.overlay_window.close()
         if self.exit_event:
             self.exit_event.set()
+        self._close_overlay(wait=False)
 
     def show_notification(self, message, title=None, error=False, tray=False,
                           _show_tab=None, params=None, images=None):
@@ -554,11 +579,13 @@ class HeadlessApp(_OverlayConfigMixin):
             self.notification_manager.submit(translated_title, translated_message, images)
 
     def get_overlay_view(self):
+        if not self.ok_config.get('use_overlay', False):
+            return None
         if self.overlay_window is None:
             from ok.core.events import communicate
             from ok.ui.overlay import Win32GdiOverlay
             hwnd_window = getattr(getattr(og, 'device_manager', None), 'hwnd_window', None)
-            self.overlay_window = Win32GdiOverlay(hwnd_window)
+            self.overlay_window = Win32GdiOverlay(hwnd_window, exit_event=self.exit_event)
             communicate.window.connect(self.overlay_window.update_overlay)
             self.overlay_window.set_boxes_enabled(self.ok_config.get('use_overlay', False))
         return self.overlay_window
@@ -624,7 +651,9 @@ class OK:
         wgc_available = _resolve('windows_graphics_available')
 
         if config.get('check_mutex', True):
-            check_mutex_fn()
+            if not check_mutex_fn():
+                raise RuntimeError(
+                    'Another application instance is still running and could not be stopped safely.')
         og.ok = self
         if pyappify.app_version:
             config['version'] = pyappify.app_version

{ok_script-2.0.2 → ok_script-2.0.3}/ok/device/capture_methods/windows_graphics.py

@@ -34,6 +34,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
         self.get_frame_lock = threading.RLock()
         self.frame_event = threading.Event()
         self.frame_requested = threading.Event()
+        self._frame_cancel_generation = 0
         self.last_frame_time = time.time()
         self.exit_event = hwnd_window.app_exit_event
         self.cputex = None
@@ -257,6 +258,12 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
         # _do_get_frame() composites child windows with BitBlt after receiving
         # the WGC frame. Serialize close with that whole request so its GDI
         # contexts cannot be released while composite_hwnds() is using them.
+        # Wake a pending request before waiting for get_frame_lock; otherwise
+        # the GUI close path can wait for the full frame timeout.
+        with self.lock:
+            self._frame_cancel_generation += 1
+            self.frame_requested.clear()
+            self.frame_event.set()
         with self.get_frame_lock:
             with self.lock:
                 logger.info('destroy windows capture')
@@ -294,7 +301,8 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
             return self._do_get_frame()
 
     def _do_get_frame(self):
-
+        if self.exit_event.is_set():
+            return None
         if self.start_or_stop():
             now = time.time()
             if now - self.last_frame_time > 10:
@@ -308,12 +316,21 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
             # consuming such a frame.
             with self.lock:
                 frame = None
+                cancel_generation = self._frame_cancel_generation
                 self.last_frame = None
                 self.frame_event.clear()
                 self.frame_requested.set()
 
             deadline = time.monotonic() + WGC_FRAME_WAIT_TIMEOUT
             while frame is None:
+                if self.exit_event.is_set():
+                    with self.lock:
+                        self.last_frame = None
+                        self.frame_requested.clear()
+                        self.frame_event.clear()
+                    return None
+                if cancel_generation != self._frame_cancel_generation:
+                    return None
                 timeout_duration = deadline - time.monotonic()
                 if timeout_duration <= 0:
                     # Serialize cancellation with frame_arrived_callback(). If
@@ -328,7 +345,9 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                             self.frame_requested.clear()
                     break
 
-                self.frame_event.wait(timeout_duration)
+                # ExitEvent cannot directly wake threading.Event, so sample it
+                # at a short interval rather than blocking shutdown for 4 s.
+                self.frame_event.wait(min(timeout_duration, .05))
 
                 with self.lock:
                     if self.frame_pool is None:

{ok_script-2.0.2 → ok_script-2.0.3}/ok/task/TaskExecutor.py

@@ -89,6 +89,8 @@ class TaskExecutor:
         self.lock = threading.Lock()
         self._wake_condition = threading.Condition()
         self._wake_version = 0
+        self._destroy_lock = threading.Lock()
+        self._destroyed = False
         if hasattr(self.exit_event, 'bind_condition'):
             self.exit_event.bind_condition(self._wake_condition)
         self._ocr_lib_lock = threading.Lock()
@@ -393,7 +395,10 @@ class TaskExecutor:
     def start(self):
         with self.lock:
             if self.thread is None:
-                self.thread = threading.Thread(target=self.execute, name="TaskExecutor")
+                # Application shutdown must not be held hostage by a custom
+                # task or interaction backend that ignores exit_event.
+                self.thread = threading.Thread(
+                    target=self.execute, name="TaskExecutor", daemon=True)
                 self.thread.start()
             if self.paused:
                 self.paused = False
@@ -623,15 +628,34 @@ class TaskExecutor:
         self._wake_executor()
 
     def destroy(self):
+        lock = getattr(self, '_destroy_lock', None)
+        if lock is None:
+            lock = self._destroy_lock = threading.Lock()
+        with lock:
+            if getattr(self, '_destroyed', False):
+                return
+            self._destroyed = True
         logger.info(f'Executor destroy')
-        for task in self.onetime_tasks:
-            task.on_destroy()
-        self.onetime_tasks = []
-        for task in self.trigger_tasks:
-            task.on_destroy()
-        self.trigger_tasks = []
+        onetime_tasks, self.onetime_tasks = self.onetime_tasks, []
+        trigger_tasks, self.trigger_tasks = self.trigger_tasks, []
+        for task in (*onetime_tasks, *trigger_tasks):
+            try:
+                task.on_destroy()
+            except Exception as error:
+                logger.error(f'task on_destroy failed for {task}: {error}')
         if self.interaction:
-            self.interaction.on_destroy()
+            try:
+                self.interaction.on_destroy()
+            except Exception as error:
+                logger.error(f'interaction on_destroy failed: {error}')
+
+    def request_destroy(self):
+        """Run cleanup away from the GUI close event when needed."""
+        if self.thread is not None and self.thread.is_alive():
+            # execute() owns normal cleanup after observing exit_event.
+            return
+        threading.Thread(
+            target=self.destroy, name="TaskExecutorCleanup", daemon=True).start()
 
     def wait_until_done(self):
         self.thread.join()