use const values instead of magic strings

kmk/modules/layers.py

@@ -1,9 +1,18 @@
 '''One layer isn't enough. Adds keys to get to more of them'''
+from micropython import const
+
 from kmk.key_validators import layer_key_validator
 from kmk.keys import make_argumented_key
 from kmk.modules.modtap import HoldTap
 
 
+class LayerType:
+    '''Defines layer types to be passed on as on_press and on_release kwargs where needed'''
+
+    LT = const(0)
+    TT = const(1)
+
+
 def curry(fn, *args, **kwargs):
     def curried(*fn_args, **fn_kwargs):
         merged_args = args + fn_args
@@ -38,8 +47,8 @@ class Layers(HoldTap):
         make_argumented_key(
             validator=layer_key_validator,
             names=('LT',),
-            on_press=curry(self.ht_pressed, key_type='LT'),
+            on_press=curry(self.ht_pressed, key_type=LayerType.LT),
-            on_release=curry(self.ht_released, key_type='LT'),
+            on_release=curry(self.ht_released, key_type=LayerType.LT),
         )
         make_argumented_key(
             validator=layer_key_validator, names=('TG',), on_press=self._tg_pressed
@@ -50,8 +59,8 @@ class Layers(HoldTap):
         make_argumented_key(
             validator=layer_key_validator,
             names=('TT',),
-            on_press=curry(self.ht_pressed, key_type='TT'),
+            on_press=curry(self.ht_pressed, key_type=LayerType.TT),
-            on_release=curry(self.ht_released, key_type='TT'),
+            on_release=curry(self.ht_released, key_type=LayerType.TT),
         )
 
     def _df_pressed(self, key, keyboard, *args, **kwargs):
@@ -125,28 +134,28 @@ class Layers(HoldTap):
 
     def ht_activate_tap(self, key, keyboard, *args, **kwargs):
         key_type = kwargs['key_type']
-        if key_type == 'LT':
+        if key_type == LayerType.LT:
             keyboard.hid_pending = True
             keyboard.keys_pressed.add(key.meta.kc)
-        elif key_type == 'TT':
+        elif key_type == LayerType.TT:
             self._tg_pressed(key, keyboard, *args, **kwargs)
 
     def ht_deactivate_tap(self, key, keyboard, *args, **kwargs):
         key_type = kwargs['key_type']
-        if key_type == 'LT':
+        if key_type == LayerType.LT:
             keyboard.hid_pending = True
             keyboard.keys_pressed.discard(key.meta.kc)
 
     def ht_activate_on_interrupt(self, key, keyboard, *args, **kwargs):
         key_type = kwargs['key_type']
-        if key_type == 'LT':
+        if key_type == LayerType.LT:
             self.ht_activate_tap(key, keyboard, *args, **kwargs)
-        elif key_type == 'TT':
+        elif key_type == LayerType.TT:
             self.ht_activate_hold(key, keyboard, *args, **kwargs)
 
     def ht_deactivate_on_interrupt(self, key, keyboard, *args, **kwargs):
         key_type = kwargs['key_type']
-        if key_type == 'LT':
+        if key_type == LayerType.LT:
             self.ht_deactivate_tap(key, keyboard, *args, **kwargs)
-        elif key_type == 'TT':
+        elif key_type == LayerType.TT:
             self.ht_deactivate_hold(key, keyboard, *args, **kwargs)

kmk/modules/modtap.py

@@ -1,14 +1,22 @@
+from micropython import const
+
 from kmk.key_validators import mod_tap_validator
 from kmk.keys import make_argumented_key
 from kmk.modules import Module
 
 
+class ActivationType:
+    NOT_ACTIVATED = const(0)
+    HOLD_TIMEOUT = const(1)
+    INTERRUPTED = const(2)
+
+
 class HoldTapKeyState:
     def __init__(self, timeout_key, *args, **kwargs):
         self.timeout_key = timeout_key
         self.args = args
         self.kwargs = kwargs
-        self.activated = False
+        self.activated = ActivationType.NOT_ACTIVATED
 
 
 class HoldTap(Module):
@@ -25,9 +33,9 @@ class HoldTap(Module):
         '''Before other key down decide to send tap kc down.'''
         if self.matrix_detected_press(keyboard):
             for key, state in self.key_states.items():
-                if not state.activated:
+                if state.activated == ActivationType.NOT_ACTIVATED:
                     # press tap because interrupted by other key
-                    self.key_states[key].activated = 'interrupt'
+                    self.key_states[key].activated = ActivationType.INTERRUPTED
                     self.ht_activate_on_interrupt(
                         key, keyboard, *state.args, **state.kwargs
                     )
@@ -67,10 +75,10 @@ class HoldTap(Module):
         if key in self.key_states:
             state = self.key_states[key]
             keyboard.cancel_timeout(state.timeout_key)
-            if state.activated == 'hold':
+            if state.activated == ActivationType.HOLD_TIMEOUT:
                 # release hold
                 self.ht_deactivate_hold(key, keyboard, *args, **kwargs)
-            elif state.activated == 'interrupt':
+            elif state.activated == ActivationType.INTERRUPTED:
                 # release tap
                 self.ht_deactivate_on_interrupt(key, keyboard, *args, **kwargs)
             else:
@@ -85,9 +93,12 @@ class HoldTap(Module):
 
     def on_tap_time_expired(self, key, keyboard, *args, **kwargs):
         '''When tap time expires activate mod if key is still being pressed.'''
-        if key in self.key_states and not self.key_states[key].activated:
+        if (
+            key in self.key_states
+            and self.key_states[key].activated == ActivationType.NOT_ACTIVATED
+        ):
             # press hold because timer expired after tap time
-            self.key_states[key].activated = 'hold'
+            self.key_states[key].activated = ActivationType.HOLD_TIMEOUT
             self.ht_activate_hold(key, keyboard, *args, **kwargs)
 
     def ht_activate_hold(self, key, keyboard, *args, **kwargs):