Merge branch '2.0.0' into Linted-pyi-files

Author: Avasam

README.md

@@ -155,9 +155,9 @@ Given these splits: 1 dummy, 2 normal, 3 dummy, 4 dummy, 5 normal, 6 normal.
 In this situation you would have only 3 splits in LiveSplit/wsplit (even though there are 6 split images, only 3 are "real" splits). This basically results in 3 groups of splits: 1st split is images 1 and 2. 2nd split is images 3, 4 and 5. 3rd split is image 6.
 
 - If you are in the 1st or 2nd image and press the skip key, it will end up on the 3rd image
-- If you are in the 3rd, 4th or 5th image and press the undo key, it will end up on the 1st image
+- If you are in the 3rd, 4th or 5th image and press the undo key, it will end up on the 2nd image
 - If you are in the 3rd, 4th or 5th image and press the skip key, it will end up on the 6th image
-- If you are in the 6th image and press the undo key, it will end up on the 3rd image
+- If you are in the 6th image and press the undo key, it will end up on the 5th image
 
 ### Loop Split Images
 

res/settings.ui

@@ -427,7 +427,7 @@
      <string/>
     </property>
     <property name="readOnly">
-     <bool>false</bool>
+     <bool>true</bool>
     </property>
    </widget>
    <widget class="QLineEdit" name="undo_split_input">
@@ -477,9 +477,6 @@
     <property name="text">
      <string/>
     </property>
-    <property name="frame">
-     <bool>true</bool>
-    </property>
     <property name="readOnly">
      <bool>true</bool>
     </property>

src/AutoControlledWorker.py

@@ -20,6 +20,8 @@ def run(self):
             except RuntimeError:
                 self.autosplit.show_error_signal.emit(error_messages.stdin_lost)
                 break
+            except EOFError:
+                continue
             # TODO: "AutoSplit Integration" needs to call this and wait instead of outright killing the app.
             # For now this can only used in a Development environment
             if line == "kill":

src/AutoSplit.py

@@ -54,7 +54,7 @@ def excepthook(exception_type: type[BaseException], exception: BaseException, _t
             sys.exit(0)
         autosplit.show_error_signal.emit(lambda: error_messages.exception_traceback(
             "AutoSplit encountered an unhandled exception and will try to recover, "
-            + f"however, there is no guarantee everything will work properly. {CREATE_NEW_ISSUE_MESSAGE}",
+            + f"however, there is no guarantee it will keep working properly. {CREATE_NEW_ISSUE_MESSAGE}",
             exception))
     return excepthook
 
@@ -100,7 +100,6 @@ class AutoSplit(QMainWindow, design.Ui_MainWindow):
     """Window Handle used for Capture Region"""
     last_saved_settings: list[Union[str, float, int, bool]] = []
     similarity = 0.0
-    live_image_function_on_open = True
     split_image_number = 0
     split_images_and_loop_number: list[tuple[AutoSplitImage, int]] = []
     split_groups: list[list[int]] = []
@@ -238,22 +237,16 @@ def __browse(self):
             self.load_start_image()
 
     def __live_image_function(self):
-        try:
-            self.capture_region_window_label.setText(self.settings_dict["captured_window_title"])
-            if not self.settings_dict["captured_window_title"]:
-                self.timer_live_image.stop()
-                self.live_image.clear()
-                if self.live_image_function_on_open:
-                    self.live_image_function_on_open = False
-                return
-            # Set live image in UI
-            if self.hwnd:
-                capture = capture_region(self.hwnd, self.settings_dict["capture_region"],
-                                         self.settings_dict["force_print_window"])
-                set_ui_image(self.live_image, capture, False)
-
-        except AttributeError:
-            pass
+        self.capture_region_window_label.setText(self.settings_dict["captured_window_title"])
+        if not (self.settings_dict["live_capture_region"] and self.settings_dict["captured_window_title"]):
+            self.live_image.clear()
+            return
+        # Set live image in UI
+        if self.hwnd:
+            capture = capture_region(self.hwnd,
+                                     self.settings_dict["capture_region"],
+                                     self.settings_dict["force_print_window"])
+            set_ui_image(self.live_image, capture, False)
 
     def load_start_image(self, started_by_button: bool = False, wait_for_delay: bool = True):
         self.timer_start_image.stop()
@@ -300,9 +293,9 @@ def __start_image_function(self):
                 or not self.start_image \
                 or time() < self.check_start_image_timestamp \
                 or (not self.settings_dict["split_hotkey"] and not self.is_auto_controlled):
-            pause_time_left = f"{self.check_start_image_timestamp - time():.1f}"
+            pause_time_left = self.check_start_image_timestamp - time()
             self.current_split_image.setText(
-                f"None\n (Paused before loading Start Image).\n {pause_time_left} sec remaining")
+                f"None\n (Paused before loading Start Image).\n {seconds_remaining_text(pause_time_left)}")
             return
 
         if self.check_start_image_timestamp > 0:
@@ -347,9 +340,9 @@ def __start_image_function(self):
                 delay_start_time = time()
                 start_delay = self.start_image.delay / 1000
                 while time() - delay_start_time < start_delay:
-                    delay_time_left = round(start_delay - (time() - delay_start_time), 1)
+                    delay_time_left = start_delay - (time() - delay_start_time)
                     self.current_split_image.setText(
-                        f"Delayed Before Starting:\n {delay_time_left} sec remaining")
+                        f"Delayed Before Starting:\n {seconds_remaining_text(delay_time_left)}")
                     # Email sent to [email protected]
                     QtTest.QTest.qWait(1)  # type: ignore
 
@@ -418,9 +411,7 @@ def __check_fps(self):
             while count < CHECK_FPS_ITERATIONS:
                 capture = self.__get_capture_for_comparison()
                 _ = image.compare_with_capture(self, capture)
-                set_ui_image(self.current_split_image, image.bytes, True)
                 count += 1
-        self.current_split_image.clear()
 
         # calculate FPS
         t1 = time()
@@ -444,9 +435,9 @@ def __undo_split(self, navigate_image_only: bool = False):
             return
 
         if not navigate_image_only:
-            for i, group in enumerate(self.split_groups):
+            for i, group in enumerate(self.split_groups,):
                 if i > 0 and self.split_image_number in group:
-                    self.split_image_number = self.split_groups[i - 1][0]
+                    self.split_image_number = self.split_groups[i - 1][-1]
                     break
         else:
             self.split_image_number -= 1
@@ -636,8 +627,8 @@ def __auto_splitter(self):
                     # check for reset while delayed and display a counter of the remaining split delay time
                     delay_start_time = time()
                     while time() - delay_start_time < split_delay:
-                        delay_time_left = round(split_delay - (time() - delay_start_time), 1)
-                        self.current_split_image.setText(f"Delayed Split: {delay_time_left} sec remaining")
+                        delay_time_left = split_delay - (time() - delay_start_time)
+                        self.current_split_image.setText(f"Delayed Split: {seconds_remaining_text(delay_time_left)}")
                         if self.__check_for_reset():
                             return
 
@@ -684,8 +675,8 @@ def __auto_splitter(self):
             if pause_time > 0:
                 pause_start_time = time()
                 while time() - pause_start_time < pause_time:
-                    pause_time_left = round(pause_time - (time() - pause_start_time), 1)
-                    self.current_split_image.setText(f"None (Paused). {pause_time_left} sec remaining")
+                    pause_time_left = pause_time - (time() - pause_start_time)
+                    self.current_split_image.setText(f"None (Paused). {seconds_remaining_text(pause_time_left)}")
 
                     if self.__check_for_reset():
                         return
@@ -869,6 +860,10 @@ def exit_program():
             exit_program()
 
 
+def seconds_remaining_text(seconds: float):
+    return f"{seconds:.1f} second{'' if 0 < seconds <= 1 else 's'} remaining"
+
+
 def main():
     # Call to QApplication outside the try-except so we can show error messages
     app = QApplication(sys.argv)

src/hotkeys.py

@@ -6,10 +6,10 @@
     from AutoSplit import AutoSplit
 
 import threading
-from keyboard._keyboard_event import KeyboardEvent, KEY_DOWN
+
 import keyboard  # https://github.com/boppreh/keyboard/issues/505
 import pyautogui  # https://github.com/asweigart/pyautogui/issues/645
-# While not usually recommended, we don'thread manipulate the mouse, and we don'thread want the extra delay
+# While not usually recommended, we don't manipulate the mouse, and we don't want the extra delay
 pyautogui.FAILSAFE = False
 
 SET_HOTKEY_TEXT = "Set Hotkey"
@@ -100,11 +100,11 @@ def _send_hotkey(key_or_scan_code: Union[int, str]):
     pyautogui.hotkey(key_or_scan_code.replace(" ", ""))
 
 
-def __validate_keypad(expected_key: str, keyboard_event: KeyboardEvent) -> bool:
+def __validate_keypad(expected_key: str, keyboard_event: keyboard.KeyboardEvent) -> bool:
     # Prevent "(keypad)delete", "(keypad)./decimal" and "del" from triggering each other
     # as well as "." and "(keypad)./decimal"
     if keyboard_event.scan_code in {83, 52}:
-        # TODO: "del" won'thread work with "(keypad)delete" if localized in non-english (ie: "suppr" in french)
+        # TODO: "del" won't work with "(keypad)delete" if localized in non-english (ie: "suppr" in french)
         return expected_key == keyboard_event.name
     # Prevent "action keys" from triggering "keypad keys"
     if keyboard_event.name and is_digit(keyboard_event.name[-1]):
@@ -125,16 +125,16 @@ def __validate_keypad(expected_key: str, keyboard_event: KeyboardEvent) -> bool:
 
 # We're doing the check here instead of saving the key code because it'll
 # cause issues with save files and the non-keypad shared keys are localized
-# while the keypad ones aren'thread.
+# while the keypad ones aren't.
 
-# Since we reuse the key string we set to send to LiveSplit, we can'thread use fake names like "num home".
+# Since we reuse the key string we set to send to LiveSplit, we can't use fake names like "num home".
 # We're also trying to achieve the same hotkey behaviour as LiveSplit has.
-def _hotkey_action(keyboard_event: KeyboardEvent, key_name: str, action: Callable[[], None]):
-    if keyboard_event.event_type == KEY_DOWN and __validate_keypad(key_name, keyboard_event):
+def _hotkey_action(keyboard_event: keyboard.KeyboardEvent, key_name: str, action: Callable[[], None]):
+    if keyboard_event.event_type == keyboard.KEY_DOWN and __validate_keypad(key_name, keyboard_event):
         action()
 
 
-def __get_key_name(keyboard_event: KeyboardEvent):
+def __get_key_name(keyboard_event: keyboard.KeyboardEvent):
     return f"num {keyboard_event.name}"  \
         if keyboard_event.is_keypad and is_digit(keyboard_event.name) \
         else str(keyboard_event.name)

typings/keyboard/__init__.pyi

@@ -9,6 +9,7 @@ from threading import Lock as _Lock
 from ._keyboard_event import KEY_DOWN, KEY_UP, KeyboardEvent
 from ._generic import GenericListener as _GenericListener
 from ._canonical_names import all_modifiers, normalize_name, sided_modifiers
+__all__ = ["all_modifiers", "normalize_name", "sided_modifiers", "KEY_DOWN", "KEY_UP", "KeyboardEvent"]
 
 __all__ = [
     "KEY_DOWN",