Merge branch 'dev' of https://github.com/Toufool/Auto-Split into Save-'Check-For-Updates-On-Open'-immediatly

Author: Avasam

src/AutoSplit.py

@@ -1,6 +1,8 @@
 #!/usr/bin/python3.9
 # -*- coding: utf-8 -*-
-from typing import Callable, List, Optional
+import traceback
+from types import FunctionType, TracebackType
+from typing import Callable, List, Optional, Type
 
 from copy import copy
 from PyQt6 import QtCore, QtGui, QtTest, QtWidgets
@@ -31,7 +33,9 @@
 DISPLAY_RESIZE_WIDTH = 240
 DISPLAY_RESIZE_HEIGHT = 180
 DISPLAY_RESIZE = (DISPLAY_RESIZE_WIDTH, DISPLAY_RESIZE_HEIGHT)
-
+CREATE_NEW_ISSUE_MESSAGE = \
+    "Please create a New Issue at <a href='https://github.com/Toufool/Auto-Split/issues'>"
+"github.com/Toufool/Auto-Split/issues</a>, describe what happened, and copy & paste the error message below"
 
 class AutoSplit(QtWidgets.QMainWindow, design.Ui_MainWindow):
     from hotkeys import send_command
@@ -53,6 +57,8 @@ class AutoSplit(QtWidgets.QMainWindow, design.Ui_MainWindow):
     pauseSignal = QtCore.pyqtSignal()
     afterSettingHotkeySignal = QtCore.pyqtSignal()
     updateCheckerWidgetSignal = QtCore.pyqtSignal(str, bool)
+    # Use this signal when trying to show an error from outside the main thread
+    showErrorSignal = QtCore.pyqtSignal(FunctionType)
 
     def __init__(self, parent=None):
         super(AutoSplit, self).__init__(parent)
@@ -103,7 +109,7 @@ def run(self):
                         try:
                             line = input()
                         except RuntimeError:
-                            # stdin not supported or lost, stop looking for inputs
+                            self.autosplit.showErrorSignal.emit(error_messages.stdinLostError)
                             break
                         # TODO: "AutoSplit Integration" needs to call this and wait instead of outright killing the app.
                         # TODO: See if we can also get LiveSplit to wait on Exit in "AutoSplit Integration"
@@ -173,6 +179,7 @@ def run(self):
         self.resetSignal.connect(self.reset)
         self.skipSplitSignal.connect(self.skipSplit)
         self.undoSplitSignal.connect(self.undoSplit)
+        self.showErrorSignal.connect(lambda errorMessageBox: errorMessageBox())
 
         # live image checkbox
         self.liveimageCheckBox.clicked.connect(self.checkLiveImage)
@@ -204,13 +211,6 @@ def run(self):
         self.hwnd_title = ''
         self.rect = ctypes.wintypes.RECT()
 
-        # Last loaded settings and last successful loaded settings file path to None until we try to load them
-        self.last_loaded_settings = None
-        self.last_successfully_loaded_settings_file_path = None
-
-        if not self.is_auto_controlled:
-            self.loadSettings(load_settings_on_open=True)
-
         # Automatic timer start
         self.timerStartImage = QtCore.QTimer()
         self.timerStartImage.timeout.connect(self.startImageFunction)
@@ -219,8 +219,12 @@ def run(self):
         self.highest_similarity = 0.0
         self.check_start_image_timestamp = 0.0
 
-        # Try to load start image
-        self.loadStartImage()
+        # Last loaded settings and last successful loaded settings file path to None until we try to load them
+        self.last_loaded_settings = None
+        self.last_successfully_loaded_settings_file_path = None
+
+        if not self.is_auto_controlled:
+            self.loadSettings(load_settings_on_open=True)
 
     # FUNCTIONS
 
@@ -237,6 +241,7 @@ def browse(self):
             # set the split image folder line to the directory text
             self.split_image_directory = new_split_image_directory
             self.splitimagefolderLineEdit.setText(f"{new_split_image_directory}/")
+            self.loadStartImage()
 
     def checkLiveImage(self):
         if self.liveimageCheckBox.isChecked():
@@ -296,6 +301,10 @@ def loadStartImage(self, started_by_button=False, wait_for_delay=True):
                 error_messages.noKeywordImageError('start_auto_splitter')
             return
 
+        if self.start_image_name is not None and (not self.splitLineEdit.text() or not self.resetLineEdit.text() or not self.pausehotkeyLineEdit.text()) and not self.is_auto_controlled:
+            error_messages.loadStartImageError()
+            return
+
         self.split_image_filenames = os.listdir(self.split_image_directory)
         self.split_image_number = 0
         self.start_image_mask = None
@@ -340,8 +349,7 @@ def loadStartImage(self, started_by_button=False, wait_for_delay=True):
         QtWidgets.QApplication.processEvents()
 
     def startImageFunction(self):
-        if time.time() < self.check_start_image_timestamp \
-                or (not self.splitLineEdit.text() and not self.is_auto_controlled):
+        if time.time() < self.check_start_image_timestamp:
             pause_time_left = "{:.1f}".format(self.check_start_image_timestamp - time.time())
             self.currentSplitImage.setText(f'None\n (Paused before loading Start Image).\n {pause_time_left} sec remaining')
             return
@@ -751,6 +759,7 @@ def autoSplitter(self):
                     reset_similarity = self.compareImage(self.reset_image, self.reset_mask, capture)
                     if reset_similarity >= self.reset_image_threshold:
                         self.send_command("reset")
+                        self.reset()
 
                 if self.checkForReset():
                     return
@@ -1189,22 +1198,46 @@ def exit():
 
 def main():
     app = QtWidgets.QApplication(sys.argv)
-    app.setWindowIcon(QtGui.QIcon(':/resources/icon.ico'))
-
-    main_window = AutoSplit()
-    main_window.show()
-    if main_window.actionCheck_for_Updates_on_Open.isChecked():
-        checkForUpdates(main_window, check_on_open=True)
+    try:
+        app.setWindowIcon(QtGui.QIcon(':/resources/icon.ico'))
+        main_window = AutoSplit()
+        main_window.show()
+        # Needs to be after main_window.show() to be shown over
+        if main_window.actionCheck_for_Updates_on_Open.isChecked():
+            checkForUpdates(main_window, check_for_updates_on_open=True)
+
+        # Kickoff the event loop every so often so we can handle KeyboardInterrupt (^C)
+        timer = QtCore.QTimer()
+        timer.timeout.connect(lambda: None)
+        timer.start(500)
+
+        exit_code = app.exec()
+    except Exception as exception:
+        # Print error to console if not running in executable
+        if getattr(sys, 'frozen', False):
+            error_messages.exceptionTraceback(
+                f"AutoSplit encountered an unrecoverable exception and will now close. {CREATE_NEW_ISSUE_MESSAGE}",
+                exception)
+        else:
+            traceback.print_exception(type(exception), exception, exception.__traceback__)
+        sys.exit(1)
 
-    # Kickoff the event loop every so often so we can handle KeyboardInterrupt (^C)
-    timer = QtCore.QTimer()
-    timer.timeout.connect(lambda: None)
-    timer.start(500)
     # Catch Keyboard Interrupts for a clean close
-    signal.signal(signal.SIGINT, lambda _,  __: sys.exit(app))
+    signal.signal(signal.SIGINT, lambda code,  _: sys.exit(code))
+
+    sys.exit(exit_code)
 
-    sys.exit(app.exec())
+
+def excepthook(exceptionType: Type[BaseException], exception: BaseException, traceback: Optional[TracebackType]):
+    # Catch Keyboard Interrupts for a clean close
+    if exceptionType is KeyboardInterrupt:
+        sys.exit(0)
+    error_messages.exceptionTraceback(
+            "AutoSplit encountered an unhandled exception and will try to recover, "
+            f"however, there is no guarantee everything will work properly. {CREATE_NEW_ISSUE_MESSAGE}",
+            exception)
 
 
 if __name__ == '__main__':
+    sys.excepthook = excepthook
     main()

src/error_messages.py

@@ -1,12 +1,20 @@
 # Error messages
-from PyQt6 import QtWidgets
+import traceback
+from PyQt6 import QtCore, QtWidgets
 
 
-def setTextMessage(message: str):
-    msgBox = QtWidgets.QMessageBox()
-    msgBox.setWindowTitle('Error')
-    msgBox.setText(message)
-    msgBox.exec()
+def setTextMessage(message: str, details: str = ''):
+    messageBox = QtWidgets.QMessageBox()
+    messageBox.setWindowTitle('Error')
+    messageBox.setTextFormat(QtCore.Qt.TextFormat.RichText)
+    messageBox.setText(message)
+    if details:
+        messageBox.setDetailedText(details)
+        for button in messageBox.buttons():
+            if messageBox.buttonRole(button) == QtWidgets.QMessageBox.ButtonRole.ActionRole:
+                button.click()
+                break
+    messageBox.exec()
 
 
 def splitImageDirectoryError():
@@ -76,5 +84,18 @@ def noSettingsFileOnOpenError():
 def tooManySettingsFilesOnOpenError():
     setTextMessage("Too many settings files found. Only one can be loaded on open if placed in the same folder as AutoSplit.exe")
 
+
 def checkForUpdatesError():
     setTextMessage("An error occurred while attempting to check for updates. Please check your connection.")
+
+def loadStartImageError():
+    setTextMessage("Start Image found, but cannot be loaded unless Start, Reset, and Pause hotkeys are set. Please set these hotkeys, and then click the Reload Start Image button.")
+
+def stdinLostError():
+    setTextMessage("stdin not supported or lost, external control like LiveSplit integration will not work.")
+
+
+def exceptionTraceback(message: str, exception: Exception):
+    setTextMessage(
+        message,
+        "\n".join(traceback.format_exception(None, exception, exception.__traceback__)))

src/menu_bar.py

@@ -89,7 +89,7 @@ def run(self):
             self.autosplit.updateCheckerWidgetSignal.emit(latest_version, self.check_on_open)
         except (RequestException, KeyError, JSONDecodeError):
             if not self.check_on_open:
-                error_messages.checkForUpdatesError()
+                self.autosplit.showErrorSignal(error_messages.checkForUpdatesError)
 
 
 def checkForUpdates(autosplit: AutoSplit, check_on_open: bool = False):

src/settings_file.py

@@ -158,10 +158,11 @@ def saveSettingsAs(self: AutoSplit):
 def loadSettings(self: AutoSplit, load_settings_on_open: bool = False, load_settings_from_livesplit: bool = False):
     if load_settings_on_open:
 
-        settings_files = []
-        for file in os.listdir(auto_split_directory):
-            if file.endswith(".pkl"):
-                settings_files.append(file)
+        settings_files = [
+            file for file
+            in os.listdir(auto_split_directory)
+            if file.endswith(".pkl")
+        ]
 
         # find all .pkls in AutoSplit folder, error if there is none or more than 1
         if len(settings_files) < 1:
@@ -191,17 +192,15 @@ def loadSettings(self: AutoSplit, load_settings_on_open: bool = False, load_sett
             settings: List[Union[str, int]] = pickle.load(f)
             settings_count = len(settings)
             if settings_count < 18:
-                if not load_settings_from_livesplit:
-                    error_messages.oldVersionSettingsFileError()
+                self.showErrorSignal.emit(error_messages.oldVersionSettingsFileError)
                 return
             # v1.3-1.4 settings. Add default pause_key and auto_start_on_reset_setting
             if settings_count == 18:
                 settings.insert(9, '')
                 settings.insert(20, 0)
             # v1.5 settings
             elif settings_count != 20:
-                if not load_settings_from_livesplit:
-                    error_messages.invalidSettingsError()
+                self.showErrorSignal.emit(error_messages.invalidSettingsError)
                 return
             self.last_loaded_settings = [
                 self.split_image_directory,
@@ -225,11 +224,7 @@ def loadSettings(self: AutoSplit, load_settings_on_open: bool = False, load_sett
                 self.loop_setting,
                 self.auto_start_on_reset_setting] = settings
     except (FileNotFoundError, MemoryError, pickle.UnpicklingError):
-        # HACK / Workaround: Executing the error QMessageBox from the auto-controlled Worker Thread makes it hangs.
-        # I don't like this solution as we should probably ensure the Worker works nicely with PyQt instead,
-        # but in the mean time, this will do.
-        if not load_settings_from_livesplit:
-            error_messages.invalidSettingsError()
+        self.showErrorSignal.emit(error_messages.invalidSettingsError)
         return
 
     self.splitimagefolderLineEdit.setText(self.split_image_directory)
@@ -309,6 +304,7 @@ def loadSettings(self: AutoSplit, load_settings_on_open: bool = False, load_sett
 
     self.last_successfully_loaded_settings_file_path = self.load_settings_file_path
     self.checkLiveImage()
+    self.loadStartImage()
 
 
 def load_check_for_updates_on_open(designWindow: design.Ui_MainWindow):