ok-script 0.0.84__tar.gz → 0.0.86__tar.gz

{ok-script-0.0.84 → ok-script-0.0.86}/PKG-INFO

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

{ok-script-0.0.84 → ok-script-0.0.86}/ok/capture/HwndWindow.py

@@ -42,31 +42,23 @@ class HwndWindow:
     real_x_offset = 0
     real_y_offset = 0
 
-    def __init__(self, exit_event, title, exe_name=None, frame_width=0, frame_height=0):
+    def __init__(self, exit_event, title, exe_name=None, frame_width=0, frame_height=0, player_id=-1):
         super().__init__()
         self.app_exit_event = exit_event
         self.exe_name = exe_name
         self.title = title
         self.stop_event = threading.Event()
         self.visible = False
+        self.player_id = player_id
         self.update_window(title, exe_name, frame_width, frame_height)
         self.thread = threading.Thread(target=self.update_window_size, name="update_window_size")
         self.thread.start()
 
-    def update_title_and_exe(self, title, exe):
-        self.title = title
-        self.exe_name = exe
-        self.hwnd = None
-        self.visible = False
-        self.exists = False
-        self.width = 0
-        self.height = 0
-        self.do_update_window_size()
-
     def stop(self):
         self.stop_event.set()
 
-    def update_window(self, title, exe_name, frame_width, frame_height):
+    def update_window(self, title, exe_name, frame_width, frame_height, player_id=-1):
+        self.player_id = player_id
         self.title = title
         self.exe_name = exe_name
         self.update_frame_size(frame_width, frame_height)
@@ -100,7 +92,7 @@ class HwndWindow:
                 name, self.hwnd, self.exe_full_path, self.real_x_offset, self.real_y_offset, self.real_width, self.real_height = find_hwnd(
                     self.title,
                     self.exe_name,
-                    self.frame_width, self.frame_height)
+                    self.frame_width, self.frame_height, player_id=self.player_id)
                 self.exists = self.hwnd is not None
             if self.hwnd is not None:
                 self.exists = win32gui.IsWindow(self.hwnd)
@@ -168,6 +160,8 @@ def find_hwnd(title, exe_name, frame_width, frame_height, player_id=-1):
                 elif not re.search(title, text):
                     return True
             name, full_path, cmdline = get_exe_by_hwnd(hwnd)
+            if not name:
+                return True
             x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
                 hwnd)
             ret = (hwnd, full_path, width, height, x, y, text)
@@ -210,6 +204,12 @@ def get_player_id_from_cmdline(cmdline):
         if i != 0:
             if cmdline[i].isdigit():
                 return int(cmdline[i])
+    for i in range(len(cmdline)):
+        if i != 0:
+            value = re.search(r'index=(\d+)', cmdline[i])
+            # Return the value if it exists, otherwise return None
+            if value is not None:
+                return int(value.group(1))
     return 0
 
 
@@ -248,8 +248,11 @@ def get_exe_by_hwnd(hwnd):
     _, pid = win32process.GetWindowThreadProcessId(hwnd)
 
     # Get the process name and executable path
-    process = psutil.Process(pid)
-    return process.name(), process.exe(), process.cmdline()
+    if pid > 0:
+        process = psutil.Process(pid)
+        return process.name(), process.exe(), process.cmdline()
+    else:
+        return None, None, None
 
 
 if __name__ == '__main__':

{ok-script-0.0.84 → ok-script-0.0.86}/ok/capture/adb/DeviceManager.py

@@ -1,4 +1,4 @@
-from adbutils import AdbTimeout
+from adbutils import AdbTimeout, AdbError
 
 from ok.alas.platform_windows import get_emulator_exe
 from ok.capture.HwndWindow import HwndWindow, find_hwnd
@@ -53,27 +53,25 @@ class DeviceManager:
             logger.debug(f'connect adb')
         return self._adb
 
-    def adb_connect(self, addr):
+    def adb_connect(self, addr, try_connect=True):
         try:
-            for info in self.adb.list():
+            for device in self.adb.device_list():
                 if self.exit_event.is_set():
                     logger.error(f"adb_connect exit_event is set")
                     return None
-                if info.serial == addr:
-                    if info.state == 'offline':
+                if device.serial == addr:
+                    if device.info['state'] == 'offline':
                         logger.debug(f'adb_connect offline disconnect first {addr}')
                         self.adb.disconnect(addr)
                     else:
                         logger.debug(f'adb_connect already connected {addr}')
-                        return self.adb.device(addr)
-            self.adb.connect(addr, timeout=5)
-            device = self.adb.device(addr)
-            logger.debug(f'adb_connect {addr} device {device}')
-            return device
+                        return device
+            if try_connect:
+                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)
-            # self.adb.server_kill()
-            # self._adb = None
         except Exception as e:
             logger.error(f"adb connect error return none {addr}", e)
 
@@ -101,9 +99,7 @@ class DeviceManager:
 
     def do_refresh(self, current=False):
         self.update_pc_device()
-
         self.refresh_emulators(current)
-
         self.refresh_phones(current)
 
         if self.exit_event.is_set():
@@ -131,7 +127,7 @@ class DeviceManager:
                     width, height = self.get_resolution(adb_device)
                     logger.debug(f'refresh_phones found an phone {adb_device}')
                     phone_device = {"address": adb_device.serial, "device": "adb", "connected": True, "imei": imei,
-                                    "nick": adb_device.prop.model or imei,
+                                    "nick": adb_device.prop.model or imei, "player_id": -1,
                                     "resolution": f'{width}x{height}'}
                     self.device_dict[imei] = phone_device
 
@@ -147,13 +143,13 @@ class DeviceManager:
                 logger.debug(f"refresh current only skip others {preferred['imei']} != {emulator.name}")
                 break
             adb_device = self.adb_connect(emulator.serial)
-            width, height = self.get_resolution(adb_device)
+            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,
                                                                    emulator.path, width, height, emulator.player_id)
             connected = adb_device is not None and name is not None
             emulator_device = {"address": emulator.serial, "device": "adb",
                                "full_path": emulator.path, "connected": connected,
-                               "imei": emulator.name,
+                               "imei": emulator.name, "player_id": emulator.player_id,
                                "nick": name or emulator.name, "emulator": emulator}
             if adb_device is not None:
                 emulator_device["resolution"] = f"{width}x{height}"
@@ -236,11 +232,11 @@ class DeviceManager:
         preferred = self.get_preferred_device()
         return preferred.get('hwnd')
 
-    def ensure_hwnd(self, title, exe, frame_width=0, frame_height=0):
+    def ensure_hwnd(self, title, exe, frame_width=0, frame_height=0, player_id=-1):
         if self.hwnd is None:
-            self.hwnd = HwndWindow(self.exit_event, title, exe, frame_width, frame_height)
+            self.hwnd = HwndWindow(self.exit_event, title, exe, frame_width, frame_height, player_id)
         else:
-            self.hwnd.update_window(title, exe, frame_width, frame_height)
+            self.hwnd.update_window(title, exe, frame_width, frame_height, player_id)
 
     def use_windows_capture(self, override_config=None, require_bg=False, use_bit_blt_only=False):
         if not override_config:
@@ -271,7 +267,7 @@ class DeviceManager:
         else:
             width, height = self.get_resolution()
             if self.config.get('capture') == "windows":
-                self.ensure_hwnd(None, preferred.get('full_path'), width, height)
+                self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
                 self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=True)
             else:
                 if not isinstance(self.capture_method, ADBCaptureMethod):
@@ -281,7 +277,7 @@ class DeviceManager:
                     self.capture_method = ADBCaptureMethod(self, self.exit_event, width=width,
                                                            height=height)
                 if self.debug and preferred.get('full_path'):
-                    self.ensure_hwnd(None, preferred.get('full_path'), width, height)
+                    self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
                 elif self.hwnd is not None:
                     self.hwnd.stop()
                     self.hwnd = None
@@ -341,12 +337,13 @@ class DeviceManager:
         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 None
         else:
             raise Exception('Device is none')
 

{ok-script-0.0.84 → ok-script-0.0.86}/ok/config/Config.py

@@ -78,8 +78,10 @@ class Config(dict):
 
     def __setitem__(self, key, value):
         if self.validate(key, value):
+            old_value = self.get(key)
             super().__setitem__(key, value)
-            self.save_file()
+            if old_value != value:
+                self.save_file()
 
     def __getitem__(self, key):
         try:

{ok-script-0.0.84 → ok-script-0.0.86}/ok/feature/FindFeature.py

@@ -44,9 +44,9 @@ class FindFeature:
         return False
 
     def find_one(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
-                 use_gray_scale=False) -> Box:
+                 use_gray_scale=False, box=None) -> Box:
         boxes = self.find_feature(feature_name, horizontal_variance, vertical_variance, threshold,
-                                  use_gray_scale=use_gray_scale)
+                                  use_gray_scale=use_gray_scale, box=box)
         if len(boxes) > 0:
             if len(boxes) > 1:
                 print(f"find_one:found {feature_name} too many {len(boxes)}", file=sys.stderr)

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/App.py

@@ -13,6 +13,7 @@ from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
 from ok.gui.StartController import StartController
+from ok.gui.debug.LogWindow import LogWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
@@ -47,6 +48,7 @@ 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'):
@@ -109,6 +111,10 @@ class App:
         self.main_window.show()
         self.main_window.raise_()
         self.main_window.activateWindow()
+        if self.config.get('debug'):
+            self.log_window = LogWindow(self.config)
+            self.log_window.show()
+            logger.debug('showing log_window')
 
     def size_relative_to_screen(self, width, height):
         screen = self.app.primaryScreen()

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/MainWindow.py

@@ -43,10 +43,7 @@ class MainWindow(MSFluentWindow):
             if self.first_tab is None:
                 self.first_tab = self.trigger_tab
             self.addSubInterface(self.trigger_tab, FluentIcon.ROBOT, self.tr('Triggers'))
-        # if debug:
-        #     debug_tab = DebugTab()
-        #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
-        # ... Add other tabs similarly
+
         self.addSubInterface(self.start_tab, FluentIcon.PLAY, self.tr('Capture'))
 
         if debug:
@@ -77,8 +74,8 @@ class MainWindow(MSFluentWindow):
         self.tray.setContextMenu(menu)
         self.tray.show()
 
-        if ok.gui.device_manager.get_preferred_device() is not None and self.onetime_tab is not None:
-            self.switchTo(self.onetime_tab)
+        if ok.gui.device_manager.config.get("preferred") is None or self.onetime_tab is None:
+            self.switchTo(self.start_tab)
 
         communicate.capture_error.connect(self.capture_error)
         communicate.notification.connect(self.show_notification)

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/debug/DebugTab.py

@@ -49,9 +49,6 @@ class DebugTab(Tab):
         capture_button.clicked.connect(lambda: self.handler.post(self.capture))
         layout.addWidget(capture_button)
 
-        # self.shortcut = QShortcut(QKeySequence("Ctrl+Alt+S"), self)
-        # self.shortcut.activated.connect(lambda: self.handler.post(self.capture))
-
         ocr_button = PushButton("OCR")
         ocr_button.clicked.connect(lambda: self.handler.post(self.ocr))
         layout.addWidget(ocr_button)

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/debug/FrameWidget.py

@@ -6,7 +6,6 @@ from PySide6.QtGui import QPainter, QColor, QPen, QFont, QGuiApplication
 from PySide6.QtWidgets import QWidget
 
 import ok.gui
-from ok.gui.Communicate import communicate
 from ok.logging.Logger import get_logger
 
 logger = get_logger(__name__)
@@ -15,10 +14,8 @@ logger = get_logger(__name__)
 class FrameWidget(QWidget):
     def __init__(self):
         super(FrameWidget, self).__init__()
-        self._visible = True
         self._mouse_position = QPoint(0, 0)
         self.setMouseTracking(True)
-        communicate.update_overlay.connect(self.update)
         # Start a timer to update mouse position using Windows API
         self.timer = QTimer(self)
         self.timer.timeout.connect(self.update_mouse_position)
@@ -27,13 +24,14 @@ class FrameWidget(QWidget):
         self.mouse_font.setPointSize(10)  # Adjust the size as needed
         screen = QGuiApplication.primaryScreen()
         self.scaling = screen.devicePixelRatio()
-        communicate.update_overlay.connect(self.update)
 
     def update_mouse_position(self):
         try:
+            if not self.isVisible():
+                return
             x, y = win32api.GetCursorPos()
             relative = self.mapFromGlobal(QPoint(x / self.scaling, y / self.scaling))
-            if self._mouse_position != relative and relative.x() > 0 and relative.y() > 0 and self._visible:
+            if self._mouse_position != relative and relative.x() > 0 and relative.y() > 0:
                 self._mouse_position = relative
                 self.update()
         except Exception as e:
@@ -45,7 +43,7 @@ class FrameWidget(QWidget):
         return self.width() / ok.gui.device_manager.width
 
     def paintEvent(self, event):
-        if not self._visible:
+        if not self.isVisible():
             return
         painter = QPainter(self)
         self.paint_border(painter)

ok-script-0.0.86/ok/gui/debug/LogWindow.py

@@ -0,0 +1,189 @@
+from PySide6.QtCore import Qt, QAbstractListModel, QModelIndex, QPoint, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QVBoxLayout, QListView, QLineEdit, QHBoxLayout, QComboBox, QAbstractItemView, QWidget, \
+    QPushButton, QLabel, QStyledItemDelegate
+
+from ok.config.Config import Config
+from ok.gui.Communicate import communicate
+
+LOG_BG_TRANS = 80
+color_codes = {
+    "INFO": QColor(85, 85, 255, LOG_BG_TRANS),  # Light blue
+    "DEBUG": QColor(85, 255, 85, LOG_BG_TRANS),  # Light green
+    "WARNING": QColor(255, 255, 85, LOG_BG_TRANS),  # Yellow
+    "ERROR": QColor(255, 85, 85, LOG_BG_TRANS),  # Red
+}
+
+
+class ColoredText:
+    """
+    Class to store colored text with its format code.
+    """
+
+    def __init__(self, text, format, level):
+        self.text = text
+        self.format = format
+        self.level = level
+
+
+class ColorDelegate(QStyledItemDelegate):
+    def __init__(self, parent=None):
+        super(ColorDelegate, self).__init__(parent)
+
+    def paint(self, painter, option, index):
+        # Get the color from the model
+        color = index.data(Qt.ForegroundRole)
+        if color:
+            painter.fillRect(option.rect, color)
+        super(ColorDelegate, self).paint(painter, option, index)
+
+
+class LogModel(QAbstractListModel):
+    def __init__(self, log_list):
+        super(LogModel, self).__init__()
+        self.log_list = log_list
+        self.logs = []
+        self.filtered_logs = self.logs[:]
+        self.current_level = "ALL"
+        self.current_keyword = ""
+
+    def data(self, index, role):
+        if role == Qt.DisplayRole:
+            return self.filtered_logs[index.row()].text
+        elif role == Qt.ForegroundRole:
+            return self.filtered_logs[index.row()].format
+
+    def rowCount(self, index):
+        return len(self.filtered_logs)
+
+    def add_log(self, level, message):
+        # Create colored text based on level
+        color_format = self.get_color_format(level)
+        colored_text = ColoredText(message, color_format, level)
+
+        if len(self.logs) >= 500:
+            self.beginRemoveRows(QModelIndex(), 0, 0)
+            self.logs.pop(0)
+            self.endRemoveRows()
+
+        self.beginInsertRows(QModelIndex(), self.rowCount(QModelIndex()), self.rowCount(QModelIndex()))
+        self.logs.append(colored_text)
+        self.endInsertRows()
+
+        self.filter_logs(self.current_level, self.current_keyword)
+
+    def filter_logs(self, level, keyword):
+        self.current_level = level
+        self.current_keyword = keyword
+        keyword = keyword.lower()
+
+        # Get the numeric severity for the current level
+        current_level_severity = level_severity.get(level, 0)
+
+        # Filter logs based on severity level and keyword
+        if level == "ALL":
+            self.filtered_logs = [log for log in self.logs if keyword in log.text.lower()]
+        else:
+            self.filtered_logs = [
+                log for log in self.logs
+                if level_severity.get(log.level, 0) >= current_level_severity
+                   and keyword in log.text.lower()
+            ]
+
+        self.layoutChanged.emit()
+        self.log_list.scrollToBottom()
+
+    def get_color_format(self, level):
+        # Define color codes for different levels
+
+        return color_codes.get(level, QColor())  # Return default color for unknown levels
+
+
+log_levels = {10: "DEBUG", 20: "INFO", 30: "WARNING", 40: "ERROR"}
+level_severity = {v: k for k, v in log_levels.items()}
+
+
+class LogWindow(QWidget):
+    def __init__(self, app_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.setGeometry(self.config['x'], self.config['y'], self.config['width'], self.config['height'])
+
+        self.refresh_signal = Signal()
+
+        self.old_pos = None
+
+        # Layouts
+        self.layout = QVBoxLayout()
+        self.filter_layout = QHBoxLayout()
+
+        # Widgets
+        self.log_list = QListView()
+        self.log_list.setStyleSheet("background:rgba(0,0,0,60);")
+        self.log_list.setSelectionMode(QAbstractItemView.NoSelection)
+        self.log_list.setItemDelegate(ColorDelegate())
+
+        self.level_filter = QComboBox()
+        self.level_filter.addItems(["ALL", "DEBUG", "INFO", "WARNING", "ERROR"])
+        self.level_filter.setCurrentText(self.config.get('level'))
+        self.level_filter.currentIndexChanged.connect(self.filter_logs)
+
+        self.keyword_filter = QLineEdit()
+        self.keyword_filter.setPlaceholderText("Filter by keyword")
+        self.keyword_filter.textChanged.connect(self.filter_logs)
+
+        self.drag_button = QLabel(self.tr("Drag"))
+        self.drag_button.setStyleSheet('background:rgba(0,0,0,255)')
+
+        self.close_button = QPushButton(self.tr("Close"))
+        self.close_button.clicked.connect(self.close)
+
+        # Adding widgets to layouts
+        self.filter_layout.addWidget(self.level_filter)
+        self.filter_layout.addWidget(self.keyword_filter, stretch=1)
+        self.filter_layout.addWidget(self.drag_button)
+        self.filter_layout.addWidget(self.close_button)
+
+        self.layout.addLayout(self.filter_layout)
+        self.layout.addWidget(self.log_list)
+
+        self.setLayout(self.layout)
+
+        self.log_model = LogModel(self.log_list)
+        self.log_list.setModel(self.log_model)
+        communicate.log.connect(self.add_log)
+
+        self.logs = []
+        self.filter_logs()
+
+    def add_log(self, level_no, message):
+        self.logs.append(message)
+        self.log_model.add_log(log_levels.get(level_no, 'DEBUG'), message)
+
+    def filter_logs(self):
+        level = self.level_filter.currentText()
+        self.config['level'] = level
+        keyword = self.keyword_filter.text()
+        self.log_model.filter_logs(level, keyword)
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            self.old_pos = event.globalPos()
+
+    def mouseMoveEvent(self, event):
+        if self.old_pos:
+            delta = QPoint(event.globalPos() - self.old_pos)
+            self.move(self.x() + delta.x(), self.y() + delta.y())
+            self.old_pos = event.globalPos()
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            self.config['x'] = self.x()
+            self.config['y'] = self.y()
+            self.old_pos = None

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/debug/Screenshot.py

@@ -78,7 +78,6 @@ class Screenshot(QObject):
         self.remove_expired()
         if self.click_screenshot_folder is not None and frame is not None:
             self.add_task(frame, self.click_screenshot_folder, key)
-        communicate.update_overlay.emit()
 
     def remove_expired(self):
         current_time = time.time()

{ok-script-0.0.84 → ok-script-0.0.86}/ok/gui/tasks/TaskCard.py

@@ -7,7 +7,7 @@ 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.OneTimeTask import OneTimeTask
+from ok.task.TriggerTask import TriggerTask
 
 
 class TaskCard(ExpandSettingCard):
@@ -19,7 +19,7 @@ class TaskCard(ExpandSettingCard):
             self.addWidget(self.reset_config)
             self.reset_config.clicked.connect(self.reset_clicked)
 
-        if isinstance(task, OneTimeTask):
+        if not isinstance(task, TriggerTask):
             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, OneTimeTask):
-                self.task_buttons.update_buttons()
-            else:
+            if isinstance(task, TriggerTask):
                 self.enable_button.setChecked(task.enabled)
+            else:
+                self.task_buttons.update_buttons()
 
     def check_changed(self, checked):
         if checked:

{ok-script-0.0.84 → ok-script-0.0.86}/ok/interaction/BaseInteraction.py

@@ -16,7 +16,7 @@ class BaseInteraction:
 
     def send_key_down(self, key):
         pass
-    
+
     def send_key_up(self, key):
         pass
 
@@ -31,6 +31,6 @@ class BaseInteraction:
 
     def click(self, x=-1, y=-1, name=None):
         if name is None:
-            logger.info(f"click {x, y}")
+            logger.debug(f"click {x, y}")
         else:
-            logger.info(f"click {name} {x, y}")
+            logger.debug(f"click {name} {x, y}")

{ok-script-0.0.84 → ok-script-0.0.86}/ok/ocr/OCR.py

@@ -90,7 +90,7 @@ class OCR:
             self.click_box(box)
             return box
         else:
-            logger.error(f'wait ocr no box {x} {y} {width} {height} {to_x} {to_y} {match}')
+            logger.warning(f'wait ocr no box {x} {y} {width} {height} {to_x} {to_y} {match}')
 
     def wait_ocr(self, x=0, y=0, to_x=1, to_y=1, width=0, height=0, name=None, box=None,
                  match: str | List[str] | Pattern[str] | List[Pattern[str]] | None = None, threshold=0,

{ok-script-0.0.84 → ok-script-0.0.86}/ok/task/BaseTask.py

@@ -27,6 +27,34 @@ class BaseTask(ExecutorOperation):
         self._paused = False
         self.lock = threading.Lock()
         self._handler = None
+        self._done = False
+        self.running = False
+
+    def get_status(self):
+        if self.running:
+            return "Running"
+        elif self.enabled:
+            if self.paused:
+                return "Paused"
+            else:
+                return "In Queue"
+        else:
+            return "Not Started"
+
+    def enable(self):
+        if not self._enabled:
+            self._enabled = True
+            self.info_clear()
+        communicate.task.emit(self)
+        self._done = False
+
+    @property
+    def done(self):
+        return self._done
+
+    def set_done(self):
+        self._done = True
+        self.disable()
 
     @property
     def handler(self) -> Handler:
@@ -120,20 +148,11 @@ class BaseTask(ExecutorOperation):
     def validate_config(self, key, value):
         pass
 
-    def enable(self):
-        if not self._enabled:
-            self._enabled = True
-            self.info_clear()
-        communicate.task.emit(self)
-
     def disable(self):
         self._enabled = False
         self.executor.current_task = None
         communicate.task.emit(self)
 
-    def get_status(self):
-        pass
-
     def run(self):
         pass