ok-script 0.0.48__tar.gz → 0.0.50__tar.gz

{ok-script-0.0.48 → ok-script-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.48
+Version: 0.0.50
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking
@@ -21,6 +21,7 @@ Requires-Dist: PySide6-Fluent-Widgets>=1.5.6
 Requires-Dist: psutil>=5.9.8
 Requires-Dist: opencv-python>=4.9.0.80
 Requires-Dist: ok-d3dshot>=0.1.5
+Requires-Dist: py7zr>=0.21.0
 
 # ok-script
 

{ok-script-0.0.48 → ok-script-0.0.50}/ok/OK.py

@@ -28,6 +28,8 @@ class OK:
 
     def __init__(self, config: Dict[str, Any]):
         print(f"AutoHelper init, config: {config}")
+        config_logger(config)
+        logger.info(f"AutoHelper init, config: {config}")
         ok.gui.ok = self
         self.debug = config.get("debug", False)
         try:
@@ -44,6 +46,7 @@ class OK:
                 self.device_manager.start()
                 self.do_init()
         except Exception as e:
+            logger.error(f'__init__ error', e)
             self.quit()
             raise e
 
@@ -94,8 +97,6 @@ class OK:
             inference_num_threads = self.config.get('ocr').get('inference_num_threads', -1)
             self.ocr = RapidOCR(inference_num_threads=inference_num_threads)
 
-        config_logger(self.config)
-
         if self.config.get('coco_feature_folder') is not None:
             coco_feature_folder = self.config.get('coco_feature_folder')
             from ok.feature.FeatureSet import FeatureSet

{ok-script-0.0.48 → ok-script-0.0.50}/ok/capture/adb/DeviceManager.py

@@ -1,12 +1,10 @@
 import threading
 
 import win32gui
-from adbutils import AdbError
 
 from ok.capture.HwndWindow import HwndWindow, find_hwnd_by_title_and_exe
 from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod, do_screencap
 from ok.capture.adb.WindowsCaptureFactory import update_capture_method
-from ok.capture.adb.vbox import installed_emulator
 from ok.capture.windows.window import get_window_bounds
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -36,8 +34,7 @@ class DeviceManager:
                              "DeviceManager")
         self.thread = None
         self.capture_method = None
-        self.update_pc_device()
-        self.start()
+        self.refresh()
 
     def refresh(self):
         if self.thread is None or not self.thread.is_alive():
@@ -121,6 +118,7 @@ class DeviceManager:
             return
         if not fast:
             self.connect_all()
+        from ok.capture.adb.vbox import installed_emulator
         installed_emulators = [] if fast else installed_emulator()
         for device in self.adb.list():
             logger.debug(f'adb.list() {device}')
@@ -295,6 +293,7 @@ class DeviceManager:
     def shell(self, *args, **kwargs):
         device = self.device
         if device is not None:
+            from adbutils import AdbError
             try:
                 return device.shell(*args, **kwargs)
             except AdbError as e:

ok-script-0.0.50/ok/config/Config.py

@@ -0,0 +1,132 @@
+from ok.gui.Communicate import communicate
+from ok.logging.Logger import get_logger
+from ok.util.json import read_json_file, write_json_file
+from ok.util.path import get_path_relative_to_exe
+
+logger = get_logger(__name__)
+
+
+class Config(dict):
+    def __init__(self, default, folder, name, validator=None):
+        """
+        Initialize the Config object.
+
+        :param default: Default configuration values.
+        :param folder: Folder where the config file is stored.
+        :param name: Name of the config file.
+        :param validator: Optional function to validate key-value pairs.
+        """
+        self.default = default
+        self.validator = validator
+        self.config_file = get_path_relative_to_exe(folder, f"{name}.json")
+
+        # Read the config file, if it exists, otherwise use default
+        config = read_json_file(self.config_file)
+        if config is None:
+            self.reset_to_default()
+        else:
+            super().__init__(config)
+            modified = self.verify_config(default)
+            if modified:
+                self.save_file()
+        logger.debug(f'init self.config = {self}')
+
+    def save_file(self):
+        """
+        Save the current configuration to the file.
+        """
+        try:
+            write_json_file(self.config_file, self)
+        except Exception as e:
+            logger.error(f'save_file error: {e}')
+
+    def reset_to_default(self):
+        """
+        Reset the configuration to the default values.
+        """
+        super().clear()
+        self.update(self.default)
+        self.save_file()
+        logger.debug(f'reset_to_default self.config = {self}')
+
+    def pop(self, key, default=None):
+        """
+        Remove and return a value from the configuration.
+
+        :param key: The key to remove.
+        :param default: The default value if the key does not exist.
+        :return: The removed value.
+        """
+        result = super().pop(key, default)
+        self.save_file()
+        return result
+
+    def popitem(self):
+        """
+        Remove and return the last key-value pair from the configuration.
+        """
+        result = super().popitem()
+        self.save_file()
+        return result
+
+    def clear(self):
+        """
+        Clear all configuration values.
+        """
+        super().clear()
+        self.save_file()
+
+    def __setitem__(self, key, value):
+        if self.validate(key, value):
+            super().__setitem__(key, value)
+            self.save_file()
+
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)
+        except KeyError as e:
+            logger.error(f'KeyError: {key} not found in config: {self}')
+            raise e
+
+    def validate(self, key, value):
+        """
+        Validate a configuration key-value pair.
+
+        :param key: The key to validate.
+        :param value: The value to validate.
+        :return: True if valid, False otherwise.
+        """
+        if self.validator is not None:
+            valid, message = self.validator(key, value)
+            if not valid:
+                communicate.config_validation.emit(message)
+                return False
+        return True
+
+    def verify_config(self, default_config):
+        """
+        Verify the configuration against the default configuration.
+
+        :param default_config: The default configuration.
+        :return: True if the config was modified, False otherwise.
+        """
+        modified = False
+
+        # Remove entries that do not exist in default_config
+        for key in list(self.keys()):
+            if key not in default_config:
+                del self[key]
+                modified = True
+
+        # Check entries in default_config
+        for key, default_value in default_config.items():
+            if key not in self or not isinstance(self[key], type(default_value)):
+                self[key] = default_value
+                modified = True
+            elif self.validator is not None:
+                valid = self.validate(key, self[key])
+                if not valid:
+                    self[key] = default_value
+                    modified = True
+
+        return modified

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/App.py

@@ -13,6 +13,7 @@ from ok.gui.MessageWindow import MessageWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
+from ok.update.Updater import Updater
 
 logger = get_logger(__name__)
 
@@ -32,6 +33,8 @@ class App:
         self.app.setAttribute(Qt.AA_DontCreateNativeWidgetSiblings)
         qconfig.theme = Theme.AUTO
 
+        self.updater = Updater(self.config, exit_event)
+
         self.about = self.config.get('about')
         self.title = self.config.get('gui_title')
         self.version = self.config.get('version')
@@ -75,8 +78,9 @@ class App:
         self.show_message_window(title, content)
 
     def show_main_window(self):
-        self.main_window = MainWindow(self.icon, self.overlay, self.about, exit_event=self.exit_event)
-        self.main_window.setWindowTitle(f'{self.title} {self.version}')  # Set the window title here
+        self.main_window = MainWindow(self.icon, self.title, self.version, self.overlay, self.about,
+                                      exit_event=self.exit_event)
+        # Set the window title here
         self.main_window.setWindowIcon(self.icon)
         if self.overlay and ok.gui.device_manager.hwnd is not None:
             self.overlay_window = OverlayWindow(ok.gui.device_manager.hwnd)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/Communicate.py

@@ -20,6 +20,8 @@ class Communicate(QObject):
     config_validation: Signal = Signal(str)
     tab = Signal(str)
     capture_error = Signal()
+    check_update = Signal()
+    download_update = Signal(float, str, str, bool)
 
     def emit_draw_box(self, key: str = None, boxes=None, color=None, frame=None):
         self.draw_box.emit(key, boxes, color, frame)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/MainWindow.py

@@ -20,7 +20,7 @@ class Communicate(QObject):
 
 
 class MainWindow(MSFluentWindow):
-    def __init__(self, icon, debug=False, about=None, exit_event=None):
+    def __init__(self, icon, title, version, debug=False, about=None, exit_event=None):
         super().__init__()
         self.exit_event = exit_event
         self.start_tab = StartTab()
@@ -42,11 +42,11 @@ class MainWindow(MSFluentWindow):
         #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
         # ... Add other tabs similarly
         if about:
-            about_tab = AboutTab(about)
+            about_tab = AboutTab(icon, title, version, about)
             self.addSubInterface(about_tab, FluentIcon.QUESTION, self.tr('About'),
                                  position=NavigationItemPosition.BOTTOM)
         # Styling the tabs and content if needed, for example:
-        self.setWindowTitle("Close Event Example")
+        self.setWindowTitle(f'{title} {version}')
 
         communicate.executor_paused.connect(self.executor_paused)
         communicate.tab.connect(self.navigate_tab)

ok-script-0.0.50/ok/gui/about/AboutTab.py

@@ -0,0 +1,135 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QHBoxLayout, QLabel
+from qfluentwidgets import TextEdit, PushButton, InfoBar, InfoBarPosition, ProgressBar
+
+import ok.gui
+from ok.capture.windows.dump import dump_threads
+from ok.gui.Communicate import communicate
+from ok.gui.about.VersionCard import VersionCard
+from ok.gui.widget.Tab import Tab
+
+
+class AboutTab(Tab):
+    def __init__(self, icon, title, version, about):
+        super().__init__()
+        self.version_card = VersionCard(icon, title, version, self)
+        # Create a QTextEdit instance
+        self.addWidget(self.version_card, align=Qt.AlignCenter)
+        if ok.gui.app.updater.enabled():
+            self.update_hbox = QHBoxLayout()
+            self.update_hbox.addStretch()
+            self.check_update_button = PushButton(self.tr("Check for updates"))
+            self.check_update_button.clicked.connect(self.check_update)
+            self.update_hbox.addWidget(self.check_update_button)
+            self.download_latest_button = PushButton()
+            self.download_latest_button.clicked.connect(self.download_latest)
+
+            self.update_hbox.addWidget(self.download_latest_button)
+            self.download_stable_button = PushButton(self.tr("Download stable version {version}").format(version=1))
+            self.download_stable_button.clicked.connect(self.download_stable)
+
+            self.update_hbox.addWidget(self.download_stable_button)
+
+            self.download_bar = ProgressBar(self)
+            self.download_bar.setFixedWidth(200)
+            self.update_hbox.addWidget(self.download_bar)
+
+            self.downloading_text = QLabel()
+            self.update_hbox.addWidget(self.downloading_text)
+
+            self.update_hbox.addStretch()
+            self.addLayout(self.update_hbox)
+            communicate.download_update.connect(self.download_update)
+            communicate.check_update.connect(self.update_update)
+            self.update_update_buttons(0)
+        text_edit = TextEdit()
+        text_edit.setHtml(about)
+        text_edit.setReadOnly(True)
+
+        # Set the layout on the widget
+        self.addWidget(text_edit)
+        if ok.gui.ok.debug:
+            dump_button = PushButton(self.tr("Dump Threads(HotKey:Ctrl+Alt+D)"))
+            dump_button.clicked.connect(dump_threads)
+            self.addWidget(dump_button)
+
+    def update_update_buttons(self, percent, progress=""):
+        if ok.gui.app.updater.latest_release and not ok.gui.app.updater.downloading:
+            self.download_latest_button.setText(self.tr("Download latest version {version} ({size})").format(
+                version=ok.gui.app.updater.latest_release.get('version'),
+                size=ok.gui.app.updater.latest_release.get('readable_size')))
+            self.download_latest_button.show()
+        else:
+            self.download_latest_button.hide()
+        if ok.gui.app.updater.stable_release and not ok.gui.app.updater.downloading:
+            self.download_stable_button.setText(self.tr("Download stable version {version}  ({size})").format(
+                version=ok.gui.app.updater.stable_release.get('version'),
+                size=ok.gui.app.updater.stable_release.get('readable_size')))
+            self.download_stable_button.show()
+        else:
+            self.download_stable_button.hide()
+        if ok.gui.app.updater.downloading:
+            self.downloading_text.show()
+            self.downloading_text.setText(
+                self.tr('Downloading {progress} {percent}%').format(progress=progress, percent=format(percent, '.1f')))
+            self.download_bar.show()
+            self.download_bar.setValue(percent)
+        else:
+            self.downloading_text.hide()
+            self.download_bar.hide()
+
+    def download_update(self, percent, progress, done, error):
+        message = ""
+        if done:
+            if error:
+                bar = InfoBar.error
+                title = self.tr('Download Error:')
+                message = error
+            else:
+                bar = InfoBar.info
+                title = self.tr('Download Complete!')
+            bar(
+                title=title,
+                content=message,
+                orient=Qt.Horizontal,
+                isClosable=True,
+                position=InfoBarPosition.TOP,
+                duration=5000,  # won't disappear automatically
+                parent=self
+            )
+        self.update_update_buttons(percent, progress)
+
+    def download_latest(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.latest_release))
+
+    def download_stable(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.stable_release))
+
+    def update_update(self):
+        self.check_update_button.setText(
+            self.tr("Check for update"))
+        self.check_update_button.setEnabled(True)
+        if ok.gui.app.updater.latest_release or ok.gui.app.updater.stable_release:
+            bar = InfoBar.info
+            message = self.tr('Found new version!')
+        elif ok.gui.app.updater.error:
+            bar = InfoBar.error
+            message = self.tr('Found new version!')
+        else:
+            bar = InfoBar.info
+            message = self.tr("This is the newest version!")
+        bar(
+            title="",
+            content=message,
+            orient=Qt.Horizontal,
+            isClosable=True,
+            position=InfoBarPosition.TOP,
+            duration=5000,  # won't disappear automatically
+            parent=self
+        )
+        self.update_update_buttons(0)
+
+    def check_update(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.check_for_updates())
+        self.check_update_button.setText(self.tr("Checking for updates"))
+        self.check_update_button.setEnabled(False)

ok-script-0.0.50/ok/gui/about/VersionCard.py

@@ -0,0 +1,40 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QLabel, QHBoxLayout, QVBoxLayout
+from qfluentwidgets import IconWidget, TextWrap, CardWidget
+
+
+class VersionCard(CardWidget):
+    """ Sample card """
+
+    def __init__(self, icon, title, version, parent=None):
+        super().__init__(parent=parent)
+
+        self.iconWidget = IconWidget(icon, self)
+        self.titleLabel = QLabel(title, self)
+        self.contentLabel = QLabel(TextWrap.wrap(version, 45, False)[0], self)
+
+        self.hBoxLayout = QHBoxLayout(self)
+        self.vBoxLayout = QVBoxLayout()
+
+        self.setFixedSize(360, 90)
+        self.iconWidget.setFixedSize(48, 48)
+
+        self.hBoxLayout.setSpacing(28)
+        self.hBoxLayout.setContentsMargins(20, 0, 0, 0)
+        self.vBoxLayout.setSpacing(2)
+        self.vBoxLayout.setContentsMargins(0, 0, 0, 0)
+        self.vBoxLayout.setAlignment(Qt.AlignVCenter)
+
+        self.hBoxLayout.setAlignment(Qt.AlignVCenter)
+        self.hBoxLayout.addWidget(self.iconWidget)
+        self.hBoxLayout.addLayout(self.vBoxLayout)
+        self.vBoxLayout.addStretch(1)
+        self.vBoxLayout.addWidget(self.titleLabel)
+        self.vBoxLayout.addWidget(self.contentLabel)
+        self.vBoxLayout.addStretch(1)
+
+        self.titleLabel.setObjectName('titleLabel')
+        self.contentLabel.setObjectName('contentLabel')
+
+    def mouseReleaseEvent(self, e):
+        super().mouseReleaseEvent(e)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/debug/Screenshot.py

@@ -36,7 +36,6 @@ class Screenshot(QObject):
         self.click_screenshot_folder = get_path_relative_to_exe(ok.gui.ok.config.get("click_screenshots_folder"))
         self.screenshot_folder = get_path_relative_to_exe(ok.gui.ok.config.get("screenshots_folder"))
         logger.debug(f"init Screenshot {self.screenshot_folder} {self.click_screenshot_folder}")
-        print(f"init Screenshot {self.screenshot_folder} {self.screenshot_folder}")
         if self.click_screenshot_folder is not None or self.screenshot_folder is not None:
             self.task_queue = queue.Queue()
             self.exit_event.bind_queue(self.task_queue)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/resources.py

@@ -334,7 +334,7 @@ StartCard\x01\x03\x00\x00\x00\x08N\
 *\x89\xe6S\xd1Vh\x08\x00\x00\x00\x00\x06\x00\x00\x00\
 \x0dTrigger Tasks\x07\x00\
 \x00\x00\x09StartCard\x01\x03\x00\x00\
-\x00\x10{I_\x85\x90\x09b\xe9N\xfbR\xa1_\x00\
+\x00\x10p\xb9Q\xfb\x90\x09b\xe9N\xfbR\xa1_\x00\
 Y\xcb\x08\x00\x00\x00\x00\x06\x00\x00\x00\x1eWait\
 ing for task to \
 be enabled\x07\x00\x00\x00\x09S\
@@ -1160,7 +1160,7 @@ qt_resource_struct = b"\
 \x00\x00\x00>\x00\x01\x00\x00\x00\x01\x00\x00\x1a\x85\
 \x00\x00\x01\x8e2\xed>\xd3\
 \x00\x00\x00(\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\
-\x00\x00\x01\x8f\xce\x0b<g\
+\x00\x00\x01\x8f\xcf\xc5~\xab\
 \x00\x00\x00T\x00\x02\x00\x00\x00\x05\x00\x00\x00\x0d\
 \x00\x00\x00\x00\x00\x00\x00\x00\
 \x00\x00\x00b\x00\x02\x00\x00\x00\x05\x00\x00\x00\x08\

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/start/SelectCaptureListView.py

@@ -9,20 +9,18 @@ class SelectCaptureListView(ListWidget):
 
     def update_for_device(self, device, hwnd, capture):
         if self.count() == 0:
-            item = QListWidgetItem(self.tr(f"Game Window(Supports Background, Low Compatibility, Low Latency)"))
-
-            # Add the QListWidgetItem to the QListWidget
+            item = QListWidgetItem(self.tr(f"Game Window"))
             self.addItem(item)
-        tips = hwnd or self.tr("Supports Background, Low Compatibility, Low Latency")
+        tips = hwnd or ""
         if device == "windows":
             title = self.tr("Game Window")
             if self.count() == 2:
                 self.takeItem(1)
         else:
-            title = self.tr("Emulator Window")
+            title = self.tr("Emulator Window(Supports Background, Fast, Low Latency)")
             if self.count() == 1:
-                item = QListWidgetItem(self.tr("ADB (Supports Background, High Compatibility, High Latency)"))
+                item = QListWidgetItem(self.tr("ADB(Supports Background, Slow, High Compatibility, High Latency)"))
                 self.addItem(item)
-        self.item(0).setText(f"{title}({tips})")
+        self.item(0).setText(f"{title} - {tips}")
         selected = 0 if capture == "windows" else 1
         self.setCurrentRow(selected)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/start/StartCard.py

@@ -143,16 +143,21 @@ class StartCard(SettingCard):
             if not ok.gui.executor.connected():
                 self.status_bar.setTitle(self.tr("Game Window Disconnected"))
                 self.status_bar.setState(True)
-            elif not ok.gui.executor.can_capture():
-                self.status_bar.setTitle(self.tr('Paused: PC Game Window Must Be in Front!'))
-                self.status_bar.setState(True)
             elif active_trigger_task_count := ok.gui.executor.active_trigger_task_count():
-                self.status_bar.setTitle(
-                    self.tr("Running") + ": " + str(active_trigger_task_count) + ' ' + self.tr("Trigger Tasks"))
-                self.status_bar.setState(False)
+                if not ok.gui.executor.can_capture():
+                    self.status_bar.setTitle(self.tr('Paused: PC Game Window Must Be in Front!'))
+                    self.status_bar.setState(True)
+                else:
+                    self.status_bar.setTitle(
+                        self.tr("Running") + ": " + str(active_trigger_task_count) + ' ' + self.tr("Trigger Tasks"))
+                    self.status_bar.setState(False)
             elif task := ok.gui.executor.current_task:
-                self.status_bar.setTitle(self.tr("Running") + ": " + task.name)
-                self.status_bar.setState(False)
+                if not ok.gui.executor.can_capture():
+                    self.status_bar.setTitle(self.tr('Paused: PC Game Window Must Be in Front!'))
+                    self.status_bar.setState(True)
+                else:
+                    self.status_bar.setTitle(self.tr("Running") + ": " + task.name)
+                    self.status_bar.setState(False)
             else:
                 self.status_bar.setTitle(self.tr("Waiting for task to be enabled"))
                 self.status_bar.setState(False)

{ok-script-0.0.48 → ok-script-0.0.50}/ok/gui/widget/Tab.py

@@ -29,9 +29,13 @@ class Tab(ScrollArea):
 
     def addCard(self, title, widget, stretch=0, parent=None):
         container = Card(title, widget)
-        self.vBoxLayout.addWidget(container, stretch, Qt.AlignTop)
+        self.addWidget(container, stretch)
         return container
 
-    def addWidget(self, widget, stretch=0):
-        self.vBoxLayout.addWidget(widget, stretch, Qt.AlignTop)
+    def addWidget(self, widget, stretch=0, align=Qt.AlignTop):
+        self.vBoxLayout.addWidget(widget, stretch, align)
         return widget
+
+    def addLayout(self, layout, stretch=0):
+        self.vBoxLayout.addLayout(layout, stretch)
+        return layout

{ok-script-0.0.48 → ok-script-0.0.50}/ok/task/TaskExecutor.py

@@ -3,6 +3,7 @@ import time
 import traceback
 
 from ok.capture.BaseCaptureMethod import CaptureException
+from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod
 from ok.capture.adb.DeviceManager import DeviceManager
 from ok.gui.Communicate import communicate
 from ok.logging.Logger import get_logger
@@ -73,6 +74,7 @@ class TaskExecutor:
         return self._frame
 
     def supports_screen_ratio(self, supported_ratio):
+        frame = self.method.get_frame() if not isinstance(self.method, ADBCaptureMethod) else None
         if supported_ratio is None:
             return True, None
         width = self.method.width
@@ -88,9 +90,13 @@ class TaskExecutor:
 
         # Calculate the difference between the actual and supported ratios
         difference = abs(actual_ratio - supported_ratio)
-
+        support = difference <= 0.01 * supported_ratio
+        if not support:
+            logger.error(f'resolution error {width}x{height} {frame is None}')
+        if not support and frame:
+            communicate.screenshot.emit(frame, "resolution_error")
         # Check if the difference is within 1%
-        return difference <= 0.01 * supported_ratio, f"{width}x{height}"
+        return support, f"{width}x{height}"
 
     def can_capture(self):
         return self.method is not None and self.interaction is not None and self.interaction.should_capture()