Reannotate segments.py

Author: tekktrik

adafruit_ht16k33/segments.py

@@ -11,6 +11,12 @@
 from time import sleep
 from adafruit_ht16k33.ht16k33 import HT16K33
 
+try:
+    from typing import Union, List, Tuple, Optional, Dict
+    from busio import I2C
+except ImportError:
+    pass
+
 
 __version__ = "0.0.0+auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_HT16K33.git"
@@ -149,11 +155,11 @@ class Seg14x4(HT16K33):
 
     def __init__(
         self,
-        i2c,
-        address = 0x70,
-        auto_write = True,
-        chars_per_display = 4,
-    ):
+        i2c: I2C,
+        address=0x70,
+        auto_write: Union[int, List[int], Tuple[int, ...]] = True,
+        chars_per_display: int = 4,
+    ) -> None:
         super().__init__(i2c, address, auto_write)
         if not 1 <= chars_per_display <= 8:
             raise ValueError(
@@ -163,7 +169,7 @@ def __init__(
         self._chars = chars_per_display * len(self.i2c_device)
         self._bytes_per_char = 2
 
-    def print(self, value, decimal = 0):
+    def print(self, value: Union[str, float], decimal: int = 0) -> None:
         """Print the value to the display.
 
         :param value: The value to print
@@ -173,7 +179,7 @@ def print(self, value, decimal = 0):
             integer if decimal is zero.
         """
 
-        if isinstance(value, (str)):
+        if isinstance(value, str):
             self._text(value)
         elif isinstance(value, (int, float)):
             self._number(value, decimal)
@@ -182,7 +188,7 @@ def print(self, value, decimal = 0):
         if self._auto_write:
             self.show()
 
-    def print_hex(self, value):
+    def print_hex(self, value: Union[int, str]) -> None:
         """Print the value as a hexidecimal string to the display.
 
         :param int value: The number to print
@@ -198,7 +204,7 @@ def __setitem__(self, key, value):
         if self._auto_write:
             self.show()
 
-    def scroll(self, count = 1):
+    def scroll(self, count: int = 1) -> None:
         """Scroll the display by specified number of places.
 
         :param int count: The number of places to scroll
@@ -214,7 +220,7 @@ def scroll(self, count = 1):
                 self._get_buffer(self._adjusted_index(i + 2 * count)),
             )
 
-    def _put(self, char, index = 0):
+    def _put(self, char: str, index: int = 0) -> None:
         """Put a character at the specified place."""
         if not 0 <= index < self._chars:
             return
@@ -230,7 +236,7 @@ def _put(self, char, index = 0):
         self._set_buffer(self._adjusted_index(index * 2), CHARS[1 + character])
         self._set_buffer(self._adjusted_index(index * 2 + 1), CHARS[character])
 
-    def _push(self, char):
+    def _push(self, char: str) -> None:
         """Scroll the display and add a character at the end."""
         if (
             char != "."
@@ -241,12 +247,12 @@ def _push(self, char):
             self._put(" ", self._chars - 1)
         self._put(char, self._chars - 1)
 
-    def _text(self, text):
+    def _text(self, text: str) -> None:
         """Display the specified text."""
         for character in text:
             self._push(character)
 
-    def _number(self, number, decimal = 0):
+    def _number(self, number: float, decimal: int = 0) -> str:
         """
         Display a floating point or integer number on the Adafruit HT16K33 based displays
 
@@ -284,12 +290,13 @@ def _number(self, number, decimal = 0):
                 places += 1
 
         # Set decimal places, if number of decimal places is specified (decimal > 0)
+        txt = None
         if places > 0 < decimal < len(stnum[places:]) and dot > 0:
             txt = stnum[: dot + decimal + 1]
         elif places > 0:
             txt = stnum[:places]
 
-        if len(txt) > self._chars + 1:
+        if txt is None or len(txt) > self._chars + 1:
             self._auto_write = auto_write
             raise ValueError("Output string ('{0}') is too long!".format(txt))
 
@@ -298,22 +305,24 @@ def _number(self, number, decimal = 0):
 
         return txt
 
-    def _adjusted_index(self, index):
+    def _adjusted_index(self, index: int) -> int:
         # Determine which part of the buffer to use and adjust index
         offset = (index // self._bytes_per_buffer()) * self._buffer_size
         return offset + index % self._bytes_per_buffer()
 
-    def _chars_per_buffer(self):
+    def _chars_per_buffer(self) -> int:
         return self._chars // len(self.i2c_device)
 
-    def _bytes_per_buffer(self):
+    def _bytes_per_buffer(self) -> int:
         return self._bytes_per_char * self._chars_per_buffer()
 
-    def _char_buffer_index(self, char_pos):
+    def _char_buffer_index(self, char_pos: int) -> int:
         offset = (char_pos // self._chars_per_buffer()) * self._buffer_size
         return offset + (char_pos % self._chars_per_buffer()) * self._bytes_per_char
 
-    def set_digit_raw(self, index, bitmask):
+    def set_digit_raw(
+        self, index: int, bitmask: Union[int, List[int, int], Tuple[int, int]]
+    ) -> None:
         """Set digit at position to raw bitmask value. Position should be a value
         of 0 to 3 with 0 being the left most character on the display.
 
@@ -339,7 +348,7 @@ def set_digit_raw(self, index, bitmask):
         if self._auto_write:
             self.show()
 
-    def marquee(self, text, delay = 0.25, loop = True):
+    def marquee(self, text: str, delay: float = 0.25, loop: bool = True) -> None:
         """
         Automatically scroll the text at the specified delay between characters
 
@@ -357,7 +366,7 @@ def marquee(self, text, delay = 0.25, loop = True):
             else:
                 self._scroll_marquee(text, delay)
 
-    def _scroll_marquee(self, text, delay):
+    def _scroll_marquee(self, text: str, delay: float):
         """Scroll through the text string once using the delay"""
         char_is_dot = False
         for character in text:
@@ -374,22 +383,22 @@ class _AbstractSeg7x4(Seg14x4):
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        i2c,
-        address = 0x70,
-        auto_write = True,
-        char_dict = None,
-        chars_per_display = 4,
-    ):
+        i2c: I2C,
+        address: Union[int, List[int], Tuple[int, ...]] = 0x70,
+        auto_write: bool = True,
+        char_dict: Optional[Dict[str, int]] = None,
+        chars_per_display: int = 4,
+    ) -> None:
         super().__init__(i2c, address, auto_write, chars_per_display)
         self._chardict = char_dict
         self._bytes_per_char = 1
 
-    def _adjusted_index(self, index):
+    def _adjusted_index(self, index: int) -> int:
         # Determine which part of the buffer to use and adjust index
         offset = (index // self._bytes_per_buffer()) * self._buffer_size
         return offset + self.POSITIONS[index % self._bytes_per_buffer()]
 
-    def scroll(self, count = 1):
+    def scroll(self, count: int = 1) -> None:
         """Scroll the display by specified number of places.
 
         :param int count: The number of places to scroll
@@ -405,7 +414,7 @@ def scroll(self, count = 1):
                 self._get_buffer(self._adjusted_index(i + count)),
             )
 
-    def _push(self, char):
+    def _push(self, char: str) -> None:
         """Scroll the display and add a character at the end."""
         if char in ":;":
             self._put(char)
@@ -418,7 +427,7 @@ def _push(self, char):
                 self._put(" ", self._chars - 1)
             self._put(char, self._chars - 1)
 
-    def _put(self, char, index = 0):
+    def _put(self, char: str, index: int = 0) -> None:
         """Put a character at the specified place."""
         # pylint: disable=too-many-return-statements
         if not 0 <= index < self._chars:
@@ -456,7 +465,7 @@ def _put(self, char, index = 0):
             return
         self._set_buffer(index, NUMBERS[character])
 
-    def set_digit_raw(self, index, bitmask):
+    def set_digit_raw(self, index: int, bitmask: int) -> None:
         """Set digit at position to raw bitmask value. Position should be a value
         of 0 to 3 with 0 being the left most digit on the display.
 
@@ -490,23 +499,23 @@ class Seg7x4(_AbstractSeg7x4):
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        i2c,
-        address = 0x70,
-        auto_write = True,
-        char_dict = None,
-        chars_per_display = 4,
-    ):
+        i2c: I2C,
+        address: Union[int, List[int], Tuple[int, ...]] = 0x70,
+        auto_write: bool = True,
+        char_dict: Optional[Dict[str, int]] = None,
+        chars_per_display: int = 4,
+    ) -> None:
         super().__init__(i2c, address, auto_write, char_dict, chars_per_display)
         # Use colon for controling two-dots indicator at the center (index 0)
         self._colon = Colon(self)
 
     @property
-    def colon(self):
+    def colon(self) -> bool:
         """Simplified colon accessor"""
         return self._colon[0]
 
     @colon.setter
-    def colon(self, turn_on):
+    def colon(self, turn_on: bool) -> None:
         self._colon[0] = turn_on
 
 
@@ -522,17 +531,17 @@ class BigSeg7x4(_AbstractSeg7x4):
 
     def __init__(
         self,
-        i2c,
-        address = 0x70,
-        auto_write = True,
-        char_dict = None,
-    ):
+        i2c: I2C,
+        address: Union[int, List[int], Tuple[int, ...]] = 0x70,
+        auto_write: bool = True,
+        char_dict: Optional[Dict[str, int]] = None,
+    ) -> None:
         super().__init__(i2c, address, auto_write, char_dict)
         # Use colon for controling two-dots indicator at the center (index 0)
         # or the two-dots indicators at the left (index 1)
         self.colons = Colon(self, 2)
 
-    def _setindicator(self, index, value):
+    def _setindicator(self, index: int, value: bool) -> None:
         """Set side LEDs (dots)
         Index is as follow :
         * 0 : two dots at the center
@@ -549,38 +558,38 @@ def _setindicator(self, index, value):
         if self._auto_write:
             self.show()
 
-    def _getindicator(self, index):
+    def _getindicator(self, index: int) -> int:
         """Get side LEDs (dots)
         See setindicator() for indexes
         """
         bitmask = 1 << (index + 1)
         return self._get_buffer(0x04) & bitmask
 
     @property
-    def top_left_dot(self):
+    def top_left_dot(self) -> bool:
         """The top-left dot indicator."""
         return bool(self._getindicator(1))
 
     @top_left_dot.setter
-    def top_left_dot(self, value):
+    def top_left_dot(self, value: bool) -> None:
         self._setindicator(1, value)
 
     @property
-    def bottom_left_dot(self):
+    def bottom_left_dot(self) -> bool:
         """The bottom-left dot indicator."""
         return bool(self._getindicator(2))
 
     @bottom_left_dot.setter
-    def bottom_left_dot(self, value):
+    def bottom_left_dot(self, value: bool) -> None:
         self._setindicator(2, value)
 
     @property
-    def ampm(self):
+    def ampm(self) -> bool:
         """The AM/PM indicator."""
         return bool(self._getindicator(3))
 
     @ampm.setter
-    def ampm(self, value):
+    def ampm(self, value: bool) -> None:
         self._setindicator(3, value)
 
 
@@ -591,11 +600,11 @@ class Colon:
 
     MASKS = (0x02, 0x0C)
 
-    def __init__(self, disp, num_of_colons = 1):
+    def __init__(self, disp: _AbstractSeg7x4, num_of_colons: int = 1) -> None:
         self._disp = disp
         self._num_of_colons = num_of_colons
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: int, value: bool) -> None:
         if key > self._num_of_colons - 1:
             raise ValueError("Trying to set a non-existent colon.")
         current = self._disp._get_buffer(0x04)
@@ -606,7 +615,7 @@ def __setitem__(self, key, value):
         if self._disp.auto_write:
             self._disp.show()
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: int) -> bool:
         if key > self._num_of_colons - 1:
             raise ValueError("Trying to access a non-existent colon.")
         return bool(self._disp._get_buffer(0x04) & self.MASKS[key])