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

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

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

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

@@ -30,7 +30,6 @@ class TaskExecutor:
     debug: bool
     global_config: object
     _ocr_lib: dict
-    _ocr_init_results: dict
     ocr_target_height: int
     current_task: object
     config_folder: str
@@ -76,7 +75,6 @@ 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
@@ -152,21 +150,10 @@ class TaskExecutor:
         try:
             logger.info('start init default ocr')
             self.ocr_lib()
-            result = self._ocr_init_results.get('default', 'success')
-            logger.info(f'default ocr init end, result: {result}, cost: {time.time() - start:.2f}s')
+            logger.info(f'default ocr init end, 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')
@@ -201,31 +188,10 @@ class TaskExecutor:
         elif lib == 'onnxocr':
             from onnxocr.onnx_paddleocr import ONNXPaddleOcr
             logger.info(f'init onnxocr {config_params}')
-            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'
+            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))
         elif lib == 'rapidocr':
             from rapidocr import RapidOCR
             params = {"Global.use_cls": False, "Global.max_side_len": 100000, "Global.min_side_len": 0,
@@ -235,9 +201,7 @@ class TaskExecutor:
             ocr_lib = RapidOCR(params=params)
         else:
             raise Exception(f'ocr lib not supported: {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]}')
+        logger.info(f'ocr_lib init {ocr_lib} {lib}')
         return ocr_lib
 
     def nullable_frame(self):

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

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

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

@@ -339,7 +339,6 @@ 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

@@ -1,113 +0,0 @@
-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()