ok-script 0.0.71__tar.gz → 0.0.72__tar.gz

{ok-script-0.0.71 → ok-script-0.0.72}/PKG-INFO

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

{ok-script-0.0.71 → ok-script-0.0.72}/ok/OK.py

@@ -41,7 +41,6 @@ class OK:
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
             self.screenshot = Screenshot(self.exit_event)
-            self.do_init()
             if config.get("use_gui"):
                 from ok.gui.App import App
                 self.app = App(config, self.exit_event)
@@ -49,6 +48,7 @@ class OK:
             else:
                 self.device_manager.set_preferred_device()
                 self.device_manager.start()
+            self.do_init()
         except Exception as e:
             logger.error(f'__init__ error', e)
             self.quit()
@@ -102,9 +102,9 @@ class OK:
 
         template_matching = self.config.get('template_matching')
         if template_matching is not None:
-            coco_feature_folder = self.config.get('template_matching').get('coco_feature_folder')
+            coco_feature_json = self.config.get('template_matching').get('coco_feature_json')
             from ok.feature.FeatureSet import FeatureSet
-            self.feature_set = FeatureSet(coco_feature_folder,
+            self.feature_set = FeatureSet(coco_feature_json,
                                           default_horizontal_variance=template_matching.get(
                                               'default_horizontal_variance', 0),
                                           default_vertical_variance=template_matching.get('default_vertical_variance',

{ok-script-0.0.71 → ok-script-0.0.72}/ok/feature/Box.py

@@ -6,12 +6,20 @@ from typing import List
 
 
 class Box:
-    def __init__(self, x: int, y: int, width: int, height: int, confidence: float = 1, name=None) -> None:
+    def __init__(self, x: int | float, y: int | float, width: int | float = 0, height: int | float = 0,
+                 confidence: float = 1,
+                 name=None, to_x: int | float = -1, to_y: int | float = -1) -> None:
         self.name = name
         self.x = int(x)
         self.y = int(y)
-        self.width = int(width)
-        self.height = int(height)
+        if to_x != -1 and to_y != -1:
+            self.width = int(to_x - x)
+            self.height = int(to_y - y)
+        else:
+            self.width = int(width)
+            self.height = int(height)
+        if self.width <= 0 or self.height <= 0:
+            raise ValueError(f'width and height must be greater than zero {x} {y} {width} {height} {to_x} {to_y}')
         self.confidence = confidence
 
     def __eq__(self, other):

{ok-script-0.0.71 → ok-script-0.0.72}/ok/feature/Feature.py

@@ -18,3 +18,6 @@ class Feature:
         self.y = y
         self.width = width
         self.height = height
+
+    def __str__(self) -> str:
+        return f'self.x: {self.x}, self.y: {self.y}, width: {self.width}, height: {self.height}'

{ok-script-0.0.71 → ok-script-0.0.72}/ok/feature/FeatureSet.py

@@ -21,19 +21,20 @@ class FeatureSet:
     feature_dict: Dict[str, Feature] = {}
     box_dict: Dict[str, Box] = {}
 
-    def __init__(self, coco_folder: str, default_horizontal_variance=0,
+    def __init__(self, coco_json: str, default_horizontal_variance=0,
                  default_vertical_variance=0, default_threshold=0.95) -> None:
         """
         Initialize the FeatureSet by loading images and annotations from a COCO dataset.
 
         Args:
-            coco_folder (str): Directory containing the JSON file and images.
+            coco_json (str): Directory containing the JSON file and images.
             width (int): Scale images to this width.
             height (int): Scale images to this height.
         """
-        self.coco_folder = resource_path(coco_folder)
+        self.coco_json = resource_path(coco_json)
+        self.coco_folder = os.path.dirname(self.coco_json)
 
-        logger.debug(f'Loading features from {self.coco_folder}')
+        logger.debug(f'Loading features from {self.coco_json}')
 
         # Process images and annotations
         self.width = 0
@@ -62,8 +63,7 @@ class FeatureSet:
         """
         self.feature_dict.clear()
         self.box_dict.clear()
-        json_path = os.path.join(self.coco_folder, '_annotations.coco.json')
-        with open(json_path, 'r') as file:
+        with open(self.coco_json, 'r') as file:
             data = json.load(file)
 
         # Create a map from image ID to file name
@@ -78,7 +78,7 @@ class FeatureSet:
             bbox = annotation['bbox']
 
             # Load and scale the image
-            image_path = f'{self.coco_folder}/{image_map[image_id]}'
+            image_path = str(os.path.join(self.coco_folder, image_map[image_id]))
             image = cv2.imread(image_path)
             _, original_width = image.shape[:2]
             if image is None:
@@ -168,7 +168,7 @@ class FeatureSet:
         if vertical_variance == 0:
             vertical_variance = self.default_vertical_variance
         if category_name not in self.feature_dict:
-            raise ValueError(f"FeatureSet: {category_name} not found in featureDict")
+            raise ValueError(f"FeatureSet: " + category_name + " not found in featureDict")
         feature = self.feature_dict[category_name]
         feature_width, feature_height = feature.width, feature.height
         if x != -1 and y != -1:

ok-script-0.0.72/ok/firebase/Analytics.py

@@ -0,0 +1,164 @@
+import ctypes
+import hashlib
+import locale
+import random
+import uuid
+
+import requests
+import wmi
+
+from ok.config.Config import Config
+from ok.logging.Logger import get_logger
+from ok.util.Handler import Handler
+
+logger = get_logger(__name__)
+
+
+class Analytics:
+    def __init__(self, app_config, exit_event):
+        self.report_url = app_config.get('analytics').get('report_url')
+        self.app_config = app_config
+        self._config = None
+        self._handler = Handler(exit_event, __name__)
+        self._handler.post(self.send_alive, 20)
+        self._user_properties = None
+        self._fv = 1
+
+    @property
+    def user_properties(self):
+        if self._user_properties is None:
+            c = wmi.WMI()
+
+            # Get OS information
+            os_info = c.Win32_OperatingSystem()[0]
+            os_version = os_info.Version.split(".")[0]
+            os_build = int(os_info.BuildNumber)
+
+            if os_version == "10" and os_build >= 22000:  # Windows 11 starts from build 22000
+                os_version = "11"
+
+            # Get CPU information
+            cpu_info = c.Win32_Processor()[0]
+            cpu_name = cpu_info.Name.strip()
+
+            # Get total memory (in GB)
+            total_memory = float(os_info.TotalVisibleMemorySize) / 1048576  # KB to GB
+
+            # Get graphics card information
+            gpu_info = c.Win32_VideoController()
+            gpu_name = None
+            for gpu in reversed(gpu_info):
+                if "intel" not in gpu.Name.lower() and "microsoft" not in gpu.Name.lower():
+                    gpu_name = gpu.Name
+                    break
+            if not gpu_name and gpu_info:
+                gpu_name = gpu_info[0].Name
+
+            # Put the information into a dictionary
+            self._user_properties = {
+                "os": 'windows',
+                "os_version": os_version,
+                "os_build": os_build,
+                "cpu": cpu_name,
+                "memory": int(total_memory),
+                "gpu": gpu_name,
+            }
+        return self._user_properties
+
+    #
+    # 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):
+        if self._config is None:
+            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'] = self.get_unique_client_id()
+        else:
+            self._fv = 0
+        return self._config.get('client_id')
+
+    def send_alive(self):
+
+        params = {
+            "device_id": self.client_id,
+            "app_version": self.app_config.get('version'),
+            "app_name": self.app_config.get('app_id') or self.app_config.get('gui_title'),
+            'locale': locale.getdefaultlocale()[0],
+            'sr': get_screen_resolution(),
+            "os": 'windows',
+        }
+
+        params.update(self.user_properties)
+
+        logger.debug(f'send report {params}')
+
+        response = requests.post(self.report_url, json=params)
+
+        if response.status_code == 200:
+            logger.debug(f'Successfully send report')
+        else:
+            logger.debug(f'Failed to send event: {response.status_code} - {response.text}')
+
+        self._handler.post(self.send_alive, 3600)
+
+    def get_unique_client_id(self):
+        user_dict = self.user_properties.copy()
+        user_dict['mac'] = uuid.getnode()
+        del user_dict['os_build']
+        return hash_dict_keys_values(user_dict)
+
+
+def get_bios_serial_number():
+    try:
+        c = wmi.WMI()
+        for bios in c.Win32_BIOS():
+            return bios.SerialNumber.strip()
+    except Exception as e:
+        print(f"Error retrieving BIOS serial number: {e}")
+        return None
+
+
+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]}"
+
+
+def hash_dict_keys_values(my_dict):
+    # Sort the dictionary by keys
+    sorted_items = sorted(my_dict.items())
+
+    # Initialize an empty string to store concatenated key-value pairs
+    concatenated_kv = ''
+
+    # Concatenate sorted key-value pairs
+    for key, value in sorted_items:
+        concatenated_kv += f'{key}{value}'
+
+    # Encode the concatenated string
+    encoded_kv = concatenated_kv.encode()
+
+    # Create a new md5 hash object
+    hash_object = hashlib.md5(encoded_kv)
+
+    # Get the hexadecimal representation of the hash
+    hash_hex = hash_object.hexdigest()
+
+    return hash_hex
+
+
+if __name__ == '__main__':
+    # Generate a unique client ID (UUID)
+    client_id = str(uuid.uuid4())
+    analytics = Analytics('G-9W3F3EQ19G', api_secret='eAkNmhrERiGg8Q3Riuxerw')
+    # Send a test event
+    analytics.send_event('app_open')
+    analytics.send_event('test1')
+    analytics.send_event('test2')

{ok-script-0.0.71 → ok-script-0.0.72}/ok/gui/App.py

@@ -8,7 +8,7 @@ from qfluentwidgets import FluentTranslator, qconfig, Theme
 
 import ok
 import ok.gui.resources
-from ok.firebase.FireBaseAnalytics import FireBaseAnalytics
+from ok.firebase.Analytics import Analytics
 from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
@@ -49,8 +49,8 @@ class App:
         self.main_window = None
         self.exit_event = exit_event
         self.icon = QIcon(self.config.get('gui_icon') or ":/icon/icon.ico")
-        if self.config.get('firebase'):
-            self.fire_base_analytics = FireBaseAnalytics(self.config, self.exit_event)
+        if self.config.get('analytics'):
+            self.fire_base_analytics = Analytics(self.config, self.exit_event)
 
         translator = QTranslator(self.app)
         full_path = os.path.join(i18n_path, f"{self.locale.name()}")

{ok-script-0.0.71 → ok-script-0.0.72}/ok/gui/MainWindow.py

@@ -1,3 +1,6 @@
+import os
+import sys
+
 from PySide6.QtCore import QObject, Signal, Qt
 from PySide6.QtGui import QKeySequence, QShortcut
 from PySide6.QtWidgets import QMenu, QSystemTrayIcon
@@ -58,7 +61,9 @@ class MainWindow(MSFluentWindow):
             self.addSubInterface(about_tab, FluentIcon.QUESTION, self.tr('About'),
                                  position=NavigationItemPosition.BOTTOM)
         # Styling the tabs and content if needed, for example:
-        self.setWindowTitle(f'{title} {version}')
+        dev = self.tr('Debug')
+        release = self.tr('Release')
+        self.setWindowTitle(f'{title} {version} {dev if debug else release}')
 
         communicate.executor_paused.connect(self.executor_paused)
         communicate.tab.connect(self.navigate_tab)
@@ -162,12 +167,16 @@ class MainWindow(MSFluentWindow):
 
     def closeEvent(self, event):
         # Create a message box that asks the user if they really want to close the window
+        if sys.platform == 'win32' and 'shutdown' in os.environ.get('SESSIONNAME', '').lower():
+            event.accept()
+            return
+
+            # Your existing code for the message box
         if ok.gui.ok.exit_event.is_set():
             event.accept()
             return
         title = self.tr('Exit')
-        content = self.tr(
-            "Are you sure you want to exit the app?")
+        content = self.tr("Are you sure you want to exit the app?")
         w = MessageBox(title, content, self.window())
         if w.exec():
             logger.info("Window closed")

{ok-script-0.0.71 → ok-script-0.0.72}/ok/gui/StartController.py

@@ -15,10 +15,8 @@ logger = get_logger(__name__)
 class StartController(QObject):
     def __init__(self, app_config, exit_event):
         super().__init__()
-        self.executor = ok.gui.executor
         self.config = app_config
         self.exit_event = exit_event
-        self.device_manager = ok.gui.device_manager
         self.handler = Handler(exit_event, __name__)
 
     def start(self, task=None):
@@ -26,18 +24,18 @@ class StartController(QObject):
 
     def do_start(self, task=None):
         communicate.starting_emulator.emit(False, None, 30)
-        self.device_manager.do_refresh()
+        ok.gui.device_manager.do_refresh()
 
-        device = self.device_manager.get_preferred_device()
+        device = ok.gui.device_manager.get_preferred_device()
 
         if device and not device['connected'] and device.get('full_path'):
-            path = self.device_manager.get_exe_path(device)
+            path = ok.gui.device_manager.get_exe_path(device)
             if path:
                 logger.info(f"starting game {path}")
                 execute(path)
                 wait_until = time.time() + 30
                 while not self.exit_event.is_set():
-                    self.device_manager.do_refresh()
+                    ok.gui.device_manager.do_refresh()
                     error = self.check_device_error()
                     if error is None:
                         break
@@ -60,24 +58,24 @@ class StartController(QObject):
         if task:
             task.enable()
             task.unpause()
-        self.executor.start()
+        ok.gui.executor.start()
         communicate.starting_emulator.emit(True, None, 0)
 
     def check_device_error(self):
-        device = self.device_manager.get_preferred_device()
+        device = ok.gui.device_manager.get_preferred_device()
         if not device:
             return self.tr('No game selected!')
-        if self.device_manager.capture_method is None:
+        if ok.gui.device_manager.capture_method is None:
             return self.tr("Selected capture method is not supported by the game or your system!")
-        if not self.device_manager.device_connected():
-            logger.error(f'Emulator is not connected {self.device_manager.device}')
+        if not ok.gui.device_manager.device_connected():
+            logger.error(f'Emulator is not connected {ok.gui.device_manager.device}')
             return self.tr("Emulator is not connected, start the emulator first!")
-        if not self.device_manager.capture_method.connected():
-            logger.error(f'Game window is not connected {self.device_manager.capture_method}')
+        if not ok.gui.device_manager.capture_method.connected():
+            logger.error(f'Game window is not connected {ok.gui.device_manager.capture_method}')
             return self.tr("Game window is not connected, please select the game window and capture method.")
         supported_ratio = self.config.get(
             'supported_screen_ratio')
-        supported, resolution = self.executor.check_frame_and_resolution(supported_ratio)
+        supported, resolution = ok.gui.executor.check_frame_and_resolution(supported_ratio)
         if not supported:
             return self.tr(
                 "Window resolution {resolution} is not supported, the supported ratio is {supported_ratio}, check if game windows is minimized, resized or out of screen.",
@@ -88,6 +86,6 @@ class StartController(QObject):
         if device and device['device'] == "adb" and self.config.get('adb'):
             packages = self.config.get('adb').get('packages')
             if packages:
-                started = self.device_manager.adb_ensure_in_front(packages)
+                started = ok.gui.device_manager.adb_ensure_in_front(packages)
                 if not started:
                     return self.tr("Can't start game, make sure the game is installed")

{ok-script-0.0.71 → ok-script-0.0.72}/ok/ocr/OCR.py

@@ -1,4 +1,5 @@
 import time
+from typing import List, Pattern
 
 import cv2
 
@@ -14,7 +15,9 @@ class OCR:
     ocr_default_threshold = 0.5
     ocr_target_height = 0
 
-    def ocr(self, x=0, y=0, to_x=1, to_y=1, width=0, height=0, box: Box = None, name=None, match=None, threshold=0,
+    def ocr(self, x=0, y=0, to_x=1, to_y=1, match: str | List[str] | Pattern[str] | List[Pattern[str]] | None = None,
+            width=0, height=0, box: Box = None, name=None,
+            threshold=0,
             frame=None, target_height=0):
         if hasattr(self, 'paused') and self.paused:
             self.sleep(1)
@@ -72,7 +75,8 @@ class OCR:
                 f"ocr_zone {box} found result: {len(detected_boxes)}) time: {(time.time() - start):.2f} scale_factor: {scale_factor:.2f}")
             return sort_boxes(detected_boxes)
 
-    def wait_click_ocr(self, x=0, y=0, to_x=1, to_y=1, width=0, height=0, box=None, name=None, match=None, threshold=0,
+    def wait_click_ocr(self, x=0, y=0, to_x=1, to_y=1, width=0, height=0, box=None, name=None,
+                       match: str | List[str] | Pattern[str] | List[Pattern[str]] | None = None, threshold=0,
                        frame=None, target_height=0, time_out=0):
         box = self.wait_ocr(x, y, width=width, height=height, to_x=to_x, to_y=to_y, box=box, name=name, match=match,
                             threshold=threshold,
@@ -83,7 +87,8 @@ class OCR:
         else:
             logger.error(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=None, threshold=0,
+    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,
                  frame=None, target_height=0, time_out=0):
         return self.wait_until(lambda:
                                self.ocr(x, y, to_x=to_x, to_y=to_y, width=width, height=height, box=box, name=name,

{ok-script-0.0.71 → ok-script-0.0.72}/ok/task/TaskExecutor.py

@@ -186,15 +186,14 @@ class TaskExecutor:
             if pre_action is not None:
                 pre_action()
             self.sleep(wait_until_before_delay)
-            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
+            self.next_frame()
+            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:

{ok-script-0.0.71 → ok-script-0.0.72}/ok_script.egg-info/PKG-INFO

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

{ok-script-0.0.71 → ok-script-0.0.72}/ok_script.egg-info/SOURCES.txt

@@ -37,7 +37,7 @@ ok/feature/Feature.py
 ok/feature/FeatureSet.py
 ok/feature/FindFeature.py
 ok/feature/__init__.py
-ok/firebase/FireBaseAnalytics.py
+ok/firebase/Analytics.py
 ok/firebase/__init__.py
 ok/gui/App.py
 ok/gui/Communicate.py

{ok-script-0.0.71 → ok-script-0.0.72}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="ok-script",
-    version="0.0.71",
+    version="0.0.72",
     author="ok-oldking",
     author_email="firedcto@gmail.com",
     description="Automation with Computer Vision for Python",