Enable mypy strict compliance

oin_thermostat/screen.py

@@ -3,36 +3,36 @@ import math
 from threading import Timer
 
 import bdfparser
-from sense_hat import SenseHat
+from sense_hat import InputEvent, SenseHat
 
 logger = logging.getLogger(__name__)
 
 COLORS = {
-    "Bleu": [0, 0, 255],
-    "Blanc": [255, 255, 255],
-    "Rouge": [255, 0, 0],
-    "Verte": [0, 127, 31],
-    "Jaune": [255, 255, 0],
-    "heat": [255, 0, 0],
-    "heating": [255, 0, 0],
-    "idle": [127, 0, 255],
-    "off": [127, 127, 127],
-    "on_setting": [255, 255, 0],
-    "off_setting": [255, 255, 255],
-    None: [0, 0, 0],
+    "Bleu": (0, 0, 255),
+    "Blanc": (255, 255, 255),
+    "Rouge": (255, 0, 0),
+    "Verte": (0, 127, 31),
+    "Jaune": (255, 255, 0),
+    "heat": (255, 0, 0),
+    "heating": (255, 0, 0),
+    "idle": (127, 0, 255),
+    "off": (127, 127, 127),
+    "on_setting": (255, 255, 0),
+    "off_setting": (255, 255, 255),
+    None: (0, 0, 0),
 }
 
 
 class Screen:
-    def __init__(self):
+    def __init__(self) -> None:
         self.sense = SenseHat()
         self._value = ""
         self._tmp = False
-        self._tmp_value = None
-        self._mode = None
+        self._tmp_value = ""
+        self._mode = ""
         self.font = bdfparser.Font("src/tom-thumb.bdf")
-        self._secondary = dict()
-        self._secondary_pixels = [[0, 0, 0]] * 8
+        self._secondary: dict[int, str] = dict()
+        self._secondary_pixels: list[tuple[int, int, int]] = [(0, 0, 0)] * 8
 
         self.timer = Timer(0, self.set_pixels)
 
@@ -40,11 +40,11 @@ class Screen:
         self.sense.stick.direction_middle = self.stick_click
 
     @property
-    def value(self):
+    def value(self) -> None | str:
         return self._value
 
     @value.setter
-    def value(self, value):
+    def value(self, value: float) -> None:
         logger.debug(f"Updated value: <{value}>")
 
         self._value = format_value(value)
@@ -52,32 +52,32 @@ class Screen:
             self.set_pixels()
 
     @property
-    def color(self):
-        return COLORS.get(self.mode, [0, 0, 0])
+    def color(self) -> tuple[int, int, int]:
+        return COLORS.get(self.mode, (0, 0, 0))
 
     @property
-    def mode(self):
+    def mode(self) -> str:
         return self._mode
 
     @mode.setter
-    def mode(self, value):
+    def mode(self, value: str) -> None:
         self._mode = value
         if not self._tmp:
             self.set_pixels()
 
     @property
-    def tmp_value(self):
+    def tmp_value(self) -> None | str:
         return self._tmp_value
 
     @tmp_value.setter
-    def tmp_value(self, value):
+    def tmp_value(self, value: float) -> None:
         logger.debug(f"Show value: <{value}>")
 
         self.timer.cancel()
         self._tmp_value = format_value(value)
         self.show_tmp()
 
-    def show_tmp(self):
+    def show_tmp(self) -> None:
         self._tmp = True
         self.set_pixels(
             self.tmp_value,
@@ -86,7 +86,12 @@ class Screen:
         self.timer = Timer(3, self.set_pixels)
         self.timer.start()
 
-    def set_pixels(self, value=None, color=None, bg_color=[0, 0, 0]):
+    def set_pixels(
+        self,
+        value: str | None = None,
+        color: tuple[int, int, int] | None = None,
+        bg_color: tuple[int, int, int] = (0, 0, 0),
+    ) -> None:
         if value is None:
             value = self.value
             self._tmp = False
@@ -99,32 +104,32 @@ class Screen:
                 for x in self.font.draw(value, mode=0).crop(8, 7).todata(3)
             ]
         else:
-            pixels = 48 * [[0, 0, 0]]
+            pixels = 48 * [(0, 0, 0)]
         pixels += self.secondary_pixels
 
         self.sense.set_pixels(pixels)
 
     @property
-    def secondary(self):
+    def secondary(self) -> dict[int, str]:
         return self._secondary
 
     @secondary.setter
-    def secondary(self, value):
+    def secondary(self, value: dict[int, str]) -> None:
         self._secondary = value
 
         for idx in range(2):
             self._secondary_pixels[4 * idx : 4 * (idx + 1)] = [
-                COLORS.get(value.get(idx, None), [0, 0, 0])
+                COLORS.get(value.get(idx, None), (0, 0, 0))
             ] * 4
 
         if not self._tmp:
             self.set_pixels()
 
     @property
-    def secondary_pixels(self):
+    def secondary_pixels(self) -> list[tuple[int, int, int]]:
         return self._secondary_pixels
 
-    def stick_click(self, event):
+    def stick_click(self, event: InputEvent) -> None:
         match (event.action, self._held):
             case ("held", False):
                 self._held = True
@@ -134,7 +139,7 @@ class Screen:
                 self.show_tmp()
 
 
-def format_value(value):
+def format_value(value: float) -> str:
     v = math.trunc(value)
     d = "." if (value - v) >= 0.5 else ""
     return f"{v}{d}"