ok-script 0.0.58__tar.gz → 0.0.60__tar.gz

{ok-script-0.0.58 → ok-script-0.0.60}/PKG-INFO

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

{ok-script-0.0.58 → ok-script-0.0.60}/ok/OK.py

@@ -9,7 +9,9 @@ import ok
 from ok.logging.Logger import get_logger, config_logger
 from ok.util.exit_event import ExitEvent
 from ok.util.path import install_path_isascii
+from ok.util.win32_process import check_mutex
 
+check_mutex()
 logger = get_logger(__name__)
 
 

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/BaseCaptureMethod.py

@@ -51,6 +51,9 @@ class BaseCaptureMethod:
         except Exception as e:
             raise CaptureException() from e
 
+    def __str__(self):
+        return f'{self.__class__.__name__}_{self.width}x{self.height}'
+
     def do_get_frame(self):
         pass
 

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/HwndWindow.py

@@ -136,7 +136,7 @@ class HwndWindow:
         return ""
 
     def __str__(self) -> str:
-        return f"title:{self.title},exe:{self.exe_name},width:{self.width},height:{self.height},exists:{self.exists},visible:{self.visible}"
+        return f"title:{self.title}_{self.exe_name}_{self.width}x{self.height}_{self.exists}_{self.visible}"
 
 
 def find_hwnd_by_title_and_exe(title, exe_name):

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/adb/DeviceManager.py

@@ -1,5 +1,3 @@
-import threading
-
 import win32gui
 
 from ok.capture.HwndWindow import HwndWindow, find_hwnd_by_title_and_exe
@@ -11,6 +9,7 @@ from ok.gui.Communicate import communicate
 from ok.interaction.ADBInteraction import ADBBaseInteraction
 from ok.interaction.Win32Interaction import Win32Interaction
 from ok.logging.Logger import get_logger
+from ok.util.Handler import Handler
 
 logger = get_logger(__name__)
 
@@ -32,14 +31,13 @@ class DeviceManager:
                                    windows_capture_config.get('exe'))
         self.config = Config({"devices": {}, "preferred": "none", "pc_full_path": None}, config_folder,
                              "DeviceManager")
-        self.thread = None
         self.capture_method = None
-        self.refresh()
+        self.handler = Handler(exit_event, 'RefreshAdb')
+        self.handler.post(self.do_refresh, 5)
 
     def refresh(self):
-        if self.thread is None or not self.thread.is_alive():
-            self.thread = threading.Thread(target=self.do_refresh, name="refresh adb")
-            self.thread.start()
+        logger.debug('calling refresh')
+        self.handler.post(self.do_refresh, remove_existing=True)
 
     @property
     def device_dict(self):
@@ -61,14 +59,17 @@ class DeviceManager:
             logger.debug(f'connect adb')
         return self._adb
 
+    def adb_connect(self, addr):
+        try:
+            self.adb.connect(addr, timeout=2)
+        except Exception as e:
+            logger.error("adb connect error", e)
+
     def connect_all(self):
         if not self._connect_all:
             for device in self.device_dict.values():
                 if device["device"] == "adb":
-                    try:
-                        self.adb.connect(device['address'])
-                    except Exception as e:
-                        logger.error("adb connect error", e)
+                    self.adb_connect(device['address'])
             self._connect_all = True
             logger.debug(f'connect_all')
 
@@ -124,7 +125,7 @@ class DeviceManager:
             logger.debug(f'adb.list() {device}')
         for emulator in installed_emulators:
             logger.debug(f"installed_emulator: {emulator}")
-            self.adb.connect(emulator.adb_address, timeout=1)
+            self.adb_connect(emulator.adb_address)
         device_list = self.adb.device_list()
         device_list = sorted(device_list, key=lambda x: x.serial)
         adb_connected = []

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/adb/vbox.py

@@ -27,25 +27,6 @@ class VBoxSerever(VBoxClass):
 
 import ctypes
 
-vbox_clsids = [
-    VBoxClass('{20190809-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer', 'ld'),
-    VBoxClass('{20191216-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer9', 'ld9'),
-    VBoxClass('{88888888-47b9-4a1e-82b2-07ccd5323c3f}', 'Nox', 'nox'),
-    VBoxClass('{baf3f651-58d8-429d-97ad-2b5699b43567}', 'BlueStacks', 'bstk'),
-    VBoxClass('{b1a7a4f2-47b9-4a1e-82b2-07ccd5323c3a}', 'Memu', 'memu'),
-    VBoxClass('{81919390-a492-11e5-a837-0800200c9a66}', 'MuMu', 'mumu'),
-    VBoxClass('{23cd1535-edaa-4f21-a4ab-45d97fd1d58b}', 'MuMu 12',
-              'mumu 12'),
-    # ('{B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F}', 'Oracle', 'oracle'),  # nobody uses this
-]
-
-OpenProcess = ctypes.windll.kernel32.OpenProcess
-OpenProcess.argtypes = [ctypes.c_uint32, ctypes.c_bool, ctypes.c_uint32]
-OpenProcess.restype = ctypes.c_void_p
-PROCESS_QUERY_INFORMATION = 0x0400
-CloseHandle = ctypes.windll.kernel32.CloseHandle
-CloseHandle.argtypes = [ctypes.c_void_p]
-
 
 def get_server(clsid):
     try:
@@ -60,6 +41,24 @@ def get_server(clsid):
 
 # current process's privilege must equal to the target process's privilege, can raise a error if not
 def installed_emulator():
+    vbox_clsids = [
+        VBoxClass('{20190809-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer', 'ld'),
+        VBoxClass('{20191216-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer9', 'ld9'),
+        VBoxClass('{88888888-47b9-4a1e-82b2-07ccd5323c3f}', 'Nox', 'nox'),
+        VBoxClass('{baf3f651-58d8-429d-97ad-2b5699b43567}', 'BlueStacks', 'bstk'),
+        VBoxClass('{b1a7a4f2-47b9-4a1e-82b2-07ccd5323c3a}', 'Memu', 'memu'),
+        VBoxClass('{81919390-a492-11e5-a837-0800200c9a66}', 'MuMu', 'mumu'),
+        VBoxClass('{23cd1535-edaa-4f21-a4ab-45d97fd1d58b}', 'MuMu 12',
+                  'mumu 12'),
+        # ('{B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F}', 'Oracle', 'oracle'),  # nobody uses this
+    ]
+
+    OpenProcess = ctypes.windll.kernel32.OpenProcess
+    OpenProcess.argtypes = [ctypes.c_uint32, ctypes.c_bool, ctypes.c_uint32]
+    OpenProcess.restype = ctypes.c_void_p
+    PROCESS_QUERY_INFORMATION = 0x0400
+    CloseHandle = ctypes.windll.kernel32.CloseHandle
+    CloseHandle.argtypes = [ctypes.c_void_p]
     logger.debug('enumerating vbox targets')
     vbox_servers: list[VBoxSerever] = []
     for vboxcls in vbox_clsids:
@@ -84,6 +83,7 @@ def installed_emulator():
 
     logger.debug(f'running VirtualBox servers: {running_servers}')
     results = []
+    server = ""
     try:
         for server in running_servers:
             logger.debug(f'checking {server}')

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/windows/BaseWindowsCaptureMethod.py

@@ -34,3 +34,11 @@ class BaseWindowsCaptureMethod(BaseCaptureMethod):
 
     def clickable(self):
         return self.hwnd_window is not None and self.hwnd_window.visible
+
+    def __str__(self):
+        result = f'{self.__class__.__name__}_{self.width}x{self.height}'
+        if self.hwnd_window is None:
+            result += '_no_window'
+        else:
+            result += f'_{self.hwnd_window}'
+        return result

{ok-script-0.0.58 → ok-script-0.0.60}/ok/capture/windows/dump.py

@@ -1,15 +1,18 @@
+import subprocess
 import sys
-import traceback
 import threading
+import traceback
 
 from ok.util.path import get_path_relative_to_exe
 
+
 def get_thread_name(thread_id):
     for thread in threading.enumerate():
         if thread.ident == thread_id:
             return thread.name
     return ""  # Return empty string if the thread name is not found
 
+
 def dump_threads():
     # Get the stack trace for each thread
     thread_dumps = []
@@ -25,3 +28,4 @@ def dump_threads():
 
     with open(output_file, "w") as file:
         file.write("\n\n".join(thread_dumps))
+        subprocess.Popen(r'explorer /select,"{}"'.format(output_file))

{ok-script-0.0.58 → ok-script-0.0.60}/ok/gui/App.py

@@ -8,6 +8,7 @@ from qfluentwidgets import FluentTranslator, qconfig, Theme
 
 import ok
 import ok.gui.resources
+from ok.firebase.FireBaseAnalytics import FireBaseAnalytics
 from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
@@ -47,6 +48,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)
 
         translator = QTranslator(self.app)
         full_path = os.path.join(i18n_path, f"{self.locale.name()}")

{ok-script-0.0.58 → ok-script-0.0.60}/ok/gui/Communicate.py

@@ -12,7 +12,7 @@ class Communicate(QObject):
     task_info = Signal()
     window = Signal(bool, int, int, int, int, int, int, float)
     loading_progress = Signal(str)
-    notification = Signal(str, str, bool)
+    notification = Signal(str, str, bool, bool)
     executor_paused: Signal = Signal(bool)
     screenshot = Signal(np.ndarray, str)
     update_overlay = Signal()

{ok-script-0.0.58 → ok-script-0.0.60}/ok/gui/MainWindow.py

@@ -7,6 +7,7 @@ import ok.gui
 from ok.capture.windows.dump import dump_threads
 from ok.gui.Communicate import communicate
 from ok.gui.about.AboutTab import AboutTab
+from ok.gui.debug.DebugTab import DebugTab
 from ok.gui.start.StartTab import StartTab
 from ok.gui.tasks.OneTimeTaskTab import OneTimeTaskTab
 from ok.gui.tasks.TriggerTaskTab import TriggerTaskTab
@@ -41,8 +42,13 @@ class MainWindow(MSFluentWindow):
         #     debug_tab = DebugTab()
         #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
         # ... Add other tabs similarly
+        if debug:
+            debug_tab = DebugTab(exit_event)
+            self.addSubInterface(debug_tab, FluentIcon.DEVELOPER_TOOLS, self.tr('Debug'),
+                                 position=NavigationItemPosition.BOTTOM)
+
         if about:
-            about_tab = AboutTab(icon, title, version, about)
+            about_tab = AboutTab(icon, title, version, debug, about)
             self.addSubInterface(about_tab, FluentIcon.QUESTION, self.tr('About'),
                                  position=NavigationItemPosition.BOTTOM)
         # Styling the tabs and content if needed, for example:
@@ -82,7 +88,7 @@ class MainWindow(MSFluentWindow):
         )
         self.tray.showMessage(title, message)
 
-    def show_notification(self, message, title=None, error=None):
+    def show_notification(self, message, title=None, error=False, tray=True):
         bar = InfoBar.error if error else InfoBar.info
         if title is None:
             title = f"{self.tr('Error') if error else 'Info'}:"
@@ -95,9 +101,8 @@ class MainWindow(MSFluentWindow):
             duration=5000,  # won't disappear automatically
             parent=self.window()
         )
-        if title is None:
-            title = self.title
-        self.tray.showMessage(title, message)
+        if tray:
+            self.tray.showMessage(title, message)
 
     def capture_error(self):
         self.show_notification(self.tr('Please check whether the game window is selected correctly!'),

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

@@ -0,0 +1,145 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QVBoxLayout
+from qfluentwidgets import PushButton, InfoBar, InfoBarPosition
+
+import ok.gui
+from ok.gui.Communicate import communicate
+from ok.gui.about.VersionCard import VersionCard
+from ok.gui.widget.Tab import Tab
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class AboutTab(Tab):
+    def __init__(self, icon, title, version, debug, about):
+        super().__init__()
+        self.version_card = VersionCard(icon, title, version, debug, self)
+        # Create a QTextEdit instance
+        self.addWidget(self.version_card)
+        about_label = QLabel()
+        about_label.setText(about)
+        about_label.setWordWrap(True)
+        about_label.setOpenExternalLinks(True)
+
+        # Set the layout on the widget
+        self.addWidget(about_label)
+        if ok.gui.app.updater.enabled():
+            self.download_latest_button = PushButton(self.tr('Download Release'))
+            self.download_latest_button.clicked.connect(self.download_latest)
+            self.download_latest_debug_button = PushButton(self.tr('Download Debug'))
+            self.download_latest_debug_button.clicked.connect(self.download_latest_debug)
+
+            self.latest_hbox = QHBoxLayout()
+            self.addLayout(self.latest_hbox)
+            self.latest_label = QLabel()
+            self.latest_label.setWordWrap(True)
+            self.latest_hbox.addWidget(self.latest_label, stretch=1)
+            self.download_latest_vbox = QVBoxLayout()
+            self.latest_hbox.addLayout(self.download_latest_vbox, stretch=0)
+            self.download_latest_vbox.addWidget(self.download_latest_button, stretch=0)
+            self.download_latest_vbox.addWidget(self.download_latest_debug_button, stretch=0)
+            self.download_latest_vbox.addStretch(1)
+
+            self.download_stable_button = PushButton(self.tr('Download Release'))
+            self.download_stable_button.clicked.connect(self.download_stable)
+            self.download_stable_debug_button = PushButton(self.tr('Download Debug'))
+            self.download_stable_debug_button.clicked.connect(self.download_stable_debug)
+            self.stable_hbox = QHBoxLayout()
+            self.stable_label = QLabel()
+            self.stable_label.setWordWrap(True)
+            self.addLayout(self.stable_hbox)
+            self.stable_hbox.addWidget(self.stable_label, stretch=1)
+
+            self.download_stable_vbox = QVBoxLayout()
+            self.stable_hbox.addLayout(self.download_stable_vbox, stretch=0)
+            self.download_stable_vbox.addWidget(self.download_stable_button, stretch=0)
+            self.download_stable_vbox.addWidget(self.download_stable_debug_button, stretch=0)
+            self.download_stable_vbox.addStretch(1)
+
+            communicate.download_update.connect(self.download_update)
+            communicate.check_update.connect(self.update_update)
+
+            self.update_update_buttons()
+
+    def update_update_buttons(self):
+        if ok.gui.app.updater.latest_release:
+            self.latest_label.setText(self.get_version_text(ok.gui.app.updater.latest_release))
+        has_release_asset = ok.gui.app.updater.latest_release is not None and ok.gui.app.updater.latest_release.get(
+            'release_asset') is not None
+        self.download_latest_button.setVisible(has_release_asset)
+        has_release_debug = ok.gui.app.updater.latest_release is not None and ok.gui.app.updater.latest_release.get(
+            'debug_asset') is not None
+        self.download_latest_debug_button.setVisible(has_release_debug)
+        self.latest_label.setVisible(has_release_asset or has_release_debug)
+
+        if ok.gui.app.updater.stable_release:
+            self.stable_label.setText(self.get_version_text(ok.gui.app.updater.stable_release))
+
+        has_release_asset = ok.gui.app.updater.stable_release is not None and ok.gui.app.updater.stable_release.get(
+            'release_asset') is not None
+        self.download_stable_button.setVisible(has_release_asset)
+        has_release_debug = ok.gui.app.updater.stable_release is not None and ok.gui.app.updater.stable_release.get(
+            'debug_asset') is not None
+        self.download_stable_debug_button.setVisible(has_release_debug)
+        self.stable_label.setVisible(has_release_asset or has_release_debug)
+
+        self.download_latest_button.setDisabled(ok.gui.app.updater.downloading)
+        self.download_stable_button.setDisabled(ok.gui.app.updater.downloading)
+        self.download_stable_debug_button.setDisabled(ok.gui.app.updater.downloading)
+        self.download_latest_debug_button.setDisabled(ok.gui.app.updater.downloading)
+
+    def update_update(self, error):
+        self.update_update_buttons()
+
+    def get_version_text(self, release):
+        text = "<h3>{title}: {version}</h3>"
+        if release.get('prerelease'):
+            title = self.tr('Beta Version')
+        else:
+            title = self.tr('Stable Version')
+        text = text.format(title=title, version=release.get('version'))
+        text += "<p>{date}</p>".format(date=release.get('date'))
+        text += "<p>{notes}</p>".format(notes=text_to_html_paragraphs(release.get('notes')))
+        return text
+
+    def download_update(self, percent, progress, done, error):
+        if done:
+            if error:
+                title = self.tr('Download Error:')
+                message = error
+                InfoBar.error(
+                    title=title,
+                    content=message,
+                    orient=Qt.Horizontal,
+                    isClosable=True,
+                    position=InfoBarPosition.TOP,
+                    duration=5000,  # won't disappear automatically
+                    parent=self
+                )
+
+        self.update_update_buttons()
+
+    @staticmethod
+    def download_latest():
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.latest_release, False))
+
+    @staticmethod
+    def download_latest_debug():
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.latest_release, True))
+
+    @staticmethod
+    def download_stable():
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.stable_release, False))
+
+    @staticmethod
+    def download_stable_debug():
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.stable_release, True))
+
+
+def text_to_html_paragraphs(text):
+    # Split the text into lines
+    lines = text.split('\n')
+
+    # Wrap each line in a <p> tag and join them
+    return ''.join(f'<p>{line}</p>' for line in lines)

{ok-script-0.0.58 → ok-script-0.0.60}/ok/gui/about/VersionCard.py

@@ -1,16 +1,19 @@
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QLabel
-from qfluentwidgets import SettingCard, PushButton, ProgressBar, InfoBar, InfoBarPosition
+from qfluentwidgets import SettingCard, PushButton, ProgressBar, InfoBar, InfoBarPosition, MessageBox
 
 import ok
 from ok.gui.Communicate import communicate
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class VersionCard(SettingCard):
     """ Sample card """
 
-    def __init__(self, icon, title, version, parent=None):
-        super().__init__(icon, title, version)
+    def __init__(self, icon, title, version, debug, parent=None):
+        super().__init__(icon, title, f'{version} {self.get_type(debug)}')
         self.downloading_text = QLabel()
         self.hBoxLayout.addWidget(self.downloading_text)
         self.hBoxLayout.addSpacing(16)
@@ -25,11 +28,17 @@ class VersionCard(SettingCard):
         self.check_update_button.clicked.connect(self.check_update)
         self.hBoxLayout.addWidget(self.check_update_button)
         self.hBoxLayout.addSpacing(16)
+        self.update_button = PushButton()
+        self.update_button.clicked.connect(self.show_update_dialog)
+        self.hBoxLayout.addWidget(self.update_button)
+        self.hBoxLayout.addSpacing(16)
         self.update_buttons(0, "")
         communicate.check_update.connect(self.update_update)
         communicate.download_update.connect(self.download_update)
 
     def download_update(self, percent, progress, done, error):
+        if done and not error:
+            self.show_update_dialog()
         self.update_buttons(percent, progress)
 
     def update_buttons(self, percent, progress):
@@ -42,6 +51,33 @@ class VersionCard(SettingCard):
         else:
             self.downloading_text.hide()
             self.download_bar.hide()
+        if ok.gui.app.updater.to_update:
+            self.update_button.setText(
+                self.tr('Update to {version} {type}').format(version=ok.gui.app.updater.to_update.get('version'),
+                                                             type=self.get_type()))
+        self.update_button.setVisible(ok.gui.app.updater.to_update is not None)
+
+    def get_type(self, debug=None):
+        if debug is None and ok.gui.app.updater.to_update is not None:
+            debug = ok.gui.app.updater.to_update.get('debug')
+        return self.tr('Debug') if debug else self.tr('Release')
+
+    def show_update_dialog(self):
+        title = self.tr('Update Now')
+        content = self.tr(
+            "Are you sure you want to update to {version} {type}?".format(
+                version=ok.gui.app.updater.to_update.get(
+                    'version'), type=self.get_type())) + '\n\n' + ok.gui.app.updater.to_update.get(
+            'notes')
+
+        w = MessageBox(title, content, self.window())
+        w.setContentCopyable(True)
+        if w.exec():
+            logger.info("user click update")
+            self.do_update()
+
+    def do_update(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.update())
 
     def update_update(self, error):
         title = self.tr('Info')
@@ -67,6 +103,6 @@ class VersionCard(SettingCard):
         self.check_update_button.setEnabled(True)
 
     def check_update(self):
-        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.check_for_updates())
+        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.60/ok/gui/debug/DebugTab.py

@@ -0,0 +1,53 @@
+import subprocess
+
+from PySide6.QtWidgets import QWidget
+from qfluentwidgets import PushButton, FlowLayout
+
+import ok.gui
+from ok.capture.windows.dump import dump_threads
+from ok.gui.widget.Tab import Tab
+from ok.logging.Logger import get_logger
+from ok.util.Handler import Handler
+
+logger = get_logger(__name__)
+
+
+class DebugTab(Tab):
+    def __init__(self, exit_event):
+        super().__init__()
+        widget = QWidget()
+        layout = FlowLayout(widget, False)
+
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setVerticalSpacing(20)
+        layout.setHorizontalSpacing(10)
+        self.addWidget(widget)
+        self.handler = Handler(exit_event, "DebugTab")
+
+        dump_button = PushButton(self.tr("Dump Threads(HotKey:Ctrl+Alt+D)"))
+        dump_button.clicked.connect(lambda: self.handler.post(dump_threads))
+        layout.addWidget(dump_button)
+
+        capture_button = PushButton(self.tr("Capture Screenshot"))
+        capture_button.clicked.connect(lambda: self.handler.post(self.capture))
+        layout.addWidget(capture_button)
+
+        open_log_folder = PushButton(self.tr("Open Logs"))
+
+    def capture(self):
+        if ok.gui.device_manager.capture_method is not None:
+            logger.info(f'ok.gui.device_manager.capture_method {ok.gui.device_manager.capture_method}')
+            capture = str(ok.gui.device_manager.capture_method)
+            frame = ok.gui.device_manager.capture_method.do_get_frame()
+            if frame is not None:
+                file_path = ok.gui.ok.screenshot.generate_screen_shot(frame, ok.gui.ok.screenshot.ui_dict,
+                                                                      ok.gui.ok.screenshot.screenshot_folder, capture)
+
+                # Use subprocess.Popen to open the file explorer and select the file
+                subprocess.Popen(r'explorer /select,"{}"'.format(file_path))
+                logger.info(f'captured screenshot: {capture}')
+                self.alert_info(self.tr('Capture Success'))
+            else:
+                self.alert_error(self.tr('Capture returned None'))
+        else:
+            self.alert_error(self.tr('No Capture Available or Selected'))

{ok-script-0.0.58 → ok-script-0.0.60}/ok/gui/debug/Screenshot.py

@@ -107,31 +107,35 @@ class Screenshot(QObject):
         pil_image = self.to_pil_image(frame)
         if pil_image is None:
             return
-        self.save_pil_image(name + '_original', folder, pil_image)
+
+        originl_name = self.save_pil_image(name + '_original', folder, pil_image)
         # Ensure no fill
         draw = ImageDraw.Draw(pil_image)
 
         frame_ratio = 1
-        for key, value in ui_dict.items():
-            boxes = value[0]
-            color = tuple([int(x) for x in value[2].getRgb()])  # Convert QColor to BGR tuple
-            for box in boxes:
-                width = int(box.width * frame_ratio)
-                height = int(box.height * frame_ratio)
-                if width <= 0 or height <= 0:
-                    logger.error(f"box height and width <=0 {box}")
-                    continue
-                x = int(box.x * frame_ratio)
-                y = int(box.y * frame_ratio)
-                # Draw a rectangle. Arguments are (x, y, width, height).
-                # Adjust these values according to the desired size and position.
-                draw.rectangle([x, y, x + width, y + height], outline=color, width=2)
-                # Put text
-                draw.text((x, y + height + 8), f"{box.name or key}_{round(box.confidence * 100)}", fill=color,
-                          font=self.pil_font)
-        self.save_pil_image(name + '_boxed', folder, pil_image)
-
-    def save_pil_image(self, name, folder, pil_image):
+        if len(ui_dict) > 0:
+            for key, value in ui_dict.items():
+                boxes = value[0]
+                color = tuple([int(x) for x in value[2].getRgb()])  # Convert QColor to BGR tuple
+                for box in boxes:
+                    width = int(box.width * frame_ratio)
+                    height = int(box.height * frame_ratio)
+                    if width <= 0 or height <= 0:
+                        logger.error(f"box height and width <=0 {box}")
+                        continue
+                    x = int(box.x * frame_ratio)
+                    y = int(box.y * frame_ratio)
+                    # Draw a rectangle. Arguments are (x, y, width, height).
+                    # Adjust these values according to the desired size and position.
+                    draw.rectangle([x, y, x + width, y + height], outline=color, width=2)
+                    # Put text
+                    draw.text((x, y + height + 8), f"{box.name or key}_{round(box.confidence * 100)}", fill=color,
+                              font=self.pil_font)
+            self.save_pil_image(name + '_boxed', folder, pil_image)
+        return originl_name
+
+    @staticmethod
+    def save_pil_image(name, folder, pil_image):
 
         now = datetime.now()
 
@@ -145,7 +149,9 @@ class Screenshot(QObject):
         try:
             pil_image.save(file)
         except OSError:
-            pil_image.save(os.path.join(folder, f"{time_string}.png"))
+            file = os.path.join(folder, f"{time_string}.png")
+            pil_image.save(file)
+        return file
 
     def stop(self):
         logger.debug(f'stop screenshot')