ok-script 0.0.7__py3-none-any.whl

autohelper/stats/StreamStats.py

@@ -0,0 +1,34 @@
+import time
+
+import numpy as np
+
+
+class StreamStats:
+    last_frame_time = 0
+    sleep_padding = 0
+
+    def __init__(self, max_size=100):
+        self.max_size = max_size
+        self.data = []
+
+    def add_frame(self):
+        now = time.time()
+        if self.last_frame_time != 0:
+            if len(self.data) >= self.max_size:
+                self.data.pop(0)
+            self.data.append(int((now - self.last_frame_time - self.sleep_padding) * 1000))
+        self.last_frame_time = now
+        self.sleep_padding = 0
+
+    def add_sleep(self, seconds):
+        self.sleep_padding += seconds
+
+    def mean(self):
+        """Calculate and return the mean of the numbers in the stream."""
+        return round(np.mean(self.data)) if self.data else 0
+
+    def percentile(self, percentile):
+        """Calculate and return the specified percentile of the numbers in the stream."""
+        if not self.data:
+            return 0
+        return np.percentile(self.data, percentile)

autohelper/task/BaseTask.py

@@ -0,0 +1,109 @@
+import time
+
+from autohelper.config.Config import Config
+from autohelper.config.InfoDict import InfoDict
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+from autohelper.task.ExecutorOperation import ExecutorOperation
+
+logger = get_logger(__name__)
+
+
+class BaseTask(ExecutorOperation):
+    _done = False
+
+    def __init__(self):
+        self.logger = get_logger(self.__class__.__name__)
+        self.name = self.__class__.__name__
+        self.success_count = 0
+        self.error_count = 0
+        self.enabled = True
+        self.running = False
+        self.config = None
+        self.info = InfoDict()
+        self.default_config = {}
+        self.last_execute_time = 0
+
+    def log_info(self, message, notify=False):
+        self.logger.info(message)
+        self.info_set("Log", message)
+        if notify:
+            self.notification(message)
+        communicate.task_info.emit()
+
+    def log_error(self, message, exception=None, notify=False):
+        self.logger.error(message, exception)
+        if exception is not None:
+            message += exception.args[0]
+        self.info_set("Error", message)
+        if notify:
+            self.notification(message)
+        communicate.task_info.emit()
+
+    @staticmethod
+    def notification(message, title=None):
+        communicate.notification.emit(title, message)
+
+    def info_clear(self):
+        self.info.clear()
+
+    def info_incr(self, key, by=1):
+        # If the key is in the dictionary, get its value. If not, return 0.
+        value = self.info.get(key, 0)
+        # Increment the value
+        value += by
+        # Store the incremented value back in the dictionary
+        self.info[key] = value
+
+    def info_add_to_list(self, key, item):
+        value = self.info.get(key, [])
+        if isinstance(item, list):
+            value += item
+        else:
+            value.append(item)
+        self.info[key] = value
+
+    def info_set(self, key, value):
+        self.info[key] = value
+
+    def can_run(self):
+        return self.enabled and not self._done
+
+    def load_config(self, folder):
+        self.config = Config(self.default_config, folder, self.__class__.__name__)
+
+    def enable(self):
+        self.enabled = True
+        self.info_clear()
+        self.set_done(False)
+        communicate.tasks.emit()
+
+    def disable(self):
+        self.enabled = False
+        communicate.tasks.emit()
+
+    def get_status(self):
+        if not self.enabled:
+            return "Disabled"
+        elif self.done:
+            return "Done"
+        elif self.enabled and self.executor.paused:
+            return "Paused"
+        elif self.running or self.enabled and time.time() - self.last_execute_time < 3:
+            return "Running"
+        else:
+            return "In Queue"
+
+    def run_frame(self):
+        pass
+
+    def reset(self):
+        self._done = False
+        pass
+
+    @property
+    def done(self):
+        return self._done
+
+    def set_done(self, done=True):
+        self._done = done

autohelper/task/ExecutorOperation.py

@@ -0,0 +1,119 @@
+from autohelper.feature.Box import Box, find_box_by_name
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ExecutorOperation:
+    executor = None
+
+    def box_in_horizontal_center(self, box, off_percent=0.02):
+        center = self.executor.method.width / 2
+        left = center - box.x
+        right = box.x + box.width - center
+        if left > 0 and right > 0 and abs(left - right) / box.width < off_percent:
+            return True
+        else:
+            return False
+
+    def is_scene(self, the_scene):
+        return isinstance(self.executor.current_scene, the_scene)
+
+    def click(self, x, y):
+        self.executor.reset_scene()
+        self.executor.interaction.click(x, y)
+
+    def click_box_if_name_match(self, boxes, names, relative_x=0.5, relative_y=0.5):
+        """
+        Clicks on a box from a list of boxes if the box's name matches one of the specified names.
+        The box to click is selected based on the order of names provided, with priority given
+        to the earliest match in the names list.
+
+        Parameters:
+        - boxes (list): A list of box objects. Each box object must have a 'name' attribute.
+        - names (str or list): A string or a list of strings representing the name(s) to match against the boxes' names.
+        - relative_x (float, optional): The relative X coordinate within the box to click,
+                                        as a fraction of the box's width. Defaults to 0.5 (center).
+        - relative_y (float, optional): The relative Y coordinate within the box to click,
+                                        as a fraction of the box's height. Defaults to 0.5 (center).
+
+        Returns:
+        - box: the matched box
+
+        The method attempts to find and click on the highest-priority matching box. If no matches are found,
+        or if there are no boxes, the method returns False. This operation is case-sensitive.
+        """
+        to_click = find_box_by_name(boxes, names)
+        if to_click is not None:
+            logger.info(f"click_box_if_name_match found {to_click}")
+            self.click_box(to_click, relative_x, relative_y)
+            return to_click
+
+    def box_of_screen(self, x, y, width, height, name=None):
+        if name is None:
+            name = f"{x} {y} {width} {height}"
+        return Box(int(x * self.executor.method.width), int(y * self.executor.method.height),
+                   int(width * self.executor.method.width), int(height * self.executor.method.height),
+                   name=name)
+
+    def click_relative(self, x, y):
+        self.executor.reset_scene()
+        self.executor.interaction.click_relative(x, y)
+
+    @property
+    def height(self):
+        return self.executor.method.height
+
+    @property
+    def width(self):
+        return self.executor.method.width
+
+    def move_relative(self, x, y):
+        self.executor.reset_scene()
+        self.executor.interaction.move_relative(x, y)
+
+    def click_box(self, box, relative_x=0.5, relative_y=0.5, raise_if_not_found=True):
+        self.executor.reset_scene()
+        if isinstance(box, list):
+            if len(box) > 0:
+                box = box[0]
+            else:
+                logger.error(f"No box")
+        if box is None:
+            logger.error(f"click_box box is None")
+            if raise_if_not_found:
+                raise Exception(f"click_box box is None")
+            return
+        self.executor.interaction.click_box(box, relative_x, relative_y)
+
+    def wait_scene(self, scene_type=None, time_out=0, pre_action=None, post_action=None):
+        return self.executor.wait_scene(scene_type, time_out, pre_action, post_action)
+
+    def sleep(self, timeout):
+        self.executor.sleep(timeout)
+
+    def send_key(self, key, down_time=0.02):
+        self.executor.interaction.send_key(key, down_time)
+
+    def wait_until(self, condition, time_out=0, pre_action=None, post_action=None):
+        return self.executor.wait_condition(condition, time_out, pre_action, post_action)
+
+    def wait_click_box(self, condition, time_out=0, pre_action=None, post_action=None, raise_if_not_found=True):
+        target = self.wait_until(condition, time_out, pre_action, post_action)
+        self.click_box(target, raise_if_not_found=raise_if_not_found)
+
+    def next_frame(self):
+        return self.executor.next_frame()
+
+    @property
+    def scene(self):
+        return self.executor.current_scene
+
+    @property
+    def frame(self):
+        return self.executor.frame
+
+    @staticmethod
+    def draw_boxes(feature_name, boxes, color="red"):
+        communicate.draw_box.emit(feature_name, boxes, color)

autohelper/task/FindFeatureTask.py

@@ -0,0 +1,6 @@
+from autohelper.feature.FindFeature import FindFeature
+from autohelper.task.BaseTask import BaseTask
+
+
+class FindFeatureTask(BaseTask, FindFeature):
+    pass

autohelper/task/TaskExecutor.py

@@ -0,0 +1,249 @@
+import threading
+import time
+import traceback
+
+from autohelper.capture.adb.DeviceManager import DeviceManager
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+from autohelper.scene.Scene import Scene
+from autohelper.stats.StreamStats import StreamStats
+
+logger = get_logger(__name__)
+
+
+class TaskDisabledException(Exception):
+    pass
+
+
+class TaskExecutor:
+    current_scene: Scene | None = None
+    last_scene: Scene | None = None
+    frame_stats = StreamStats()
+    _frame = None
+    paused = True
+    ocr = None
+    pause_start = time.time()
+    pause_end_time = time.time()
+
+    def __init__(self, device_manager: DeviceManager,
+                 wait_until_timeout=10, wait_until_before_delay=1, wait_until_check_delay=1,
+                 exit_event=threading.Event(), tasks=[], scenes=[], feature_set=None, ocr=None, config_folder=None):
+        self.device_manager = device_manager
+        self.feature_set = feature_set
+        self.wait_until_check_delay = wait_until_check_delay
+        self.wait_until_before_delay = wait_until_before_delay
+        self.wait_scene_timeout = wait_until_timeout
+        self.exit_event = exit_event
+        self.ocr = ocr
+        self.current_task = None
+        self.tasks = tasks
+        self.scenes = scenes
+        self.config_folder = config_folder or "config"
+        for scene in self.scenes:
+            scene.executor = self
+            scene.feature_set = self.feature_set
+        for task in self.tasks:
+            task.executor = self
+            task.feature_set = self.feature_set
+            task.load_config(self.config_folder)
+        self.thread = threading.Thread(target=self.execute, name="TaskExecutor")
+        self.thread.start()
+
+    @property
+    def interaction(self):
+        return self.device_manager.interaction
+
+    @property
+    def method(self):
+        return self.device_manager.capture_method
+
+    def next_frame(self):
+        self.reset_scene()
+        start = time.time()
+        while not self.exit_event.is_set():
+            if self.method and self.interaction.should_capture():
+                self._frame = self.method.get_frame()
+                if self._frame is not None:
+                    height, width = self._frame.shape[:2]
+                    if height <= 0 or width <= 0:
+                        logger.warning(f"captured wrong size frame: {width}x{height}")
+                        self._frame = None
+                    communicate.frame.emit(self._frame)
+                    return self._frame
+            self.sleep(0.001)
+            if time.time() - start > self.wait_scene_timeout:
+                return None
+
+    @property
+    def frame(self):
+        if self._frame is None:
+            return self.next_frame()
+        else:
+            return self._frame
+
+    def sleep(self, timeout):
+        """
+        Sleeps for the specified timeout, checking for an exit event every 100ms, with adjustments to prevent oversleeping.
+
+        :param timeout: The total time to sleep in seconds.
+        """
+        self.frame_stats.add_sleep(timeout)
+        self.pause_end_time = time.time() + timeout
+        while True:
+            if self.exit_event.is_set():
+                logger.info("Exit event set. Exiting early.")
+                return
+            if self.current_task and not self.current_task.enabled:
+                raise TaskDisabledException()
+            if not (self.paused or not self.interaction.should_capture()):
+                to_sleep = self.pause_end_time - time.time()
+                if to_sleep <= 0:
+                    return
+            time.sleep(0.001)
+
+    def pause(self):
+        self.paused = True
+        self.pause_start = time.time()
+        communicate.executor_paused.emit(self.paused)
+        communicate.tasks.emit()
+
+    def start(self):
+        can_run = False
+        for task in self.tasks:
+            if task.can_run():
+                can_run = True
+                break
+        if not can_run:
+            return False
+        self.pause_end_time += self.pause_start - time.time()
+        self.paused = False
+        communicate.executor_paused.emit(self.paused)
+        communicate.tasks.emit()
+        return True
+
+    def wait_scene(self, scene_type, time_out, pre_action, post_action):
+        return self.wait_condition(lambda: self.detect_scene(scene_type), time_out, pre_action, post_action)
+
+    def wait_condition(self, condition, time_out, pre_action, post_action):
+        self.sleep(self.wait_until_before_delay)
+        start = time.time()
+        if time_out == 0:
+            time_out = self.wait_scene_timeout
+        while not self.exit_event.is_set():
+            self.reset_scene()
+            if pre_action is not None:
+                pre_action()
+            self._frame = self.next_frame()
+            if self._frame is not None:
+                result = condition()
+                self.add_frame_stats()
+                result_str = list_or_obj_to_str(result)
+                if result:
+                    logger.debug(f"found result {result_str}")
+                    self.sleep(self.wait_until_check_delay)
+                    return result
+            if post_action is not None:
+                post_action()
+            if time.time() - start > time_out:
+                logger.info(f"wait_until timeout {condition} {time_out} seconds")
+                break
+            self.sleep(0.01)
+        return None
+
+    def reset_scene(self):
+        self._frame = None
+        self.last_scene = self.current_scene
+        self.current_scene = None
+
+    def execute(self):
+        logger.info(f"start execute")
+        while not self.exit_event.is_set():
+            self._frame = self.next_frame()
+            start = time.time()
+            if self._frame is not None:
+                self.detect_scene()
+                task_executed = 0
+                for index, task in enumerate(self.tasks):
+                    if task.done or not task.enabled:
+                        continue
+                    self.current_task = task
+                    task.running = True
+                    task.last_execute_time = start
+                    try:
+                        result = task.run_frame()
+                        if result is not None:
+                            if result:
+                                task.success_count += 1
+                            else:
+                                task.error_count += 1
+                    except TaskDisabledException:
+                        logger.info(f"{task.name} is disabled, breaking")
+                    except Exception as e:
+                        traceback.print_exc()
+                        stack_trace_str = traceback.format_exc()
+                        logger.error(f"{task.name} exception: {e}, traceback: {stack_trace_str}")
+                        task.error_count += 1
+                    self.current_task = None
+                    task.running = False
+                    processing_time = time.time() - start
+                    task_executed += 1
+                    if processing_time > 0.5:
+                        logger.debug(
+                            f"{task.__class__.__name__} taking too long get new frame {processing_time} {task_executed} {len(self.tasks)}")
+                        self.next_frame()
+                        start = time.time()
+
+                # if task_executed == 0:
+                #     self.pause()
+                self.add_frame_stats()
+                self.sleep(0.001)
+
+    def add_frame_stats(self):
+        self.frame_stats.add_frame()
+        mean = self.frame_stats.mean()
+        if mean > 0:
+            communicate.frame_time.emit(mean)
+            communicate.fps.emit(round(1000 / mean))
+            scene = "None"
+            if self.current_scene is not None:
+                scene = self.current_scene.name or self.current_scene.__class__.__name__
+            communicate.scene.emit(scene)
+
+    def latest_scene(self):
+        return self.current_scene or self.last_scene
+
+    def detect_scene(self, scene_type=None):
+        latest_scene = self.latest_scene()
+        if latest_scene is not None:
+            # detect the last scene optimistically
+            if latest_scene.detect(self._frame):
+                self.current_scene = latest_scene
+                return latest_scene
+        for scene in self.scenes:
+            if scene_type is not None and not isinstance(scene, scene_type):
+                continue
+            if scene != latest_scene:
+                if scene.detect(self._frame):
+                    self.current_scene = scene
+                    logger.debug(f"TaskExecutor: scene changed {scene.__class__.__name__}")
+                    return scene
+        if self.current_scene is not None:
+            logger.debug(f"TaskExecutor: scene changed to None")
+            self.current_scene = None
+        return self.current_scene
+
+    def stop(self):
+        self.exit_event.set()
+
+    def wait_until_done(self):
+        self.thread.join()
+
+
+def list_or_obj_to_str(val):
+    if val is not None:
+        if isinstance(val, list):
+            return ', '.join(str(obj) for obj in val)
+        else:
+            return str(val)
+    else:
+        return None

autohelper/util/json.py

@@ -0,0 +1,27 @@
+import json
+import os
+
+from autohelper.util.path import ensure_dir_for_file
+
+
+def read_json_file(file_path) -> dict | None:
+    if not os.path.exists(file_path):
+        return None
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return data
+    except json.JSONDecodeError:
+        return 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

autohelper/util/list.py

@@ -0,0 +1,2 @@
+def get_first_item(lst, default=None):
+    return next(iter(lst), default) if lst is not None else default

autohelper/util/path.py

@@ -0,0 +1,37 @@
+import os
+import sys
+
+
+def get_path_relative_to_exe(*files):
+    if getattr(sys, 'frozen', False):
+        # The application is running as a bundled executable
+        application_path = os.path.abspath(sys.executable)
+    else:
+        # The application is running as a Python script
+        application_path = os.path.abspath(sys.argv[0])
+    the_dir = os.path.dirname(application_path)
+
+    # Join the directory with the file paths
+    path = os.path.join(the_dir, *files)
+
+    # Normalize the path
+    normalized_path = os.path.normpath(path)
+
+    return normalized_path
+
+
+def ensure_dir_for_file(file_path):
+    # Extract the directory from the file path
+    directory = os.path.dirname(file_path)
+
+    # Check if the directory exists
+    if not os.path.exists(directory):
+        # If the directory does not exist, create it (including any intermediate directories)
+        os.makedirs(directory)
+
+
+def get_path_in_package(base, file):
+    the_dir = os.path.dirname(os.path.realpath(base))
+
+    # Get the path of the file relative to the script
+    return os.path.join(the_dir, file)

autohelper/util/thread.py

@@ -0,0 +1,12 @@
+import threading
+
+
+def run_in_new_thread(func):
+    # Create a new thread and run the function in it
+    thread = threading.Thread(target=func)
+
+    # Start the new thread
+    thread.start()
+
+    # Return the thread
+    return thread

autohelper/util/win32_process.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import ctypes
+import msvcrt
+import os
+from typing import Union
+
+
+def all_pids() -> list[int]:
+    pidbuffer = 512
+    bytes_written = ctypes.c_uint32()
+    while True:
+        pids = (ctypes.c_uint32 * pidbuffer)()
+        bufsize = ctypes.sizeof(pids)
+        if ctypes.windll.kernel32.K32EnumProcesses(pids, bufsize, ctypes.byref(bytes_written)) == 0:
+            return []
+        if bytes_written.value < bufsize:
+            break
+        pidbuffer *= 2
+    pidcount = bytes_written.value // 4
+    return list(pids[:pidcount])
+
+
+NtQuerySystemInformation = ctypes.windll.ntdll.NtQuerySystemInformation
+NtQuerySystemInformation.argtypes = (ctypes.c_int32, ctypes.c_void_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32))
+SystemProcessIdInformation = 0x58
+
+
+class UNICODE_STRING(ctypes.Structure):
+    _fields_ = [
+        ('Length', ctypes.c_ushort),
+        ('MaximumLength', ctypes.c_ushort),
+        ('Buffer', ctypes.c_wchar_p),
+    ]
+
+    @classmethod
+    def create(cls, init_with: Union[str, int]):
+        buffer = ctypes.create_unicode_buffer(init_with)
+        bufsize = len(buffer)
+        if isinstance(init_with, str):
+            wchlen = bufsize - 1  # exclude null
+        else:
+            wchlen = 0
+        return cls(wchlen * 2, bufsize * 2, ctypes.cast(buffer, ctypes.c_wchar_p))
+
+    def __str__(self):
+        return ctypes.wstring_at(self.Buffer, self.Length // 2)
+
+
+class SYSTEM_PROCESS_ID_INFORMATION(ctypes.Structure):
+    _fields_ = [
+        ('ProcessId', ctypes.c_size_t),
+        ('ImageName', UNICODE_STRING),
+    ]
+
+
+def resolve_image_name(pid: int):
+    """Resolves the image name of a process, in NT device path (\\Device\\HarddiskVolumeX\\...) format."""
+    info = SYSTEM_PROCESS_ID_INFORMATION()
+    info.ProcessId = pid
+    status = NtQuerySystemInformation(SystemProcessIdInformation, ctypes.byref(info), ctypes.sizeof(info), None)
+    if status == -1073741820:
+        info.ImageName = UNICODE_STRING.create(info.ImageName.MaximumLength // 2)
+        status = NtQuerySystemInformation(SystemProcessIdInformation, ctypes.byref(info), ctypes.sizeof(info), None)
+        return str(info.ImageName)
+    else:
+        return ''
+
+
+GetFinalPathNameByHandleW = ctypes.windll.kernel32.GetFinalPathNameByHandleW
+GetFinalPathNameByHandleW.argtypes = (ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_uint32, ctypes.c_uint32)
+
+
+def get_final_path(path: os.PathLike) -> str:
+    with open(path, 'rb', buffering=0) as f:
+        handle = msvcrt.get_osfhandle(f.fileno())
+        buf = ctypes.create_unicode_buffer(32768)
+        pathlen = GetFinalPathNameByHandleW(handle, buf, 32768, 2)
+        if pathlen == 0:
+            raise ctypes.WinError()
+        return buf[:pathlen]
+
+
+def _test():
+    for pid in all_pids():
+        print(pid, resolve_image_name(pid), sep='\t')