ok-script 0.0.12__tar.gz → 0.0.13__tar.gz

{ok-script-0.0.12 → ok-script-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.12
+Version: 0.0.13
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking
@@ -17,6 +17,7 @@ Requires-Dist: PyDirectInput~=1.0.4
 Requires-Dist: pywin32==306
 Requires-Dist: typing-extensions~=4.10.0
 Requires-Dist: PySide6~=6.6.2
+Requires-Dist: PySide6-Fluent-Widgets~=1.5.5
 
 # ok-script
 

{ok-script-0.0.12 → ok-script-0.0.13}/ok/OK.py

@@ -8,7 +8,6 @@ from PySide6.QtWidgets import QApplication
 import ok
 from ok.logging.Logger import get_logger, config_logger
 
-
 logger = get_logger(__name__)
 
 
@@ -44,10 +43,8 @@ class OK:
 
     def start(self):
         if self.config.get("use_gui"):
-            self.app.show_loading()
-            from ok.gui.util.InitWorker import InitWorker
-            self.worker = InitWorker(self.do_init)
-            self.worker.start()
+            self.do_init()
+            self.app.show_main_window()
             self.app.exec()
         else:
             self.task_executor.start()
@@ -102,7 +99,9 @@ class OK:
         self.init_message("TaskExecutor init Start")
         from ok.task.TaskExecutor import TaskExecutor
         self.task_executor = TaskExecutor(self.device_manager, exit_event=self.exit_event,
-                                          tasks=self.config['tasks'], scenes=self.config['scenes'],
+                                          onetime_tasks=self.config.get('onetime_tasks', []),
+                                          trigger_tasks=self.config.get('trigger_tasks', []),
+                                          scenes=self.config['scenes'],
                                           feature_set=self.feature_set,
                                           ocr=self.ocr, config_folder=self.config.get("config_folder") or "config")
         self.init_message("TaskExecutor init Done")
@@ -118,6 +117,8 @@ class OK:
         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('capture_window_title'), self.config.get("debug"),
+                                                self.config.get('capture_window_title'),
+                                                self.config.get('capture_window_exe_name'),
+                                                self.config.get("debug"),
                                                 self.exit_event)
             ok.gui.device_manager = self.device_manager

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/BaseCaptureMethod.py

@@ -28,3 +28,6 @@ class BaseCaptureMethod:
 
     def clickable(self):
         pass
+
+    def connected(self):
+        pass

ok-script-0.0.13/ok/capture/HwndWindow.py

@@ -0,0 +1,198 @@
+# original https://github.com/dantmnf & https://github.com/hakaboom/winAuto
+import ctypes
+import re
+import threading
+
+import win32process
+from win32 import win32gui
+
+from ok.capture.windows.window import is_foreground_window, get_window_bounds
+from ok.gui.Communicate import communicate
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class HwndWindow:
+    visible = True
+    x = 0
+    y = 0
+    width = 0
+    height = 0
+    title_height = 0
+    border = 0
+    scaling = 1
+    top_cut = 0
+    right_cut = 0
+    bottom_cut = 0
+    left_cut = 0
+    window_change_listeners = []
+    frame_aspect_ratio = 0
+    hwnd = None
+    frame_width = 0
+    frame_height = 0
+    exists = False
+    title = None
+
+    def __init__(self, title="", exe_name=None, exit_event=threading.Event(), frame_width=0, frame_height=0):
+        super().__init__()
+        self.app_exit_event = exit_event
+        self.exe_name = exe_name
+        self.stop_event = threading.Event()
+        self.update_title_re(title)
+        self.visible = False
+        self.update_frame_size(frame_width, frame_height)
+        self.do_update_window_size()
+        self.thread = threading.Thread(target=self.update_window_size)
+        self.thread.start()
+
+    def update_title_and_exe(self, title, exe):
+        self.update_title_re(title)
+        self.exe_name = exe
+        self.hwnd = None
+        self.visible = False
+        self.exists = False
+        self.width = 0
+        self.height = 0
+        self.do_update_window_size()
+
+    def stop(self):
+        self.stop_event.set()
+
+    def update_title_re(self, title):
+        if not title:
+            self.title = None
+        else:
+            self.title = re.compile(title)
+
+    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.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}")
+
+    def update_window_size(self):
+        while not self.app_exit_event.is_set() and not self.stop_event.is_set():
+            self.do_update_window_size()
+            self.app_exit_event.wait(0.1)
+
+    def get_abs_cords(self, x, y):
+        return int(self.x * self.scaling + (self.border * self.scaling + x)), int(
+            self.y * self.scaling + (y + self.title_height * self.scaling))
+
+    def get_top_left_frame_offset(self):
+        return int(self.border * self.scaling), int(
+            self.title_height * self.scaling)
+
+    def do_update_window_size(self):
+        try:
+            visible, x, y, border, title_height, width, height, scaling = self.visible, self.x, self.y, self.border, self.title_height, self.width, self.height, self.scaling
+            if self.hwnd is None:
+                self.hwnd = find_hwnd_by_title_and_exe(self.title, self.exe_name)
+                self.exists = self.hwnd is not None
+            if self.hwnd is not None:
+                self.exists = win32gui.IsWindow(self.hwnd)
+                if self.exists:
+                    visible = is_foreground_window(self.hwnd)
+                    x, y, border, title_height, width, height, scaling = get_window_bounds(
+                        self.hwnd)
+                    if self.frame_aspect_ratio != 0:
+                        window_ratio = width / height
+                        if window_ratio < self.frame_aspect_ratio:
+                            cropped_window_height = int(width / self.frame_aspect_ratio)
+                            title_height += height - cropped_window_height
+                            height = cropped_window_height
+                    height = height
+                    width = width
+                    title_height = title_height
+                else:
+                    self.hwnd = None
+                changed = False
+                if visible != self.visible or self.scaling != scaling:
+                    self.visible = visible
+                    self.scaling = scaling
+                    changed = True
+                if (
+                        x != self.x or y != self.y or border != self.border or title_height != self.title_height or width != self.width or height != self.height or scaling != self.scaling) and (
+                        (x >= 0 and y >= 0) or self.visible):
+                    self.x, self.y, self.border, self.title_height, self.width, self.height = x, y, border, title_height, width, height
+                    changed = True
+                if changed:
+                    logger.debug(
+                        f"do_update_window_size changed: {self.visible} {self.x} {self.y} {self.border} {self.width} {self.height} {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:
+            logger.error(f"do_update_window_size exception", e)
+
+    def frame_ratio(self, size):
+        if self.frame_width > 0 and self.width > 0:
+            return int(size / self.frame_width * self.width)
+        else:
+            return size
+
+    def title_text(self):
+        if self.hwnd:
+            return win32gui.GetWindowText(self.hwnd)
+        return ""
+
+
+def find_hwnd_by_title_and_exe(title, exe):
+    if not title and not exe:
+        return None
+    hwnds = find_hwnds_by_title(title)
+    if exe is not None:
+        for hwnd in hwnds:
+            exe_2 = get_exe_name_by_hwnd(hwnd)
+            if exe_2 == exe:
+                return hwnd
+    if len(hwnds) > 0:
+        return hwnds[0]
+
+
+def find_hwnds_by_title(title):
+    hwnds = []
+    if not title:
+        return hwnds
+
+    def enum_windows_proc(hwnd, lParam):
+        text = win32gui.GetWindowText(hwnd)
+        if text and win32gui.IsWindowVisible(hwnd):
+            if isinstance(title, str) and title == text:
+                hwnds.append(hwnd)
+            elif re.search(title, text):
+                hwnds.append(hwnd)
+
+    win32gui.EnumWindows(enum_windows_proc, None)
+    if len(hwnds) > 0:
+        if len(hwnds) > 1:
+            logger.warning(f"Found multiple hwnds {len(hwnds)}")
+    return hwnds
+
+
+OpenProcess = ctypes.windll.kernel32.OpenProcess
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+GetModuleFileNameExW = ctypes.windll.psapi.GetModuleFileNameExW
+
+PROCESS_QUERY_INFORMATION = 0x0400
+PROCESS_VM_READ = 0x0010
+
+
+def get_exe_name_by_hwnd(hwnd):
+    # Get the process ID of the window
+    _, pid = win32process.GetWindowThreadProcessId(hwnd)
+
+    # Open the process
+    h_process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, pid)
+    if h_process:
+        # Get the executable name
+        exe_name = ctypes.create_unicode_buffer(1024)
+        GetModuleFileNameExW(h_process, None, exe_name, 1024)
+
+        # Close the process handle
+        CloseHandle(h_process)
+
+        return exe_name.value

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/adb/ADBCaptureMethod.py

@@ -1,6 +1,7 @@
 # original https://github.com/Toufool/AutoSplit/blob/master/src/capture_method/WindowsGraphicsCaptureMethod.py
 import cv2
 import numpy as np
+from adbutils import AdbError
 from typing_extensions import override
 
 from ok.capture.BaseCaptureMethod import BaseCaptureMethod
@@ -17,6 +18,7 @@ class ADBCaptureMethod(BaseCaptureMethod):
         super().__init__()
         self.exit_event = exit_event
         self._size = (width, height)
+        self._connected = (width != 0 and height != 0)
         self.device = device
 
     @property
@@ -41,17 +43,26 @@ class ADBCaptureMethod(BaseCaptureMethod):
         frame = do_screencap(self.device)
         if frame is not None:
             height, width, _ = frame.shape
+            self._connected = True
             self._size = (width, height)
+        else:
+            self._connected = False
         return frame
 
+    def connected(self):
+        return self._connected and self.device is not None
+
 
 def do_screencap(device) -> np.ndarray | None:
     if device is not None:
-        png_bytes = device.shell("screencap -p", encoding=None)
-        if png_bytes is not None and len(png_bytes) > 0:
-            image_data = np.frombuffer(png_bytes, dtype=np.uint8)
-            image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)
-            if image is not None:
-                return image
-            else:
-                logger.error(f"Screencap image decode error, probably disconnected")
+        try:
+            png_bytes = device.shell("screencap -p", encoding=None)
+            if png_bytes is not None and len(png_bytes) > 0:
+                image_data = np.frombuffer(png_bytes, dtype=np.uint8)
+                image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)
+                if image is not None:
+                    return image
+                else:
+                    logger.error(f"Screencap image decode error, probably disconnected")
+        except AdbError as e:
+            logger.error(f"Device {device} error", e)

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/adb/DeviceManager.py

@@ -1,11 +1,13 @@
 import threading
 
 import adbutils
+import win32gui
 
-from ok.capture.HwndWindow import HwndWindow
+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.vbox import installed_emulator
 from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
+from ok.capture.windows.window import get_window_bounds
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
 from ok.interaction.ADBInteraction import ADBBaseInteraction
@@ -17,18 +19,22 @@ logger = get_logger(__name__)
 
 class DeviceManager:
 
-    def __init__(self, config_folder, hwnd_title=None, debug=False, exit_event=None):
+    def __init__(self, config_folder, hwnd_title=None, exe_name=None, debug=False, exit_event=None):
         self._device = None
-        self.adb = None
+        self._connect_all = False
+        self.adb = self.adb = adbutils.AdbClient(host="127.0.0.1")
+        logger.debug(f'connect adb')
         self.hwnd_title = hwnd_title
+        self.exe_name = exe_name
         self.debug = debug
         self.interaction = None
         self.exit_event = exit_event
         if hwnd_title is not None:
-            self.hwnd = HwndWindow(hwnd_title, exit_event)
-        self.config = Config({"devices": {}}, config_folder, "DeviceManager")
+            self.hwnd = HwndWindow(hwnd_title, exe_name, exit_event)
+        self.config = Config({"devices": {}, "preferred": "none"}, config_folder, "DeviceManager")
         self.thread = None
         self.capture_method = None
+        self.start()
 
     def refresh(self):
         if self.thread is None or not self.thread.is_alive():
@@ -40,18 +46,40 @@ class DeviceManager:
         return self.config.get("devices")
 
     def connect_all(self):
-        for device in self.device_dict.values():
-            self.adb.connect(device['address'])
-        logger.debug(f'connect_all {self.adb.device_list()}')
+        if not self._connect_all:
+            for device in self.device_dict.values():
+                if device["device"] == "adb":
+                    self.adb.connect(device['address'])
+            self._connect_all = True
+            logger.debug(f'connect_all {self.adb.device_list()}')
 
     def get_devices(self):
-        return self.device_dict.values()
+        return list(self.device_dict.values())
 
     def do_refresh(self):
-        if self.adb is None:
-            self.adb = adbutils.AdbClient(host="127.0.0.1")
-            logger.debug(f'connect adb')
         self.connect_all()
+
+        if self.hwnd_title:
+            nick = ""
+            width = 0
+            height = 0
+            hwnd = find_hwnd_by_title_and_exe(self.hwnd_title, self.exe_name)
+            if hwnd is not None:
+                nick = win32gui.GetWindowText(hwnd)
+                _, _, _, _, width, height, _ = get_window_bounds(
+                    hwnd)
+            if not nick:
+                nick = self.exe_name
+            self.device_dict[self.hwnd_title] = {"address": "", "imei": self.hwnd_title, "device": "windows",
+                                                 "model": "", "nick": nick, "width": width,
+                                                 "height": height,
+                                                 "hwnd": nick, "capture": "windows",
+                                                 "connected": hwnd is not None
+                                                 }
+            if width != 0:
+                self.device_dict[self.hwnd_title]["resolution"] = f"{width}x{height}"
+            communicate.adb_devices.emit(False)
+
         installed_emulators = installed_emulator()
         for device in self.adb.list():
             logger.debug(f'adb.list() {device}')
@@ -75,7 +103,7 @@ class DeviceManager:
                 height, width, _ = frame.shape
             adb_device = {"address": device.serial, "imei": imei, "device": "adb", "capture": "adb", "width": width,
                           "height": height,
-                          "model": device.prop.model, "nick": device.prop.model, "connected": True, "preferred": False,
+                          "model": device.prop.model, "nick": device.prop.model, "connected": True,
                           "resolution": f"{width}x{height}"}
             found = False
             for emulator in installed_emulators:
@@ -95,24 +123,12 @@ class DeviceManager:
                 self.device_dict[imei] = adb_device
             adb_connected.append(imei)
         for imei in self.device_dict:
-            if imei not in adb_connected:
+            if imei not in adb_connected and self.device_dict[imei]['device'] == 'adb':
                 self.device_dict[imei]['connected'] = False
-        if self.hwnd_title:
-            nick = ""
-            width = 0
-            height = 0
-            if self.hwnd:
-                nick = self.hwnd.title_text()
-                width = self.hwnd.width
-                height = self.hwnd.height
-            self.device_dict[self.hwnd_title] = {"address": "", "imei": self.hwnd_title, "device": "windows",
-                                                 "model": "", "nick": nick or self.hwnd_title, "width": width,
-                                                 "height": height,
-                                                 "hwnd": nick, "capture": "windows",
-                                                 "connected": self.hwnd is not None and self.hwnd.exists,
-                                                 "resolution": f"{width}x{height}"}
-        communicate.adb_devices.emit()
+
+        communicate.adb_devices.emit(True)
         self.config.save_file()
+        self.start()
         logger.debug(f'refresh {self.device_dict}')
 
     def set_preferred_device(self, imei=None):
@@ -127,12 +143,11 @@ class DeviceManager:
             self.config["preferred"] = imei
             self.config.save_file()
         logger.debug(f'preferred device: {preferred}')
+        self.start()
 
     def get_preferred_device(self):
         imei = self.config.get("preferred")
         preferred = self.device_dict.get(imei)
-        if preferred is None:
-            raise ValueError(f"preferred device {imei} is none")
         return preferred
 
     def set_hwnd_name(self, hwnd_name):
@@ -140,19 +155,32 @@ class DeviceManager:
         if preferred.get("hwnd") != hwnd_name:
             preferred['hwnd'] = hwnd_name
             self.config.save_file()
+            self.start()
 
     def set_capture(self, capture):
         preferred = self.get_preferred_device()
-        preferred['capture'] = capture
-        self.config.save_file()
+        if preferred.get("capture") != capture:
+            preferred['capture'] = capture
+            self.config.save_file()
+        self.start()
 
     def get_hwnd_name(self):
         preferred = self.get_preferred_device()
         return preferred.get('hwnd')
 
+    def ensure_hwnd(self, title, exe, frame_width=0, frame_height=0):
+        if self.hwnd is None:
+            self.hwnd = HwndWindow(title, exe, self.exit_event, frame_width, frame_height)
+        else:
+            self.hwnd.update_frame_size(frame_width, frame_height)
+            self.hwnd.update_title_and_exe(title, exe)
+
     def start(self):
         preferred = self.get_preferred_device()
+        if preferred is None:
+            return
         if preferred['device'] == 'windows':
+            self.ensure_hwnd(self.hwnd_title, self.exe_name)
             if not isinstance(self.capture_method, WindowsGraphicsCaptureMethod):
                 if self.capture_method is not None:
                     self.capture_method.close()
@@ -160,39 +188,32 @@ class DeviceManager:
                 self.interaction = Win32Interaction(self.capture_method)
             self.capture_method.hwnd_window = self.hwnd
         else:
+            self.connect_all()
             for adb_device in self.adb.device_list():
                 if adb_device.serial == preferred.get('address'):
+                    logger.debug(f"set device {adb_device}")
                     self._device = adb_device
             hwnd_name = preferred.get('hwnd')
             width = preferred.get('width', 0)
             height = preferred.get('height', 0)
             if preferred.get('capture') == "windows":
-                if not hwnd_name:
-                    raise ValueError(f"adb device preferred hwnd is none, capture is windows {preferred}")
-                if self.hwnd is None:
-                    self.hwnd = HwndWindow(hwnd_name, self.exit_event, width, height)
+                self.ensure_hwnd(hwnd_name, None, width, height)
                 if not isinstance(self.capture_method, WindowsGraphicsCaptureMethod):
                     if self.capture_method is not None:
                         self.capture_method.close()
                     self.capture_method = WindowsGraphicsCaptureMethod(self.hwnd)
-                self.hwnd.title = hwnd_name
                 self.capture_method.hwnd_window = self.hwnd
             elif not isinstance(self.capture_method, ADBCaptureMethod):
                 if self.capture_method is not None:
                     self.capture_method.close()
                 self.capture_method = ADBCaptureMethod(self._device, self.exit_event, width=width,
                                                        height=height)
-            self.interaction = ADBBaseInteraction(self, self.capture_method)
-            if self.debug:
-                if self.hwnd is None and hwnd_name:
-                    if self.hwnd is None:
-                        self.hwnd = HwndWindow(hwnd_name, self.exit_event, width, height)
-                self.hwnd.title = hwnd_name
+            self.interaction = ADBBaseInteraction(self, self.capture_method, width, height)
+            if self.debug and hwnd_name:
+                self.ensure_hwnd(hwnd_name, None, width, height)
             elif self.hwnd is not None:
                 self.hwnd.stop()
                 self.hwnd = None
-            if self.hwnd:
-                self.hwnd.update_frame_size(width, height)
 
     @property
     def device(self):

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/adb/vbox.py

@@ -85,15 +85,16 @@ def installed_emulator():
 
     logger.debug(f'running VirtualBox servers: {running_servers}')
     results = []
-    for server in running_servers:
-        logger.debug(f'checking {server}')
-        hproc = OpenProcess(PROCESS_QUERY_INFORMATION, False, server.pid)
-        if not hproc:
-            logger.debug(f'try OpenProcess failed for PID {server.pid}')
-            continue
-        CloseHandle(hproc)
-        logger.debug(f'checking hproc end {server}')
-        try:
+    try:
+        for server in running_servers:
+            logger.debug(f'checking {server}')
+            hproc = OpenProcess(PROCESS_QUERY_INFORMATION, False, server.pid)
+            if not hproc:
+                logger.debug(f'try OpenProcess failed for PID {server.pid}')
+                continue
+            CloseHandle(hproc)
+            logger.debug(f'checking hproc end {server}')
+
             client = win32com.client.Dispatch(server.clsid)
             for machine in client.Machines:
                 machine_name = machine.Name
@@ -118,8 +119,8 @@ def installed_emulator():
                                                         address, 2, 1, override_identifier=identifier,
                                                         preload_device_info={'emulator_hypervisor': 'vbox'}))
             logger.debug(f'try checking {server}')
-        except Exception as e:
-            logger.error(f'failed to check server :{server} {e}', e)
+    except Exception as e:
+        logger.error(f'failed to check server :{server} {e}', e)
     return results
 
 

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -37,6 +37,8 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
     item = None
     session = None
     cputex = None
+    rtdevice = None
+    dxdevice = None
 
     def __init__(self, hwnd_window: HwndWindow):
         super().__init__()
@@ -105,6 +107,9 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
                 return self.get_frame()
         self.last_frame = img
 
+    def connected(self):
+        return self.hwnd_window is not None and self.hwnd_window.exists
+
     def start_or_stop(self, capture_cursor=False):
         if self.hwnd_window.exists and self.frame_pool is None:
             logger.info('init windows capture')
@@ -205,7 +210,7 @@ class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
         return self.hwnd_window.get_abs_cords(x, y)
 
     def clickable(self):
-        return self.hwnd_window.visible
+        return self.hwnd_window is not None and self.hwnd_window.visible
 
 
 def crop_image(image, border, title_height):

{ok-script-0.0.12 → ok-script-0.0.13}/ok/capture/windows/utils.py

@@ -1,6 +1,4 @@
 import asyncio
-import ctypes
-import ctypes.wintypes
 import os
 import sys
 from collections.abc import Callable, Iterable
@@ -83,23 +81,6 @@ def try_delete_dc(dc: "PyCDC"):
         pass
 
 
-def get_window_bounds(hwnd: int) -> tuple[int, int, int, int]:
-    extended_frame_bounds = ctypes.wintypes.RECT()
-    ctypes.windll.dwmapi.DwmGetWindowAttribute(
-        hwnd,
-        DWMWA_EXTENDED_FRAME_BOUNDS,
-        ctypes.byref(extended_frame_bounds),
-        ctypes.sizeof(extended_frame_bounds),
-    )
-
-    window_rect = win32gui.GetWindowRect(hwnd)
-    window_left_bounds = extended_frame_bounds.left - window_rect[0]
-    window_top_bounds = extended_frame_bounds.top - window_rect[1]
-    window_width = extended_frame_bounds.right - extended_frame_bounds.left
-    window_height = extended_frame_bounds.bottom - extended_frame_bounds.top
-    return window_left_bounds, window_top_bounds, window_width, window_height
-
-
 def open_file(file_path: str | bytes | os.PathLike[str] | os.PathLike[bytes]):
     os.startfile(file_path)  # noqa: S606
 

{ok-script-0.0.12 → ok-script-0.0.13}/ok/config/Config.py

@@ -5,6 +5,7 @@ from ok.util.path import get_path_relative_to_exe
 class Config:
     def __init__(self, default, folder, name):
         super().__init__()
+        self.default = default
         self.config_file = get_path_relative_to_exe(folder, f"{name}.json")
         self.config = read_json_file(self.config_file)
         if self.config is None:
@@ -15,6 +16,11 @@ class Config:
     def save_file(self):
         write_json_file(self.config_file, self.config)
 
+    def reset_to_default(self):
+        self.config.clear()
+        self.update(self.default)
+        self.save_file()
+
     def update(self, *args, **kwargs):
         self.config.update(*args, **kwargs)
         self.save_file()