ok-script 0.0.91__tar.gz → 0.0.93__tar.gz

{ok-script-0.0.91 → ok-script-0.0.93}/PKG-INFO

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

{ok-script-0.0.91 → ok-script-0.0.93}/ok/OK.py

@@ -37,6 +37,9 @@ class OK:
         config['debug'] = config.get("debug", False)
         self.debug = config['debug']
         try:
+            if self.debug:
+                import win32api
+                win32api.SetConsoleCtrlHandler(self.console_handler, True)
             self.config = config
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
@@ -59,6 +62,7 @@ class OK:
             if self.config.get("use_gui"):
                 if not self.init_error:
                     self.app.show_main_window()
+                logger.debug('start app.exec()')
                 self.app.exec()
             else:
                 self.task_executor.start()
@@ -135,6 +139,26 @@ class OK:
         while not self.exit_event.is_set():
             time.sleep(1)
 
+    def console_handler(self, event):
+        import win32con
+        if event == win32con.CTRL_C_EVENT:
+            logger.info("CTRL+C event dump threads")
+            from ok.capture.windows.dump import dump_threads
+            dump_threads()
+            self.quit()
+        elif event == win32con.CTRL_CLOSE_EVENT:
+            logger.info("Close event quit")
+            self.quit()
+        elif event == win32con.CTRL_LOGOFF_EVENT:
+            logger.info("Logoff event quit")
+            self.quit()
+        elif event == win32con.CTRL_SHUTDOWN_EVENT:
+            logger.info("Shutdown event quit")
+            self.quit()
+        else:  # Perform clean-up tasks here
+            print("Performing clean-up...")
+        return True
+
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()

{ok-script-0.0.91 → ok-script-0.0.93}/ok/capture/adb/DeviceManager.py

@@ -67,7 +67,7 @@ class DeviceManager:
                         logger.debug(f'adb_connect already connected {addr}')
                         return device
             if try_connect:
-                self.adb.connect(addr, timeout=5)
+                self.adb.connect(addr, timeout=3)
                 logger.debug(f'adb_connect {addr}')
                 return self.adb_connect(addr, try_connect=False)
         except AdbTimeout as e:

ok-script-0.0.93/ok/capture/windows/dump.py

@@ -0,0 +1,80 @@
+import os
+import signal
+import sys
+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 = []
+    for thread_id, frame in sys._current_frames().items():
+        thread_name = get_thread_name(thread_id)
+        thread_dump = f"Stack for thread {thread_id} (Name: {thread_name}):\n"
+        thread_dump += "".join(traceback.format_stack(frame))
+        thread_dumps.append(thread_dump)
+
+    # Write the thread dumps to a file
+    output_file = get_path_relative_to_exe(os.path.join('logs', "thread_dumps.txt"))
+    print(f'Dumping threads to {output_file}')
+
+    with open(output_file, "w") as file:
+        file.write("\n\n".join(thread_dumps))
+        # subprocess.Popen(r'explorer /select,"{}"'.format(output_file))
+
+
+def kill_dump():
+    print("Killing dump")
+    dump_threads()
+    sys.exit(0)
+
+
+def console_handler(event):
+    import win32con
+    if event == win32con.CTRL_C_EVENT:
+        print("CTRL+C event")
+        dump_threads()
+        sys.exit(0)
+    elif event == win32con.CTRL_CLOSE_EVENT:
+        print("Close event")
+    elif event == win32con.CTRL_LOGOFF_EVENT:
+        print("Logoff event")
+    elif event == win32con.CTRL_SHUTDOWN_EVENT:
+        print("Shutdown event")
+    # Perform clean-up tasks here
+    print("Performing clean-up...")
+    # sys.exit(0)  # Exit the program
+    return True
+
+
+if __name__ == '__main__':
+
+    import psutil
+    import faulthandler
+
+    # Enable the fault handler
+    faulthandler.enable()
+
+    # Iterate over all running processes
+    for proc in psutil.process_iter(['pid', 'name', 'status', 'exe']):
+        # Check if the process is unresponsive
+        # print(proc.info['exe'])
+        if proc.info['name'] == 'python.exe':
+            # Dump the traceback
+            print(f'dump {proc.pid} {proc.cmdline()} {proc.info["pid"] == os.getpid()}')
+            # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+            # Kill the process
+            # os.kill(proc.info['pid'], signal.SIGTERM)
+
+    # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+    # Kill the process
+    os.kill(16916, signal.SIGTERM)

{ok-script-0.0.91 → ok-script-0.0.93}/ok/gui/App.py

@@ -13,7 +13,6 @@ from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
 from ok.gui.StartController import StartController
-from ok.gui.debug.LogWindow import LogWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
@@ -95,26 +94,28 @@ class App:
         self.show_message_window(title, content)
 
     def show_main_window(self):
+
+        if self.overlay and ok.gui.device_manager.hwnd is not None:
+            self.overlay_window = OverlayWindow(ok.gui.device_manager.hwnd)
+
+        if self.config.get('debug'):
+            from ok.gui.debug.LogWindow import LogWindow
+            self.log_window = LogWindow(self.config)
+            self.log_window.show()
+            logger.debug('showing log_window')
+
         self.main_window = MainWindow(self.config, self.icon, self.title, self.version, self.overlay, self.about,
                                       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)
 
         size = self.size_relative_to_screen(width=0.5, height=0.6)
         self.main_window.resize(size)
         self.main_window.setMinimumSize(size)
 
-        # Optional: Move the window to the center of the screen
-
         self.main_window.show()
         self.main_window.raise_()
         self.main_window.activateWindow()
-        if self.config.get('debug'):
-            self.log_window = LogWindow(self.config)
-            self.log_window.show()
-            logger.debug('showing log_window')
 
     def size_relative_to_screen(self, width, height):
         screen = self.app.primaryScreen()

{ok-script-0.0.91 → ok-script-0.0.93}/ok/gui/MainWindow.py

@@ -1,9 +1,8 @@
 import os
-import sys
 
 from PySide6.QtCore import QObject, Signal, Qt
 from PySide6.QtWidgets import QMenu, QSystemTrayIcon
-from qfluentwidgets import FluentIcon, NavigationItemPosition, MSFluentWindow, InfoBar, InfoBarPosition, MessageBox
+from qfluentwidgets import FluentIcon, NavigationItemPosition, MSFluentWindow, InfoBar, InfoBarPosition
 
 import ok.gui
 from ok.gui.Communicate import communicate
@@ -158,22 +157,11 @@ class MainWindow(MSFluentWindow):
         self.comm.speak.emit("Hello, PySide6 with parameters!")
 
     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():
-            logger.info("system shutting down")
-            ok.gui.ok.quit()
-            event.accept()
-            return
-
         if ok.gui.ok.exit_event.is_set():
+            logger.info("Window closed exit_event.is_set")
             event.accept()
             return
-        title = self.tr('Exit')
-        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")
+        else:
+            logger.info("Window closed exit_event.is not set")
             ok.gui.ok.quit()
             event.accept()
-        else:
-            event.ignore()

{ok-script-0.0.91 → ok-script-0.0.93}/ok/gui/StartController.py

@@ -39,7 +39,7 @@ class StartController(QObject):
                     error = self.check_device_error()
                     if error is None:
                         break
-                    logger.debug(f'waiting for game to start error {error}')
+                    logger.error(f'waiting for game to start error {error}')
                     remaining_time = wait_until - time.time()
                     if remaining_time <= 0:
                         communicate.starting_emulator.emit(True, self.tr('Start game timeout!'), 0)

{ok-script-0.0.91 → ok-script-0.0.93}/ok/gui/debug/DebugTab.py

@@ -1,7 +1,7 @@
 import subprocess
 from ctypes import windll, wintypes
 
-from PySide6.QtCore import Qt, Signal
+from PySide6.QtCore import Qt, Signal, QCoreApplication
 from PySide6.QtWidgets import QWidget, QFileDialog, QCompleter, QVBoxLayout, QHBoxLayout
 from _ctypes import byref
 from qfluentwidgets import PushButton, FlowLayout, ComboBox, SearchLineEdit, TextEdit
@@ -46,7 +46,7 @@ class DebugTab(Tab):
         # self.dump_shortcut.activated.connect(dump_threads)
 
         capture_button = PushButton(self.tr("Capture Screenshot"))
-        capture_button.clicked.connect(lambda: self.handler.post(self.capture))
+        capture_button.clicked.connect(lambda: self.handler.post(capture))
         layout.addWidget(capture_button)
 
         ocr_button = PushButton("OCR")
@@ -202,20 +202,22 @@ class DebugTab(Tab):
             self.select_screenshot_button.setText(self.tr("Drop or Select Screenshot"))
             self.config['target_images'] = None
 
-    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}')
-                alert_info(self.tr('Capture Success'), True)
-            else:
-                alert_error(self.tr('Capture returned None'))
+def capture():
+    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}')
+        current_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,
+                                                                  current_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: {current_capture}')
+            alert_info(QCoreApplication.translate('DebugTab', 'Capture Success'), True)
         else:
-            alert_error(self.tr('No Capture Available or Selected'))
+            alert_error(QCoreApplication.translate('DebugTab', 'Capture returned None'))
+    else:
+        alert_error(QCoreApplication.translate('DebugTab', 'No Capture Available or Selected'))

{ok-script-0.0.91 → ok-script-0.0.93}/ok/gui/debug/LogWindow.py

@@ -1,7 +1,8 @@
-from PySide6.QtCore import Qt, QAbstractListModel, QModelIndex, QPoint, Signal
+from PySide6.QtCore import Qt, QAbstractListModel, QPoint, QModelIndex
 from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QVBoxLayout, QListView, QLineEdit, QHBoxLayout, QComboBox, QAbstractItemView, QWidget, \
-    QPushButton, QLabel, QStyledItemDelegate
+from PySide6.QtWidgets import QWidget, \
+    QStyledItemDelegate, QListView, QVBoxLayout, QHBoxLayout, QAbstractItemView, QComboBox, QLineEdit, QLabel, \
+    QPushButton
 
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -39,19 +40,19 @@ class ColorDelegate(QStyledItemDelegate):
 
 
 class LogModel(QAbstractListModel):
-    def __init__(self, log_list):
+    def __init__(self):
         super(LogModel, self).__init__()
-        self.log_list = log_list
         self.logs = []
-        self.filtered_logs = self.logs[:]
+        self.filtered_logs = []
         self.current_level = "ALL"
         self.current_keyword = ""
 
     def data(self, index, role):
-        if role == Qt.DisplayRole:
-            return self.filtered_logs[index.row()].text
-        elif role == Qt.ForegroundRole:
-            return self.filtered_logs[index.row()].format
+        if 0 <= index.row() < len(self.filtered_logs):
+            if role == Qt.DisplayRole:
+                return self.filtered_logs[index.row()].text
+            elif role == Qt.ForegroundRole:
+                return self.filtered_logs[index.row()].format
 
     def rowCount(self, index):
         return len(self.filtered_logs)
@@ -62,15 +63,15 @@ class LogModel(QAbstractListModel):
         colored_text = ColoredText(message, color_format, level)
         self.logs.append(colored_text)
         if len(self.logs) >= 500:
-            self.beginRemoveRows(QModelIndex(), 0, 0)
+            # self.beginRemoveRows(QModelIndex(), 0, 0)
             self.logs.pop(0)
-            self.endRemoveRows()
-
+            # self.endRemoveRows()
         self.beginInsertRows(QModelIndex(), self.rowCount(QModelIndex()), self.rowCount(QModelIndex()))
         self.do_filter_logs()
         self.endInsertRows()
-        self.layoutChanged.emit()
-        self.log_list.scrollToBottom()
+
+        # self.layoutChanged.emit()
+        # self.log_list.scrollToBottom()
 
     def do_filter_logs(self):
 
@@ -92,9 +93,10 @@ class LogModel(QAbstractListModel):
     def filter_logs(self, level, keyword):
         self.current_level = level
         self.current_keyword = keyword
+        self.beginRemoveRows(QModelIndex(), 0, self.rowCount(QModelIndex()) - 1)
+        self.filtered_logs.clear()
+        self.endRemoveRows()
         self.do_filter_logs()
-        self.layoutChanged.emit()
-        self.log_list.scrollToBottom()
 
     def get_color_format(self, level):
         # Define color codes for different levels
@@ -118,8 +120,6 @@ class LogWindow(QWidget):
                              app_config.get('config_folder'), 'log_window')
         self.setGeometry(self.config['x'], self.config['y'], self.config['width'], self.config['height'])
 
-        self.refresh_signal = Signal()
-
         self.old_pos = None
 
         # Layouts
@@ -158,16 +158,15 @@ class LogWindow(QWidget):
 
         self.setLayout(self.layout)
 
-        self.log_model = LogModel(self.log_list)
+        self.log_model = LogModel()
         self.log_list.setModel(self.log_model)
-        communicate.log.connect(self.add_log)
 
-        self.logs = []
-        self.filter_logs()
+        communicate.log.connect(self.add_log)
 
     def add_log(self, level_no, message):
-        self.logs.append(message)
+        # print('add_log', level_no, message)
         self.log_model.add_log(log_levels.get(level_no, 'DEBUG'), message)
+        self.log_list.scrollToBottom()
 
     def filter_logs(self):
         level = self.level_filter.currentText()