micropython-stubber 1.20.0__py3-none-any.whl → 1.20.2__py3-none-any.whl

mpflash/mpflash/mpboard_id/add_boards.py

@@ -0,0 +1,255 @@
+"""
+Collects board name and description information from MicroPython and writes it to JSON and CSV files.
+"""
+
+import re
+from pathlib import Path
+from typing import List, Optional
+
+import inquirer
+import rich
+import rich.table
+from rich.console import Console
+from rich.progress import track
+
+import mpflash.vendor.basicgit as git
+from mpflash.logger import log
+from mpflash.mpboard_id import Board
+from mpflash.mpboard_id.store import write_boardinfo_json
+from mpflash.vendor.versions import micropython_versions
+
+# look for all mpconfigboard.h files and extract the board name
+# from the #define MICROPY_HW_BOARD_NAME "PYBD_SF6"
+# and the #define MICROPY_HW_MCU_NAME "STM32F767xx"
+RE_H_MICROPY_HW_BOARD_NAME = re.compile(r"#define\s+MICROPY_HW_BOARD_NAME\s+\"(.+)\"")
+RE_H_MICROPY_HW_MCU_NAME = re.compile(r"#define\s+MICROPY_HW_MCU_NAME\s+\"(.+)\"")
+# find in the mpconfigboard.cmake files
+
+RE_CMAKE_MICROPY_HW_BOARD_NAME = re.compile(r"MICROPY_HW_BOARD_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\"")
+RE_CMAKE_MICROPY_HW_MCU_NAME = re.compile(r"MICROPY_HW_MCU_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\"")
+# TODO: normal make files
+
+
+def boards_from_repo(mpy_path: Path, version: str, family: Optional[str] = None) -> List[Board]:
+    """Collects board name and decriptions from mpconfigboard.h files.
+
+    Args:
+        mpy_path (Path): The path to the MicroPython repository.
+        version (str): The version of MicroPython.
+
+    Returns:
+        List[Board]: A list of Board objects containing the board information.
+    """
+    if not mpy_path.exists() or not mpy_path.is_dir():
+        raise FileNotFoundError(f"MicroPython path {mpy_path} does not exist.")
+    if not family:
+        family = "micropython"
+    if not version:
+        version = git.get_local_tag()  # type: ignore
+    if not version:
+        raise ValueError("No version provided and no local tag found.")
+
+    board_list: List[Board] = []
+    # look in mpconfigboard.h files
+    board_list = boards_from_cmake(mpy_path, version, family)
+
+    # look for variants in the .cmake files
+    board_list.extend(boards_from_headers(mpy_path, version, family))
+    # TODO:? look for variants in the Makefile files
+
+    return board_list
+
+
+def boards_from_cmake(mpy_path: Path, version: str, family: str):
+    """Get boards from the mpconfigboard.cmake files to the board_list."""
+    board_list = []
+    for path in mpy_path.glob("ports/**/mpconfigboard.cmake"):
+        board = path.parent.name
+        port = path.parent.parent.parent.name
+        with open(path, "r") as f:
+            board_name = mcu_name = "-"
+            for line in f:
+                line = line.strip()
+                if match := RE_CMAKE_MICROPY_HW_BOARD_NAME.match(line):
+                    description = match["variant"]
+                    board_list.append(
+                        Board(
+                            board_id=board,
+                            port=port,
+                            board_name=board_name,
+                            mcu_name=mcu_name,
+                            description=description,
+                            path=path.relative_to(mpy_path),
+                            version=version,
+                            family=family,
+                        )
+                    )
+                elif match := RE_CMAKE_MICROPY_HW_MCU_NAME.match(line):
+                    description = match["variant"]
+                    board_list.append(
+                        Board(
+                            board_id=board,
+                            port=port,
+                            board_name=board_name,
+                            mcu_name=mcu_name,
+                            description=description,
+                            path=path.relative_to(mpy_path),
+                            version=version,
+                            family=family,
+                        )
+                    )
+    return board_list
+
+
+def boards_from_headers(mpy_path: Path, version: str, family: str):
+    """Get boards from the mpconfigboard.h files to the board_list."""
+    board_list = []
+    for path in mpy_path.glob("ports/**/mpconfigboard.h"):
+        board = path.parent.name
+        port = path.parent.parent.parent.name
+        with open(path, "r") as f:
+            board_name = mcu_name = "-"
+            found = 0
+            for line in f:
+                if match := RE_H_MICROPY_HW_BOARD_NAME.match(line):
+                    board_name = match[1]
+                    found += 1
+                elif match := RE_H_MICROPY_HW_MCU_NAME.match(line):
+                    mcu_name = match[1]
+                    found += 1
+                if found == 2:
+                    description = f"{board_name} with {mcu_name}" if mcu_name != "-" else board_name
+                    board_list.append(
+                        Board(
+                            board_id=board,
+                            port=port,
+                            board_name=board_name,
+                            mcu_name=mcu_name,
+                            description=description,
+                            path=path.relative_to(mpy_path),
+                            version=version,
+                            family=family,
+                        )
+                    )
+                    found = 0
+            if found == 1:
+                description = board_name
+                board_list.append(
+                    Board(
+                        board_id=board,
+                        port=port,
+                        board_name=board_name,
+                        mcu_name=mcu_name,
+                        description=description,
+                        path=path.relative_to(mpy_path),
+                        version=version,
+                        family=family,
+                    )
+                )
+    return board_list
+
+
+def boards_for_versions(versions: List[str], mpy_path: Path):
+    """Gets the list of boards for multiple versions of MicroPython.
+
+    Args:
+        versions (List[str]): The list of MicroPython versions.
+        mpy_path (Path): The path to the MicroPython repository.
+
+    Returns:
+        List[Board]: The list of Board objects.
+    """
+    board_list: List[Board] = []
+    for version in track(versions, description="Searching MicroPython versions"):
+        if git.checkout_tag(tag=version, repo=mpy_path):
+            new_ones = boards_from_repo(mpy_path, version, family="micropython")
+            print(f"Found {len(new_ones)} board definitions for {version}.")
+            board_list += new_ones
+        else:
+            print(f"Could not checkout version {version}.")
+
+    # sort the board_list by description and board
+    print("Total number of boards found:", len(board_list))
+
+    board_list = unique_boards(board_list)
+    print("Unique board descriptions found:", len(board_list))
+    return board_list
+
+
+def unique_boards(board_list: List[Board], *, key_version: bool = True):
+    """Remove duplicate boards by 'BOARD_ID description' from the list."""
+    seen = set()
+    result = []
+    for x in board_list:
+        if key_version:
+            key = f"{x.board_id}|{x.version}|{x.description}"
+        else:
+            key = f"{x.board_id}|{x.description}"
+        if key not in seen:
+            result.append(x)
+            seen.add(key)
+    result.sort(key=lambda x: x.description.lower())
+    return result
+
+
+def make_table(board_list: List[Board]) -> rich.table.Table:
+    """Creates a rich table with board information."""
+    is_wide = True
+
+    table = rich.table.Table(title="MicroPython Board Information")
+    table.add_column("BOARD_ID", justify="left", style="green")
+    table.add_column("Description", justify="left", style="cyan")
+    table.add_column("Port", justify="left", style="magenta")
+    table.add_column("Board Name", justify="left", style="blue")
+    if is_wide:
+        table.add_column("MCU Name", justify="left", style="blue")
+    table.add_column("Detection", justify="left", style="yellow")
+    table.add_column("Version", justify="left", style="blue")
+    if is_wide:
+        table.add_column("Family", justify="left", style="blue")
+
+    for board in board_list:
+        row = [board.board_id, board.description, *(board.port, board.board_name)]
+        if is_wide:
+            row.append(board.mcu_name)
+        row.extend((str(Path(board.path).suffix), board.version))
+        if is_wide:
+            row.append(board.family)
+        table.add_row(*row)
+
+    return table
+
+
+def ask_mpy_path():
+    """Ask the user for the path to the MicroPython repository."""
+    questions = [
+        inquirer.Text(
+            "mpy_path", message="Enter the path to the MicroPython repository", default=".\\repos\\micropython"
+        )
+    ]
+    if answers := inquirer.prompt(questions):
+        return Path(answers["mpy_path"])
+    else:
+        raise ValueError("No path provided.")
+
+
+def main():
+    """Main function to collect and write board information."""
+
+    console = Console()
+
+    mpy_path = ask_mpy_path()
+    versions = micropython_versions(minver="v1.10") + ["master"]
+    board_list = boards_for_versions(versions, mpy_path)
+
+    here = Path(__file__).parent
+    log.info(write_boardinfo_json(board_list, folder=here))
+    # write_files(board_list, folder=CONFIG.board_path)
+
+    # table of when the board was added
+    table = make_table(unique_boards(board_list, key_version=False))
+    console.print(table)
+
+
+if __name__ == "__main__":
+    main()

mpflash/mpflash/mpboard_id/board.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import  Union
+
+
+# - source : get_boardnames.py
+@dataclass
+class Board:
+    """
+    MicroPython Board definitions, parsed from the make and header files
+    """
+
+    port: str  # micropython port
+    board_id: str  # BOARD_ID (Foldername) as used in the make files
+    board_name: str  # Short board description
+    description: str  # Long board description
+    path: Union[Path, str]
+    version: str = field(default="")  # version of MicroPython""
+    # versions: List[str] = field(default=[])  # version of MicroPython""
+    family: str = field(default="micropython")
+    mcu_name: str = field(default="")
+    cpu: str = field(default="")
+    # TODO: add variant
+
+    def __post_init__(self):
+        if not self.cpu:
+            if " with " in self.description:
+                self.cpu = self.description.split(" with ")[-1]
+            else:
+                self.cpu = self.port
+
+    @staticmethod
+    def from_dict(data: dict) -> "Board":
+        return Board(**data)
+
+    def to_dict(self) -> dict:
+        return self.__dict__

mpflash/mpflash/mpboard_id/board_id.py

@@ -3,61 +3,68 @@ Translate board description to board designator
 """
 
 import functools
-import json
 from pathlib import Path
 from typing import Optional
 
 from mpflash.errors import MPFlashError
-from mpflash.vendor.versions import clean_version
+from mpflash.logger import log
+from mpflash.mpboard_id.store import read_known_boardinfo
+from mpflash.vendor.versions import clean_version, get_stable_mp_version
 
-###############################################################################################
-HERE = Path(__file__).parent
-###############################################################################################
 
-
-def find_board_id(
-    descr: str, short_descr: str, board_info: Optional[Path] = None, version: str = "stable"
+def find_board_id_by_description(
+    descr: str,
+    short_descr: str,
+    *,
+    version: str,
+    board_info: Optional[Path] = None,
 ) -> Optional[str]:
-    # TODO: use the json file instead of the csv and get the cpu
-    boards = find_board_by_description(
-        descr=descr,
-        short_descr=short_descr,
-        board_info=board_info,
-        version=clean_version(version),
-    )
-    return boards[-1]["board"]
+    """Find the MicroPython BOARD_ID based on the description in the firmware"""
+
+    try:
+        boards = _find_board_id_by_description(
+            descr=descr,
+            short_descr=short_descr,
+            board_info=board_info,
+            version=clean_version(version) if version else None,
+        )
+        return boards[-1].board_id
+    except MPFlashError:
+        return "UNKNOWN_BOARD"
 
 
 @functools.lru_cache(maxsize=20)
-def find_board_by_description(*, descr: str, short_descr: str, version="v1.21.0", board_info: Optional[Path] = None):
+def _find_board_id_by_description(
+    *,
+    descr: str,
+    short_descr: str,
+    version: Optional[str] = None,
+    board_info: Optional[Path] = None,
+):
     """
-    Find the MicroPython BOARD designator based on the description in the firmware
+    Find the MicroPython BOARD_ID based on the description in the firmware
     using the pre-built board_info.json file
     """
-    if not board_info:
-        board_info = HERE / "board_info.json"
-    if not board_info.exists():
-        raise FileNotFoundError(f"Board info file not found: {board_info}")
-
-    info = _read_board_info(board_info)
-
-    # filter for matching version
-    if version == "preview":
-        # TODO: match last stable
-        version = "v1.22.2"
-    version_matches = [b for b in info if b["version"].startswith(version)]
-    if not version_matches:
-        raise MPFlashError(f"No board info found for version {version}")
-    matches = [b for b in version_matches if b["description"] == descr]
-    if not matches and short_descr:
-        matches = [b for b in version_matches if b["description"] == short_descr]
-    if not matches:
-        raise MPFlashError(f"No board info found for description {descr}")
-    return sorted(matches, key=lambda x: x["version"])
 
+    candidate_boards = read_known_boardinfo(board_info)
 
-@functools.lru_cache(maxsize=20)
-def _read_board_info(board_info):
-    with open(board_info, "r") as file:
-        info = json.load(file)
-    return info
+    if version:
+        # filter for matching version
+        if version in ("preview", "stable"):
+            # match last stable
+            version = get_stable_mp_version()
+        known_versions = sorted({b.version for b in candidate_boards})
+        if version not in known_versions:
+            # FIXME if latest stable is newer than the last version in the boardlist this will fail
+            log.trace(f"Version {version} not found in board info, using latest known version {known_versions[-1]}")
+            version = known_versions[-1]
+        version_matches = [b for b in candidate_boards if b.version.startswith(version)]
+        if not version_matches:
+            raise MPFlashError(f"No board info found for version {version}")
+        candidate_boards = version_matches
+    matches = [b for b in candidate_boards if b.description == descr]
+    if not matches and short_descr:
+        matches = [b for b in candidate_boards if b.description == short_descr]
+    if not matches:
+        raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
+    return sorted(matches, key=lambda x: x.version)

mpflash/mpflash/mpboard_id/store.py

@@ -0,0 +1,42 @@
+import functools
+import zipfile
+from pathlib import Path
+from typing import List, Optional
+
+import jsons
+
+from mpflash.mpboard_id.board import Board
+
+###############################################################################################
+HERE = Path(__file__).parent
+###############################################################################################
+
+
+def write_boardinfo_json(board_list: List[Board], *, folder: Path):
+    """Writes the board information to JSON and CSV files.
+
+    Args:
+        board_list (List[Board]): The list of Board objects.
+    """
+    import zipfile
+
+    # create a zip file with the json file
+    with zipfile.ZipFile(folder / "board_info.zip", "w", compression=zipfile.ZIP_DEFLATED) as zipf:
+        # write the list to json file inside the zip
+        with zipf.open("board_info.json", "w") as fp:
+            fp.write(jsons.dumps(board_list, jdkwargs={"indent": 4}).encode())
+
+
+@functools.lru_cache(maxsize=20)
+def read_known_boardinfo(board_info: Optional[Path] = None) -> List[Board]:
+
+    if not board_info:
+        board_info = HERE / "board_info.zip"
+    if not board_info.exists():
+        raise FileNotFoundError(f"Board info file not found: {board_info}")
+
+    with zipfile.ZipFile(board_info, "r") as zf:
+        with zf.open("board_info.json", "r") as file:
+            info = jsons.loads(file.read().decode(encoding="utf-8"), List[Board])
+
+    return info

mpflash/mpflash/mpremoteboard/__init__.py

@@ -13,7 +13,7 @@ from rich.progress import track
 from tenacity import retry, stop_after_attempt, wait_fixed
 
 from mpflash.errors import MPFlashError
-from mpflash.mpboard_id.board_id import find_board_id
+from mpflash.mpboard_id.board_id import find_board_id_by_description
 from mpflash.mpremoteboard.runner import run
 
 ###############################################################################################
@@ -64,7 +64,7 @@ class MPRemoteBoard:
         return f"MPRemoteBoard({self.serialport}, {self.family} {self.port}, {self.board}, {self.version})"
 
     @staticmethod
-    def connected_boards(bluetooth: bool = False) -> List[str]:
+    def connected_boards(bluetooth: bool = False, description: bool = False) -> List[str]:
         # TODO: rename to connected_comports
         """
         Get a list of connected comports.
@@ -81,8 +81,19 @@ class MPRemoteBoard:
             # filter out bluetooth ports
             comports = [p for p in comports if "bluetooth" not in p.description.lower()]
             comports = [p for p in comports if "BTHENUM" not in p.hwid]
-
-        return sorted([p.device for p in comports])
+        if description:
+            output = [
+                f"{p.device} {(p.manufacturer + ' ') if p.manufacturer and not p.description.startswith(p.manufacturer) else ''}{p.description}"
+                for p in comports
+            ]
+        else:
+            output = [p.device for p in comports]
+
+        if sys.platform == "win32":
+            # Windows sort of comports by number - but fallback to device name
+            return sorted(output, key=lambda x: int(x.split()[0][3:]) if x.split()[0][3:].isdigit() else x)
+        # sort by device name
+        return sorted(output)
 
     @retry(stop=stop_after_attempt(RETRIES), wait=wait_fixed(1), reraise=True)  # type: ignore ## retry_error_cls=ConnectionError,
     def get_mcu_info(self, timeout: int = 2):
@@ -116,10 +127,10 @@ class MPRemoteBoard:
             self.description = descr = info["board"]
             pos = descr.rfind(" with")
             short_descr = descr[:pos].strip() if pos != -1 else ""
-            if board_name := find_board_id(descr, short_descr):
+            if board_name := find_board_id_by_description(descr, short_descr, version=self.version):
                 self.board = board_name
             else:
-                self.board = "UNKNOWN"
+                self.board = "UNKNOWN_BOARD"
 
     def disconnect(self) -> bool:
         """
@@ -200,6 +211,7 @@ class MPRemoteBoard:
             transient=True,
             get_time=lambda: time.time(),
             show_speed=False,
+            refresh_per_second=1,
         ):
             time.sleep(1)
             try:

mpflash/mpflash/mpremoteboard/runner.py

@@ -21,6 +21,17 @@ class LogTags:
     ignore_tags: LogTagList
 
 
+DEFAULT_RESET_TAGS = [
+    # ESP32 reset causes
+    "rst cause:1, boot mode:",  # 1 -> hardware watch dog reset
+    "rst cause:2, boot mode:",  # 2 -> software watch dog reset (From an exception)
+    "rst cause:3, boot mode:",  # 3 -> software watch dog reset system_restart (Possibly unfed watchdog got angry)
+    "rst cause:4, boot mode:",  # 4 -> soft restart (Possibly with a restart command)
+    "boot.esp32: PRO CPU has been reset by WDT.",
+    "rst:0x10 (RTCWDT_RTC_RESET)",
+]
+
+
 def run(
     cmd: List[str],
     timeout: int = 60,
@@ -57,18 +68,7 @@ def run(
         The return code and the output as a list of strings
     """
     if not reset_tags:
-        reset_tags = [
-            "rst cause:1, boot mode:",
-            "rst cause:2, boot mode:",
-            "rst cause:3, boot mode:",
-            "rst cause:4, boot mode:",
-        ]
-        # 0 -> normal startup by power on
-        # 1 -> hardware watch dog reset
-        # 2 -> software watch dog reset (From an exception)
-        # 3 -> software watch dog reset system_restart (Possibly unfed watchdog got angry)
-        # 4 -> soft restart (Possibly with a restart command)
-        # 5 -> wake up from deep-sleep
+        reset_tags = DEFAULT_RESET_TAGS
     if not error_tags:
         error_tags = ["Traceback ", "Error: ", "Exception: ", "ERROR :", "CRIT  :"]
     if not warning_tags:

mpflash/mpflash/uf2disk.py

@@ -0,0 +1,12 @@
+"""Info to support mounting and unmounting of UF2 drives on linux and macos"""
+
+
+class UF2Disk:
+    """Info to support mounting and unmounting of UF2 drives on linux"""
+
+    device_path: str
+    label: str
+    mountpoint: str
+
+    def __repr__(self):
+        return repr(self.__dict__)