ok-script 0.0.68__tar.gz → 0.0.70__tar.gz

{ok-script-0.0.68 → ok-script-0.0.70}/PKG-INFO

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

{ok-script-0.0.68 → ok-script-0.0.70}/ok/OK.py

@@ -34,7 +34,8 @@ class OK:
         config_logger(config)
         logger.info(f"AutoHelper init, config: {config}")
         ok.gui.ok = self
-        self.debug = config.get("debug", False)
+        config['debug'] = config.get("debug", False)
+        self.debug = config['debug']
         try:
             self.config = config
             self.init_device_manager()
@@ -135,9 +136,6 @@ class OK:
     def init_device_manager(self):
         if self.device_manager is None:
             from ok.capture.adb.DeviceManager import DeviceManager
-            self.device_manager = DeviceManager(self.config.get("config_folder") or "config",
-                                                self.config.get('windows'),
-                                                self.config.get('adb'),
-                                                self.config.get("debug"),
+            self.device_manager = DeviceManager(self.config,
                                                 self.exit_event)
             ok.gui.device_manager = self.device_manager

{ok-script-0.0.68 → ok-script-0.0.70}/ok/capture/BaseCaptureMethod.py

@@ -28,7 +28,7 @@ class BaseCaptureMethod:
             try:
                 self.get_frame()
             except Exception as e:
-                logger.error('get frame error')
+                logger.error('width get frame error', e)
         return self._size[0]
 
     @property
@@ -37,7 +37,7 @@ class BaseCaptureMethod:
             try:
                 self.get_frame()
             except Exception as e:
-                logger.error('get frame error')
+                logger.error('height get frame error', e)
         return self._size[1]
 
     def get_frame(self) -> np.ndarray | None:

{ok-script-0.0.68 → ok-script-0.0.70}/ok/capture/HwndWindow.py

@@ -1,5 +1,4 @@
 # original https://github.com/dantmnf & https://github.com/hakaboom/winAuto
-import os.path
 import re
 import threading
 import time
@@ -75,13 +74,13 @@ class HwndWindow:
     def update_frame_size(self, width, height):
         logger.debug(f"update_frame_size:{self.frame_width}x{self.frame_height} to {width}x{height}")
         if width != self.frame_width or height != self.frame_height:
-            self.hwnd = None
             self.frame_width = width
             self.frame_height = height
             if width > 0 and height > 0:
                 self.frame_aspect_ratio = width / height
-                logger.debug(f"HwndWindow: frame ratio:{self.frame_aspect_ratio} width: {width}, height: {height}")
-            self.do_update_window_size()
+                logger.debug(f"HwndWindow: frame ratio: width: {width}, height: {height}")
+        self.hwnd = None
+        self.do_update_window_size()
 
     def update_window_size(self):
         while not self.app_exit_event.is_set() and not self.stop_event.is_set():
@@ -101,7 +100,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_aspect_ratio)
+                    self.frame_width, self.frame_height)
                 self.exists = self.hwnd is not None
             if self.hwnd is not None:
                 self.exists = win32gui.IsWindow(self.hwnd)
@@ -131,8 +130,8 @@ class HwndWindow:
                     self.x, self.y, self.border, self.title_height, self.width, self.height, self.ext_left_bounds, self.ext_top_bounds = x, y, border, title_height, width, height, ext_left_bounds, ext_top_bounds
                     changed = True
                 if changed:
-                    logger.debug(
-                        f"do_update_window_size changed,visible:{self.visible} x:{self.x} y:{self.y} border:{self.border} width:{self.width} height:{self.height} self.title_height:{self.title_height} scaling:{self.scaling}")
+                    logger.info(
+                        f"do_update_window_size changed,visible:{self.visible} x:{self.x} y:{self.y} border:{self.border} window:{self.width}x{self.height} self.title_height:{self.title_height} real:{self.real_width}x{self.real_height} scaling:{self.scaling}")
                     communicate.window.emit(self.visible, self.x, self.y, self.border, self.title_height, self.width,
                                             self.height, self.scaling)
         except Exception as e:
@@ -153,10 +152,11 @@ class HwndWindow:
         return f"title:{self.title}_{self.exe_name}_{self.width}x{self.height}_{self.hwnd}_{self.exists}_{self.visible}"
 
 
-def find_hwnd(title, exe_name, frame_aspect_ratio=0):
+def find_hwnd(title, exe_name, frame_width, frame_height):
     results = []
     if exe_name is None and title is None:
         return None, None, None, 0, 0, 0, 0
+    frame_aspect_ratio = frame_width / frame_height if frame_height != 0 else 0
 
     def callback(hwnd, lParam):
         if win32gui.IsWindowVisible(hwnd) and win32gui.IsWindowEnabled(hwnd):
@@ -179,33 +179,54 @@ def find_hwnd(title, exe_name, frame_aspect_ratio=0):
 
     win32gui.EnumWindows(callback, None)
     biggest = None
-    ratio_match = None
     if len(results) > 0:
         for result in results:
             from ok.capture.windows.BitBltCaptureMethod import bit_blt_test_hwnd
             if (biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]) and bit_blt_test_hwnd(result[0]):
                 biggest = result
-        for result in results:
-            if frame_aspect_ratio != 0:
-                ratio = result[2] / result[3]
-                difference = abs(ratio - frame_aspect_ratio)
-                support = difference <= 0.01 * frame_aspect_ratio
-                if support and biggest != result:
-                    ratio_match = result
         x_offset = 0
         y_offset = 0
         real_width, real_height = biggest[2], biggest[3]
-        if ratio_match is not None and ratio_match[4] - biggest[4] >= 0 and ratio_match[5] - biggest[5] >= 0:
-            x_offset = ratio_match[4] - biggest[4]
-            y_offset = ratio_match[5] - biggest[5]
-            real_width = ratio_match[2]
-            real_height = ratio_match[3]
-        logger.debug(f'find_hwnd {results} {biggest} {ratio_match} {x_offset, y_offset, real_width, real_height}')
+        if biggest is not None and frame_aspect_ratio != 0:
+            matching_child = enum_child_windows(biggest, frame_aspect_ratio)
+            if matching_child is not None:
+                x_offset, y_offset, real_width, real_height = matching_child
+        logger.info(f'find_hwnd {frame_width, frame_height} {biggest} {x_offset, y_offset, real_width, real_height}')
         return biggest[6], biggest[0], biggest[1], x_offset, y_offset, real_width, real_height,
     else:
         return None, None, None, 0, 0, 0, 0
 
 
+def enum_child_windows(biggest, frame_aspect_ratio):
+    ratio_match = []
+    """
+    A function to enumerate all child windows of the given parent window handle
+    and print their handle and window title.
+    """
+
+    def child_callback(hwnd, _):
+        visible = win32gui.IsWindowVisible(hwnd)
+        parent = win32gui.GetParent(hwnd)
+        rect = win32gui.GetWindowRect(hwnd)
+        real_width = rect[2] - rect[0]
+        real_height = rect[3] - rect[1]
+        logger.info(f'find_hwnd child_callback {visible} {biggest[0]} {parent} {rect} {real_width} {real_height}')
+        if visible and parent == biggest[0]:
+            ratio = real_width / real_height
+            difference = abs(ratio - frame_aspect_ratio)
+            support = difference <= 0.01 * frame_aspect_ratio
+            percent = (real_width * real_height) / (biggest[2] * biggest[3])
+            if support and percent >= 0.7:
+                x_offset = rect[0] - biggest[4]
+                y_offset = rect[1] - biggest[5]
+                ratio_match.append((x_offset, y_offset, real_width, real_height))
+        return True
+
+    win32gui.EnumChildWindows(biggest[0], child_callback, None)
+    if len(ratio_match) > 0:
+        return ratio_match[0]
+
+
 def get_exe_by_hwnd(hwnd):
     # Get the process ID associated with the window
     _, pid = win32process.GetWindowThreadProcessId(hwnd)
@@ -215,31 +236,10 @@ def get_exe_by_hwnd(hwnd):
     return process.name(), process.exe()
 
 
-def enum_windows(emulator_path=None):
-    if emulator_path is not None:
-        emulator_path = os.path.normpath(emulator_path)
-
-    def callback(hwnd, extra):
-        name, full_path = get_exe_by_hwnd(hwnd)
-        if emulator_path and emulator_path != full_path:
-            return True
-        buff = win32gui.GetWindowText(hwnd)
-        if buff and win32gui.IsWindowVisible(hwnd):
-            rect = win32gui.GetWindowRect(hwnd)
-            width = rect[2] - rect[0]
-            height = rect[3] - rect[1]
-            extra.append((hwnd, buff, width, height))
-        return True
-
-    windows = []
-    win32gui.EnumWindows(callback, windows)
-    return windows
-
-
 if __name__ == '__main__':
     print(find_hwnd("MuMu模拟器12", None))
-    hwnd_window = HwndWindow(threading.Event(), None, 'D:\\MuMuPlayer-12.0\\shell\\MuMuPlayer.exe', 16, 9)
-    from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
-
-    method = BitBltCaptureMethod(hwnd_window)
-    method.get_frame()
+    # hwnd_window = HwndWindow(threading.Event(), None, 'D:\\MuMuPlayer-12.0\\shell\\MuMuPlayer.exe', 16, 9)
+    # from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
+    #
+    # method = BitBltCaptureMethod(hwnd_window)
+    # method.get_frame()

{ok-script-0.0.68 → ok-script-0.0.70}/ok/capture/adb/DeviceManager.py

@@ -16,19 +16,25 @@ logger = get_logger(__name__)
 
 class DeviceManager:
 
-    def __init__(self, config_folder, windows_capture_config, adb_capture_config, debug=False, exit_event=None):
+    def __init__(self, app_config, exit_event=None):
         self._device = None
         self._adb = None
-        self.windows_capture_config = windows_capture_config
-        self.adb_capture_config = adb_capture_config
-        self.debug = debug
+        self.supported_ratio = parse_ratio(app_config.get(
+            'supported_screen_ratio'))
+        self.windows_capture_config = app_config.get('windows')
+        self.adb_capture_config = app_config.get('adb')
+        self.debug = app_config.get('debug')
         self.interaction = None
         self.device_dict = {}
         self.exit_event = exit_event
-        if windows_capture_config is not None:
-            self.hwnd = HwndWindow(exit_event, windows_capture_config.get('title'),
-                                   windows_capture_config.get('exe'))
-        self.config = Config({"preferred": "none", "pc_full_path": "none", 'capture': 'windows'}, config_folder,
+        self.resolution_dict = {}
+        if self.windows_capture_config is not None:
+            self.hwnd = HwndWindow(exit_event, self.windows_capture_config.get('title'),
+                                   self.windows_capture_config.get('exe'))
+        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')
@@ -73,7 +79,7 @@ class DeviceManager:
     def update_pc_device(self):
         if self.windows_capture_config is not None:
             name, hwnd, full_path, x, y, width, height = find_hwnd(self.windows_capture_config.get('title'),
-                                                                   self.windows_capture_config.get('exe'))
+                                                                   self.windows_capture_config.get('exe'), 0, 0)
             nick = name or self.windows_capture_config.get('exe')
             pc_device = {"address": "", "imei": 'pc', "device": "windows",
                          "model": "", "nick": nick, "width": width,
@@ -98,7 +104,7 @@ class DeviceManager:
 
         if self.exit_event.is_set():
             return
-        self.start()
+        self.do_start()
 
         logger.debug(f'refresh {self.device_dict}')
 
@@ -112,10 +118,11 @@ class DeviceManager:
                         found = True
                         break
                 if not found:
+                    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,
-                                    "resolution": self.get_resolution(adb_device)}
+                                    "resolution": f'{width}x{height}'}
                     self.device_dict[imei] = phone_device
 
     def refresh_emulators(self):
@@ -124,8 +131,9 @@ class DeviceManager:
         installed_emulators = manager.all_emulator_instances
         for emulator in installed_emulators:
             adb_device = self.adb_connect(emulator.serial)
+            width, height = self.get_resolution(adb_device)
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
-                                                                   emulator.path)
+                                                                   emulator.path, width, height)
             connected = adb_device is not None and name is not None
             emulator_device = {"address": emulator.serial, "device": "adb",
                                "full_path": emulator.path, "connected": connected,
@@ -142,10 +150,16 @@ class DeviceManager:
             device = self.device
         width, height = 0, 0
         if device is not None:
+            if resolution := self.resolution_dict.get(device.serial):
+                return resolution
             frame = do_screencap(device)
             if frame is not None:
                 height, width, _ = frame.shape
-        return height, width
+                if self.supported_ratio is None or abs(width / height - self.supported_ratio) < 0.01:
+                    self.resolution_dict[device.serial] = (width, height)
+                else:
+                    logger.warning(f'resolution error {device.serial} {self.supported_ratio} {width, height}')
+        return width, height
 
     def set_preferred_device(self, imei=None, index=-1):
         logger.debug(f"set_preferred_device {imei} {index}")
@@ -156,7 +170,12 @@ class DeviceManager:
         preferred = self.device_dict.get(imei)
         if preferred is None:
             if len(self.device_dict) > 0:
-                preferred = next(iter(self.device_dict.values()))
+                connected_device = None
+                for device in self.device_dict.values():
+                    if device.get('connected') or connected_device is None:
+                        connected_device = device
+                logger.info(f'first start use first or connected device {connected_device}')
+                preferred = connected_device
                 imei = preferred['imei']
             else:
                 logger.warning(f'no devices')
@@ -233,17 +252,18 @@ class DeviceManager:
                 self.interaction = Win32Interaction(self.capture_method)
             preferred['connected'] = self.capture_method.connected()
         else:
-            height, width = self.get_resolution()
+            width, height = self.get_resolution()
             if self.config.get('capture') == "windows":
                 self.ensure_hwnd(None, preferred.get('full_path'), width, height)
                 self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=True)
-            elif not isinstance(self.capture_method, ADBCaptureMethod):
-                logger.debug(f'use adb capture')
-                if self.capture_method is not None:
-                    self.capture_method.close()
-                self.capture_method = ADBCaptureMethod(self, self.exit_event, width=width,
-                                                       height=height)
-                if self.debug:
+            else:
+                if not isinstance(self.capture_method, ADBCaptureMethod):
+                    logger.debug(f'use adb capture')
+                    if self.capture_method is not None:
+                        self.capture_method.close()
+                    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)
                 elif self.hwnd is not None:
                     self.hwnd.stop()
@@ -259,7 +279,7 @@ class DeviceManager:
 
     def update_resolution_for_hwnd(self):
         if self.hwnd is not None and self.hwnd.frame_aspect_ratio == 0:
-            height, width = self.get_resolution()
+            width, height = self.get_resolution()
             logger.debug(f'update resolution for {self.hwnd} {width}x{height}')
             self.hwnd.update_frame_size(width, height)
 
@@ -363,3 +383,12 @@ class DeviceManager:
         elif installed := self.adb_check_installed(packages):
             self.adb_start_package(installed)
             return True
+
+
+def parse_ratio(ratio_str):
+    if ratio_str:
+        # Split the string into two parts: '16' and '9'
+        numerator, denominator = ratio_str.split(':')
+        # Convert the strings to integers and perform the division
+        ratio_float = int(numerator) / int(denominator)
+        return ratio_float

{ok-script-0.0.68 → ok-script-0.0.70}/ok/capture/windows/BitBltCaptureMethod.py

@@ -40,8 +40,15 @@ class BitBltCaptureMethod(BaseWindowsCaptureMethod):
 
     @override
     def do_get_frame(self) -> MatLike | None:
-        return bit_blt_capture_frame(self.hwnd_window.hwnd, self.hwnd_window.real_x_offset or self.hwnd_window.border,
-                                     self.hwnd_window.real_y_offset or self.hwnd_window.title_height,
+        if self.hwnd_window.real_x_offset != 0 or self.hwnd_window.real_y_offset != 0:
+            x = self.hwnd_window.real_x_offset
+            y = self.hwnd_window.real_y_offset
+        else:
+            x = self.hwnd_window.border
+            y = self.hwnd_window.title_height
+
+        return bit_blt_capture_frame(self.hwnd_window.hwnd, x,
+                                     y,
                                      self.hwnd_window.real_width or self.hwnd_window.width,
                                      self.hwnd_window.real_height or self.hwnd_window.height,
                                      self.hwnd_window.ext_left_bounds, self.hwnd_window.ext_top_bounds)

{ok-script-0.0.68 → ok-script-0.0.70}/ok/firebase/FireBaseAnalytics.py

@@ -1,5 +1,10 @@
+import ctypes
 import json
+import locale
+import random
+import time
 import uuid
+from urllib.parse import urlencode
 
 import requests
 import wmi
@@ -10,6 +15,8 @@ from ok.util.Handler import Handler
 
 FIREBASE_ENDPOINT = 'https://www.google-analytics.com/mp/collect'
 
+GTAG_ENDPOINT = "https://www.google-analytics.com/g/collect"
+
 logger = get_logger(__name__)
 
 
@@ -20,8 +27,9 @@ class FireBaseAnalytics:
         self.app_config = app_config
         self._config = None
         self._handler = Handler(exit_event, __name__)
-        self._handler.post(self.report_open, 10)
+        self._handler.post(self.send_gtag, 0)
         self._user_properties = None
+        self._fv = 1
 
     @property
     def user_properties(self):
@@ -64,8 +72,10 @@ class FireBaseAnalytics:
             }
         return self._user_properties
 
-    def report_open(self):
-        self.send_event('app_open', {'version': self.app_config.get('version'), 'debug': self.app_config.get('debug')})
+    #
+    # def report_open(self):
+    #     self._handler.post(self.send_gtag, 5)
+    #     # self.send_event('app_open', {'version': self.app_config.get('version'), 'debug': self.app_config.get('debug')})
 
     @property
     def client_id(self):
@@ -73,8 +83,66 @@ class FireBaseAnalytics:
             self._config = Config({'client_id': ''}, self.app_config.get("config_folder") or "config", 'statistics')
         if not self._config.get('client_id'):
             self._config['client_id'] = get_unique_client_id()
+        else:
+            self._fv = 0
         return self._config.get('client_id')
 
+    def send_gtag(self):
+        # Define the parameters in a dictionary
+        params = {
+            'v': '2',
+            'tid': self.measurement_id,
+            'gtm': '45je4630v9186643593za200',
+            '_p': random_number(),
+            # 'gcd': '13l3l3l3l1',
+            'npa': '0',
+            'dma': '0',
+            'tag_exp': '0',
+            'cid': self.client_id,
+            'ul': locale.getdefaultlocale()[0],
+            'sr': get_screen_resolution(),
+            'uaa': 'x86',
+            'uab': '64',
+            # 'uafvl': 'Microsoft Edge;125.0.2535.85|Chromium;125.0.6422.142|Not.A/Brand;24.0.0.0',
+            'uamb': '0',
+            'uam': '',
+            'uap': 'Windows',
+            'uapv': '15.0.0',
+            'uaw': '0',
+            'are': '1',
+            'frm': '0',
+            'pscdl': 'noapi',
+            '_s': '1',
+            'sid': int(time.time()),
+            'sct': '1',
+            'seg': '1',
+            'dl': 'https://ok-script.com/',
+            'dt': 'AppStartGTAG2',
+            'en': 'page_view',
+            '_ee': '1',
+            'ep.version': self.app_config.get('version')
+            # 'tfd': '5133'
+        }
+        if self._fv:
+            params['_fv'] = self._fv
+
+        # Send the GET request
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Origin': 'https://ok-script.com',
+            'Referer': 'https://ok-script.com/'
+        }
+        query_string = urlencode(params)
+
+        response = requests.post(f'{GTAG_ENDPOINT}', data=params)
+
+        logger.debug(f'send gtag {GTAG_ENDPOINT}?{query_string}')
+        if response.status_code == 204:
+            logger.debug(f'Successfully sent gtag')
+        else:
+            logger.debug(f'Failed to send event: {response.status_code} - {response.text}')
+
     def send_event(self, event_name, params=None):
         if params is None:
             params = dict()
@@ -107,7 +175,17 @@ class FireBaseAnalytics:
 
 
 def get_unique_client_id():
-    return str(uuid.uuid4())
+    return f'{random_number()}.{random_number()}'
+
+
+def random_number():
+    return random.randint(0, 2147483647)
+
+
+def get_screen_resolution():
+    user32 = ctypes.windll.user32
+    screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
+    return f"{screensize[0]}x{screensize[1]}"
 
 
 if __name__ == '__main__':

{ok-script-0.0.68 → ok-script-0.0.70}/ok/gui/App.py

@@ -8,11 +8,11 @@ from qfluentwidgets import FluentTranslator, qconfig, Theme
 
 import ok
 import ok.gui.resources
-from ok.capture.adb.StartController import StartController
 from ok.firebase.FireBaseAnalytics import FireBaseAnalytics
 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.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger

{ok-script-0.0.68/ok/capture/adb → ok-script-0.0.70/ok/gui}/StartController.py

@@ -26,7 +26,7 @@ class StartController(QObject):
 
     def do_start(self, task=None):
         communicate.starting_emulator.emit(False, None, 30)
-        self.device_manager.do_refresh(fast=True)
+        self.device_manager.do_refresh()
 
         device = self.device_manager.get_preferred_device()
 
@@ -37,6 +37,7 @@ class StartController(QObject):
                 execute(path)
                 wait_until = time.time() + 30
                 while not self.exit_event.is_set():
+                    self.device_manager.do_refresh()
                     error = self.check_device_error()
                     if error is None:
                         break

{ok-script-0.0.68 → ok-script-0.0.70}/ok/gui/debug/FrameWidget.py

@@ -30,11 +30,14 @@ class FrameWidget(QWidget):
         communicate.update_overlay.connect(self.update)
 
     def update_mouse_position(self):
-        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:
-            self._mouse_position = relative
-            self.update()
+        try:
+            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:
+                self._mouse_position = relative
+                self.update()
+        except Exception as e:
+            logger.warning(f'GetCursorPos exception {e}')
 
     def frame_ratio(self):
         if ok.gui.device_manager.width == 0: