mpflash 0.7.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

mpflash/flash_uf2.py

@@ -15,7 +15,7 @@ from mpflash.mpremoteboard import MPRemoteBoard
 
 from .common import PORT_FWTYPES
 from .config import config
-from .flash_uf2_linux import dismount_uf2, wait_for_UF2_linux
+from .flash_uf2_linux import dismount_uf2_linux, wait_for_UF2_linux
 from .flash_uf2_macos import wait_for_UF2_macos
 from .flash_uf2_windows import wait_for_UF2_windows
 
@@ -29,9 +29,9 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     - copy the firmware file to the drive
     - wait for the device to restart (5s)
 
-    for Lunix :
-    pmount and pumount are used to mount and unmount the drive
-    as this is not done automatically by the OS in headless mode.
+    for Linux - to support headless operation ( GH Actions ) :
+        pmount and pumount are used to mount and unmount the drive
+        as this is not done automatically by the OS in headless mode.
     """
     if ".uf2" not in PORT_FWTYPES[mcu.port]:
         log.error(f"UF2 not supported on {mcu.board} on {mcu.serialport}")
@@ -63,7 +63,7 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     shutil.copy(fw_file, destination)
     log.success("Done copying, resetting the board and wait for it to restart")
     if sys.platform in ["linux"]:
-        dismount_uf2()
+        dismount_uf2_linux()
     for _ in track(range(5 + 2), description="Waiting for the board to restart", transient=True, refresh_per_second=2):
         time.sleep(1)  # 5 secs to short on linux
     return mcu

mpflash/flash_uf2_linux.py

@@ -88,7 +88,7 @@ def pumount(disk: UF2Disk):
         log.warning(f"{disk.label} already dismounted")
 
 
-def dismount_uf2():
+def dismount_uf2_linux():
     global glb_dismount_me
     for disk in glb_dismount_me:
         pumount(disk)

mpflash/flash_uf2_macos.py

@@ -3,11 +3,9 @@
 # sourcery skip: snake-case-functions
 from __future__ import annotations
 
-import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import List
 
 from loguru import logger as log
 from rich.progress import track

mpflash/list.py

@@ -1,52 +1,13 @@
 from typing import List
 
-from rich import print
-from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, track
-from rich.table import Column, Table
+from rich.progress import track
+from rich.table import Table
 
 from mpflash.mpremoteboard import MPRemoteBoard
 from mpflash.vendor.versions import clean_version
 
-from .config import config
 from .logger import console
 
-rp_spinner = SpinnerColumn(finished_text="✅")
-rp_text = TextColumn("{task.description} {task.fields[device]}", table_column=Column())
-rp_bar = BarColumn(bar_width=None, table_column=Column())
-
-
-def list_mcus(bluetooth: bool = False):
-    """
-    Retrieves information about connected microcontroller boards.
-
-    Returns:
-        List[MPRemoteBoard]: A list of MPRemoteBoard instances with board information.
-    Raises:
-        ConnectionError: If there is an error connecting to a board.
-    """
-    conn_mcus = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards(bluetooth) if sp not in config.ignore_ports]
-
-    # a lot of boilerplate to show a progress bar with the comport currently scanned
-    # low update rate to facilitate screen readers/narration
-    with Progress(rp_spinner, rp_text, rp_bar, TimeElapsedColumn(), refresh_per_second=2) as progress:
-        tsk_scan = progress.add_task("[green]Scanning", visible=False, total=None)
-        progress.tasks[tsk_scan].fields["device"] = "..."
-        progress.tasks[tsk_scan].visible = True
-        progress.start_task(tsk_scan)
-        try:
-            for mcu in conn_mcus:
-                progress.update(tsk_scan, device=mcu.serialport.replace("/dev/", ""))
-                try:
-                    mcu.get_mcu_info()
-                except ConnectionError as e:
-                    print(f"Error: {e}")
-                    continue
-        finally:
-            # transient
-            progress.stop_task(tsk_scan)
-            progress.tasks[tsk_scan].visible = False
-    return conn_mcus
-
 
 def show_mcus(
     conn_mcus: List[MPRemoteBoard],
@@ -57,11 +18,9 @@ def show_mcus(
 
 
 def abbrv_family(family: str, is_wide: bool) -> str:
-    ABRV = {"micropython": "upy", "circuitpython": "cpy"}
     if not is_wide:
-        if family in ABRV:
-            return ABRV[family]
-        return family[:4]
+        ABRV = {"micropython": "upy", "circuitpython": "cpy", "unknown": "?"}
+        return ABRV.get(family, family[:4])
     return family
 
 

mpflash/mpboard_id/__init__.py

@@ -4,56 +4,38 @@ that is included in the module.
 
 """
 
-import json
 from functools import lru_cache
-from pathlib import Path
-from typing import List, Optional, Tuple, TypedDict, Union
+from typing import List, Optional, Tuple
 
-from mpflash.common import PORT_FWTYPES
 from mpflash.errors import MPFlashError
+from mpflash.mpboard_id.board import Board
+from mpflash.mpboard_id.store import read_known_boardinfo
 from mpflash.vendor.versions import clean_version
 
 # KNOWN ports and boards are sourced from the micropython repo,
 # this info is stored in the board_info.json file
 
 
-# Board  based on the dataclass Board but changed to TypedDict
-# - source : get_boardnames.py
-class Board(TypedDict):
-    """MicroPython Board definition"""
-
-    description: str
-    port: str
-    board: str
-    board_name: str
-    mcu_name: str
-    path: Union[Path, str]
-    version: str
-    cpu: str
-
-
-@lru_cache(maxsize=None)
-def read_known_boardinfo() -> List[Board]:
-    """Reads the board_info.json file and returns the data as a list of Board objects"""
-    with open(Path(__file__).parent / "board_info.json", "r") as file:
-        return json.load(file)
-
-
 def get_known_ports() -> List[str]:
     # TODO: Filter for Version
     mp_boards = read_known_boardinfo()
     # select the unique ports from info
-    ports = set({board["port"] for board in mp_boards if board["port"] in PORT_FWTYPES.keys()})
+    ports = set({board.port for board in mp_boards if board.port})
     return sorted(list(ports))
 
 
-def get_known_boards_for_port(port: str, versions: Optional[List[str]] = None):
+def get_known_boards_for_port(port: Optional[str] = "", versions: Optional[List[str]] = None) -> List[Board]:
     """
     Returns a list of boards for the given port and version(s)
 
-    port : str : The Micropython port to filter for
-    versions : List[str] : The Micropython versions to filter for (actual versions required)"""
+    port: The Micropython port to filter for
+    versions:  Optional, The Micropython versions to filter for (actual versions required)
+    """
     mp_boards = read_known_boardinfo()
+    if versions:
+        preview_or_stable = "preview" in versions or "stable" in versions
+    else:
+        preview_or_stable = False
 
     # filter for 'preview' as they are not in the board_info.json
     # instead use stable version
@@ -65,9 +47,17 @@ def get_known_boards_for_port(port: str, versions: Optional[List[str]] = None):
         # make sure of the v prefix
         versions = [clean_version(v) for v in versions]
         # filter for the version(s)
-        mp_boards = [board for board in mp_boards if board["version"] in versions]
+        mp_boards = [board for board in mp_boards if board.version in versions]
+        if not mp_boards and preview_or_stable:
+            # nothing found - perhaps there is a newer version for which we do not have the board info yet
+            # use the latest known version from the board info
+            mp_boards = read_known_boardinfo()
+            last_known_version = sorted({b.version for b in mp_boards})[-1]
+            mp_boards = [board for board in mp_boards if board.version == last_known_version]
+
     # filter for the port
-    mp_boards = [board for board in mp_boards if board["port"] == port]
+    if port:
+        mp_boards = [board for board in mp_boards if board.port == port]
     return mp_boards
 
 
@@ -80,7 +70,7 @@ def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List
     """
     mp_boards = get_known_boards_for_port(port, versions)
 
-    boards = set({(f'{board["version"]} {board["description"]}', board["board"]) for board in mp_boards})
+    boards = set({(f"{board.version} {board.description}", board.board_id) for board in mp_boards})
     return sorted(list(boards))
 
 
@@ -89,11 +79,11 @@ def find_known_board(board_id: str) -> Board:
     """Find the board for the given BOARD_ID or 'board description' and return the board info as a Board object"""
     info = read_known_boardinfo()
     for board_info in info:
-        if board_id in (board_info["board"], board_info["description"]):
-            if "cpu" not in board_info or not board_info["cpu"]:
-                if " with " in board_info["description"]:
-                    board_info["cpu"] = board_info["description"].split(" with ")[-1]
+        if board_id in (board_info.board_id, board_info.description):
+            if not board_info.cpu:
+                if " with " in board_info.description:
+                    board_info.cpu = board_info.description.split(" with ")[-1]
                 else:
-                    board_info["cpu"] = board_info["port"]
+                    board_info.cpu = board_info.port
             return board_info
     raise MPFlashError(f"Board {board_id} not found")

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/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/mpboard_id/board_id.py

@@ -3,17 +3,14 @@ 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.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_by_description(
     descr: str,
@@ -31,45 +28,43 @@ def find_board_id_by_description(
             board_info=board_info,
             version=clean_version(version) if version else None,
         )
-        return boards[-1]["board"]
+        return boards[-1].board_id
     except MPFlashError:
         return "UNKNOWN_BOARD"
 
 
 @functools.lru_cache(maxsize=20)
 def _find_board_id_by_description(
-    *, descr: str, short_descr: str, version: Optional[str] = None, board_info: Optional[Path] = None
+    *,
+    descr: str,
+    short_descr: str,
+    version: Optional[str] = None,
+    board_info: Optional[Path] = None,
 ):
     """
     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}")
 
-    candidate_boards = _read_board_info(board_info)
+    candidate_boards = read_known_boardinfo(board_info)
 
     if version:
         # filter for matching version
         if version in ("preview", "stable"):
             # match last stable
             version = get_stable_mp_version()
-        version_matches = [b for b in candidate_boards if b["version"].startswith(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]
+    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]
+        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"])
-
-
-@functools.lru_cache(maxsize=20)
-def _read_board_info(board_info):
-    with open(board_info, "r") as file:
-        info = json.load(file)
-    return info
+    return sorted(matches, key=lambda x: x.version)

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