Better "seconds remaining" text

Author: Avasam

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/AutoSplit.py

@@ -300,9 +300,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 +347,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
 
@@ -636,8 +636,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 +684,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 +869,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

@@ -3,6 +3,7 @@ This type stub file was generated by pyright.
 """
 from __future__ import print_function as _print_function
 import typing
+import collections.abc
 
 import re as _re
 import itertools as _itertools
@@ -13,6 +14,7 @@ from threading import Lock as _Lock, Thread as _Thread
 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"]
 
 try:
     # Python2
@@ -103,12 +105,12 @@ key events. In this case `keyboard` will be unable to report events.
 - This program makes no attempt to hide itself, so don't use it for keyloggers or online gaming bots. Be responsible.
 """
 
-Callback = typing.Callable[[KeyboardEvent], None]
+Callback = collections.abc.Callable[[KeyboardEvent], None]
 
 version: str
-_is_str = typing.Callable[[typing.Any], bool]
-_is_number = typing.Callable[[typing.Any], bool]
-_is_list: typing.Callable[[typing.Any], bool]
+_is_str = collections.abc.Callable[[typing.Any], bool]
+_is_number = collections.abc.Callable[[typing.Any], bool]
+_is_list: collections.abc.Callable[[typing.Any], bool]
 
 
 class _State:
@@ -120,10 +122,6 @@ class _Event(_UninterruptibleEvent):
         ...
 
 
-if _platform.system() == 'Windows':
-    ...
-else:
-    ...
 _modifier_scan_codes: set
 
 
@@ -197,14 +195,16 @@ class _KeyboardListener(_GenericListener):
 _listener: _KeyboardListener
 
 
-def key_to_scan_codes(key: typing.Union[int, str, typing.List[typing.Union[int, str]]], error_if_missing: bool = ...) -> typing.List[int]:
+def key_to_scan_codes(key: typing.Union[int, str, typing.List[typing.Union[int, str]]],
+                      error_if_missing: bool = ...) -> typing.List[int]:
     """
     Returns a list of scan codes associated with this key (name or scan code).
     """
     ...
 
 
-def parse_hotkey(hotkey) -> tuple[tuple[tuple[Unknown] | Unknown | tuple[()] | tuple[Unknown, ...]]] | tuple[tuple[tuple[Unknown] | Unknown | tuple[()] | tuple[Unknown, ...], ...]] | tuple[Unknown, ...]:
+def parse_hotkey(hotkey) -> tuple[tuple[tuple[Unknown] | Unknown | tuple[()] | tuple[Unknown, ...]]
+                                  ] | tuple[tuple[tuple[Unknown] | Unknown | tuple[()] | tuple[Unknown, ...], ...]] | tuple[Unknown, ...]:
     """
     Parses a user-provided hotkey into nested tuples representing the
     parsed structure, with the bottom values being lists of scan codes.
@@ -274,10 +274,10 @@ def call_later(fn, args=..., delay=...) -> None:
     ...
 
 
-_hooks: dict[typing.Callable, Unknown]
+_hooks: dict[collections.abc.Callable, Unknown]
 
 
-def hook(callback: Callback, suppress=..., on_remove=...) -> typing.Callable[[], None]:
+def hook(callback: Callback, suppress=..., on_remove=...) -> collections.abc.Callable[[], None]:
     """
     Installs a global listener on all available keyboards, invoking `callback`
     each time a key is pressed or released.
@@ -296,21 +296,22 @@ def hook(callback: Callback, suppress=..., on_remove=...) -> typing.Callable[[],
     ...
 
 
-def on_press(callback: Callback, suppress=...) -> typing.Callable[[], None]:
+def on_press(callback: Callback, suppress=...) -> collections.abc.Callable[[], None]:
     """
     Invokes `callback` for every KEY_DOWN event. For details see `hook`.
     """
     ...
 
 
-def on_release(callback: Callback, suppress=...) -> typing.Callable[[], None]:
+def on_release(callback: Callback, suppress=...) -> collections.abc.Callable[[], None]:
     """
     Invokes `callback` for every KEY_UP event. For details see `hook`.
     """
     ...
 
 
-def hook_key(key: typing.Union[int, str, typing.List[typing.Union[int, str]]], callback: Callback, suppress: bool = ...) -> typing.Callable[[], None]:
+def hook_key(key: typing.Union[int, str, typing.List[typing.Union[int, str]]],
+             callback: Callback, suppress: bool = ...) -> collections.abc.Callable[[], None]:
     """
     Hooks key up and key down events for a single key. Returns the event handler
     created. To remove a hooked key use `unhook_key(key)` or
@@ -322,21 +323,21 @@ def hook_key(key: typing.Union[int, str, typing.List[typing.Union[int, str]]], c
     ...
 
 
-def on_press_key(key, callback: Callback, suppress=...) -> typing.Callable[[], None]:
+def on_press_key(key, callback: Callback, suppress=...) -> collections.abc.Callable[[], None]:
     """
     Invokes `callback` for KEY_DOWN event related to the given key. For details see `hook`.
     """
     ...
 
 
-def on_release_key(key, callback: Callback, suppress=...) -> typing.Callable[[], None]:
+def on_release_key(key, callback: Callback, suppress=...) -> collections.abc.Callable[[], None]:
     """
     Invokes `callback` for KEY_UP event related to the given key. For details see `hook`.
     """
     ...
 
 
-def unhook(remove: typing.Callable[[], None]) -> None:
+def unhook(remove: collections.abc.Callable[[], None]) -> None:
     """
     Removes a previously added hook, either by callback or by the return value
     of `hook`.
@@ -355,7 +356,7 @@ def unhook_all() -> None:
     ...
 
 
-def block_key(key) -> typing.Callable[[], None]:
+def block_key(key) -> collections.abc.Callable[[], None]:
     """
     Suppresses all key events of the given key, regardless of modifiers.
     """
@@ -365,7 +366,7 @@ def block_key(key) -> typing.Callable[[], None]:
 unblock_key = unhook_key
 
 
-def remap_key(src, dst) -> typing.Callable[[], None]:
+def remap_key(src, dst) -> collections.abc.Callable[[], None]:
     """
     Whenever the key `src` is pressed or released, regardless of modifiers,
     press or release the hotkey `dst` instead.
@@ -388,7 +389,8 @@ def parse_hotkey_combinations(hotkey) -> tuple[tuple[tuple[Unknown, ...], ...],
 _hotkeys: dict
 
 
-def add_hotkey(hotkey, callback: Callback, args=..., suppress=..., timeout=..., trigger_on_release=...) -> typing.Callable[[], None]:
+def add_hotkey(hotkey, callback: collections.abc.Callable, args=..., suppress=..., timeout=...,
+               trigger_on_release=...) -> collections.abc.Callable[[], None]:
     """
     Invokes a callback every time a hotkey is pressed. The hotkey must
     be in the format `ctrl+shift+a, s`. This would trigger when the user holds
@@ -453,7 +455,7 @@ def unhook_all_hotkeys() -> None:
 unregister_all_hotkeys = remove_all_hotkeys = clear_all_hotkeys = unhook_all_hotkeys
 
 
-def remap_hotkey(src, dst, suppress=..., trigger_on_release=...) -> typing.Callable[[], None]:
+def remap_hotkey(src, dst, suppress=..., trigger_on_release=...) -> collections.abc.Callable[[], None]:
     """
     Whenever the hotkey `src` is pressed, suppress it and send
     `dst` instead.
@@ -589,10 +591,11 @@ def get_typed_strings(events, allow_backspace=...):
     ...
 
 
-_recording: typing.Optional[tuple[Unknown | _queue.Queue[Unknown], typing.Callable[[], None]]]
+_recording: typing.Optional[tuple[Unknown | _queue.Queue[Unknown], collections.abc.Callable[[], None]]]
 
 
-def start_recording(recorded_events_queue=...) -> tuple[Unknown | _queue.Queue[Unknown], typing.Callable[[], None]]:
+def start_recording(recorded_events_queue=...) -> tuple[Unknown
+                                                        | _queue.Queue[Unknown], collections.abc.Callable[[], None]]:
     """
     Starts recording all keyboard events into a global variable, or the given
     queue if any. Returns the queue of events and the hooked function.
@@ -639,7 +642,13 @@ replay = play
 _word_listeners: dict
 
 
-def add_word_listener(word, callback: Callback, triggers=..., match_suffix=..., timeout=...) -> typing.Callable[[], None]:
+def add_word_listener(
+    word,
+    callback: Callback,
+    triggers=...,
+    match_suffix=...,
+    timeout=...) -> collections.abc.Callable[[],
+                                             None]:
     """
     Invokes a callback every time a sequence of characters is typed (e.g. 'pet')
     and followed by a trigger key (e.g. space). Modifiers (e.g. alt, ctrl,
@@ -676,7 +685,8 @@ def remove_word_listener(word_or_handler) -> None:
     ...
 
 
-def add_abbreviation(source_text, replacement_text, match_suffix=..., timeout=...) -> typing.Callable[[], None]:
+def add_abbreviation(source_text, replacement_text, match_suffix=...,
+                     timeout=...) -> collections.abc.Callable[[], None]:
     """
     Registers a hotkey that replaces one typed text with another. For example
 

typings/keyboard/_canonical_names.pyi

@@ -0,0 +1,11 @@
+"""
+This type stub file was generated by pyright.
+"""
+
+canonical_names = ...
+sided_modifiers = ...
+all_modifiers = ...
+
+
+def normalize_name(name: str) -> str:
+    ...