Add basedpyright and start making fixes

Author: multiplemonomials

.github/workflows/basic_checks.yml

@@ -156,6 +156,7 @@ jobs:
         run: |
           cd tools
           ruff check --diff python/mbed_tools python/mbed_platformio
+          basedpyright
           
 
   docs-check:

tools/pyproject.toml

@@ -73,6 +73,7 @@ unit-tests = [
 ]
 linters = [
     "ruff",
+    "basedpyright",
     "SCons" # For packages imported by the PlatformIO scripts
 ]
 greentea = [
@@ -207,4 +208,28 @@ max-args = 10
 
 [tool.ruff.lint.flake8-annotations]
 # Don't require a return type annotation for __init__ in most cases
-mypy-init-return = true
+mypy-init-return = true
+
+[tool.basedpyright]
+
+# Don't warn about things deprecated more recently than python 3.7
+pythonVersion = "3.7"
+
+include = [
+    "python/mbed_tools/**",
+    "python/mbed_platformio/**"
+]
+
+# For right now, we can configure basedpyright in relatively permissive mode.
+# We will allow code where the types of things are partially unknown, as there is
+# lots of legacy code in that category.
+# Also the PlatformIO code has to work with SCons, which is fundamentally type
+# annotation proof, so that can likely never pass these checks.
+reportUnknownVariableType = false
+reportUnknownMemberType = false
+reportUnknownLambdaType = false
+reportMissingTypeArgument = false
+reportUnknownArgumentType = false
+reportUnknownParameterType = false
+reportAny = false
+reportExplicitAny = false

tools/python/mbed_tools/project/project.py

@@ -32,7 +32,7 @@ def import_project(url: str, dst_path: Any = None, recursive: bool = False) -> p
     if not dst_path:
         dst_path = pathlib.Path(git_data["dst_path"])
 
-    git_utils.clone(url, dst_path)
+    _ = git_utils.clone(url, dst_path)
     if recursive:
         libs = LibraryReferences(root=dst_path, ignore_paths=["mbed-os"])
         libs.fetch()

tools/python/mbed_tools/py.typed

@@ -14,10 +14,13 @@
 To start the terminal clients should call the "run" function, this is the entry point to the module.
 """
 
+import codecs
+import typing
 from typing import Any
 
 from serial import Serial
 from serial.tools.miniterm import Miniterm
+from typing_extensions import override
 
 
 def run(port: str, baud: int, echo: bool = True) -> None:
@@ -31,7 +34,7 @@ def run(port: str, baud: int, echo: bool = True) -> None:
         baud: Serial baud rate.
         echo: Echo user input back to the console.
     """
-    term = SerialTerminal(Serial(port=port, baudrate=str(baud)), echo=echo)
+    term = SerialTerminal(Serial(port=port, baudrate=baud), echo=echo)
     term.start()
 
     try:
@@ -55,21 +58,23 @@ class SerialTerminal(Miniterm):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Set the rx/tx encoding and special characters."""
         super().__init__(*args, **kwargs)
-        self.exit_character = CTRL_C
-        self.menu_character = CTRL_T
-        self.reset_character = CTRL_B
-        self.help_character = CTRL_H
+        self.exit_character: str = CTRL_C
+        self.menu_character: str = CTRL_T
+        self.reset_character: str = CTRL_B
+        self.help_character: str = CTRL_H
         self.set_rx_encoding("UTF-8")
         self.set_tx_encoding("UTF-8")
 
     def reset(self) -> None:
         """Send a reset signal."""
-        self.serial.sendBreak()
+        self.serial.send_break()
 
+    @override
     def get_help_text(self) -> str:
         """Return the text displayed when the user requests help."""
         return HELP_TEXT
 
+    @override
     def writer(self) -> None:
         """Implements terminal behaviour."""
         menu_active = False
@@ -79,6 +84,9 @@ def writer(self) -> None:
             except KeyboardInterrupt:
                 input_key = self.exit_character
 
+            if input_key is None:
+                continue
+
             if (menu_active and input_key in VALID_MENU_KEYS) or (input_key == self.help_character):
                 self.handle_menu_key(input_key)
                 menu_active = False
@@ -103,7 +111,8 @@ def _write_transformed_char(self, text: str) -> None:
         for transformation in self.tx_transformations:
             text = transformation.tx(text)
 
-        self.serial.write(self.tx_encoder.encode(text))
+        encoder = typing.cast(codecs.IncrementalEncoder, self.tx_encoder)
+        _ = self.serial.write(encoder.encode(text))
 
     def _echo_transformed_char(self, text: str) -> None:
         for transformation in self.tx_transformations:

tools/python/mbed_tools/sterm/terminal.py

@@ -75,23 +75,17 @@ def _targets_accumulate_hierarchy(all_targets_data: Dict[str, Any], target_name:
     return targets_in_order
 
 
-def _add_attribute_element(
-    accumulator: Dict[str, Any], attribute_name: str, elements_to_add: List[Any]
-) -> Dict[str, Any]:
+def _add_attribute_element(accumulator: Dict[str, Any], attribute_name: str, elements_to_add: List[Any]) -> None:
     """
     Adds an attribute element to an attribute.
 
     Args:
         accumulator: a store of attributes to be updated
         attribute_name: name of the attribute to update
         elements_to_add: element to add to the attribute list
-
-    Returns:
-        The accumulator object with the new elements added
     """
     for element in elements_to_add:
         accumulator[attribute_name].append(element)
-    return accumulator
 
 
 def _element_matches(element_to_remove: str, element_to_check: str) -> bool:
@@ -113,19 +107,14 @@ def _element_matches(element_to_remove: str, element_to_check: str) -> bool:
     return element_to_check == element_to_remove or element_to_check.startswith(f"{element_to_remove}=")
 
 
-def _remove_attribute_element(
-    accumulator: Dict[str, Any], attribute_name: str, elements_to_remove: List[Any]
-) -> Dict[str, Any]:
+def _remove_attribute_element(accumulator: Dict[str, Any], attribute_name: str, elements_to_remove: List[Any]) -> None:
     """
     Removes an attribute element from an attribute.
 
     Args:
         accumulator: a store of attributes to be updated
         attribute_name: name of the attribute to update
         elements_to_remove: element to remove from the attribute list
-
-    Returns:
-        The accumulator object with the desired elements removed
     """
     existing_elements = accumulator[attribute_name]
     combinations_to_check = itertools.product(existing_elements, elements_to_remove)
@@ -137,7 +126,6 @@ def _remove_attribute_element(
 
     for element in checked_elements_to_remove:
         accumulator[attribute_name].remove(element)
-    return accumulator
 
 
 def _calculate_attribute_elements(

tools/python/mbed_tools/targets/_internal/targets_json_parsers/accumulating_attribute_parser.py

@@ -4,10 +4,14 @@
 #
 """Interface to the Board Database."""
 
+from __future__ import annotations
+
 import json
 from collections.abc import Set as AbstractSet
 from dataclasses import asdict
-from typing import Callable, Iterable, Iterator
+from typing import Callable, Iterable, Iterator, Sequence
+
+from typing_extensions import override
 
 from mbed_tools.targets._internal import board_database
 from mbed_tools.targets.board import Board
@@ -23,7 +27,7 @@ class Boards(AbstractSet):
     """
 
     @classmethod
-    def from_offline_database(cls) -> "Boards":
+    def from_offline_database(cls) -> Boards:
         """
         Initialise with the offline board database.
 
@@ -32,23 +36,26 @@ def from_offline_database(cls) -> "Boards":
         """
         return cls(Board.from_offline_board_entry(b) for b in board_database.get_offline_board_data())
 
-    def __init__(self, boards_data: Iterable["Board"]) -> None:
+    def __init__(self, boards_data: Iterable[Board]) -> None:
         """
         Initialise with a list of boards.
 
         Args:
             boards_data: iterable of board data from a board database source.
         """
-        self._boards_data = tuple(boards_data)
+        self._boards_data: Sequence[Board] = tuple(boards_data)
 
-    def __iter__(self) -> Iterator["Board"]:
+    @override
+    def __iter__(self) -> Iterator[Board]:
         """Yield an Board on each iteration."""
         yield from self._boards_data
 
+    @override
     def __len__(self) -> int:
         """Return the number of boards."""
         return len(self._boards_data)
 
+    @override
     def __contains__(self, board: object) -> bool:
         """
         Check if a board is in the collection of boards.

tools/python/mbed_tools/targets/boards.py

@@ -24,7 +24,7 @@
 
 import dotenv
 
-dotenv.load_dotenv(dotenv.find_dotenv(usecwd=True))
+_ = dotenv.load_dotenv(dotenv.find_dotenv(usecwd=True))
 
 
 class Env:
@@ -51,26 +51,6 @@ def MBED_API_AUTH_TOKEN(self) -> str:  # noqa: N802
         """
         return os.getenv("MBED_API_AUTH_TOKEN", "")
 
-    @property
-    def MBED_DATABASE_MODE(self) -> str:  # noqa: N802
-        """
-        Database mode to use when retrieving board data.
-
-        Mbed Targets supports an online and offline mode, which controls where to look up the board database.
-
-        The board lookup can be from either the online or offline database, depending
-        on the value of an environment variable called `MBED_DATABASE_MODE`.
-
-        The mode can be set to one of the following:
-
-        - `AUTO`: the offline database is searched first, if the board isn't found the online database is searched.
-        - `ONLINE`: the online database is always used.
-        - `OFFLINE`: the offline database is always used.
-
-        If `MBED_DATABASE_MODE` is not set, it defaults to `AUTO`.
-        """
-        return os.getenv("MBED_DATABASE_MODE", "AUTO")
-
 
 env = Env()
 """Instance of `Env` class."""

tools/python/mbed_tools/targets/env.py

@@ -9,13 +9,10 @@
 """
 
 import logging
-from enum import Enum
 from typing import Callable
 
 from mbed_tools.targets.board import Board
 from mbed_tools.targets.boards import Boards
-from mbed_tools.targets.env import env
-from mbed_tools.targets.exceptions import BoardDatabaseError, UnknownBoardError, UnsupportedModeError
 
 logger = logging.getLogger(__name__)
 
@@ -80,39 +77,4 @@ def get_board(matching: Callable) -> Board:
     Raises:
         UnknownBoard: a board matching the criteria could not be found in the board database.
     """
-    database_mode = _get_database_mode()
-
-    if database_mode == _DatabaseMode.OFFLINE:
-        logger.info("Using the offline database (only) to identify boards.")
-        return Boards.from_offline_database().get_board(matching)
-
-    if database_mode == _DatabaseMode.ONLINE:
-        logger.info("Using the online database (only) to identify boards.")
-        return Boards.from_online_database().get_board(matching)
-    try:
-        logger.info("Using the offline database to identify boards.")
-        return Boards.from_offline_database().get_board(matching)
-    except UnknownBoardError:
-        logger.info("Unable to identify a board using the offline database, trying the online database.")
-        try:
-            return Boards.from_online_database().get_board(matching)
-        except BoardDatabaseError as ex:
-            logger.exception("Unable to access the online database to identify a board.")
-            raise UnknownBoardError from ex
-
-
-class _DatabaseMode(Enum):
-    """Selected database mode."""
-
-    OFFLINE = 0
-    ONLINE = 1
-    AUTO = 2
-
-
-def _get_database_mode() -> _DatabaseMode:
-    database_mode = env.MBED_DATABASE_MODE
-    try:
-        return _DatabaseMode[database_mode]
-    except KeyError as ex:
-        msg = f"{database_mode} is not a supported database mode."
-        raise UnsupportedModeError(msg) from ex
+    return Boards.from_offline_database().get_board(matching)

tools/python/mbed_tools/targets/get_board.py

@@ -31,4 +31,7 @@ echo ">> Formatting with ruff..."
 ruff format
 
 echo ">> Linting with ruff..."
-ruff check --fix python/mbed_tools python/mbed_platformio
+ruff check --fix python/mbed_tools python/mbed_platformio
+
+echo ">> Linting and type checking with basedpyright..."
+basedpyright