Adding mypy typing

Author: william-stearns

meshtastic/__init__.py

@@ -104,13 +104,13 @@ def onConnection(interface, topic=pub.AUTO_TOPIC): # called when we (re)connect
 LOCAL_ADDR = "^local"
 """A special ID that means the local node"""
 
-BROADCAST_NUM = 0xFFFFFFFF
+BROADCAST_NUM: int = 0xFFFFFFFF
 """if using 8 bit nodenums this will be shortened on the target"""
 
 BROADCAST_ADDR = "^all"
 """A special ID that means broadcast"""
 
-OUR_APP_VERSION = 20300
+OUR_APP_VERSION: int = 20300
 """The numeric buildnumber (shared with android apps) specifying the
    level of device code we are guaranteed to understand
 

meshtastic/__main__.py

@@ -8,6 +8,7 @@
 import platform
 import sys
 import time
+from typing import List
 
 import pyqrcode # type: ignore[import-untyped]
 import yaml
@@ -22,7 +23,7 @@
 from meshtastic.ble_interface import BLEInterface
 from meshtastic.mesh_interface import MeshInterface
 
-def onReceive(packet, interface):
+def onReceive(packet, interface) -> None:
     """Callback invoked when a packet arrives"""
     args = mt_config.args
     try:
@@ -53,7 +54,7 @@ def onReceive(packet, interface):
         print(f"Warning: There is no field {ex} in the packet.")
 
 
-def onConnection(interface, topic=pub.AUTO_TOPIC):  # pylint: disable=W0613
+def onConnection(interface, topic=pub.AUTO_TOPIC) -> None:  # pylint: disable=W0613
     """Callback invoked when we connect/disconnect from a radio"""
     print(f"Connection changed: {topic.getName()}")
 
@@ -63,7 +64,7 @@ def checkChannel(interface: MeshInterface, channelIndex: int) -> bool:
     logging.debug(f"ch:{ch}")
     return (ch and ch.role != channel_pb2.Channel.Role.DISABLED)
 
-def getPref(node, comp_name):
+def getPref(node, comp_name) -> bool:
     """Get a channel or preferences value"""
 
     name = splitCompoundName(comp_name)
@@ -78,11 +79,11 @@ def getPref(node, comp_name):
     # First validate the input
     localConfig = node.localConfig
     moduleConfig = node.moduleConfig
-    found = False
+    found: bool = False
     for config in [localConfig, moduleConfig]:
         objDesc = config.DESCRIPTOR
         config_type = objDesc.fields_by_name.get(name[0])
-        pref = False
+        pref = False		#FIXME - checkme - Used here as boolean, but set 2 lines below as a string.
         if config_type:
             pref = config_type.message_type.fields_by_name.get(snake_name)
             if pref or wholeField:
@@ -129,15 +130,15 @@ def getPref(node, comp_name):
     return True
 
 
-def splitCompoundName(comp_name):
+def splitCompoundName(comp_name: str) -> List[str]:
     """Split compound (dot separated) preference name into parts"""
-    name = comp_name.split(".")
+    name: List[str] = comp_name.split(".")
     if len(name) < 2:
         name[0] = comp_name
         name.append(comp_name)
     return name
 
-def traverseConfig(config_root, config, interface_config):
+def traverseConfig(config_root, config, interface_config) -> bool:
     """Iterate through current config level preferences and either traverse deeper if preference is a dict or set preference"""
     snake_name = meshtastic.util.camel_to_snake(config_root)
     for pref in config:
@@ -884,7 +885,7 @@ def setSimpleConfig(modem_preset):
         sys.exit(1)
 
 
-def printConfig(config):
+def printConfig(config) -> None:
     """print configuration"""
     objDesc = config.DESCRIPTOR
     for config_section in objDesc.fields:
@@ -901,12 +902,12 @@ def printConfig(config):
                 print(f"    {temp_name}")
 
 
-def onNode(node):
+def onNode(node) -> None:
     """Callback invoked when the node DB changes"""
     print(f"Node changed: {node}")
 
 
-def subscribe():
+def subscribe() -> None:
     """Subscribe to the topics the user probably wants to see, prints output to stdout"""
     pub.subscribe(onReceive, "meshtastic.receive")
     # pub.subscribe(onConnection, "meshtastic.connection")
@@ -917,7 +918,7 @@ def subscribe():
     # pub.subscribe(onNode, "meshtastic.node")
 
 
-def export_config(interface):
+def export_config(interface) -> str:
     """used in --export-config"""
     configObj = {}
 
@@ -949,7 +950,7 @@ def export_config(interface):
         if alt:
             configObj["location"]["alt"] = alt
 
-    config = MessageToDict(interface.localNode.localConfig)
+    config = MessageToDict(interface.localNode.localConfig)	#checkme - Used as a dictionary here and a string below
     if config:
         # Convert inner keys to correct snake/camelCase
         prefs = {}
@@ -959,7 +960,7 @@ def export_config(interface):
             else:
                 prefs[pref] = config[pref]
         if mt_config.camel_case:
-            configObj["config"] = config
+            configObj["config"] = config		#Identical command here and 2 lines below?
         else:
             configObj["config"] = config
 
@@ -975,10 +976,10 @@ def export_config(interface):
         else:
             configObj["module_config"] = prefs
 
-    config = "# start of Meshtastic configure yaml\n"
-    config += yaml.dump(configObj)
-    print(config)
-    return config
+    config_txt = "# start of Meshtastic configure yaml\n"		#checkme - "config" (now changed to config_out) was used as a string here and a Dictionary above
+    config_txt += yaml.dump(configObj)
+    print(config_txt)
+    return config_txt
 
 
 def common():

meshtastic/ble_interface.py

@@ -1,11 +1,12 @@
 """Bluetooth interface
 """
+import io
 import logging
 import time
 import struct
 import asyncio
 from threading import Thread, Event
-from typing import Optional
+from typing import List, Optional, Tuple
 
 from bleak import BleakScanner, BleakClient
 
@@ -32,7 +33,7 @@ class BLEState(): # pylint: disable=C0115
         MESH = False
 
 
-    def __init__(self, address: Optional[str], noProto: bool = False, debugOut = None, noNodes: bool = False):
+    def __init__(self, address: Optional[str], noProto: bool = False, debugOut: Optional[io.TextIOWrapper] = None, noNodes: bool = False) -> None:
         self.state = BLEInterface.BLEState()
 
         if not address:
@@ -72,14 +73,14 @@ def __init__(self, address: Optional[str], noProto: bool = False, debugOut = Non
         self.client.start_notify(FROMNUM_UUID, self.from_num_handler)
 
 
-    async def from_num_handler(self, _, b): # pylint: disable=C0116
+    async def from_num_handler(self, _, b: bytes) -> None: # pylint: disable=C0116
         from_num = struct.unpack('<I', bytes(b))[0]
         logging.debug(f"FROMNUM notify: {from_num}")
         self.should_read = True
 
 
-    def scan(self):
-        "Scan for available BLE devices"
+    def scan(self) -> List[Tuple]:
+        """Scan for available BLE devices"""
         with BLEClient() as client:
             return [
                 (x[0], x[1]) for x in (client.discover(
@@ -89,8 +90,8 @@ def scan(self):
             ]
 
 
-    def find_device(self, address):
-        "Find a device by address"
+    def find_device(self, address: Optional[str]):
+        """Find a device by address"""
         meshtastic_devices = self.scan()
 
         addressed_devices = list(filter(lambda x: address in (x[1].local_name, x[0].name), meshtastic_devices))
@@ -106,18 +107,21 @@ def find_device(self, address):
             raise BLEInterface.BLEError(f"More than one Meshtastic BLE peripheral with identifier or address '{address}' found.")
         return addressed_devices[0][0]
 
-    def _sanitize_address(address): # pylint: disable=E0213
-        "Standardize BLE address by removing extraneous characters and lowercasing"
-        return address \
-            .replace("-", "") \
-            .replace("_", "") \
-            .replace(":", "") \
-            .lower()
-
-    def connect(self, address):
+    def _sanitize_address(address: Optional[str]) -> Optional[str]: # pylint: disable=E0213
+        """Standardize BLE address by removing extraneous characters and lowercasing"""
+        if address is None:
+            return None
+        else:
+            return address \
+                .replace("-", "") \
+                .replace("_", "") \
+                .replace(":", "") \
+                .lower()
+
+    def connect(self, address) -> BLEClient:
         "Connect to a device by address"
         device = self.find_device(address)
-        client = BLEClient(device.address)
+        client: BLEClient = BLEClient(device.address)
         client.connect()
         try:
             client.pair()
@@ -128,12 +132,12 @@ def connect(self, address):
         return client
 
 
-    def _receiveFromRadioImpl(self):
+    def _receiveFromRadioImpl(self) -> None:
         self._receiveThread_started.set()
         while self._receiveThread_started.is_set():
             if self.should_read:
                 self.should_read = False
-                retries = 0
+                retries: int = 0
                 while True:
                     b = bytes(self.client.read_gatt_char(FROMRADIO_UUID))
                     if not b:
@@ -148,8 +152,8 @@ def _receiveFromRadioImpl(self):
                 time.sleep(0.1)
         self._receiveThread_stopped.set()
 
-    def _sendToRadioImpl(self, toRadio):
-        b = toRadio.SerializeToString()
+    def _sendToRadioImpl(self, toRadio) -> None:
+        b: bytes = toRadio.SerializeToString()
         if b:
             logging.debug(f"TORADIO write: {b.hex()}")
             self.client.write_gatt_char(TORADIO_UUID, b, response = True)
@@ -158,7 +162,7 @@ def _sendToRadioImpl(self, toRadio):
             self.should_read = True
 
 
-    def close(self):
+    def close(self) -> None:
         if self.state.MESH:
             MeshInterface.close(self)
 
@@ -173,7 +177,7 @@ def close(self):
 
 class BLEClient():
     """Client for managing connection to a BLE device"""
-    def __init__(self, address = None, **kwargs):
+    def __init__(self, address = None, **kwargs) -> None:
         self._eventThread = Thread(target = self._run_event_loop)
         self._eventThread_started = Event()
         self._eventThread_stopped = Event()

meshtastic/remote_hardware.py

@@ -8,7 +8,7 @@
 from meshtastic.util import our_exit
 
 
-def onGPIOreceive(packet, interface):
+def onGPIOreceive(packet, interface) -> None:
     """Callback for received GPIO responses"""
     logging.debug(f"packet:{packet} interface:{interface}")
     gpioValue = 0
@@ -37,7 +37,7 @@ class RemoteHardwareClient:
     code for how you can connect to your own custom meshtastic services
     """
 
-    def __init__(self, iface):
+    def __init__(self, iface) -> None:
         """
         Constructor
 

meshtastic/serial_interface.py

@@ -4,7 +4,7 @@
 import platform
 import time
 
-from typing import Optional
+from typing import List, Optional
 
 import serial # type: ignore[import-untyped]
 
@@ -18,7 +18,7 @@
 class SerialInterface(StreamInterface):
     """Interface class for meshtastic devices over a serial link"""
 
-    def __init__(self, devPath: Optional[str]=None, debugOut=None, noProto=False, connectNow=True, noNodes: bool=False):
+    def __init__(self, devPath: Optional[str]=None, debugOut=None, noProto: bool=False, connectNow: bool=True, noNodes: bool=False) -> None:
         """Constructor, opens a connection to a specified serial port, or if unspecified try to
         find one Meshtastic device by probing
 
@@ -31,13 +31,13 @@ def __init__(self, devPath: Optional[str]=None, debugOut=None, noProto=False, co
         self.devPath: Optional[str] = devPath
 
         if self.devPath is None:
-            ports = meshtastic.util.findPorts(True)
+            ports: List[str] = meshtastic.util.findPorts(True)
             logging.debug(f"ports:{ports}")
             if len(ports) == 0:
                 print("No Serial Meshtastic device detected, attempting TCP connection on localhost.")
                 return
             elif len(ports) > 1:
-                message = "Warning: Multiple serial ports were detected so one serial port must be specified with the '--port'.\n"
+                message: str = "Warning: Multiple serial ports were detected so one serial port must be specified with the '--port'.\n"
                 message += f"  Ports detected:{ports}"
                 meshtastic.util.our_exit(message)
             else:
@@ -65,7 +65,7 @@ def __init__(self, devPath: Optional[str]=None, debugOut=None, noProto=False, co
             self, debugOut=debugOut, noProto=noProto, connectNow=connectNow, noNodes=noNodes
         )
 
-    def close(self):
+    def close(self) -> None:
         """Close a connection to the device"""
         self.stream.flush()
         time.sleep(0.1)