ok-script 0.0.96__tar.gz → 0.0.98__tar.gz

{ok-script-0.0.96 → ok-script-0.0.98}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.96
+Version: 0.0.98
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.96 → ok-script-0.0.98}/ok/capture/HwndWindow.py

@@ -243,13 +243,17 @@ def enum_child_windows(biggest, frame_aspect_ratio):
 
 def get_exe_by_hwnd(hwnd):
     # Get the process ID associated with the window
-    _, pid = win32process.GetWindowThreadProcessId(hwnd)
+    try:
+        _, pid = win32process.GetWindowThreadProcessId(hwnd)
 
-    # Get the process name and executable path
-    if pid > 0:
-        process = psutil.Process(pid)
-        return process.name(), process.exe(), process.cmdline()
-    else:
+        # Get the process name and executable path
+        if pid > 0:
+            process = psutil.Process(pid)
+            return process.name(), process.exe(), process.cmdline()
+        else:
+            return None, None, None
+    except Exception as e:
+        logger.error('get_exe_by_hwnd error', e)
         return None, None, None
 
 

{ok-script-0.0.96 → ok-script-0.0.98}/ok/capture/adb/ADBCaptureMethod.py

@@ -1,5 +1,4 @@
 # original https://github.com/Toufool/AutoSplit/blob/master/src/capture_method/WindowsGraphicsCaptureMethod.py
-import cv2
 import numpy as np
 from typing_extensions import override
 
@@ -26,7 +25,7 @@ class ADBCaptureMethod(BaseCaptureMethod):
     def screencap(self):
         if self.exit_event.is_set():
             return None
-        frame = do_screencap(self.device_manager.device)
+        frame = self.device_manager.do_screencap(self.device_manager.device)
         if frame is not None:
             self._connected = True
         else:
@@ -37,19 +36,3 @@ class ADBCaptureMethod(BaseCaptureMethod):
         if not self._connected and self.device_manager.device is not None:
             self.screencap()
         return self._connected and self.device_manager.device is not None
-
-
-def do_screencap(device) -> np.ndarray | None:
-    if device is None:
-        return None
-    try:
-        png_bytes = device.shell("screencap -p", encoding=None)
-        if png_bytes is not None and len(png_bytes) > 0:
-            image_data = np.frombuffer(png_bytes, dtype=np.uint8)
-            image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)
-            if image is not None:
-                return image
-            else:
-                logger.error(f"Screencap image decode error, probably disconnected")
-    except Exception as e:
-        logger.error('screencap', e)

{ok-script-0.0.96 → ok-script-0.0.98}/ok/capture/adb/DeviceManager.py

@@ -1,8 +1,13 @@
-from adbutils import AdbTimeout, AdbError
+import os
+import threading
+
+import cv2
+import numpy as np
+from adbutils import AdbError
 
 from ok.alas.platform_windows import get_emulator_exe
 from ok.capture.HwndWindow import HwndWindow, find_hwnd
-from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod, do_screencap
+from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod
 from ok.capture.adb.WindowsCaptureFactory import update_capture_method
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -19,6 +24,7 @@ class DeviceManager:
     def __init__(self, app_config, exit_event=None):
         self._device = None
         self._adb = None
+        self._adb_lock = threading.Lock()
         supported_resolution = app_config.get(
             'supported_resolution', {})
         self.supported_ratio = parse_ratio(supported_resolution.get('ratio'))
@@ -47,11 +53,39 @@ class DeviceManager:
 
     @property
     def adb(self):
-        if self._adb is None:
-            import adbutils
-            self._adb = adbutils.AdbClient(host="127.0.0.1")
-            logger.debug(f'connect adb')
-        return self._adb
+        with self._adb_lock:
+            if self._adb is None:
+                import adbutils
+                logger.debug(f'init adb')
+                from adbutils._utils import _get_bin_dir
+                bin_dir = _get_bin_dir()
+                exe = os.path.join(bin_dir, "adb.exe" if os.name == 'nt' else 'adb')
+                from adbutils._utils import _is_valid_exe
+                if os.path.isfile(exe) and _is_valid_exe(exe):
+                    os.environ['ADBUTILS_ADB_PATH'] = exe
+                    logger.info(f'set ADBUTILS_ADB_PATH {os.getenv("ADBUTILS_ADB_PATH")}')
+                else:
+                    logger.error(f'set ADBUTILS_ADB_PATH failed {exe}')
+                self._adb = adbutils.AdbClient(host="127.0.0.1", socket_timeout=4)
+                try:
+                    self._adb.device_list()
+                except AdbError as e:
+                    self.try_kill_adb(e)
+            return self._adb
+
+    def try_kill_adb(self, e=None):
+        logger.error('try kill adb server', e)
+        import psutil
+        for proc in psutil.process_iter():
+            # Check whether the process name matches
+            if proc.name() == 'adb.exe' or proc.name() == 'adb':
+                logger.info(f'kill adb by process name {proc.cmdline()}')
+                try:
+                    proc.kill()
+                except Exception as e:
+                    logger.error(f'kill adb server failed', e)
+        logger.info('try kill adb end')
+        # self._adb.server_kill()
 
     def adb_connect(self, addr, try_connect=True):
         try:
@@ -67,11 +101,12 @@ class DeviceManager:
                         logger.debug(f'adb_connect already connected {addr}')
                         return device
             if try_connect:
-                self.adb.connect(addr, timeout=3)
+                self.adb.connect(addr, timeout=5)
                 logger.debug(f'adb_connect {addr}')
                 return self.adb_connect(addr, try_connect=False)
-        except AdbTimeout as e:
-            logger.error(f"adb connect error try kill server {addr}", e)
+        except AdbError as e:
+            logger.error(f"adb connect error {addr}", e)
+            self.try_kill_adb(e)
         except Exception as e:
             logger.error(f"adb connect error return none {addr}", e)
 
@@ -137,11 +172,12 @@ class DeviceManager:
         from ok.alas.emulator_windows import EmulatorManager
         manager = EmulatorManager()
         installed_emulators = manager.all_emulator_instances
+        logger.info(f'installed emulators {installed_emulators}')
         for emulator in installed_emulators:
             preferred = self.get_preferred_device()
             if current and preferred is not None and preferred['imei'] != emulator.name:
                 logger.debug(f"refresh current only skip others {preferred['imei']} != {emulator.name}")
-                break
+                continue
             adb_device = self.adb_connect(emulator.serial)
             width, height = self.get_resolution(adb_device) if adb_device is not None else 0, 0
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
@@ -164,7 +200,7 @@ class DeviceManager:
         if device is not None:
             if resolution := self.resolution_dict.get(device.serial):
                 return resolution
-            frame = do_screencap(device)
+            frame = self.do_screencap(device)
             if frame is not None:
                 height, width, _ = frame.shape
                 if self.supported_ratio is None or abs(width / height - self.supported_ratio) < 0.01:
@@ -198,15 +234,43 @@ class DeviceManager:
             self.start()
         logger.debug(f'preferred device: {preferred}')
 
-    @staticmethod
-    def adb_get_imei(device):
+    def shell_device(self, device, *args, **kwargs):
+        kwargs.setdefault('timeout', 5)
         try:
-            return device.shell("settings get secure android_id") or device.shell(
-                "service call iphonesubinfo 4") or device.prop.model
+            return device.shell(*args, **kwargs)
+        except AdbError as e:
+            logger.error(f"adb shell AdbError try kill server {device}", e)
+            self.try_kill_adb(e)
+            addr = self.get_preferred_device()['address']
+            self.refresh_emulators()
+            self.refresh_phones()
+            new_addr = self.get_preferred_device()['address']
+            logger.error(f"shell_wrapper error occurred, try refresh_emulators {addr} {new_addr}", e)
+            device = self.adb_connect(device.serial)
+            return device.shell(*args, **kwargs)
         except Exception as e:
-            logger.error(f"adb_get_imei error maybe offline {device}")
+            logger.error(f"adb shell error maybe offline {device}", e)
             return None
 
+    def adb_get_imei(self, device):
+        return (self.shell_device(device, "settings get secure android_id") or
+                self.shell_device(device, "service call iphonesubinfo 4") or device.prop.model)
+
+    def do_screencap(self, device) -> np.ndarray | None:
+        if device is None:
+            return None
+        try:
+            png_bytes = self.shell_device(device, "screencap -p", encoding=None)
+            if png_bytes is not None and len(png_bytes) > 0:
+                image_data = np.frombuffer(png_bytes, dtype=np.uint8)
+                image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)
+                if image is not None:
+                    return image
+                else:
+                    logger.error(f"Screencap image decode error, probably disconnected")
+        except Exception as e:
+            logger.error('screencap', e)
+
     def get_preferred_device(self):
         imei = self.config.get("preferred")
         preferred = self.device_dict.get(imei)
@@ -331,19 +395,10 @@ class DeviceManager:
 
     def shell(self, *args, **kwargs):
         # Set default timeout to 5 if not provided
-        kwargs.setdefault('timeout', 5)
 
         device = self.device
         if device is not None:
-            try:
-                return device.shell(*args, **kwargs)
-            except AdbError as e:
-                logger.debug(f'shell adb error {args} {e}')
-            except Exception as e:
-                addr = self.get_preferred_device()['address']
-                self.refresh_emulators()
-                new_addr = self.get_preferred_device()['address']
-                logger.error(f"shell_wrapper error occurred, try refresh_emulators {addr} {new_addr}", e)
+            return self.shell_device(device, *args, **kwargs)
         else:
             raise Exception('Device is none')
 

{ok-script-0.0.96 → ok-script-0.0.98}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -51,11 +51,12 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
 
     def convert_dx_frame(self):
         frame = self.last_dx_frame
-        self.last_dx_frame = None
         if not frame:
-            logger.warning('convert_dx_frame self.last_dx_frame is none')
+            # logger.warning('convert_dx_frame self.last_dx_frame is none')
             return None
-
+        start = time.time()
+        dx_time = self.last_frame_time
+        self.last_dx_frame = None
         need_reset_framepool = False
         if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
             need_reset_framepool = True
@@ -94,6 +95,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                                         (desc.Height, mapinfo.RowPitch // 4, 4))[
                   :, :desc.Width].copy()
             self.immediatedc.Unmap(cputex, 0)
+            # logger.debug(f'frame latency {(time.time() - start):.3f} {(time.time() - dx_time):.3f}')
             return img
         except OSError as e:
             if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
@@ -150,7 +152,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 self.evtoken = item.add_Closed(delegate)
                 self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
                                                                                 DirectXPixelFormat.B8G8R8A8UIntNormalized,
-                                                                                2, item.Size)
+                                                                                1, item.Size)
                 self.session = self.frame_pool.CreateCaptureSession(item)
                 pool = self.frame_pool
                 pool.add_FrameArrived(

{ok-script-0.0.96 → ok-script-0.0.98}/ok/color/Color.py

@@ -104,6 +104,11 @@ def find_color_rectangles(image, color_range, min_width, min_height, max_width=-
         raise ValueError("Image not found or path is incorrect")
     if box is not None:
         image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+        x_offset = box.x
+        y_offset = box.y
+    else:
+        x_offset = 0
+        y_offset = 0
 
     # Convert color range to BGR format for OpenCV
     lower_bound = np.array([color_range['b'][0], color_range['g'][0], color_range['r'][0]], dtype="uint8")
@@ -139,7 +144,7 @@ def find_color_rectangles(image, color_range, min_width, min_height, max_width=-
             if percent >= threshold:
                 # Store the result
                 results.append(
-                    Box(x, y, w, h, confidence=percent)
+                    Box(x + x_offset, y + y_offset, w, h, confidence=percent)
                 )
 
     return results

{ok-script-0.0.96 → ok-script-0.0.98}/ok/feature/Box.py

@@ -95,6 +95,9 @@ class Box:
         return Box(self.x + x_offset, self.y + y_offset, self.width + width_offset, self.height + height_offset,
                    self.confidence, name or self.name)
 
+    def crop_frame(self, frame):
+        return frame[self.y:self.y + self.height, self.x:self.x + self.width]
+
     def center(self):
         return self.x + self.width / 2, self.y + self.height / 2
 

{ok-script-0.0.96 → ok-script-0.0.98}/ok/feature/FeatureSet.py

@@ -174,7 +174,7 @@ class FeatureSet:
             template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
         if category_name.startswith('edge_'):
             search_area = cv2.cvtColor(search_area, cv2.COLOR_BGR2GRAY)
-            # search_area = cv2.Canny(search_area, self.canny_lower, self.canny_higher)
+            search_area = cv2.Canny(search_area, self.canny_lower, self.canny_higher)
         elif category_name.startswith('gray_'):
             search_area = cv2.cvtColor(search_area, cv2.COLOR_BGR2GRAY)
 
@@ -258,7 +258,7 @@ def read_from_json(coco_json, width=-1, height=-1, canny_lower=50, canny_upper=1
                 if ok_compressed:
                     if category_name.startswith('edge_'):
                         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-                        # image = cv2.Canny(image, canny_lower, canny_upper)
+                        image = cv2.Canny(image, canny_lower, canny_upper)
                     elif category_name.startswith('gray_'):
                         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
                 feature_dict[category_name] = Feature(image, x, y)

{ok-script-0.0.96 → ok-script-0.0.98}/ok/feature/FindFeature.py

@@ -31,13 +31,24 @@ class FindFeature:
             setattr(self, feature, result)
         return ret
 
+    def wait_feature(self, feature, horizontal_variance=0, vertical_variance=0, threshold=0, wait_until_before_delay=-1,
+                     time_out=0, pre_action=None, post_action=None, use_gray_scale=False, box=None,
+                     raise_if_not_found=False):
+        return self.wait_until(
+            lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold,
+                                  use_gray_scale=use_gray_scale, box=box),
+            time_out,
+            pre_action,
+            post_action, wait_until_before_delay, raise_if_not_found)
+
     def wait_click_feature(self, feature, horizontal_variance=0, vertical_variance=0, threshold=0, relative_x=0.5,
                            relative_y=0.5,
-                           time_out=0, pre_action=None, post_action=None):
-        box = self.wait_until(lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold),
-                              time_out,
-                              pre_action,
-                              post_action)
+                           time_out=0, pre_action=None, post_action=None, box=None, raise_if_not_found=True):
+        box = self.wait_until(
+            lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold, box=box),
+            time_out,
+            pre_action,
+            post_action, raise_if_not_found)
         if box is not None:
             self.click_box(box, relative_x, relative_y)
             return True

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/App.py

@@ -47,7 +47,6 @@ class App:
         self.loading_window = None
         self.overlay_window = None
         self.main_window = None
-        self.log_window = None
         self.exit_event = exit_event
         self.icon = QIcon(self.config.get('gui_icon') or ":/icon/icon.ico")
         if self.config.get('analytics'):
@@ -98,12 +97,6 @@ class App:
         if self.overlay and ok.gui.device_manager.hwnd is not None:
             self.overlay_window = OverlayWindow(ok.gui.device_manager.hwnd)
 
-        if self.config.get('debug'):
-            from ok.gui.debug.LogWindow import LogWindow
-            self.log_window = LogWindow(self.config)
-            self.log_window.show()
-            logger.debug('showing log_window')
-
         self.main_window = MainWindow(self.config, self.icon, self.title, self.version, self.overlay, self.about,
                                       self.exit_event)
         # Set the window title here

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/debug/DebugTab.py

@@ -29,6 +29,9 @@ class DebugTab(Tab):
 
         self.config = Config({'target_task': "", 'target_images': [], 'target_function': ""},
                              app_config.get('config_folder'), 'debug')
+        self.log_window_config = Config({'width': 800, 'height': 300, 'x': 0, 'y': 0, 'keyword': '',
+                                         'level': 'ALL', 'show': True},
+                                        app_config.get('config_folder'), 'log_window')
         tool_widget = QWidget()
         layout = FlowLayout(tool_widget, False)
 
@@ -53,7 +56,14 @@ class DebugTab(Tab):
         ocr_button.clicked.connect(lambda: self.handler.post(self.ocr))
         layout.addWidget(ocr_button)
 
-        open_log_folder = PushButton(self.tr("Open Logs"))
+        self.log_window = None
+
+        log_window_button = PushButton(self.tr("Open Logs"))
+        log_window_button.clicked.connect(self.toggle_log_window)
+        layout.addWidget(log_window_button)
+
+        if self.log_window_config.get('show'):
+            self.toggle_log_window()
 
         call_task_widget = QWidget()
         call_task_container = QVBoxLayout(call_task_widget)
@@ -98,6 +108,22 @@ class DebugTab(Tab):
         self.handler.post(self.bind_hot_keys)
         self.handler.post(self.check_hotkey, 0.1)
 
+        ok.gui.app.app.aboutToQuit.connect(self.unregister)
+
+    def toggle_log_window(self):
+        if self.log_window is None:
+            from ok.gui.debug.LogWindow import LogWindow
+            self.log_window = LogWindow(self.log_window_config)
+            self.log_window.show()
+            self.log_window_config['show'] = True
+        elif self.log_window.isVisible():
+            self.log_window.hide()
+            self.log_window_config['show'] = False
+        else:
+            self.log_window_config['show'] = True
+            self.log_window.show()
+        logger.debug('showing log_window')
+
     def check_hotkey(self):
         # Example event type, you should use the appropriate QEvent.Type for your case
         msg = wintypes.MSG()
@@ -127,8 +153,10 @@ class DebugTab(Tab):
             logger.debug("Failed to register hotkey for Alt+Ctrl+S")
         logger.debug('bind_hot_keys')
 
-    def __del__(self):
+    @staticmethod
+    def unregister():
         # Unregister the hotkeys
+        logger.debug('Unregister the hotkeys')
         windll.user32.UnregisterHotKey(None, 1)
         windll.user32.UnregisterHotKey(None, 2)
 

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/debug/LogWindow.py

@@ -4,7 +4,6 @@ from PySide6.QtWidgets import QWidget, \
     QStyledItemDelegate, QListView, QVBoxLayout, QHBoxLayout, QAbstractItemView, QComboBox, QLineEdit, QLabel, \
     QPushButton
 
-from ok.config.Config import Config
 from ok.gui.Communicate import communicate
 
 LOG_BG_TRANS = 80
@@ -70,9 +69,6 @@ class LogModel(QAbstractListModel):
         self.do_filter_logs()
         self.endInsertRows()
 
-        # self.layoutChanged.emit()
-        # self.log_list.scrollToBottom()
-
     def do_filter_logs(self):
 
         keyword = self.current_keyword.lower()
@@ -109,15 +105,13 @@ level_severity = {v: k for k, v in log_levels.items()}
 
 
 class LogWindow(QWidget):
-    def __init__(self, app_config):
+    def __init__(self, config):
         super().__init__()
         self.setWindowTitle('Log Viewer')
         self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint | Qt.Tool)
         self.setAttribute(Qt.WA_TranslucentBackground)
 
-        self.config = Config({'width': 800, 'height': 300, 'x': 0, 'y': 0,
-                              'level': 'ALL'},
-                             app_config.get('config_folder'), 'log_window')
+        self.config = config
         self.setGeometry(self.config['x'], self.config['y'], self.config['width'], self.config['height'])
 
         self.old_pos = None
@@ -139,6 +133,8 @@ class LogWindow(QWidget):
 
         self.keyword_filter = QLineEdit()
         self.keyword_filter.setPlaceholderText("Filter by keyword")
+        if keyword := self.config.get('keyword'):
+            self.keyword_filter.setText(keyword)
         self.keyword_filter.textChanged.connect(self.filter_logs)
 
         self.drag_button = QLabel(self.tr("Drag"))
@@ -162,6 +158,11 @@ class LogWindow(QWidget):
         self.log_list.setModel(self.log_model)
 
         communicate.log.connect(self.add_log)
+        self.filter_logs()
+
+    def close(self):
+        super().close()
+        self.config['show'] = False
 
     def add_log(self, level_no, message):
         # print('add_log', level_no, message)
@@ -170,8 +171,9 @@ class LogWindow(QWidget):
 
     def filter_logs(self):
         level = self.level_filter.currentText()
-        self.config['level'] = level
         keyword = self.keyword_filter.text()
+        self.config['keyword'] = keyword
+        self.config['level'] = level
         self.log_model.filter_logs(level, keyword)
 
     def mousePressEvent(self, event):

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/tasks/OneTimeTaskTab.py

@@ -13,7 +13,7 @@ class OneTimeTaskTab(TaskTab):
         super().__init__()
 
         for task in ok.gui.executor.onetime_tasks:
-            task_card = TaskCard(task)
+            task_card = TaskCard(task, True)
             self.addWidget(task_card)
 
     def in_current_list(self, task):

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/tasks/TaskCard.py

@@ -7,19 +7,19 @@ from ok.gui.Communicate import communicate
 from ok.gui.common.OKIcon import OKIcon
 from ok.gui.tasks.ConfigItemFactory import config_widget
 from ok.task.BaseTask import BaseTask
-from ok.task.TriggerTask import TriggerTask
 
 
 class TaskCard(ExpandSettingCard):
-    def __init__(self, task: BaseTask):
+    def __init__(self, task: BaseTask, onetime):
         super().__init__(FluentIcon.INFO, task.name, task.description)
         self.task = task
+        self.onetime = onetime
         if task.default_config:
             self.reset_config = PushButton(FluentIcon.CANCEL, self.tr("Reset Config"), self)
             self.addWidget(self.reset_config)
             self.reset_config.clicked.connect(self.reset_clicked)
 
-        if not isinstance(task, TriggerTask):
+        if onetime:
             self.task_buttons = TaskButtons(self.task)
             self.addWidget(self.task_buttons)
         else:
@@ -49,10 +49,10 @@ class TaskCard(ExpandSettingCard):
 
     def update_buttons(self, task):
         if task == self.task:
-            if isinstance(task, TriggerTask):
-                self.enable_button.setChecked(task.enabled)
-            else:
+            if self.onetime:
                 self.task_buttons.update_buttons()
+            else:
+                self.enable_button.setChecked(task.enabled)
 
     def check_changed(self, checked):
         if checked:

{ok-script-0.0.96 → ok-script-0.0.98}/ok/gui/tasks/TriggerTaskTab.py

@@ -13,7 +13,7 @@ class TriggerTaskTab(TaskTab):
         super().__init__()
 
         for task in ok.gui.executor.trigger_tasks:
-            task_card = TaskCard(task)
+            task_card = TaskCard(task, False)
             self.addWidget(task_card)
 
     def in_current_list(self, task):

{ok-script-0.0.96 → ok-script-0.0.98}/ok/interaction/Win32Interaction.py

@@ -20,7 +20,7 @@ class Win32Interaction(BaseInteraction):
         if not is_admin():
             logger.error(f"You must be an admin to use Win32Interaction")
 
-    def send_key(self, key, down_time=0.02):
+    def send_key(self, key, down_time=0.01):
         if not self.capture.clickable():
             logger.error(f"can't click on {key}, because capture is not clickable")
             return

{ok-script-0.0.96 → ok-script-0.0.98}/ok/ocr/OCR.py

@@ -12,7 +12,7 @@ logger = get_logger(__name__)
 
 class OCR:
     executor = None
-    ocr_default_threshold = 0.5
+    ocr_default_threshold = 0.8
     ocr_target_height = 0
 
     def ocr(self, x=0, y=0, to_x=1, to_y=1, match: str | List[str] | Pattern[str] | List[Pattern[str]] | None = None,
@@ -75,7 +75,7 @@ class OCR:
             communicate.emit_draw_box("ocr", detected_boxes, "red")
             communicate.emit_draw_box("ocr_zone", box, "blue")
             logger.debug(
-                f"ocr_zone {box} found result: {len(detected_boxes)}) time: {(time.time() - start):.2f} scale_factor: {scale_factor:.2f}")
+                f"ocr_zone {box} found result: {detected_boxes}) time: {(time.time() - start):.2f} scale_factor: {scale_factor:.2f}")
             if not detected_boxes and ocr_boxes:
                 logger.info(f'ocr detected but no match: {match} {ocr_boxes}')
             return sort_boxes(detected_boxes)

{ok-script-0.0.96 → ok-script-0.0.98}/ok/task/ExecutorOperation.py

@@ -138,7 +138,7 @@ class ExecutorOperation:
     def move_relative(self, x, y):
         self.executor.interaction.move_relative(x, y)
 
-    def click_box(self, box: Box | List[Box] = None, relative_x=0.5, relative_y=0.5, raise_if_not_found=True,
+    def click_box(self, box: Box | List[Box] = None, relative_x=0.5, relative_y=0.5, raise_if_not_found=False,
                   move_back=False):
         if isinstance(box, list):
             if len(box) > 0:
@@ -156,7 +156,6 @@ class ExecutorOperation:
         return self.executor.wait_scene(scene_type, time_out, pre_action, post_action)
 
     def sleep(self, timeout):
-        self.executor.reset_scene()
         self.executor.sleep(timeout)
 
     def send_key(self, key, down_time=0.02):
@@ -174,10 +173,12 @@ class ExecutorOperation:
         self.executor.reset_scene()
         self.executor.interaction.send_key_up(key)
 
-    def wait_until(self, condition, time_out=0, pre_action=None, post_action=None, wait_until_before_delay=0):
-        return self.executor.wait_condition(condition, time_out, pre_action, post_action, wait_until_before_delay)
+    def wait_until(self, condition, time_out=0, pre_action=None, post_action=None, wait_until_before_delay=-1,
+                   raise_if_not_found=False):
+        return self.executor.wait_condition(condition, time_out, pre_action, post_action, wait_until_before_delay,
+                                            raise_if_not_found)
 
-    def wait_click_box(self, condition, time_out=0, pre_action=None, post_action=None, raise_if_not_found=True):
+    def wait_click_box(self, condition, time_out=0, pre_action=None, post_action=None, raise_if_not_found=False):
         target = self.wait_until(condition, time_out, pre_action, post_action)
         self.click_box(box=target, raise_if_not_found=raise_if_not_found)
         return target