ok-script 0.0.99__tar.gz → 0.0.100__tar.gz

{ok-script-0.0.99 → ok-script-0.0.100}/PKG-INFO

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

{ok-script-0.0.99 → ok-script-0.0.100}/ok/OK.py

@@ -6,6 +6,7 @@ from typing import Dict, Any
 from PySide6.QtWidgets import QApplication
 
 import ok
+from ok.config.Config import Config
 from ok.logging.Logger import get_logger, config_logger
 from ok.util.exit_event import ExitEvent
 from ok.util.path import install_path_isascii
@@ -31,6 +32,7 @@ class OK:
     def __init__(self, config: Dict[str, Any]):
         print(f"AutoHelper init, config: {config}")
         config["config_folder"] = config.get("config_folder") or 'configs'
+        Config.config_folder = config["config_folder"]
         config_logger(config)
         logger.info(f"AutoHelper init, config: {config}")
         ok.gui.ok = self

{ok-script-0.0.99 → ok-script-0.0.100}/ok/capture/adb/DeviceManager.py

@@ -41,7 +41,6 @@ class DeviceManager:
         else:
             self.hwnd = None
         self.config = Config({"preferred": "none", "pc_full_path": "none", 'capture': 'windows'},
-                             app_config.get('config_folder'),
                              "devices")
         self.capture_method = None
         self.handler = Handler(exit_event, 'RefreshAdb')

{ok-script-0.0.99 → ok-script-0.0.100}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -23,17 +23,17 @@ logger = get_logger(__name__)
 class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     name = "Windows Graphics Capture"
     description = "fast, most compatible, capped at 60fps"
-    last_dx_frame = None
-    last_frame_time = 0
-    frame_pool = None
-    item = None
-    session = None
-    cputex = None
-    rtdevice = None
-    dxdevice = None
 
     def __init__(self, hwnd_window: HwndWindow):
         super().__init__(hwnd_window)
+        self.last_frame = None
+        self.last_frame_time = 0
+        self.frame_pool = None
+        self.item = None
+        self.session = None
+        self.cputex = None
+        self.rtdevice = None
+        self.dxdevice = None
         self.start_or_stop()
 
     def frame_arrived_callback(self, x, y):
@@ -41,7 +41,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
             self.last_frame_time = time.time()
             next_frame = self.frame_pool.TryGetNextFrame()
             if next_frame is not None:
-                self.last_dx_frame = next_frame
+                self.last_frame = self.convert_dx_frame(next_frame)
             else:
                 logger.warning('frame_arrived_callback TryGetNextFrame returned None')
         except Exception as e:
@@ -49,14 +49,10 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
             self.close()
             return
 
-    def convert_dx_frame(self):
-        frame = self.last_dx_frame
+    def convert_dx_frame(self, frame):
         if not frame:
             # 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
@@ -206,9 +202,16 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     @override
     def do_get_frame(self):
         if self.start_or_stop():
-            frame = self.convert_dx_frame()
+            frame = self.last_frame
+            self.last_frame = None
             if frame is None:
-                return
+                if time.time() - self.last_frame_time > 10:
+                    logger.warning(f'no frame for 10 sec, try to restart')
+                    self.close()
+                    self.last_frame_time = time.time()
+                    return self.do_get_frame()
+                else:
+                    return None
             latency = time.time() - self.last_frame_time
 
             frame = self.crop_image(frame)

{ok-script-0.0.99 → ok-script-0.0.100}/ok/color/Color.py

@@ -42,6 +42,38 @@ def is_close_to_pure_color(image, max_colors=5000, percent=0.97):
     return percentage > percent
 
 
+def keep_pixels_in_color_range(image, color_range):
+    lower_bound, upper_bound = color_range_to_bound(color_range)
+    mask = cv2.inRange(image, lower_bound, upper_bound)
+
+    # Apply mask to original image
+    result = cv2.bitwise_and(image, image, mask=mask)
+
+    # Count the number of white pixels in the mask
+    pixel_count = np.count_nonzero(mask)
+
+    return result, pixel_count
+
+
+def get_connected_area_by_color(image, color_range, connectivity=4):
+    lower_bound, upper_bound = color_range_to_bound(color_range)
+
+    # Create mask
+    mask = cv2.inRange(image, lower_bound, upper_bound)
+
+    # Find connected components
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask, connectivity=connectivity)
+
+    # Print the area of each connected component
+    return num_labels, stats
+
+
+def color_range_to_bound(color_range):
+    lower_bound = np.array([color_range['b'][0], color_range['g'][0], color_range['r'][0]], dtype="uint8")
+    upper_bound = np.array([color_range['b'][1], color_range['g'][1], color_range['r'][1]], dtype="uint8")
+    return lower_bound, upper_bound
+
+
 def calculate_colorfulness(image, box=None):
     if box is not None:
         image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
@@ -111,8 +143,7 @@ def find_color_rectangles(image, color_range, min_width, min_height, max_width=-
         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")
-    upper_bound = np.array([color_range['b'][1], color_range['g'][1], color_range['r'][1]], dtype="uint8")
+    lower_bound, upper_bound = color_range_to_bound(color_range)
 
     # Create a mask for the color range
     mask = cv2.inRange(image, lower_bound, upper_bound)

{ok-script-0.0.99 → ok-script-0.0.100}/ok/config/Config.py

@@ -7,7 +7,9 @@ logger = get_logger(__name__)
 
 
 class Config(dict):
-    def __init__(self, default, folder, name, validator=None):
+    config_folder = 'configs'
+
+    def __init__(self, default, name, folder=None, validator=None):
         """
         Initialize the Config object.
 
@@ -18,6 +20,8 @@ class Config(dict):
         """
         self.default = default
         self.validator = validator
+        if folder is None:
+            folder = self.config_folder
         self.config_file = get_path_relative_to_exe(folder, f"{name}.json")
 
         # Read the config file, if it exists, otherwise use default

{ok-script-0.0.99 → ok-script-0.0.100}/ok/feature/CompressCoco.py

@@ -1,6 +1,5 @@
 import json
 import os
-import sys
 
 import cv2
 import numpy as np
@@ -10,8 +9,8 @@ from PIL.PngImagePlugin import PngInfo
 from ok.feature.FeatureSet import read_from_json
 
 
-def compress_coco(coco_json, canny_upper, canny_lower) -> None:
-    feature_dict, *_ = read_from_json(coco_json, canny_lower=canny_lower, canny_upper=canny_upper)
+def compress_coco(coco_json) -> None:
+    feature_dict, *_ = read_from_json(coco_json)
     with open(coco_json, 'r') as file:
         image_dict = {}
         data = json.load(file)
@@ -46,14 +45,22 @@ def compress_coco(coco_json, canny_upper, canny_lower) -> None:
                 h, w = feature.mat.shape[:2]
                 background[y:y + h, x:x + w] = feature.mat
 
-            # Add metadata
-            metadata = {
-                "ok_compressed": "1"
-            }
-
             # Save the image with metadata
             save_image_with_metadata(background, image_path)
 
+        replaced = False
+        for image in data['images']:
+            image['file_name'], replaced = replace_extension(image['file_name'])
+
+        if replaced:
+            with open(coco_json, 'w') as json_file:
+                json.dump(data, json_file, indent=4)
+
+
+def replace_extension(filename):
+    if filename.endswith('.jpg'):
+        return filename[:-4] + '.png', True
+
 
 def save_image_with_metadata(image, image_path):
     # Convert OpenCV image (numpy array) to PIL Image
@@ -65,11 +72,9 @@ def save_image_with_metadata(image, image_path):
     metadata.add_text('ok_compressed', '1')
     metadata.add_text("Author", "ok_compress")
     metadata.add_text("Description", "This is a sample image")
-
+    new_path, replaced = replace_extension(image_path)
+    if replaced:
+        os.remove(image_path)
     # Save the image with metadata
-    pil_image.save(image_path, 'PNG', optimize=True, pnginfo=metadata)
-
-
-if __name__ == '__main__':
-    json_file = sys.argv[1]
-    compress_coco(json_file)
+    pil_image.save(new_path, 'PNG', optimize=True, pnginfo=metadata)
+    return image_path

{ok-script-0.0.99 → ok-script-0.0.100}/ok/feature/FeatureSet.py

@@ -41,8 +41,6 @@ class FeatureSet:
         # Process images and annotations
         self.width = 0
         self.height = 0
-        self.canny_lower = 50
-        self.canny_higher = 150
         if default_threshold == 0:
             default_threshold = 0.95
         self.default_threshold = default_threshold
@@ -69,14 +67,12 @@ class FeatureSet:
             width (int): Target width for scaling images.
             height (int): Target height for scaling images.
         """
-        self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height,
-                                                                      self.canny_lower, self.canny_higher)
+        self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height)
         if self.debug and not compressed:
             from ok.feature.CompressCoco import compress_coco
             logger.info(f'coco not compressed try to compress the COCO dataset')
-            compress_coco(self.coco_json, self.canny_lower, self.canny_higher)
-            self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height,
-                                                                          self.canny_lower, self.canny_higher)
+            compress_coco(self.coco_json)
+            self.feature_dict, self.box_dict, compressed = read_from_json(self.coco_json, self.width, self.height)
 
     def get_box_by_name(self, mat, category_name: str) -> Box:
         self.check_size(mat)
@@ -106,10 +102,10 @@ class FeatureSet:
 
     def find_one(self, mat: np.ndarray, category_name: str, horizontal_variance: float = 0,
                  vertical_variance: float = 0,
-                 threshold=0, use_gray_scale=False) -> Box:
+                 threshold=0, use_gray_scale=False, canny_lower=0, canny_higher=0) -> Box:
         boxes = self.find_feature(mat, category_name, horizontal_variance=horizontal_variance,
                                   vertical_variance=vertical_variance, threshold=threshold,
-                                  use_gray_scale=use_gray_scale)
+                                  use_gray_scale=use_gray_scale, canny_lower=canny_lower, canny_higher=canny_higher)
         if len(boxes) > 1:
             logger.warning(f"find_one:found too many {len(boxes)} return first", file=sys.stderr)
         if len(boxes) >= 1:
@@ -117,7 +113,7 @@ class FeatureSet:
 
     def find_feature(self, mat: np.ndarray, category_name: str, horizontal_variance: float = 0,
                      vertical_variance: float = 0, threshold: float = 0, use_gray_scale: bool = False, x=-1, y=-1,
-                     to_x=-1, to_y=-1, width=-1, height=-1, box=None) -> List[Box]:
+                     to_x=-1, to_y=-1, width=-1, height=-1, box=None, canny_lower=0, canny_higher=0) -> List[Box]:
         """
         Find a feature within a given variance.
 
@@ -168,17 +164,19 @@ class FeatureSet:
 
         search_area = mat[search_y1:search_y2, search_x1:search_x2, :3]
         # Crop the search area from the image
-        template = feature.mat
+
         if use_gray_scale:
             search_area = cv2.cvtColor(search_area, cv2.COLOR_BGR2GRAY)
-            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)
-        elif category_name.startswith('gray_'):
+            if len(feature.mat.shape) != 2:
+                feature.mat = cv2.cvtColor(feature.mat, cv2.COLOR_BGR2GRAY)
+        if canny_lower != 0 and canny_higher != 0:
             search_area = cv2.cvtColor(search_area, cv2.COLOR_BGR2GRAY)
+            search_area = cv2.Canny(search_area, canny_lower, canny_higher)
+            if len(feature.mat.shape) != 2:
+                feature.mat = cv2.cvtColor(feature.mat, cv2.COLOR_BGR2GRAY)
+                feature.mat = cv2.Canny(feature.mat, canny_lower, canny_higher)
 
-        result = cv2.matchTemplate(search_area, template, cv2.TM_CCOEFF_NORMED)
+        result = cv2.matchTemplate(search_area, feature.mat, cv2.TM_CCOEFF_NORMED)
 
         # Define a threshold for acceptable matches
         locations = filter_and_sort_matches(result, threshold, feature_width, feature_height)
@@ -198,7 +196,7 @@ class FeatureSet:
         return result
 
 
-def read_from_json(coco_json, width=-1, height=-1, canny_lower=50, canny_upper=150):
+def read_from_json(coco_json, width=-1, height=-1):
     feature_dict = {}
     box_dict = {}
     ok_compressed = None
@@ -255,18 +253,17 @@ def read_from_json(coco_json, width=-1, height=-1, canny_lower=50, canny_upper=1
             if category_name in feature_dict:
                 raise ValueError(f"Multiple boxes found for category {category_name}")
             if not category_name.startswith('box_'):
-                if ok_compressed:
-                    if category_name.startswith('edge_'):
-                        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-                        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)
             box_dict[category_name] = Box(x, y, image.shape[1], image.shape[0], name=category_name)
 
     return feature_dict, box_dict, ok_compressed
 
 
+def replace_extension(filename):
+    if filename.endswith('.jpg'):
+        return filename[:-4] + '.png', True
+
+
 def filter_and_sort_matches(result, threshold, w, h):
     # Find all matches above the confidence threshold
     loc = np.where(result >= threshold)

{ok-script-0.0.99 → ok-script-0.0.100}/ok/feature/FindFeature.py

@@ -11,9 +11,11 @@ class FindFeature:
         self.executor = None
 
     def find_feature(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
-                     use_gray_scale=False, x=-1, y=-1, to_x=-1, to_y=-1, width=-1, height=-1, box=None) -> List[Box]:
+                     use_gray_scale=False, x=-1, y=-1, to_x=-1, to_y=-1, width=-1, height=-1, box=None, canny_lower=0,
+                     canny_higher=0) -> List[Box]:
         return self.feature_set.find_feature(self.executor.frame, feature_name, horizontal_variance, vertical_variance,
-                                             threshold, use_gray_scale, x, y, to_x, to_y, width, height, box=box)
+                                             threshold, use_gray_scale, x, y, to_x, to_y, width, height, box=box,
+                                             canny_lower=canny_lower, canny_higher=canny_higher)
 
     def get_box_by_name(self, name):
         return self.feature_set.get_box_by_name(self.executor.frame, name)
@@ -43,9 +45,11 @@ class FindFeature:
 
     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=None, raise_if_not_found=True):
+                           time_out=0, pre_action=None, post_action=None, box=None, raise_if_not_found=True,
+                           use_gray_scale=False, canny_lower=0, canny_higher=0):
         box = self.wait_until(
-            lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold, box=box),
+            lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold, box=box,
+                                  use_gray_scale=use_gray_scale, canny_lower=canny_lower, canny_higher=canny_higher),
             time_out,
             pre_action,
             post_action, raise_if_not_found)
@@ -55,9 +59,10 @@ class FindFeature:
         return False
 
     def find_one(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
-                 use_gray_scale=False, box=None) -> Box:
+                 use_gray_scale=False, box=None, canny_lower=0, canny_higher=0) -> Box:
         boxes = self.find_feature(feature_name, horizontal_variance, vertical_variance, threshold,
-                                  use_gray_scale=use_gray_scale, box=box)
+                                  use_gray_scale=use_gray_scale, box=box, canny_lower=canny_lower,
+                                  canny_higher=canny_higher)
         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.99 → ok-script-0.0.100}/ok/firebase/Analytics.py

@@ -83,7 +83,7 @@ class Analytics:
     @property
     def client_id(self):
         if self._config is None:
-            self._config = Config({'client_id': ''}, self.app_config.get("config_folder") or "config", 'statistics')
+            self._config = Config({'client_id': ''}, 'statistics')
         if not self._config.get('client_id'):
             self._config['client_id'] = self.get_unique_client_id()
         else:

{ok-script-0.0.99 → ok-script-0.0.100}/ok/gui/MainWindow.py

@@ -25,26 +25,26 @@ class Communicate(QObject):
 class MainWindow(MSFluentWindow):
     def __init__(self, config, icon, title, version, debug=False, about=None, exit_event=None):
         super().__init__()
+        logger.info('main window __init__')
         self.original_layout = None
         self.exit_event = exit_event
         self.start_tab = StartTab()
-        self.first_tab = None
         self.onetime_tab = None
         self.trigger_tab = None
         self.emulator_starting_dialog = None
 
+        self.addSubInterface(self.start_tab, FluentIcon.PLAY, self.tr('Capture'))
+
         if len(ok.gui.executor.onetime_tasks) > 0:
             self.onetime_tab = OneTimeTaskTab()
-            self.first_tab = self.onetime_tab
+            self.first_task_tab = self.onetime_tab
             self.addSubInterface(self.onetime_tab, FluentIcon.BOOK_SHELF, self.tr('Tasks'))
         if len(ok.gui.executor.trigger_tasks) > 0:
             self.trigger_tab = TriggerTaskTab()
-            if self.first_tab is None:
-                self.first_tab = self.trigger_tab
+            if self.first_task_tab is None:
+                self.first_task_tab = self.trigger_tab
             self.addSubInterface(self.trigger_tab, FluentIcon.ROBOT, self.tr('Triggers'))
 
-        self.addSubInterface(self.start_tab, FluentIcon.PLAY, self.tr('Capture'))
-
         if debug:
             debug_tab = DebugTab(config, exit_event)
             self.addSubInterface(debug_tab, FluentIcon.DEVELOPER_TOOLS, self.tr('Debug'),
@@ -73,13 +73,14 @@ class MainWindow(MSFluentWindow):
         self.tray.setContextMenu(menu)
         self.tray.show()
 
-        if ok.gui.device_manager.config.get("preferred") is None or self.onetime_tab is None:
-            self.switchTo(self.start_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)
         communicate.config_validation.connect(self.config_validation)
         communicate.starting_emulator.connect(self.starting_emulator)
+        logger.info('main window __init__ done')
 
     def starting_emulator(self, done, error, seconds_left):
         if error:
@@ -92,7 +93,6 @@ class MainWindow(MSFluentWindow):
             if self.emulator_starting_dialog is None:
                 self.emulator_starting_dialog = StartLoadingDialog(seconds_left,
                                                                    self)
-
             else:
                 self.emulator_starting_dialog.set_seconds_left(seconds_left)
             self.emulator_starting_dialog.show()
@@ -133,9 +133,7 @@ class MainWindow(MSFluentWindow):
     def navigate_tab(self, index):
         if index == "start":
             self.switchTo(self.start_tab)
-        elif index == "first":
-            self.switchTo(self.first_tab)
-        elif index == "first" and self.onetime_tab is not None:
+        elif index == "onetime" and self.onetime_tab is not None:
             self.switchTo(self.onetime_tab)
         elif index == "trigger" and self.trigger_tab is not None:
             self.switchTo(self.trigger_tab)

{ok-script-0.0.99 → ok-script-0.0.100}/ok/gui/debug/DebugTab.py

@@ -28,10 +28,9 @@ class DebugTab(Tab):
         super().__init__()
 
         self.config = Config({'target_task': "", 'target_images': [], 'target_function': ""},
-                             app_config.get('config_folder'), 'debug')
+                             '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')
+                                         'level': 'ALL', 'show': True}, 'log_window')
         tool_widget = QWidget()
         layout = FlowLayout(tool_widget, False)
 

{ok-script-0.0.99 → ok-script-0.0.100}/ok/gui/debug/FrameWidget.py

@@ -33,7 +33,7 @@ class FrameWidget(QWidget):
             relative = self.mapFromGlobal(QPoint(x / self.scaling, y / self.scaling))
             if self._mouse_position != relative and relative.x() > 0 and relative.y() > 0:
                 self._mouse_position = relative
-                self.update()
+            self.update()
         except Exception as e:
             logger.warning(f'GetCursorPos exception {e}')
 

{ok-script-0.0.99 → ok-script-0.0.100}/ok/gui/start/StartCard.py

@@ -46,7 +46,7 @@ class StartCard(SettingCard):
             elif ok.gui.executor.active_trigger_task_count():
                 communicate.tab.emit("trigger")
             else:
-                communicate.tab.emit("first")
+                communicate.tab.emit("start")
             self.status_bar.show()
 
     def clicked(self):

{ok-script-0.0.99 → ok-script-0.0.100}/ok/ocr/OCR.py

@@ -18,7 +18,7 @@ class OCR:
     def ocr(self, x=0, y=0, to_x=1, to_y=1, match: str | List[str] | Pattern[str] | List[Pattern[str]] | None = None,
             width=0, height=0, box: Box = None, name=None,
             threshold=0,
-            frame=None, target_height=0):
+            frame=None, target_height=0, use_grayscale=False):
         if hasattr(self, 'paused') and self.paused:
             self.sleep(1)
         if threshold == 0:
@@ -42,6 +42,8 @@ class OCR:
                 image = image[y:y + h, x:x + w]
                 if not box.name and match:
                     box.name = str(match)
+            if use_grayscale:
+                image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
             image, scale_factor = resize_image(image, original_height, target_height)
 

{ok-script-0.0.99 → ok-script-0.0.100}/ok/task/BaseTask.py

@@ -136,8 +136,8 @@ class BaseTask(ExecutorOperation):
     def info_add(self, key, count=1):
         self.info[key] = self.info.get(key, 0) + count
 
-    def load_config(self, folder):
-        self.config = Config(self.default_config, folder, self.__class__.__name__, self.validate)
+    def load_config(self):
+        self.config = Config(self.default_config, self.__class__.__name__, validator=self.validate)
 
     def validate(self, key, value):
         message = self.validate_config(key, value)
@@ -168,5 +168,5 @@ class BaseTask(ExecutorOperation):
     def set_executor(self, executor):
         self.executor = executor
         self.feature_set = executor.feature_set
-        self.load_config(executor.config_folder)
+        self.load_config()
         self.on_create()

{ok-script-0.0.99 → ok-script-0.0.100}/ok/task/ExecutorOperation.py

@@ -1,3 +1,4 @@
+import time
 from typing import List
 
 from ok.color.Color import calculate_color_percentage
@@ -7,6 +8,7 @@ from ok.gui.Communicate import communicate
 
 class ExecutorOperation:
     executor = None
+    last_click_time = 0
 
     def exit_is_set(self):
         return self.executor.exit_event.is_set()
@@ -32,13 +34,29 @@ class ExecutorOperation:
     def is_scene(self, the_scene):
         return isinstance(self.executor.current_scene, the_scene)
 
-    def click(self, x: int | Box = -1, y=-1, move_back=False, name=None):
+    def reset_scene(self):
+        self.executor.reset_scene()
+
+    def click(self, x: int | Box = -1, y=-1, move_back=False, name=None, interval=-1):
         if isinstance(x, Box):
-            self.click_box(x, move_back=move_back)
-            return
+            return self.click_box(x, move_back=move_back)
+        if not self.check_interval(interval):
+            self.executor.reset_scene()
+            return False
         communicate.emit_draw_box("click", [Box(max(0, x - 10), max(0, y - 10), 20, 20, name="click")], "green")
         self.executor.reset_scene()
         self.executor.interaction.click(x, y, move_back, name=name)
+        return True
+
+    def check_interval(self, interval):
+        if interval <= 0:
+            return True
+        now = time.time()
+        if now - self.last_click_time < interval:
+            return False
+        else:
+            self.last_click_time = now
+            return True
 
     def mouse_down(self, x=-1, y=-1, name=None):
         frame = self.executor.nullable_frame()
@@ -52,8 +70,8 @@ class ExecutorOperation:
         communicate.emit_draw_box("mouse_up", self.box_of_screen(0.5, 0.5, width=0.01, height=0.01, name="click"),
                                   "green",
                                   frame)
-        self.executor.reset_scene()
         self.executor.interaction.mouse_up()
+        self.executor.reset_scene()
 
     def right_click(self, x=-1, y=-1, move_back=False, name=None):
         communicate.emit_draw_box("right_click", [Box(max(0, x - 10), max(0, y - 10), 20, 20, name="right_click")],
@@ -75,8 +93,8 @@ class ExecutorOperation:
         self.executor.interaction.swipe(from_x, from_y, to_x, to_y, ms)
         self.sleep(duration)
 
-    def screenshot(self, name=None):
-        communicate.screenshot.emit(self.frame, name)
+    def screenshot(self, name=None, frame=None):
+        communicate.screenshot.emit(self.frame if frame is None else frame, name)
 
     def click_box_if_name_match(self, boxes, names, relative_x=0.5, relative_y=0.5):
         """
@@ -158,12 +176,16 @@ class ExecutorOperation:
     def sleep(self, timeout):
         self.executor.sleep(timeout)
 
-    def send_key(self, key, down_time=0.02):
+    def send_key(self, key, down_time=0.02, interval=-1):
+        if not self.check_interval(interval):
+            self.executor.reset_scene()
+            return False
         frame = self.executor.nullable_frame()
         communicate.emit_draw_box("send_key", [Box(max(0, 0), max(0, 0), 20, 20, name="send_key_" + str(key))], "green",
                                   frame)
         self.executor.reset_scene()
         self.executor.interaction.send_key(key, down_time)
+        return True
 
     def send_key_down(self, key):
         self.executor.reset_scene()

{ok-script-0.0.99 → ok-script-0.0.100}/ok/task/TaskExecutor.py

@@ -257,8 +257,10 @@ class TaskExecutor:
 
     def execute(self):
         logger.info(f"start execute")
-        last_frame_time = 0
         while not self.exit_event.is_set():
+            if self.paused:
+                logger.info(f'executor is paused sleep')
+                self.sleep(1)
             task, cycled = self.next_task()
             if not task:
                 time.sleep(1)

{ok-script-0.0.99 → ok-script-0.0.100}/ok/util/json.py

@@ -17,11 +17,7 @@ def read_json_file(file_path) -> dict | None:
 
 
 def write_json_file(file_path, data):
-    try:
-        ensure_dir_for_file(file_path)
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(data, f, indent=4, ensure_ascii=False)
-        return True
-    except Exception as e:
-        print(f"Error writing to JSON file: {e}")
-        return False
+    ensure_dir_for_file(file_path)
+    with open(file_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)
+    return True

{ok-script-0.0.99 → ok-script-0.0.100}/ok_script.egg-info/PKG-INFO

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