ok-script 2.0.7b1__tar.gz → 2.0.8__tar.gz

{ok_script-2.0.7b1/ok_script.egg-info → ok_script-2.0.8}/PKG-INFO

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

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/__init__.py

@@ -231,15 +231,35 @@ def _create_ok_config(config):
 
 
 class _OverlayConfigMixin:
+    def _blur_enabled(self):
+        executor = getattr(og, 'executor', None)
+        return (callable(self.config.get('blur_area'))
+                and bool(getattr(executor, 'basic_options', {}).get('Enable Blur', False)))
+
+    def _overlay_needed(self):
+        return self.ok_config.get('use_overlay', False) or self._blur_enabled()
+
     def overlay_state(self):
         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):
+        if self._overlay_needed():
             overlay = self.get_overlay_view()
             if overlay is not None:
-                overlay.set_boxes_enabled(True)
+                overlay.set_boxes_enabled(self.ok_config.get('use_overlay', False))
+
+    def _on_blur_patches(self, patches):
+        # A live setting change can enable blur without a new window geometry event.
+        # The new overlay does not receive the signal currently being dispatched.
+        if self._blur_enabled() and self.overlay_window is None:
+            overlay = self.get_overlay_view()
+            if overlay is not None:
+                overlay.update_blur_patches(patches)
+
+    def _on_clear_blur_patches(self):
+        if not self._overlay_needed() and self.overlay_window is not None:
+            self._close_overlay(wait=False)
 
     def _close_overlay(self, wait=True):
         overlay = self.overlay_window
@@ -269,7 +289,7 @@ class _OverlayConfigMixin:
         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:
+        elif name == 'boxes' and not value and overlay is not None and not self._blur_enabled():
             self._close_overlay()
             return self.overlay_state()
         if overlay is not None:
@@ -301,6 +321,8 @@ class App(_OverlayConfigMixin):
             task_executor.load_tr()
         self.ok_config = _create_ok_config(config)
         communicate.quit.connect(self.quit)
+        communicate.blur_overlay.connect(self._on_blur_patches)
+        communicate.clear_blur_overlay.connect(self._on_clear_blur_patches)
 
         self.about = self.config.get('about')
         self.title = self.config.get('gui_title')
@@ -341,6 +363,9 @@ class App(_OverlayConfigMixin):
         logger.debug('init app end')
 
     def quit(self):
+        from ok.core.events import communicate
+        communicate.blur_overlay.disconnect(self._on_blur_patches)
+        communicate.clear_blur_overlay.disconnect(self._on_clear_blur_patches)
         self.exit_event.set()
         self._close_overlay(wait=False)
         self._close_device_manager()
@@ -412,10 +437,8 @@ class App(_OverlayConfigMixin):
         self.show_message_window(title, content)
 
     def update_overlay(self, visible, x, y, window_width, window_height, width, height, scaling):
-        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 not self._overlay_needed():
+            # Keep the native window only while debug boxes or UID blur need it.
             if self.overlay_window is not None:
                 self._close_overlay(wait=False)
             return
@@ -427,7 +450,7 @@ class App(_OverlayConfigMixin):
 
     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):
+        if not self._overlay_needed():
             return None
         if self.overlay_window is None:
             from ok.core.events import communicate
@@ -515,6 +538,8 @@ class HeadlessApp(_OverlayConfigMixin):
         self.to_translate = None
         communicate.quit.connect(self.quit)
         communicate.adb_devices.connect(self.sync_overlay_source)
+        communicate.blur_overlay.connect(self._on_blur_patches)
+        communicate.clear_blur_overlay.connect(self._on_clear_blur_patches)
 
         self.locale = LocaleName(config.get("locale", "en_US"))
         from ok.core.start_controller import StartController
@@ -562,6 +587,8 @@ class HeadlessApp(_OverlayConfigMixin):
         from ok.core.events import communicate
         communicate.adb_devices.disconnect(self.sync_overlay_source)
         communicate.notification.disconnect(self.show_notification)
+        communicate.blur_overlay.disconnect(self._on_blur_patches)
+        communicate.clear_blur_overlay.disconnect(self._on_clear_blur_patches)
         if self.notification_manager is not None:
             self.notification_manager.stop()
         if self.exit_event:
@@ -581,7 +608,7 @@ 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):
+        if not self._overlay_needed():
             return None
         if self.overlay_window is None:
             from ok.core.events import communicate

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/core/start_controller.py

@@ -193,6 +193,12 @@ class StartController:
                 dx11_config = og.global_config.get_config('Launch with DX11')
                 if dx11_config and dx11_config.get('Launch with DX11'):
                     args = "-dx11 -d3d11 -force-d3d11"
+                if device['device'] == "windows":
+                    launch_arguments = (self.config.get('windows') or {}).get('launch_arguments')
+                    if callable(launch_arguments):
+                        launch_arguments = launch_arguments()
+                    if launch_arguments:
+                        args = f'{args or ""} {launch_arguments}'.strip()
                 if not execute(path, arguments=args, start_method=self.start_method):
                     communicate.starting_emulator.emit(True, self.tr("Start game failed, please start game first"), 0)
                     return False

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/device/capture_methods/windows_graphics.py

@@ -157,6 +157,17 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
         return 0
 
     def start_or_stop(self, capture_cursor=False):
+        # Lifecycle changes may call close(), which needs get_frame_lock.
+        # Always acquire it before lock, just as do_get_frame() does, so a
+        # concurrent startup refresh cannot deadlock a frame request.
+        if not self.get_frame_lock.acquire(timeout=WGC_FRAME_WAIT_TIMEOUT):
+            raise TimeoutError('Windows Graphics Capture is busy, please retry starting the game')
+        try:
+            return self._start_or_stop(capture_cursor)
+        finally:
+            self.get_frame_lock.release()
+
+    def _start_or_stop(self, capture_cursor=False):
         with self.lock:
             if self.exit_event.is_set():
                 logger.warning('start_or_stop exit_event.is_set() return')
@@ -297,8 +308,12 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     def do_get_frame(self):
         # frame_requested and last_frame represent one in-flight request. Keep
         # concurrent task/UI callers from consuming each other's response.
-        with self.get_frame_lock:
+        if not self.get_frame_lock.acquire(timeout=WGC_FRAME_WAIT_TIMEOUT):
+            raise TimeoutError('Windows Graphics Capture is busy, please retry starting the game')
+        try:
             return self._do_get_frame()
+        finally:
+            self.get_frame_lock.release()
 
     def _do_get_frame(self):
         if self.exit_event.is_set():

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/task/TaskExecutor.py

@@ -532,6 +532,18 @@ class TaskExecutor:
         ]
         return min(delays, default=default)
 
+    def _prepare_task_for_run(self, is_trigger_task):
+        """Prepare a task's input backend before the first frame is requested.
+
+        Foreground interaction backends such as Pynput only report a capture
+        frame while the target window is active.  One-time tasks used to
+        request that frame first and only bring the target window forward from
+        inside ``task.run()``, which is too late and can leave the task waiting
+        indefinitely.
+        """
+        if not is_trigger_task and self.interaction is not None:
+            self.interaction.on_run()
+
     def execute(self):
         logger.info(f"start execute")
         while not self.exit_event.is_set():
@@ -553,6 +565,7 @@ class TaskExecutor:
                 self.current_task = task
                 if not is_trigger_task:
                     communicate.task.emit(task)
+                self._prepare_task_for_run(is_trigger_task)
                 if cycled or self._frame is None:
                     if self.next_frame(time_out=4) is None and is_trigger_task:
                         logger.info("no frame available, skip remaining trigger tasks")

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/util/logger.py

@@ -49,6 +49,9 @@ class Logger:
         stack_trace_str = self.exception_to_str(exception)
         self.logger.error(f"{self.name}:{message} {stack_trace_str}")
 
+    def exception(self, message, *args, **kwargs):
+        self.logger.exception(f"{self.name}:{message}", *args, **kwargs)
+
     def critical(self, message):
         self.logger.critical(f"{self.name}:{message}")
 

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok/util/windows_schedule.py

@@ -1252,7 +1252,7 @@ class WindowsScheduleManager:
     <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
     <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
     <AllowHardTerminate>true</AllowHardTerminate>
-    <StartWhenAvailable>false</StartWhenAvailable>
+    <StartWhenAvailable>true</StartWhenAvailable>
     <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
     <AllowStartOnDemand>true</AllowStartOnDemand>
     <Enabled>true</Enabled>

{ok_script-2.0.7b1 → ok_script-2.0.8/ok_script.egg-info}/PKG-INFO

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

{ok_script-2.0.7b1 → ok_script-2.0.8}/ok_script.egg-info/SOURCES.txt

@@ -330,6 +330,7 @@ tests/test_nemu_ipc_capture.py
 tests/test_notifications.py
 tests/test_ok_mutex.py
 tests/test_overlay_custom_draw.py
+tests/test_overlay_lifecycle.py
 tests/test_package_metadata.py
 tests/test_process.py
 tests/test_process_mutex.py
@@ -355,4 +356,5 @@ tests/test_web_task_tabs.py
 tests/test_web_ui_pages.py
 tests/test_web_ui_tasks.py
 tests/test_windows_graphics_capture.py
-tests/test_windows_schedule_target_parse.py
+tests/test_windows_schedule_target_parse.py
+tests/test_windows_schedule_xml.py

{ok_script-2.0.7b1 → ok_script-2.0.8}/tests/test_logger.py

@@ -1,10 +1,31 @@
 import logging
 from unittest.mock import Mock
 
+import pytest
+
 import ok.util.logger as logger_module
 from ok.util.logger import SafeFileHandler, config_logger
 
 
+@pytest.mark.parametrize("use_exception_message", [False, True])
+def test_logger_exception_preserves_original_traceback(caplog, use_exception_message):
+    logger = logger_module.Logger.get_logger("ok.ui.qt.MainWindow")
+    logger.logger = logging.getLogger("test.logger_exception")
+
+    try:
+        raise RuntimeError("schedule resolution failed")
+    except RuntimeError as error:
+        logger.exception(error if use_exception_message else "schedule task index sync failed in __init__")
+
+    record = caplog.records[-1]
+    assert record.levelno == logging.ERROR
+    assert record.getMessage().startswith("MainWindow:")
+    assert record.exc_info[0] is RuntimeError
+    assert str(record.exc_info[1]) == "schedule resolution failed"
+    assert "Traceback (most recent call last)" in caplog.text
+    assert "RuntimeError: schedule resolution failed" in caplog.text
+
+
 def test_config_logger_does_not_create_file_log_during_pytest(tmp_path, monkeypatch):
     monkeypatch.chdir(tmp_path)
 

ok_script-2.0.8/tests/test_overlay_lifecycle.py

@@ -0,0 +1,105 @@
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+from ok import App, HeadlessApp, og
+from ok.core.events import communicate
+
+
+@pytest.mark.parametrize("app_type", [App, HeadlessApp])
+def test_blur_initializes_overlay_without_debug_boxes(app_type, monkeypatch):
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options={"Enable Blur": True}), raising=False)
+    app = object.__new__(app_type)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": False}
+    overlay = Mock()
+    app.get_overlay_view = Mock(return_value=overlay)
+
+    app.initialize_overlay()
+
+    app.get_overlay_view.assert_called_once_with()
+    overlay.set_boxes_enabled.assert_called_once_with(False)
+
+
+@pytest.mark.parametrize("app_type", [App, HeadlessApp])
+def test_blur_only_getter_creates_overlay_with_boxes_disabled(app_type, monkeypatch):
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options={"Enable Blur": True}), raising=False)
+    monkeypatch.setattr(og, "device_manager", SimpleNamespace(hwnd_window=None), raising=False)
+    overlay = Mock()
+    monkeypatch.setattr("ok.ui.overlay.Win32GdiOverlay", Mock(return_value=overlay))
+    app = object.__new__(app_type)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": False}
+    app.overlay_window = None
+    app.exit_event = None
+
+    try:
+        assert app.get_overlay_view() is overlay
+        overlay.set_boxes_enabled.assert_called_once_with(False)
+    finally:
+        communicate.window.disconnect(overlay.update_overlay)
+
+
+@pytest.mark.parametrize("app_type", [App, HeadlessApp])
+def test_blur_event_creates_overlay_after_live_setting_change(app_type, monkeypatch):
+    options = {"Enable Blur": False}
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options=options), raising=False)
+    app = object.__new__(app_type)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": False}
+    app.overlay_window = None
+    overlay = Mock()
+    app.get_overlay_view = Mock(return_value=overlay)
+    patches = [object()]
+
+    app._on_blur_patches(patches)
+    app.get_overlay_view.assert_not_called()
+    options["Enable Blur"] = True
+    app._on_blur_patches(patches)
+
+    app.get_overlay_view.assert_called_once_with()
+    overlay.update_blur_patches.assert_called_once_with(patches)
+
+
+def test_window_update_keeps_blur_only_overlay(monkeypatch):
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options={"Enable Blur": True}), raising=False)
+    app = object.__new__(App)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": False}
+    overlay = Mock()
+    app.overlay_window = overlay
+
+    app.update_overlay(True, 1, 2, 100, 80, 100, 80, 1)
+
+    overlay.update_overlay.assert_called_once_with(True, 1, 2, 100, 80, 100, 80, 1)
+
+
+def test_disabling_debug_boxes_preserves_active_blur(monkeypatch):
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options={"Enable Blur": True}), raising=False)
+    app = object.__new__(HeadlessApp)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": True}
+    overlay = Mock()
+    app.overlay_window = overlay
+    app._close_overlay = Mock()
+
+    app.set_overlay_setting("boxes", False)
+
+    app._close_overlay.assert_not_called()
+    overlay.set_boxes_enabled.assert_called_once_with(False)
+
+
+def test_disabling_last_overlay_feature_releases_window(monkeypatch):
+    options = {"Enable Blur": True}
+    monkeypatch.setattr(og, "executor", SimpleNamespace(basic_options=options), raising=False)
+    app = object.__new__(HeadlessApp)
+    app.config = {"blur_area": lambda *_: None}
+    app.ok_config = {"use_overlay": False}
+    app.overlay_window = Mock()
+    app._close_overlay = Mock()
+
+    options["Enable Blur"] = False
+    app._on_clear_blur_patches()
+
+    app._close_overlay.assert_called_once_with(wait=False)

{ok_script-2.0.7b1 → ok_script-2.0.8}/tests/test_start_controller.py

@@ -38,6 +38,7 @@ class TestStartController(unittest.TestCase):
         controller = StartController.__new__(StartController)
         controller.exit_event = threading.Event()
         controller.start_timeout = 20
+        controller.config = {}
         controller.start_method = 'start'
         controller.STARTED_WINDOW_STABLE_SECONDS = 2
         controller.STARTED_WINDOW_POLL_INTERVAL = 1
@@ -61,6 +62,23 @@ class TestStartController(unittest.TestCase):
 
         self.assertFalse(controller.starting)
 
+    def test_capture_refresh_timeout_closes_loading_and_reports_error(self):
+        controller = self.make_controller()
+        controller.start_exe = True
+        controller.tr = lambda message: message
+        message = 'Windows Graphics Capture is busy, please retry starting the game'
+        device_manager = SimpleNamespace(do_refresh=Mock(side_effect=TimeoutError(message)))
+        emit = Mock()
+        fake_communicate = SimpleNamespace(starting_emulator=SimpleNamespace(emit=emit))
+
+        with patch.object(start_controller_module, 'og', SimpleNamespace(device_manager=device_manager)), \
+                patch.object(start_controller_module, 'communicate', fake_communicate):
+            self.assertFalse(controller.do_start())
+
+        self.assertFalse(controller.starting)
+        self.assertEqual((False, None, controller.start_timeout), emit.call_args_list[0].args)
+        self.assertEqual((True, message, 0), emit.call_args_list[-1].args)
+
     def test_started_window_must_be_usable_and_stable_before_continuing(self):
         controller = self.make_controller()
         window = FakeWindow([(80, 80), (120, 120), (140, 120), (140, 120), (140, 120)])
@@ -122,6 +140,75 @@ class TestStartController(unittest.TestCase):
         self.assertEqual(['execute', 'stable', 'ready'], call_order)
         execute.assert_called_once_with(r'C:\game.exe', arguments=None, start_method='os.startfile')
 
+    def make_launch_context(self, device_type='windows', connected=False, dx11=False):
+        controller = self.make_controller()
+        controller._wait_until_started_window_stable = Mock(return_value=True)
+        controller._wait_until_device_ready = Mock(return_value=True)
+        device_manager = Mock()
+        device_manager.get_preferred_device.return_value = {
+            'connected': connected,
+            'device': device_type,
+        }
+        device_manager.get_exe_path.return_value = r'C:\game.exe'
+        fake_og = SimpleNamespace(device_manager=device_manager, global_config=Mock())
+        fake_og.global_config.get_config.return_value = {'Launch with DX11': dx11}
+        return controller, fake_og
+
+    def test_launch_arguments_preserve_dx11_and_launch_method(self):
+        for start_method in ('start', 'os.startfile'):
+            for dx11 in (False, True):
+                for extra_args in ('-custom="value with spaces"', None, '', lambda: '-custom', lambda: None):
+                    with self.subTest(start_method=start_method, dx11=dx11, extra_args=extra_args):
+                        controller, fake_og = self.make_launch_context(dx11=dx11)
+                        controller.start_method = start_method
+                        controller.config = {'windows': {'launch_arguments': extra_args}}
+                        expected_args = '-dx11 -d3d11 -force-d3d11' if dx11 else None
+                        extra = extra_args() if callable(extra_args) else extra_args
+                        if extra:
+                            expected_args = f'{expected_args or ""} {extra}'.strip()
+
+                        with patch.object(start_controller_module, 'og', fake_og), \
+                                patch.object(start_controller_module, 'is_admin', return_value=True), \
+                                patch.object(start_controller_module, 'execute', return_value=True) as execute:
+                            self.assertTrue(controller.start_device())
+
+                        execute.assert_called_once_with(
+                            r'C:\game.exe', arguments=expected_args, start_method=start_method)
+
+    def test_launch_arguments_callback_reads_current_settings_on_each_launch(self):
+        controller, fake_og = self.make_launch_context()
+        settings = {'package': 'hd'}
+        callback = Mock(side_effect=lambda: f'-krqlv={settings["package"]}')
+        controller.config = {'windows': {'launch_arguments': callback}}
+
+        with patch.object(start_controller_module, 'og', fake_og), \
+                patch.object(start_controller_module, 'is_admin', return_value=True), \
+                patch.object(start_controller_module, 'execute', return_value=True) as execute:
+            self.assertTrue(controller.start_device())
+            self.assertEqual('-krqlv=hd', execute.call_args.kwargs['arguments'])
+            settings['package'] = 'uhd'
+            self.assertTrue(controller.start_device())
+            self.assertEqual('-krqlv=uhd', execute.call_args.kwargs['arguments'])
+
+        self.assertEqual([unittest.mock.call(), unittest.mock.call()], callback.call_args_list)
+
+    def test_launch_arguments_callback_is_skipped_for_connected_games_and_adb(self):
+        for device_type, connected in (('windows', True), ('adb', False)):
+            with self.subTest(device_type=device_type, connected=connected):
+                controller, fake_og = self.make_launch_context(device_type, connected)
+                callback = Mock(return_value='-windows-only')
+                controller.config = {'windows': {'launch_arguments': callback}}
+
+                with patch.object(start_controller_module, 'og', fake_og), \
+                        patch.object(start_controller_module, 'execute', return_value=True) as execute:
+                    self.assertTrue(controller.start_device())
+
+                callback.assert_not_called()
+                if connected:
+                    execute.assert_not_called()
+                else:
+                    execute.assert_called_once_with(r'C:\game.exe', arguments=None, start_method='start')
+
     def test_gpu_driver_warning_identifies_each_enabled_vendor_feature(self):
         controller = self.make_controller()
         emit = Mock()

{ok_script-2.0.7b1 → ok_script-2.0.8}/tests/test_task_executor_queue.py

@@ -131,6 +131,60 @@ class TestTaskExecutorQueue(unittest.TestCase):
         task.on_destroy.assert_called_once_with()
         interaction.on_destroy.assert_called_once_with()
 
+    def test_prepare_one_time_task_before_first_frame(self):
+        executor = self.make_executor([])
+        interaction = SimpleNamespace(on_run=Mock(), on_destroy=Mock())
+        executor.device_manager = SimpleNamespace(interaction=interaction)
+
+        executor._prepare_task_for_run(is_trigger_task=False)
+
+        interaction.on_run.assert_called_once_with()
+
+    def test_prepare_trigger_task_does_not_force_foreground(self):
+        executor = self.make_executor([])
+        interaction = SimpleNamespace(on_run=Mock())
+        executor.device_manager = SimpleNamespace(interaction=interaction)
+
+        executor._prepare_task_for_run(is_trigger_task=True)
+
+        interaction.on_run.assert_not_called()
+
+    def test_one_time_task_prepares_interaction_before_first_frame(self):
+        executor = self.make_executor([])
+        executor.paused = False
+        executor._frame = None
+        executor._last_frame_time = time.time()
+        executor.reset_scene = lambda check_enabled=True: None
+        interaction = SimpleNamespace(on_run=Mock())
+        executor.device_manager = SimpleNamespace(interaction=interaction)
+
+        task = SimpleNamespace(
+            name="FishingOnce",
+            start_time=None,
+            running=False,
+            exit_after_task=False,
+            config={},
+            run=Mock(),
+            disable=Mock(),
+            on_destroy=Mock(),
+        )
+        events = []
+        interaction.on_run.side_effect = lambda: events.append("on_run")
+        executor.next_frame = Mock(
+            side_effect=lambda time_out=6: events.append("next_frame"))
+        task.run.side_effect = lambda: (
+            events.append("run"),
+            executor.exit_event.set(),
+        )
+        executor.next_task = lambda: (task, False, False)
+
+        with patch.object(task_executor_module.communicate.task, "emit"), \
+                patch.object(task_executor_module.communicate.task_done, "emit"), \
+                patch.object(task_executor_module, "prevent_sleeping"):
+            executor.execute()
+
+        self.assertEqual(["on_run", "next_frame", "run"], events)
+
 
 if __name__ == '__main__':
     unittest.main()

{ok_script-2.0.7b1 → ok_script-2.0.8}/tests/test_windows_graphics_capture.py

@@ -2,7 +2,7 @@ import unittest
 import threading
 import time
 from types import SimpleNamespace
-from unittest.mock import patch
+from unittest.mock import Mock, patch
 
 import numpy as np
 
@@ -28,6 +28,108 @@ class _FakeFramePool:
         return self.frame
 
 
+class _ObservedRLock:
+    def __init__(self):
+        self.lock = threading.RLock()
+        self.attempted = threading.Event()
+
+    def acquire(self, **kwargs):
+        self.attempted.set()
+        return self.lock.acquire(**kwargs)
+
+    def release(self):
+        self.lock.release()
+
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, *_args):
+        self.release()
+
+
+class TestWindowsGraphicsCaptureLifecycle(unittest.TestCase):
+    def _method(self):
+        method = object.__new__(WindowsGraphicsCaptureMethod)
+        method.lock = threading.RLock()
+        method.get_frame_lock = _ObservedRLock()
+        method.exit_event = threading.Event()
+        method.frame_requested = threading.Event()
+        method.frame_event = threading.Event()
+        method._frame_cancel_generation = 0
+        method._hwnd_window = SimpleNamespace(exists=True, capture_target_signature='new')
+        method.get_capture_hwnd = lambda: 123
+        method.capture_target_signature = 'old'
+        method.frame_pool = Mock()
+        method.session = None
+        method.rtdevice = method.dxdevice = method.immediatedc = method.cputex = None
+        method.contexts = {}
+        method.last_start_failure_key = 123
+        method.last_start_failure_time = time.time()
+        return method
+
+    def test_target_change_does_not_hold_capture_lock_while_waiting_for_frame_request(self):
+        method = self._method()
+        pool = method.frame_pool
+        results = []
+        errors = []
+
+        def refresh():
+            try:
+                results.append(method.start_or_stop())
+            except Exception as error:
+                errors.append(error)
+
+        # Simulate a frame consumer already owning the request lock while the
+        # startup thread discovers a changed window target.
+        with method.get_frame_lock:
+            method.get_frame_lock.attempted.clear()
+            worker = threading.Thread(target=refresh, daemon=True)
+            worker.start()
+            self.assertTrue(method.get_frame_lock.attempted.wait(1))
+            acquired = method.lock.acquire(timeout=.2)
+            if acquired:
+                method.lock.release()
+        worker.join(1)
+
+        self.assertTrue(acquired, 'startup held the capture lock while waiting for a frame request')
+        self.assertFalse(worker.is_alive())
+        self.assertEqual([], errors)
+        self.assertEqual([False], results)
+        pool.Close.assert_called_once()
+        self.assertIsNone(method.frame_pool)
+
+    def test_busy_capture_reports_error_instead_of_waiting_indefinitely(self):
+        for operation in ('start_or_stop', 'do_get_frame'):
+            with self.subTest(operation=operation):
+                method = self._method()
+                errors = []
+
+                def call():
+                    try:
+                        getattr(method, operation)()
+                    except Exception as error:
+                        errors.append(error)
+
+                with method.get_frame_lock, patch.object(windows_graphics_module, 'WGC_FRAME_WAIT_TIMEOUT', .05):
+                    worker = threading.Thread(target=call, daemon=True)
+                    worker.start()
+                    worker.join(.5)
+                    self.assertFalse(worker.is_alive())
+                self.assertEqual(1, len(errors))
+                self.assertIsInstance(errors[0], TimeoutError)
+                self.assertIn('Windows Graphics Capture is busy', str(errors[0]))
+
+    def test_frame_request_can_restart_changed_target_without_deadlocking_itself(self):
+        method = self._method()
+        pool = method.frame_pool
+
+        self.assertIsNone(method.do_get_frame())
+
+        pool.Close.assert_called_once()
+        self.assertIsNone(method.frame_pool)
+
+
 class TestCaptureTargetSignature(unittest.TestCase):
     def test_capture_origin_uses_fallback_crop_for_embedded_title_bar(self):
         window = object.__new__(HwndWindow)