Adding mypy typing

meshtastic/stream_interface.py

@@ -1,5 +1,6 @@
 """Stream Interface base class
 """
+import io
 import logging
 import threading
 import time
@@ -7,6 +8,8 @@ import traceback
 
 import serial # type: ignore[import-untyped]
 
+from typing import Optional, cast
+
 from meshtastic.mesh_interface import MeshInterface
 from meshtastic.util import is_windows11, stripnl
 
@@ -19,7 +22,7 @@ MAX_TO_FROM_RADIO_SIZE = 512
 class StreamInterface(MeshInterface):
     """Interface class for meshtastic devices over a stream link (serial, TCP, etc)"""
 
-    def __init__(self, debugOut=None, noProto=False, connectNow=True, noNodes=False):
+    def __init__(self, debugOut: Optional[io.TextIOWrapper]=None, noProto: bool=False, connectNow: bool=True, noNodes: bool=False) -> None:
         """Constructor, opens a connection to self.stream
 
         Keyword Arguments:
@@ -51,7 +54,7 @@ class StreamInterface(MeshInterface):
             if not noProto:
                 self.waitForConfig()
 
-    def connect(self):
+    def connect(self) -> None:
         """Connect to our radio
 
         Normally this is called automatically by the constructor, but if you
@@ -62,7 +65,7 @@ class StreamInterface(MeshInterface):
         # if the reading statemachine was parsing a bad packet make sure
         # we write enough start bytes to force it to resync (we don't use START1
         # because we want to ensure it is looking for START1)
-        p = bytearray([START2] * 32)
+        p: bytes = bytearray([START2] * 32)
         self._writeBytes(p)
         time.sleep(0.1)  # wait 100ms to give device time to start running
 
@@ -73,7 +76,7 @@ class StreamInterface(MeshInterface):
         if not self.noProto:  # Wait for the db download if using the protocol
             self._waitConnected()
 
-    def _disconnected(self):
+    def _disconnected(self) -> None:
         """We override the superclass implementation to close our port"""
         MeshInterface._disconnected(self)
 
@@ -85,7 +88,7 @@ class StreamInterface(MeshInterface):
             # pylint: disable=W0201
             self.stream = None
 
-    def _writeBytes(self, b):
+    def _writeBytes(self, b: bytes) -> None:
         """Write an array of bytes to our stream and flush"""
         if self.stream:  # ignore writes when stream is closed
             self.stream.write(b)
@@ -97,24 +100,24 @@ class StreamInterface(MeshInterface):
                 # we sleep here to give the TBeam a chance to work
                 time.sleep(0.1)
 
-    def _readBytes(self, length):
+    def _readBytes(self, length) -> Optional[bytes]:
         """Read an array of bytes from our stream"""
         if self.stream:
             return self.stream.read(length)
         else:
             return None
 
-    def _sendToRadioImpl(self, toRadio):
+    def _sendToRadioImpl(self, toRadio) -> None:
         """Send a ToRadio protobuf to the device"""
         logging.debug(f"Sending: {stripnl(toRadio)}")
-        b = toRadio.SerializeToString()
-        bufLen = len(b)
+        b: bytes = toRadio.SerializeToString()
+        bufLen: int = len(b)
         # We convert into a string, because the TCP code doesn't work with byte arrays
-        header = bytes([START1, START2, (bufLen >> 8) & 0xFF, bufLen & 0xFF])
+        header: bytes = bytes([START1, START2, (bufLen >> 8) & 0xFF, bufLen & 0xFF])
         logging.debug(f"sending header:{header} b:{b}")
         self._writeBytes(header + b)
 
-    def close(self):
+    def close(self) -> None:
         """Close a connection to the device"""
         logging.debug("Closing stream")
         MeshInterface.close(self)
@@ -124,7 +127,7 @@ class StreamInterface(MeshInterface):
         if self._rxThread != threading.current_thread():
             self._rxThread.join()  # wait for it to exit
 
-    def __reader(self):
+    def __reader(self) -> None:
         """The reader thread that reads bytes from our stream"""
         logging.debug("in __reader()")
         empty = bytes()
@@ -132,13 +135,13 @@ class StreamInterface(MeshInterface):
         try:
             while not self._wantExit:
                 # logging.debug("reading character")
-                b = self._readBytes(1)
+                b: Optional[bytes] = self._readBytes(1)
                 # logging.debug("In reader loop")
                 # logging.debug(f"read returned {b}")
-                if len(b) > 0:
-                    c = b[0]
+                if b is not None and len(cast(bytes, b)) > 0:
+                    c: int = b[0]
                     # logging.debug(f'c:{c}')
-                    ptr = len(self._rxBuf)
+                    ptr: int = len(self._rxBuf)
 
                     # Assume we want to append this byte, fixme use bytearray instead
                     self._rxBuf = self._rxBuf + b