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

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

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

{ok_script-2.0.3 → ok_script-2.0.5}/ok/device/DeviceManager.py

@@ -131,6 +131,10 @@ class DeviceManager:
 
     def close(self):
         """Stop capture resources before Qt/Python teardown begins."""
+        hwnd_window = self.hwnd_window
+        if hwnd_window is not None:
+            hwnd_window.stop()
+
         capture_method = self.capture_method
         self.capture_method = None
         if capture_method is not None:

{ok_script-2.0.3 → ok_script-2.0.5}/ok/device/capture_methods/hwnd_window.py

@@ -68,7 +68,7 @@ class HwndWindow:
         self.global_config = global_config
         self.mute_option.validator = self.validate_mute_config
         self.update_window(title, exe_name, frame_width, frame_height, player_id, hwnd_class, top_hwnd_class)
-        self.thread = threading.Thread(target=self.update_window_size, name="update_window_size")
+        self.thread = threading.Thread(target=self.update_window_size, name="update_window_size", daemon=True)
         self.thread.start()
 
     def validate_mute_config(self, key, value):
@@ -82,7 +82,13 @@ class HwndWindow:
         return True, None
 
     def stop(self):
-        self.stop_event.set()
+        try:
+            self.stop_event.set()
+            window_thread = getattr(self, 'thread', None)
+            if window_thread is not None and window_thread is not threading.current_thread():
+                window_thread.join(timeout=1)
+        except Exception as error:
+            logger.error(f'hwnd window close failed: {error}')
 
     def _front_hwnd_candidates(self):
         return list(dict.fromkeys(hwnd for hwnd in (self.top_hwnd, self.hwnd) if hwnd))
@@ -183,12 +189,15 @@ class HwndWindow:
         self.do_update_window_size()
 
     def update_window_size(self):
-        while not self.app_exit_event.is_set() and not self.stop_event.is_set():
-            self.do_update_window_size()
-            time.sleep(0.2)
-        if self.hwnd and self.mute_option.get('Mute Game while in Background'):
-            logger.info(f'exit reset mute state to 0')
-            set_mute_state(self.hwnd, 0)
+        try:
+            while not self.app_exit_event.is_set() and not self.stop_event.is_set():
+                self.do_update_window_size()
+                time.sleep(0.2)
+            if self.hwnd and self.mute_option.get('Mute Game while in Background'):
+                logger.info(f'exit reset mute state to 0')
+                set_mute_state(self.hwnd, 0)
+        except Exception as error:
+            logger.error(f'update_window_size exception: {error}')
 
     def get_abs_cords(self, x, y):
         return self.x + x, self.y + y

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

@@ -30,6 +30,7 @@ class TaskExecutor:
     debug: bool
     global_config: object
     _ocr_lib: dict
+    _ocr_init_results: dict
     ocr_target_height: int
     current_task: object
     config_folder: str
@@ -75,6 +76,7 @@ class TaskExecutor:
         self.debug = debug
         self.global_config = global_config
         self._ocr_lib = {}
+        self._ocr_init_results = {}
         if self.config.get('ocr') and not self.config.get('ocr').get('default', False):
             self.config['ocr']['default'] = self.config.get('ocr')
         self.current_task = None
@@ -150,10 +152,21 @@ class TaskExecutor:
         try:
             logger.info('start init default ocr')
             self.ocr_lib()
-            logger.info(f'default ocr init end, cost: {time.time() - start:.2f}s')
+            result = self._ocr_init_results.get('default', 'success')
+            logger.info(f'default ocr init end, result: {result}, cost: {time.time() - start:.2f}s')
         except Exception as e:
             logger.error(f'init default ocr error, cost: {time.time() - start:.2f}s', e)
 
+    @staticmethod
+    def _onnxocr_test_frame():
+        import cv2
+        import numpy as np
+
+        frame = np.full((160, 640, 3), 255, dtype=np.uint8)
+        cv2.putText(frame, 'okscript', (24, 110), cv2.FONT_HERSHEY_SIMPLEX,
+                    2.5, (0, 0, 0), 5, cv2.LINE_AA)
+        return frame
+
     def _create_ocr_lib(self, name):
         ocr_config = self.config.get('ocr').get(name)
         lib = ocr_config.get('lib')
@@ -188,10 +201,31 @@ class TaskExecutor:
         elif lib == 'onnxocr':
             from onnxocr.onnx_paddleocr import ONNXPaddleOcr
             logger.info(f'init onnxocr {config_params}')
-            ocr_lib = ONNXPaddleOcr(use_angle_cls=False,
-                                    logger=logger,
-                                    use_npu=config_params.get('use_npu', True),
-                                    use_openvino=config_params.get('use_openvino', False))
+            use_npu = config_params.get('use_npu', True)
+            use_openvino = config_params.get('use_openvino', False)
+            if use_npu:
+                test_frame = self._onnxocr_test_frame()
+                try:
+                    ocr_lib = ONNXPaddleOcr(use_angle_cls=False,
+                                            logger=logger,
+                                            use_npu=True,
+                                            use_openvino=use_openvino)
+                    test_result = ocr_lib.ocr(test_frame)
+                    self._ocr_init_results[name] = f'use_npu=True, test_ocr={test_result!r}'
+                except Exception as error:
+                    logger.warning(f'onnxocr NPU test failed, falling back to CPU: {error}')
+                    ocr_lib = ONNXPaddleOcr(use_angle_cls=False,
+                                            logger=logger,
+                                            use_npu=False,
+                                            use_openvino=use_openvino)
+                    self._ocr_init_results[name] = (
+                        f'use_npu=False (NPU test failed: {error!r})')
+            else:
+                ocr_lib = ONNXPaddleOcr(use_angle_cls=False,
+                                        logger=logger,
+                                        use_npu=False,
+                                        use_openvino=use_openvino)
+                self._ocr_init_results[name] = 'use_npu=False'
         elif lib == 'rapidocr':
             from rapidocr import RapidOCR
             params = {"Global.use_cls": False, "Global.max_side_len": 100000, "Global.min_side_len": 0,
@@ -201,7 +235,9 @@ class TaskExecutor:
             ocr_lib = RapidOCR(params=params)
         else:
             raise Exception(f'ocr lib not supported: {lib}')
-        logger.info(f'ocr_lib init {ocr_lib} {lib}')
+        if name not in self._ocr_init_results:
+            self._ocr_init_results[name] = f'lib={lib}, success'
+        logger.info(f'ocr_lib init {ocr_lib} {lib}, result: {self._ocr_init_results[name]}')
         return ocr_lib
 
     def nullable_frame(self):

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

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

{ok_script-2.0.3 → ok_script-2.0.5}/ok_script.egg-info/SOURCES.txt

@@ -339,6 +339,7 @@ tests/test_qt_page_layout.py
 tests/test_runtime_startup.py
 tests/test_start_controller.py
 tests/test_start_tab_overlay.py
+tests/test_task_executor_ocr.py
 tests/test_task_executor_queue.py
 tests/test_task_ui.py
 tests/test_template_tab.py

ok_script-2.0.5/tests/test_task_executor_ocr.py

@@ -0,0 +1,113 @@
+import sys
+import threading
+import types
+import unittest
+from unittest.mock import patch
+
+import cv2  # Keep OpenCV loaded while patch.dict restores fake OCR modules.
+import numpy as np
+
+import ok.task.TaskExecutor as task_executor_module
+from ok.task.TaskExecutor import TaskExecutor
+
+
+class TestTaskExecutorOCR(unittest.TestCase):
+    @staticmethod
+    def make_executor(use_npu=True):
+        executor = TaskExecutor.__new__(TaskExecutor)
+        executor.config = {
+            'ocr': {
+                'default': {
+                    'lib': 'onnxocr',
+                    'params': {'use_npu': use_npu},
+                },
+            },
+        }
+        executor._ocr_lib = {}
+        executor._ocr_lib_lock = threading.Lock()
+        executor._ocr_init_results = {}
+        return executor
+
+    @staticmethod
+    def fake_onnxocr(ocr_side_effect=None):
+        instances = []
+
+        class FakeONNXPaddleOcr:
+            def __init__(self, **kwargs):
+                self.kwargs = kwargs
+                self.frames = []
+                instances.append(self)
+
+            def ocr(self, frame):
+                self.frames.append(frame)
+                if ocr_side_effect is not None:
+                    raise ocr_side_effect
+                return [[('box', ('okscript', 0.99))]]
+
+        package = types.ModuleType('onnxocr')
+        module = types.ModuleType('onnxocr.onnx_paddleocr')
+        module.ONNXPaddleOcr = FakeONNXPaddleOcr
+        package.onnx_paddleocr = module
+        return instances, {
+            'onnxocr': package,
+            'onnxocr.onnx_paddleocr': module,
+        }
+
+    def test_npu_ocr_runs_generated_frame_smoke_test(self):
+        executor = self.make_executor(use_npu=True)
+        instances, modules = self.fake_onnxocr()
+
+        with patch.dict(sys.modules, modules):
+            result = executor._create_ocr_lib('default')
+
+        self.assertIs(result, instances[0])
+        self.assertEqual([True], [instance.kwargs['use_npu'] for instance in instances])
+        self.assertEqual(1, len(instances[0].frames))
+        frame = instances[0].frames[0]
+        self.assertIsInstance(frame, np.ndarray)
+        self.assertEqual((160, 640, 3), frame.shape)
+        self.assertLess(frame.min(), 255)
+        self.assertIn('use_npu=True', executor._ocr_init_results['default'])
+        self.assertIn('okscript', executor._ocr_init_results['default'])
+
+    def test_failed_npu_ocr_falls_back_to_non_npu_instance(self):
+        executor = self.make_executor(use_npu=True)
+        instances, modules = self.fake_onnxocr(RuntimeError('NPU unavailable'))
+
+        with patch.dict(sys.modules, modules):
+            result = executor._create_ocr_lib('default')
+
+        self.assertIs(result, instances[1])
+        self.assertEqual([True, False], [instance.kwargs['use_npu'] for instance in instances])
+        self.assertEqual(1, len(instances[0].frames))
+        self.assertEqual(0, len(instances[1].frames))
+        self.assertIn('use_npu=False', executor._ocr_init_results['default'])
+        self.assertIn('NPU unavailable', executor._ocr_init_results['default'])
+
+    def test_disabled_npu_skips_smoke_test(self):
+        executor = self.make_executor(use_npu=False)
+        instances, modules = self.fake_onnxocr()
+
+        with patch.dict(sys.modules, modules):
+            result = executor._create_ocr_lib('default')
+
+        self.assertIs(result, instances[0])
+        self.assertEqual([False], [instance.kwargs['use_npu'] for instance in instances])
+        self.assertEqual([], instances[0].frames)
+        self.assertEqual('use_npu=False', executor._ocr_init_results['default'])
+
+    def test_default_init_finish_log_includes_npu_test_result(self):
+        executor = self.make_executor(use_npu=True)
+        executor._ocr_lib['default'] = object()
+        executor._ocr_init_results['default'] = 'use_npu=True, test_ocr=okscript'
+
+        with patch.object(task_executor_module.logger, 'info') as info:
+            executor._init_default_ocr()
+
+        finish_log = info.call_args_list[-1].args[0]
+        self.assertIn('default ocr init end', finish_log)
+        self.assertIn('use_npu=True, test_ocr=okscript', finish_log)
+
+
+if __name__ == '__main__':
+    unittest.main()