Merge branch 'master' into after-ephemera/oled-improvement-revival

kmk/kmk_keyboard.py

@@ -386,6 +386,10 @@ class KMKKeyboard:
         self._hid_helper = self._hid_helper(**self._go_args)
         self._hid_send_enabled = True
 
+    def _deinit_hid(self) -> None:
+        self._hid_helper.clear_all()
+        self._hid_helper.send()
+
     def _init_matrix(self) -> None:
         if self.matrix is None:
             if debug.enabled:
@@ -498,8 +502,12 @@ class KMKKeyboard:
 
     def go(self, hid_type=HIDModes.USB, secondary_hid_type=None, **kwargs) -> None:
         self._init(hid_type=hid_type, secondary_hid_type=secondary_hid_type, **kwargs)
-        while True:
-            self._main_loop()
+        try:
+            while True:
+                self._main_loop()
+        finally:
+            debug('Unexpected error: cleaning up')
+            self._deinit_hid()
 
     def _init(
         self,

kmk/modules/modtap.py

@@ -2,6 +2,7 @@ from kmk.keys import make_argumented_key
 from kmk.modules.holdtap import HoldTap, HoldTapKeyMeta
 
 
+# Deprecation Notice: The `ModTap` class serves as an alias for `HoldTap` and will be removed in a future update. Please use `HoldTap` instead.
 class ModTap(HoldTap):
     def __init__(self):
         super().__init__()

kmk/modules/oneshot.py

@@ -1,9 +1,14 @@
 from kmk.keys import make_argumented_key
 from kmk.modules.holdtap import ActivationType, HoldTap, HoldTapKeyMeta
+from kmk.modules.layers import LayerKeyMeta
+from kmk.utils import Debug
+
+debug = Debug(__name__)
 
 
-def oneshot_validator(kc, tap_time=None):
-    return HoldTapKeyMeta(tap=kc, hold=kc, prefer_hold=False, tap_time=tap_time)
+class OneShotKeyMeta(HoldTapKeyMeta):
+    def __init__(self, kc, tap_time=None):
+        super().__init__(tap=kc, hold=kc, prefer_hold=False, tap_time=tap_time)
 
 
 class OneShot(HoldTap):
@@ -12,30 +17,49 @@ class OneShot(HoldTap):
     def __init__(self):
         super().__init__()
         make_argumented_key(
-            validator=oneshot_validator,
+            validator=OneShotKeyMeta,
             names=('OS', 'ONESHOT'),
             on_press=self.osk_pressed,
             on_release=self.osk_released,
         )
 
     def process_key(self, keyboard, current_key, is_pressed, int_coord):
-        '''Release os key after interrupting keyup.'''
+        '''Release os key after interrupting non-os keyup, or reset timeout and
+        stack multiple os keys.'''
+        send_buffer = False
+
         for key, state in self.key_states.items():
             if key == current_key:
                 continue
 
+            if (isinstance(current_key.meta, OneShotKeyMeta)) or (
+                isinstance(current_key.meta, LayerKeyMeta)
+            ):
+                keyboard.cancel_timeout(state.timeout_key)
+                if key.meta.tap_time is None:
+                    tap_time = self.tap_time
+                else:
+                    tap_time = key.meta.tap_time
+                state.timeout_key = keyboard.set_timeout(
+                    tap_time,
+                    lambda k=key: self.on_tap_time_expired(k, keyboard),
+                )
+                continue
+
             if state.activated == ActivationType.PRESSED and is_pressed:
                 state.activated = ActivationType.HOLD_TIMEOUT
             elif state.activated == ActivationType.RELEASED and is_pressed:
                 state.activated = ActivationType.INTERRUPTED
             elif state.activated == ActivationType.INTERRUPTED:
                 if is_pressed:
-                    keyboard.remove_key(key.meta.tap)
-                    self.key_buffer.append((int_coord, current_key, is_pressed))
-                    keyboard.set_timeout(False, lambda: self.send_key_buffer(keyboard))
-                    current_key = None
-                else:
-                    self.ht_released(key, keyboard)
+                    send_buffer = True
+                self.key_buffer.insert(0, (0, key, False))
+
+        if send_buffer:
+            self.key_buffer.append((int_coord, current_key, is_pressed))
+            current_key = None
+
+        self.send_key_buffer(keyboard)
 
         return current_key
 
@@ -51,8 +75,8 @@ class OneShot(HoldTap):
         try:
             state = self.key_states[key]
         except KeyError:
-            if keyboard.debug_enabled:
-                print(f'OneShot.osk_released: no such key {key}')
+            if debug.enabled:
+                debug(f'OneShot.osk_released: no such key {key}')
             return keyboard
 
         if state.activated == ActivationType.PRESSED:

kmk/modules/power.py

@@ -103,9 +103,9 @@ class Power(Module):
         '''
         Sleeps longer and longer to save power the more time in between updates.
         '''
-        if check_deadline(ticks_ms(), self._powersave_start) <= 60000:
+        if check_deadline(ticks_ms(), self._powersave_start, 60000):
             sleep(8 / 1000)
-        elif check_deadline(ticks_ms(), self._powersave_start) >= 240000:
+        elif check_deadline(ticks_ms(), self._powersave_start, 240000) is False:
             sleep(180 / 1000)
         return
 
@@ -123,7 +123,7 @@ class Power(Module):
         return
 
     def usb_rescan_timer(self):
-        return bool(check_deadline(ticks_ms(), self._usb_last_scan) > 5000)
+        return bool(check_deadline(ticks_ms(), self._usb_last_scan, 5000) is False)
 
     def usb_time_reset(self):
         self._usb_last_scan = ticks_ms()