mpflash 0.4.0.post3__tar.gz → 0.4.2__tar.gz

{mpflash-0.4.0.post3 → mpflash-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpflash
-Version: 0.4.0.post3
+Version: 0.4.2
 Summary: Flash and download tool for MicroPython firmwares
 Home-page: https://github.com/Josverl/micropython-stubber/blob/main/src/mpflash/README.md
 License: MIT

mpflash-0.4.2/mpflash/ask_input.py

@@ -0,0 +1,163 @@
+"""Download input handling for mpflash."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Sequence, Tuple, Union
+
+from loguru import logger as log
+
+from mpflash.common import micropython_versions
+from mpflash.config import config
+from mpflash.mpboard_id.api import known_mp_boards, known_mp_ports
+from mpflash.mpremoteboard import MPRemoteBoard
+
+
+@dataclass
+class Params:
+    ports: List[str] = field(default_factory=list)
+    boards: List[str] = field(default_factory=list)
+    versions: List[str] = field(default_factory=list)
+    fw_folder: Path = Path()
+
+
+@dataclass
+class DownloadParams(Params):
+    clean: bool = False
+    force: bool = False
+
+
+@dataclass
+class FlashParams(Params):
+    # TODO: Should Serial port be a list?
+    serial: str = ""
+    erase: bool = True
+    bootloader: bool = True
+    cpu: str = ""
+
+
+ParamType = Union[DownloadParams, FlashParams]
+
+
+def ask_missing_params(
+    params: ParamType,
+    action: str = "download",
+) -> ParamType:
+    if not config.interactive:
+        # no interactivity allowed
+        return params
+    # import only when needed to reduce load time
+    import inquirer
+
+    questions = []
+    if isinstance(params, FlashParams) and (not params.serial or "?" in params.versions):
+        ask_serialport(questions, action=action)
+
+    if not params.versions or "?" in params.versions:
+        ask_versions(questions, action=action)
+
+    if not params.boards or "?" in params.boards:
+        ask_port_board(questions, action=action)
+
+    answers = inquirer.prompt(questions)
+    if not answers:
+        return params
+    # print(repr(answers))
+    if isinstance(params, FlashParams) and "serial" in answers:
+        params.serial = answers["serial"]
+    if "port" in answers:
+        params.ports = [answers["port"]]
+    if "boards" in answers:
+        params.boards = answers["boards"]
+    if "versions" in answers:
+        # make sure it is a list
+        params.versions = answers["versions"] if isinstance(answers["versions"], list) else [answers["versions"]]
+
+    log.debug(repr(params))
+
+    return params
+
+
+def some_boards(answers: dict) -> Sequence[Tuple[str, str]]:
+    if "versions" in answers:
+        _versions = list(answers["versions"])
+        if "stable" in _versions:
+            _versions.remove("stable")
+            _versions.append(micropython_versions()[-2])
+        if "preview" in _versions:
+            _versions.remove("preview")
+            _versions.append(micropython_versions()[-1])
+            _versions.append(micropython_versions()[-2])
+
+        some_boards = known_mp_boards(answers["port"], _versions)  #    or known_mp_boards(answers["port"])
+    else:
+        some_boards = known_mp_boards(answers["port"])
+
+    if some_boards:
+        # Create a dictionary where the keys are the second elements of the tuples
+        # This will automatically remove duplicates because dictionaries cannot have duplicate keys
+        unique_dict = {item[1]: item for item in some_boards}
+        # Get the values of the dictionary, which are the unique items from the original list
+        some_boards = list(unique_dict.values())
+    else:
+        some_boards = [("No boards found", "")]
+    return some_boards
+
+
+def ask_port_board(questions: list, *, action: str):
+    # import only when needed to reduce load time
+    import inquirer
+
+    questions.extend(
+        (
+            inquirer.List(
+                "port",
+                message=f"What port do you want to {action}?",
+                choices=known_mp_ports(),
+                autocomplete=True,
+            ),
+            inquirer.Checkbox(
+                "boards",
+                message=f"What board do you want to {action}?",
+                choices=some_boards,
+                validate=lambda _, x: True if x else "Please select at least one board",  # type: ignore
+            ),
+        )
+    )
+
+
+def ask_versions(questions: list, *, action: str):
+    # import only when needed to reduce load time
+    import inquirer
+
+    input_ux = inquirer.Checkbox if action == "download" else inquirer.List
+    mp_versions: List[str] = micropython_versions()
+    mp_versions = [v for v in mp_versions if "preview" not in v]
+    mp_versions.append("preview")
+    mp_versions.reverse()  # newest first
+    questions.append(
+        input_ux(
+            "versions",
+            message=f"What version(s) do you want to {action}?",
+            choices=mp_versions,
+            autocomplete=True,
+            validate=lambda _, x: True if x else "Please select at least one version",  # type: ignore
+        )
+    )
+
+
+def ask_serialport(questions: list, *, action: str):
+    # import only when needed to reduce load time
+    import inquirer
+
+    serialports = MPRemoteBoard.connected_boards()
+    questions.append(
+        inquirer.List(
+            "serial",
+            message="What serial port do you want use ?",
+            validate=lambda _, x: True if x else "Please enter a serial port",  # type: ignore
+            choices=serialports,
+            other=True,
+        )
+    )
+
+    return questions

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/cli_download.py

@@ -3,14 +3,15 @@
 from pathlib import Path
 from typing import List, Tuple
 
-from mpflash.common import clean_version
 import rich_click as click
 
+from mpflash.common import clean_version
+
+from .ask_input import DownloadParams, ask_missing_params
 from .cli_group import cli
+from .cli_list import list_mcus
 from .config import config
 from .download import download
-from .download_input import DownloadParams, ask_missing_params
-from .cli_list import list_mcus
 
 
 def connected_ports_boards() -> Tuple[List[str], List[str]]:
@@ -27,6 +28,7 @@ def connected_ports_boards() -> Tuple[List[str], List[str]]:
 @click.option(
     "--destination",
     "-d",
+    "fw_folder",
     type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
     default=config.firmware_folder,
     show_default=True,
@@ -36,18 +38,21 @@ def connected_ports_boards() -> Tuple[List[str], List[str]]:
     "--version",
     "-v",
     "versions",
+    default=["stable"],
     multiple=True,
-    help="The version of MicroPython to to download. Use 'preview' to include preview versions.",
     show_default=True,
-    default=["stable"],
+    help="The version of MicroPython to to download.",
+    metavar="SEMVER, 'stable', 'preview' or '?'",
 )
 @click.option(
     "--board",
     "-b",
     "boards",
     multiple=True,
+    default=["?"],
     show_default=True,
-    help="The board(s) to download the firmware for.",  # Use '--board all' to download all boards.",
+    help="The board(s) to download the firmware for.",
+    metavar="BOARD_ID or ?",
 )
 @click.option(
     "--clean/--no-clean",
@@ -59,8 +64,8 @@ def connected_ports_boards() -> Tuple[List[str], List[str]]:
     "--force",
     default=False,
     is_flag=True,
-    help="""Force download of firmware even if it already exists.""",
     show_default=True,
+    help="""Force download of firmware even if it already exists.""",
 )
 def cli_download(
     **kwargs,
@@ -70,18 +75,17 @@ def cli_download(
     if not params.boards:
         # nothing specified - detect connected boards
         params.ports, params.boards = connected_ports_boards()
+    # ask for any remaining parameters
+    params = ask_missing_params(params, action="download")
+    assert isinstance(params, DownloadParams)
 
     params.versions = [clean_version(v, drop_v=True) for v in params.versions]  # remove leading v from version
 
-    # ask for any remaining parameters
-    params = ask_missing_params(params)
-    # preview is not a version, it is an option to include preview versions
     download(
-        params.destination,
+        params.fw_folder,
         params.ports,
         params.boards,
         params.versions,
         params.force,
         params.clean,
-        params.preview,
     )

mpflash-0.4.2/mpflash/cli_flash.py

@@ -0,0 +1,225 @@
+from pathlib import Path
+
+import rich_click as click
+from loguru import logger as log
+
+from mpflash.mpboard_id.api import find_mp_board
+
+from .ask_input import FlashParams, ask_missing_params
+from .cli_download import connected_ports_boards
+from .cli_group import cli
+from .cli_list import show_mcus
+from .common import clean_version
+from .config import config
+from .flash import WorkList, auto_update, enter_bootloader, find_firmware
+from .flash_esp import flash_esp
+from .flash_stm32 import flash_stm32
+from .flash_uf2 import flash_uf2
+from .mpremoteboard import MPRemoteBoard
+
+# #########################################################################################################
+# CLI
+# #########################################################################################################
+
+
+@cli.command(
+    "flash",
+    short_help="Flash one or all connected MicroPython boards with a specific firmware and version.",
+)
+@click.option(
+    "--firmware",
+    "-f",
+    "fw_folder",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+    default=config.firmware_folder,
+    show_default=True,
+    help="The folder to retrieve the firmware from.",
+)
+@click.option(
+    "--version",
+    "-v",
+    "version",  # single version
+    default="stable",
+    multiple=False,
+    show_default=True,
+    help="The version of MicroPython to flash.",
+    metavar="SEMVER, 'stable', 'preview' or '?'",
+)
+@click.option(
+    "--serial",
+    "--serial-port",
+    "-s",
+    "serial",
+    default="auto",
+    show_default=True,
+    help="Which serial port(s) to flash",
+    metavar="SERIAL_PORT",
+)
+@click.option(
+    "--port",
+    "-p",
+    "ports",
+    help="The MicroPython port to flash",
+    metavar="PORT",
+    default=[],
+    multiple=True,
+)
+@click.option(
+    "--board",
+    "-b",
+    "boards",
+    multiple=False,
+    default=[],
+    help="The MicroPython board ID to flash. If not specified will try to read the BOARD_ID from the connected MCU.",
+    metavar="BOARD_ID or ?",
+)
+@click.option(
+    "--cpu",
+    "--chip",
+    "-c",
+    "cpu",
+    help="The CPU type to flash. If not specified will try to read the CPU from the connected MCU.",
+    metavar="CPU",
+)
+@click.option(
+    "--erase/--no-erase",
+    default=True,
+    show_default=True,
+    help="""Erase flash before writing new firmware. (not on UF2 boards)""",
+)
+@click.option(
+    "--bootloader/--no-bootloader",
+    default=True,
+    is_flag=True,
+    show_default=True,
+    help="""Enter micropython bootloader mode before flashing.""",
+)
+def cli_flash_board(**kwargs):
+    todo: WorkList = []
+
+    # version to versions
+    if "version" in kwargs:
+        kwargs["versions"] = [kwargs.pop("version")]
+    params = FlashParams(**kwargs)
+    print(f"{params=}")
+    # print(f"{params.version=}")
+    print(f"{params.versions=}")
+    if not params.boards:
+        # nothing specified - detect connected boards
+        params.ports, params.boards = connected_ports_boards()
+    # Ask for missing input if needed
+    params = ask_missing_params(params, action="flash")
+    # TODO: Just in time Download of firmware
+
+    assert isinstance(params, FlashParams)
+
+    if len(params.versions) > 1:
+        print(repr(params.versions))
+        log.error(f"Only one version can be flashed at a time, not {params.versions}")
+        return
+    params.versions = [clean_version(v) for v in params.versions]
+    if params.versions[0] and params.boards[0] and params.serial:
+        # update a single board
+        todo = manual_worklist(
+            params.versions[0],
+            params.fw_folder,
+            params.serial,
+            params.boards[0],
+            # params.ports[0],
+        )
+    elif params.serial:
+        if params.serial == "auto":
+            # Update all micropython boards to the latest version
+            todo = auto_worklist(params.versions[0], params.fw_folder)
+        else:
+            # just this serial port on auto
+            todo = oneport_worklist(
+                params.versions[0],
+                params.fw_folder,
+                params.serial,
+            )
+
+    if flashed := flash_list(
+        todo,
+        params.fw_folder,
+        params.erase,
+        params.bootloader,
+    ):
+        log.info(f"Flashed {len(flashed)} boards")
+        show_mcus(flashed, title="Connected boards after flashing")
+
+
+def oneport_worklist(
+    version: str,
+    fw_folder: Path,
+    serial_port: str,
+    # preview: bool,
+) -> WorkList:
+    """Create a worklist for a single serial-port."""
+    conn_boards = [MPRemoteBoard(serial_port)]
+    todo = auto_update(conn_boards, version, fw_folder)
+    show_mcus(conn_boards)
+    return todo
+
+
+def auto_worklist(version: str, fw_folder: Path) -> WorkList:
+    conn_boards = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports]
+    return auto_update(conn_boards, version, fw_folder)
+
+
+def manual_worklist(
+    version: str,
+    fw_folder: Path,
+    serial_port: str,
+    board: str,
+    # port: str,
+) -> WorkList:
+    mcu = MPRemoteBoard(serial_port)
+    # TODO : Find a way to avoid needing to specify the port
+    # Lookup the matching port and cpu in board_info based in the board name
+    port = find_mp_board(board)["port"]
+    mcu.port = port
+    mcu.cpu = port if port.startswith("esp") else ""
+    mcu.board = board
+    firmwares = find_firmware(fw_folder=fw_folder, board=board, version=version, port=port)
+    if not firmwares:
+        log.error(f"No firmware found for {port} {board} version {version}")
+        return []
+        # use the most recent matching firmware
+    return [(mcu, firmwares[-1])]
+
+
+def flash_list(
+    todo: WorkList,
+    fw_folder: Path,
+    erase: bool,
+    bootloader: bool,
+):
+    """Flash a list of boards with the specified firmware."""
+    flashed = []
+    for mcu, fw_info in todo:
+        fw_file = fw_folder / fw_info["filename"]  # type: ignore
+        if not fw_file.exists():
+            log.error(f"File {fw_file} does not exist, skipping {mcu.board} on {mcu.serialport}")
+            continue
+        log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info['version']}")
+        updated = None
+        # try:
+        if mcu.port in ["samd", "rp2", "nrf"]:  #  [k for k, v in PORT_FWTYPES.items() if v == ".uf2"]:
+            if bootloader:
+                enter_bootloader(mcu)
+            updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
+        elif mcu.port in ["stm32"]:
+            if bootloader:
+                enter_bootloader(mcu)
+            updated = flash_stm32(mcu, fw_file, erase=erase)
+        elif mcu.port in ["esp32", "esp8266"]:
+            #  bootloader is handled by esptool for esp32/esp8266
+            updated = flash_esp(mcu, fw_file=fw_file, erase=erase)
+        else:
+            log.error(f"Don't (yet) know how to flash {mcu.port}-{mcu.board} on {mcu.serialport}")
+
+        if updated:
+            flashed.append(updated)
+        else:
+            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/cli_group.py

@@ -13,8 +13,10 @@ def cb_verbose(ctx, param, value):
     """Callback to set the log level to DEBUG if verbose is set"""
     if value:
         set_loglevel("DEBUG")
+        config.verbose = True
     else:
         set_loglevel("INFO")
+        config.verbose = False
     return value
 
 
@@ -24,6 +26,12 @@ def cb_ignore(ctx, param, value):
     return value
 
 
+def cb_interactive(ctx, param, value):
+    if value:
+        config.interactive = value
+    return value
+
+
 def cb_quiet(ctx, param, value):
     if value:
         make_quiet()
@@ -31,6 +39,7 @@ def cb_quiet(ctx, param, value):
 
 
 @click.group()
+@click.version_option(package_name="mpflash")
 @click.option(
     "--quiet",
     "-q",
@@ -41,6 +50,16 @@ def cb_quiet(ctx, param, value):
     envvar="MPFLASH_QUIET",
     show_default=True,
 )
+@click.option(
+    "--interactive/--no-interactive",
+    "-i/-x",
+    is_eager=True,
+    help="Suppresses all request for Input.",
+    callback=cb_interactive,
+    # envvar="MPFLASH_QUIET",
+    default=True,
+    show_default=True,
+)
 @click.option(
     "-V",
     "--verbose",
@@ -61,7 +80,7 @@ def cb_quiet(ctx, param, value):
     show_default=True,
     metavar="SERIALPORT",
 )
-def cli(quiet: bool, **kwargs):
+def cli(**kwargs):
     """mpflash - MicroPython Tool.
 
     A CLI to download and flash MicroPython firmware to different ports and boards.

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/cli_list.py

@@ -6,10 +6,11 @@ from rich import print
 from rich.progress import track
 from rich.table import Table
 
+from mpflash.mpremoteboard import MPRemoteBoard
+
 from .cli_group import cli
 from .config import config
 from .logger import console, make_quiet
-from .mpremoteboard import MPRemoteBoard
 
 
 @cli.command("list", help="List the connected MCU boards.")
@@ -67,8 +68,8 @@ def show_mcus(
         title=title,
         header_style="bold blue",
         collapse_padding=True,
-        width=100,
-        # row_styles=["blue", "yellow"]
+        width=110,
+        row_styles=["blue", "yellow"],
     )
     table.add_column("Serial", overflow="fold")
     table.add_column("Family")
@@ -89,7 +90,7 @@ def show_mcus(
             mcu.serialport.replace("/dev/", ""),
             mcu.family,
             mcu.port,
-            mcu.board if mcu.board != "UNKNOWN" else mcu.description,
+            f"{mcu.board}\n{mcu.description}".strip(),
             # mcu.variant,
             mcu.cpu,
             mcu.version,

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/cli_main.py

@@ -3,8 +3,8 @@
 # import rich_click as click
 
 from .cli_download import cli_download
-from .cli_group import cli
 from .cli_flash import cli_flash_board
+from .cli_group import cli
 from .cli_list import cli_list_mcus
 
 # from loguru import logger as log
@@ -14,8 +14,9 @@ def mpflash():
     cli.add_command(cli_flash_board)
     cli.add_command(cli_list_mcus)
     cli.add_command(cli_download)
-    cli(auto_envvar_prefix="MPFLASH")
+    # cli(auto_envvar_prefix="MPFLASH")
+    cli()
 
 
-if __name__ == "__main__":
-    mpflash()
+# if __name__ == "__main__":
+mpflash()

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/common.py

@@ -1,7 +1,9 @@
+import os
 import time
+from functools import lru_cache
 from typing import TypedDict
 
-from github import Github
+from github import Auth, Github
 from loguru import logger as log
 from packaging.version import parse
 from rich.progress import track
@@ -19,6 +21,14 @@ PORT_FWTYPES = {
     "renesas-ra": [".hex"],
 }
 
+# Token with no permissions to avoid throttling
+# https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#getting-a-higher-rate-limit
+PAT_NO_ACCESS = (
+    "github_pat" + "_11AAHPVFQ0qAkDnSUaMKSp" + "_ZkDl5NRRwBsUN6EYg9ahp1Dvj4FDDONnXVgimxC2EtpY7Q7BUKBoQ0Jq72X"
+)
+PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
+GH_CLIENT = Github(auth=Auth.Token(PAT))
+
 
 class FWInfo(TypedDict):
     filename: str
@@ -27,6 +37,7 @@ class FWInfo(TypedDict):
     variant: str
     preview: bool
     version: str
+    build: str
 
 
 #############################################################
@@ -52,7 +63,7 @@ def clean_version(
     if version in {"", "-"}:
         return version
     if version.lower() == "stable":
-        _v = get_stable_version()
+        _v = get_stable_mp_version()
         if not _v:
             log.warning("Could not determine the latest stable version")
             return "stable"
@@ -89,12 +100,12 @@ def clean_version(
     return version
 
 
-def micropython_versions(minver: str = "v1.9.2"):
+@lru_cache(maxsize=10)
+def micropython_versions(minver: str = "v1.20"):
     """Get the list of micropython versions from github tags"""
     try:
-        g = Github()
-        _ = 1 / 0
-        repo = g.get_repo("micropython/micropython")
+        gh_client = GH_CLIENT
+        repo = gh_client.get_repo("micropython/micropython")
         versions = [tag.name for tag in repo.get_tags() if parse(tag.name) >= parse(minver)]
     except Exception:
         versions = [
@@ -116,19 +127,23 @@ def micropython_versions(minver: str = "v1.9.2"):
             "v1.12",
             "v1.11",
             "v1.10",
-            "v1.9.4",
-            "v1.9.3",
         ]
         versions = [v for v in versions if parse(v) >= parse(minver)]
     return sorted(versions)
 
 
-def get_stable_version() -> str:
+def get_stable_mp_version() -> str:
     # read the versions from the git tags
     all_versions = micropython_versions(minver="v1.17")
     return [v for v in all_versions if not v.endswith(V_PREVIEW)][-1]
 
 
+def get_preview_mp_version() -> str:
+    # read the versions from the git tags
+    all_versions = micropython_versions(minver="v1.17")
+    return [v for v in all_versions if v.endswith(V_PREVIEW)][-1]
+
+
 #############################################################
 def wait_for_restart(mcu: MPRemoteBoard, timeout: int = 10):
     """wait for the board to restart"""

{mpflash-0.4.0.post3 → mpflash-0.4.2}/mpflash/config.py

@@ -1,16 +1,18 @@
 """centralized configuration for mpflash"""
 
-import platformdirs
-
-from typing import List
 from pathlib import Path
+from typing import List
+
+import platformdirs
 
 
 class MPtoolConfig:
     """Centralized configuration for mpflash"""
 
     quiet: bool = False
+    verbose: bool = False
     ignore_ports: List[str] = []
+    interactive: bool = True
     firmware_folder: Path = platformdirs.user_downloads_path() / "firmware"