Passing pyright!

Author: multiplemonomials

tools/pyproject.toml

@@ -20,7 +20,6 @@ dependencies = [
     "jinja2>=2.11.3",
     "python-dotenv",
     "Click>=8.0", # Need at least this version for pathlib.Path support
-    "GitPython",
     "tqdm",
     "tabulate",
     "requests>=2.20",
@@ -34,7 +33,7 @@ dependencies = [
     # Needed for downloading CMSIS MCU descriptions
     "cmsis-pack-manager>=0.5.0",
 
-    # USB device detection on Mac
+    # USB device detection on Windows
     "pywin32; platform_system=='Windows'",
 
     # USB device detection on Linux
@@ -74,7 +73,14 @@ unit-tests = [
 linters = [
     "ruff",
     "basedpyright",
-    "SCons" # For packages imported by the PlatformIO scripts
+
+    # To pass Pyright we need all the platform-dependent packages
+    "platformio",
+    "SCons",
+    "psutil",
+    "pyudev",
+    "beautifulsoup4",
+    "lxml"
 ]
 greentea = [
     ## Additional requirements to install into the Mbed environment when running Greentea tests
@@ -191,6 +197,7 @@ ignore = [
     'BLE001',  # Allow catching Exception
     'S603',    # Allow running subprocesses with variable arguments (why is this a lint in the first place??)
     'ERA001',  # Allow commented code
+    'T201',    # Allow print()
 
     # For now allow old-style type annotations. Currently there's lots of code that uses them, and I am
     # not sure if there is a way to upgrade them automatically. And since this project still supports
@@ -233,8 +240,16 @@ reportUnknownArgumentType = false
 reportUnknownParameterType = false
 reportAny = false
 reportExplicitAny = false
+reportMissingTypeStubs = false
 
 # Use "medium strict" member variable annotation rules, where the type checker
 # is allowed to infer the types of class variables based on what gets assigned in __init__
 reportIncompatibleUnannotatedOverride = true
-reportUnannotatedClassAttribute = false
+reportUnannotatedClassAttribute = false
+
+# Conflicts with Ruff rules
+reportImplicitStringConcatenation = false
+
+# Allow isinstance() even when it seems unneccessary based on type annotations.
+# This call is useful to check that the runtime types match the annotations.
+reportUnnecessaryIsInstance = false

tools/python/mbed_platformio/build_mbed_ce.py

@@ -13,10 +13,11 @@
 import json
 import pathlib
 import sys
+import typing
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import click
+from click.parser import split_arg_string
 from platformio.proc import exec_command
 from SCons.Script import ARGUMENTS, DefaultEnvironment
 
@@ -29,9 +30,9 @@
 
 # Directories
 FRAMEWORK_DIR = Path(platform.get_package_dir("framework-mbed-ce"))
-BUILD_DIR = Path(env.subst("$BUILD_DIR"))
-PROJECT_DIR = Path(env.subst("$PROJECT_DIR"))
-PROJECT_SRC_DIR = Path(env.subst("$PROJECT_SRC_DIR"))
+BUILD_DIR = Path(typing.cast(str, env.subst("$BUILD_DIR")))
+PROJECT_DIR = Path(typing.cast(str, env.subst("$PROJECT_DIR")))
+PROJECT_SRC_DIR = Path(typing.cast(str, env.subst("$PROJECT_SRC_DIR")))
 CMAKE_API_DIR = BUILD_DIR / ".cmake" / "api" / "v1"
 CMAKE_API_QUERY_DIR = CMAKE_API_DIR / "query"
 CMAKE_API_REPLY_DIR = CMAKE_API_DIR / "reply"
@@ -61,7 +62,7 @@
 
 
 def get_mbed_target() -> str:
-    board_type = env.subst("$BOARD")
+    board_type = typing.cast(str, env.subst("$BOARD"))
     variant = PIO_VARIANT_TO_MBED_TARGET[board_type] if board_type in PIO_VARIANT_TO_MBED_TARGET else board_type.upper()
     return board.get("build.mbed_variant", variant)
 
@@ -72,7 +73,7 @@ def is_proper_mbed_ce_project() -> bool:
 
 def create_default_project_files() -> None:
     if not PROJECT_MBED_APP_JSON5.exists():
-        PROJECT_MBED_APP_JSON5.write_text(
+        _ = PROJECT_MBED_APP_JSON5.write_text(
             """
 {
    "target_overrides": {
@@ -111,9 +112,12 @@ def is_cmake_reconfigure_required() -> bool:
 
 def run_tool(command_and_args: list[str] | None = None) -> None:
     result = exec_command(command_and_args)
-    if result["returncode"] != 0:
-        sys.stderr.write(result["out"] + "\n")
-        sys.stderr.write(result["err"] + "\n")
+
+    # Note: Pyright seems to think that this will always fail due to missing type annotations
+    # for exec_command(), but I believe the actual code is fine.
+    if result["returncode"] != 0:  # pyright: ignore[reportUnnecessaryComparison]
+        print(result["out"], file=sys.stderr)
+        print(result["err"], file=sys.stderr)
         env.Exit(1)
 
     if int(ARGUMENTS.get("PIOVERBOSE", 0)):
@@ -139,7 +143,7 @@ def get_cmake_code_model(cmake_args: list) -> dict:
         (BUILD_DIR / "CMakeCache.txt").touch()
 
     if not CMAKE_API_REPLY_DIR.is_dir() or not any(CMAKE_API_REPLY_DIR.iterdir()):
-        sys.stderr.write("Error: Couldn't find CMake API response file\n")
+        print("Error: Couldn't find CMake API response file", file=sys.stderr)
         env.Exit(1)
 
     codemodel = {}
@@ -153,10 +157,10 @@ def get_cmake_code_model(cmake_args: list) -> dict:
 
 
 def get_target_config(project_configs: dict, target_index: int) -> dict[str, Any]:
-    target_json = project_configs.get("targets")[target_index].get("jsonFile", "")
+    target_json = project_configs["targets"][target_index].get("jsonFile", "")
     target_config_file = CMAKE_API_REPLY_DIR / target_json
     if not target_config_file.is_file():
-        sys.stderr.write(f"Error: Couldn't find target config {target_json}\n")
+        print(f"Error: Couldn't find target config {target_json}", file=sys.stderr)
         env.Exit(1)
 
     with target_config_file.open(encoding="utf-8") as fp:
@@ -165,7 +169,7 @@ def get_target_config(project_configs: dict, target_index: int) -> dict[str, Any
 
 def load_target_configurations(cmake_codemodel: dict) -> dict:
     configs = {}
-    project_configs = cmake_codemodel.get("configurations")[0]
+    project_configs = cmake_codemodel["configurations"][0]
     for config in project_configs.get("projects", []):
         for target_index in config.get("targetIndexes", []):
             target_config = get_target_config(project_configs, target_index)
@@ -242,12 +246,12 @@ def get_app_defines(app_config: dict) -> list[tuple[str, str]]:
         "-DMBED_TARGET=" + get_mbed_target(),
         "-DUPLOAD_METHOD=NONE",  # Disable Mbed CE upload method system as PlatformIO has its own
         # Add in any extra options from higher layers
-        *click.parser.split_arg_string(board.get("build.cmake_extra_args", "")),
+        *split_arg_string(board.get("build.cmake_extra_args", "")),
     ]
 )
 
 if not project_codemodel:
-    sys.stderr.write("Error: Couldn't find code model generated by CMake\n")
+    print("Error: Couldn't find code model generated by CMake", file=sys.stderr)
     env.Exit(1)
 
 target_configs = load_target_configurations(project_codemodel)
@@ -270,7 +274,7 @@ def get_app_defines(app_config: dict) -> list[tuple[str, str]]:
 # within this archive.
 mbed_ce_lib_path = pathlib.Path("$BUILD_DIR") / "mbed-os" / "libmbed-os.a"
 link_args = ["-Wl,--whole-archive", '"' + str(mbed_ce_lib_path) + '"', "-Wl,--no-whole-archive"]
-env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", str(mbed_ce_lib_path))
+_ = env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", str(mbed_ce_lib_path))
 
 # Get other linker flags from Mbed. We want these to appear after the application objects and Mbed libraries
 # because they contain the C/C++ library link flags.
@@ -297,5 +301,5 @@ def get_app_defines(app_config: dict) -> list[tuple[str, str]]:
 # Note that this seems to execute CMake, causing the code model query to be re-done.
 # So, we have to do this after we are done using the results of said query.
 project_ld_script = generate_project_ld_script()
-env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", str(project_ld_script))
+_ = env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", str(project_ld_script))
 env.Append(LDSCRIPT_PATH=str(project_ld_script))

tools/python/mbed_platformio/cmake_to_scons_converter.py

@@ -9,9 +9,10 @@
 
 import collections
 import pathlib
-from typing import TYPE_CHECKING
+import typing
+from typing import TYPE_CHECKING, Sequence
 
-import click
+from click.parser import split_arg_string
 
 if TYPE_CHECKING:
     from SCons.Environment import Base as Environment
@@ -151,15 +152,15 @@ def _get_flags_for_compile_group(compile_group_json: dict) -> list[str]:
         fragment = ccfragment.get("fragment", "").strip()
         if not fragment or fragment.startswith("-D"):
             continue
-        flags.extend(click.parser.split_arg_string(fragment))
+        flags.extend(split_arg_string(fragment))
     return flags
 
 
-def extract_flags(target_json: dict) -> dict[str, list[str]]:
+def extract_flags(target_json: dict) -> dict[str, list[str] | None]:
     """
     Returns a dictionary with flags for SCons based on a given CMake target
     """
-    default_flags = collections.defaultdict(list)
+    default_flags: dict[str, list[str]] = collections.defaultdict(list)
     for cg in target_json["compileGroups"]:
         default_flags[cg["language"]].extend(_get_flags_for_compile_group(cg))
 
@@ -173,11 +174,11 @@ def extract_flags(target_json: dict) -> dict[str, list[str]]:
 
 def find_included_files(environment: Environment) -> set[str]:
     """
-    Process a list of flags produced by extract_flags() to find files manually included by '-include'
+    Process an environment produced by prepare_build_envs() to find files manually included by '-include'
     """
     result = set()
     for flag_var in ["CFLAGS", "CXXFLAGS", "CCFLAGS"]:
-        language_flags = environment.get(flag_var)
+        language_flags = typing.cast(Sequence[str], environment.get(flag_var))
         for index in range(len(language_flags)):
             if language_flags[index] == "-include" and index < len(language_flags) - 1:
                 result.add(language_flags[index + 1])
@@ -212,7 +213,7 @@ def extract_link_args(target_json: dict) -> list[str]:
         fragment_role = f.get("role", "").strip()
         if not fragment or not fragment_role:
             continue
-        args = click.parser.split_arg_string(fragment)
+        args = split_arg_string(fragment)
         if fragment_role == "flags":
             result.extend(args)
 

tools/python/mbed_tools/build/_internal/config/assemble_build_config.py

@@ -65,7 +65,7 @@ def make_relative_if_possible(path: Path) -> Path:
 def _assemble_config_from_sources(
     target_attributes: dict, mbed_lib_files: List[Path], mbed_app_file: Optional[Path] = None
 ) -> Config:
-    config = Config(source.prepare(target_attributes, source_name="target"))
+    config = Config(**source.prepare(target_attributes, source_name="target"))
     previous_filter_data = None
     app_data = None
     if mbed_app_file:

tools/python/mbed_tools/build/_internal/config/config.py

@@ -4,11 +4,15 @@
 #
 """Build configuration representation."""
 
+from __future__ import annotations
+
 import logging
 import pathlib
 from collections import UserDict
 from typing import Any, Hashable, Iterable, List
 
+import typing_extensions
+
 from mbed_tools.build._internal.config.source import ConfigSetting, Override
 
 logger = logging.getLogger(__name__)
@@ -28,10 +32,11 @@ class Config(UserDict):
     # All paths will be relative to the Mbed program root directory, or absolute if outside said directory.
     json_sources: List[pathlib.Path]
 
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, **kwargs: dict[str, Any]) -> None:
         self.json_sources = []
+        super().__init__(**kwargs)
 
+    @typing_extensions.override
     def __setitem__(self, key: Hashable, item: Any) -> None:
         """Set an item based on its key."""
         if key == CONFIG_SECTION:

tools/python/mbed_tools/build/_internal/memory_banks.py

@@ -8,7 +8,9 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, NotRequired, TypedDict
+    from typing import Any, TypedDict
+
+    from typing_extensions import NotRequired
 
 import copy
 import logging

tools/python/mbed_tools/build/_internal/write_files.py

@@ -28,4 +28,4 @@ def write_file(file_path: pathlib.Path, file_contents: str) -> None:
         raise InvalidExportOutputDirectoryError(msg)
 
     output_directory.mkdir(parents=True, exist_ok=True)
-    file_path.write_text(file_contents)
+    _ = file_path.write_text(file_contents)

tools/python/mbed_tools/build/config.py

@@ -9,7 +9,8 @@
 from typing import Any, Tuple
 
 from mbed_tools.build._internal.cmake_file import render_mbed_config_cmake_template
-from mbed_tools.build._internal.config.assemble_build_config import Config, assemble_config
+from mbed_tools.build._internal.config.assemble_build_config import assemble_config
+from mbed_tools.build._internal.config.config import Config
 from mbed_tools.build._internal.memory_banks import incorporate_memory_bank_data_from_cmsis, process_memory_banks
 from mbed_tools.build._internal.write_files import write_file
 from mbed_tools.build.exceptions import MbedBuildError
@@ -43,7 +44,9 @@ def generate_config(target_name: str, toolchain: str, program: MbedProgram) -> T
     # Process memory banks and save JSON data for other tools (e.g. memap) to use
     memory_banks_json_content = process_memory_banks(config)
     program.files.cmake_build_dir.mkdir(parents=True, exist_ok=True)
-    (program.files.cmake_build_dir / MEMORY_BANKS_JSON_FILE).write_text(json.dumps(memory_banks_json_content, indent=4))
+    _ = (program.files.cmake_build_dir / MEMORY_BANKS_JSON_FILE).write_text(
+        json.dumps(memory_banks_json_content, indent=4)
+    )
 
     cmake_file_contents = render_mbed_config_cmake_template(
         target_name=target_name, config=config, toolchain_name=toolchain

tools/python/mbed_tools/build/flash.py

@@ -20,7 +20,7 @@ def _flash_dev(disk: pathlib.Path, image_path: pathlib.Path) -> None:
         disk: Device mount point.
         image_path: Image file to be copied to device.
     """
-    shutil.copy(image_path, disk, follow_symlinks=False)
+    _ = shutil.copy(image_path, disk, follow_symlinks=False)
     if platform.system() != "Windows":
         os.sync()
 

tools/python/mbed_tools/cli/cmsis_mcu_descr.py

@@ -105,24 +105,19 @@ def get_mcu_names_used_by_targets_json5() -> Set[str]:
     """
     Accumulate set of all `device_name` properties used by all targets defined in targets.json5 and custom_targets.json/json5.
     """
+    LOGGER.info("Scanning targets.json5 for used MCU names...")
+    json_contents = decode_json_file(TARGETS_JSON5_PATH)
+
     # Search for files starting with "custom_targets" of type .json or .json5. Also exclude some folders like build and mbed-os
     exclude_dirs = ["build", "mbed-os", ".git"]
     file_pattern = r"custom_targets\.(json|json5)"
-    custom_targets_file = find_json_files(PROJECT_ROOT, exclude_dirs, file_pattern)
+    custom_targets_files = find_json_files(PROJECT_ROOT, exclude_dirs, file_pattern)
 
-    custom_targets_json_path = {}
-    for file in custom_targets_file:
-        if file.exists():
-            custom_targets_json_path = file
-            LOGGER.info(f"Custom_targets file detected - {custom_targets_json_path}")
+    for file in custom_targets_files:
+        LOGGER.info(f"Custom_targets file detected - {file}")
+        json_contents.update(decode_json_file(file))
 
     used_mcu_names = set()
-    LOGGER.info("Scanning targets.json5 for used MCU names...")
-    json_contents = decode_json_file(TARGETS_JSON5_PATH)
-    if custom_targets_file:
-        LOGGER.info("Scanning custom_targets.json/json5. for used MCU names...")
-        json_contents.update(decode_json_file(custom_targets_json_path))
-
     for target_details in json_contents.values():
         if "device_name" in target_details:
             used_mcu_names.add(target_details["device_name"])