additional callback typing, enums, mypy

Author: georgeharker

adafruit_neotrellis/multitrellis.py

@@ -29,19 +29,33 @@
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_neotrellis.git"
 
-from typing import List, Optional, Sequence
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Sequence, TypeAlias
 
-from adafruit_neotrellis.neotrellis import CallbackType, NeoTrellis
+from adafruit_neotrellis.neotrellis import KeyEvent as SeesawKeyEvent
+from adafruit_neotrellis.neotrellis import KeypadEdge  # noqa: F401
+from adafruit_neotrellis.neotrellis import NeoTrellis
 from adafruit_seesaw.neopixel import ColorType
 
 
+@dataclass
+class KeyEvent:
+    x: int
+    y: int
+    edge: int  # KeypadEdge
+
+
+CallbackType: TypeAlias = Callable[[KeyEvent], None]
+
+
 class MultiTrellis:
     """Driver for multiple connected Adafruit NeoTrellis boards."""
 
     _trelli: List[List[NeoTrellis]]
     _rows: int
     _cols: int
     _key_pads: List[List[NeoTrellis]]
+    _callbacks: List[List[Optional[CallbackType]]]
 
     def __init__(self, neotrellis_array: List[List[NeoTrellis]]):
         self._trelli = neotrellis_array
@@ -76,15 +90,23 @@ def __init__(self, neotrellis_array: List[List[NeoTrellis]]):
         self._height = row_size_sum[self._rows - 1]
         self._key_pads: List[List[NeoTrellis]] = []
 
+        for y in range(self._height):
+            self._key_pads.append([])
         for py in range(self._rows):
             for px in range(self._cols):
                 t = self._trelli[py][px]
                 for ky in range(t.height):
                     y = t.y_base + ky
-                    self._key_pads.append([])
                     for kx in range(t.width):
                         self._key_pads[y].append(t)
 
+    @staticmethod
+    def _callback_wrapper(t: NeoTrellis,
+                          event: SeesawKeyEvent,
+                          cb: CallbackType) -> None:
+        x, y = t.key_xy(event.number)
+        cb(KeyEvent(x=x, y=y, edge=event.edge))
+
     @property
     def width(self):
         return self._width
@@ -110,26 +132,28 @@ def __getitem__(self, subscript: int) -> Sequence[NeoTrellis]:
     def get_keypad(self, x: int, y: int) -> NeoTrellis:
         return self._key_pads[y][x]
 
-    def activate_key(self, x: int, y: int, edge: int, enable: bool = True):
+    def activate_key(self, x: int, y:
+                     int, edge:  # KeypadEdge
+                     int, enable: bool = True):
         """Activate or deactivate a key on the trellis. x and y are the index
         of the key measured from the top lefthand corner. Edge specifies what
         edge to register an event on and can be NeoTrellis.EDGE_FALLING or
         NeoTrellis.EDGE_RISING. enable should be set to True if the event is
         to be enabled, or False if the event is to be disabled."""
         pad = self._key_pads[y][x]
-        pad.activate_key(pad.key_index(x, y), enable)
+        pad.activate_key(pad.key_index(x, y), edge, enable)
 
     def set_callback(self, x: int, y: int, function: CallbackType):
         """Set a callback function for when an event for the key at index x, y
         (measured from the top lefthand corner) is detected."""
         pad = self._key_pads[y][x]
-        pad.callbacks[pad.key_index(x, y)] = function
+        self._callbacks[y][x] = function
+        pad.callbacks[pad.key_index(x, y)] = lambda t, e: self._callback_wrapper(t, e, function)
 
     def get_callback(self, x: int, y: int) -> Optional[CallbackType]:
         """Get a callback function for when an event for the key at index x, y
         (measured from the top lefthand corner) is detected."""
-        pad = self._key_pads[y][x]
-        return pad.callbacks[pad.key_index(x, y)]
+        return self._callbacks[y][x]
 
     def color(self, x: int, y: int, color: ColorType):
         """Set the color of the pixel at index x, y measured from the top

adafruit_neotrellis/neotrellis.py

@@ -49,6 +49,7 @@
 from time import sleep
 from typing import Callable, List, Optional, Sequence, Tuple, TypeAlias
 
+from adafruit_seesaw.keypad import KeypadEdge  # noqa: F401
 from adafruit_seesaw.keypad import KeyEvent, Keypad, ResponseType
 from adafruit_seesaw.neopixel import ColorType, NeoPixel
 from micropython import const
@@ -65,7 +66,7 @@
 SYNC_DELAY = const(0.0005)
 INIT_DELAY = const(0.0005)
 
-CallbackType: TypeAlias = Callable[[KeyEvent], None]
+CallbackType: TypeAlias = Callable[['NeoTrellis', KeyEvent], None]
 
 
 class NeoTrellis(Keypad):
@@ -97,7 +98,9 @@ def __init__(self, i2c_bus, interrupt: bool = False,
         self.pixels = NeoPixel(self, _NEO_TRELLIS_NEOPIX_PIN, self.width * self.height)
         sleep(INIT_DELAY)
 
-    def activate_key(self, key: int, edge: int, enable: bool = True) -> None:
+    def activate_key(self, key:
+                     int, edge:  # KeypadEdge
+                     int, enable: bool = True) -> None:
         """Activate or deactivate a key on the trellis. Key is the key number from
            0 to 16. Edge specifies what edge to register an event on and can be
            NeoTrellis.EDGE_FALLING or NeoTrellis.EDGE_RISING. enable should be set
@@ -128,18 +131,22 @@ def sync(self) -> None:
             buf = self.read_keypad(available)
             for r in buf:
                 if r.response_type == ResponseType.TYPE_KEY:
-                    (e, n) = r.data_edge_num()
-                    evt = KeyEvent(n, e)
+                    evt = r.data_keyevent()
                     callback = self.callbacks[evt.number]
                     if (
                         callback is not None
                         and evt.number < _NEO_TRELLIS_NUM_KEYS
                     ):
-                        callback(evt)
+                        callback(self, evt)
 
     def local_key_index(self, x: int, y: int) -> int:
         return int(y * self.width + x)
 
     def key_index(self, x: int, y: int) -> int:
         return int((y - self.y_base) * self.width + (x - self.x_base))
 
+    def local_key_xy(self, key: int) -> Tuple[int, int]:
+        return key // self.width, key % self.width
+
+    def key_xy(self, key: int) -> Tuple[int, int]:
+        return self.y_base + key // self.width, self.x_base + key % self.width