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

mpflash/mpflash/cli_download.py

@@ -0,0 +1,107 @@
+"""CLI to Download MicroPython firmware for specific ports, boards and versions."""
+
+from pathlib import Path
+from typing import List, Tuple
+
+import rich_click as click
+from loguru import logger as log
+
+from mpflash.mpboard_id import find_stored_board
+from mpflash.vendor.versions 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
+
+
+@cli.command(
+    "download",
+    help="Download MicroPython firmware for specific ports, boards and versions.",
+)
+@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,
+    help="The folder to download the firmware to.",
+)
+@click.option(
+    "--version",
+    "-v",
+    "versions",
+    default=["stable"],
+    multiple=True,
+    show_default=True,
+    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.",
+    metavar="BOARD_ID or ?",
+)
+@click.option(
+    "--clean/--no-clean",
+    default=True,
+    show_default=True,
+    help="""Remove dates and hashes from the downloaded firmware filenames.""",
+)
+@click.option(
+    "--force",
+    default=False,
+    is_flag=True,
+    show_default=True,
+    help="""Force download of firmware even if it already exists.""",
+)
+def cli_download(
+    **kwargs,
+):
+    params = DownloadParams(**kwargs)
+    params.versions = list(params.versions)
+    params.boards = list(params.boards)
+    if params.boards:
+        pass
+        # TODO Clean board - same as in cli_flash.py
+    else:
+        # no boards specified - detect connected boards
+        params.ports, params.boards = connected_ports_boards()
+
+    params = ask_missing_params(params, action="download")
+    if not params:  # Cancelled by user
+        exit(1)
+    params.versions = [clean_version(v, drop_v=True) for v in params.versions]
+    assert isinstance(params, DownloadParams)
+
+    download(
+        params.fw_folder,
+        params.ports,
+        params.boards,
+        params.versions,
+        params.force,
+        params.clean,
+    )
+
+
+def connected_ports_boards() -> Tuple[List[str], List[str]]:
+    """
+    Returns a tuple containing lists of unique ports and boards from the connected MCUs.
+    Boards that are physically connected, but give no tangible response are ignored.
+
+    Returns:
+        A tuple containing two lists:
+            - A list of unique ports where MCUs are connected.
+            - A list of unique board names of the connected MCUs.
+    """
+    mpr_boards = [b for b in list_mcus() if b.connected]
+    ports = list({b.port for b in mpr_boards})
+    boards = list({b.board for b in mpr_boards})
+    return ports, boards

mpflash/mpflash/cli_flash.py

@@ -0,0 +1,170 @@
+from pathlib import Path
+
+import rich_click as click
+from loguru import logger as log
+
+from mpflash.errors import MPFlashError
+from mpflash.mpboard_id import find_stored_board
+from mpflash.vendor.versions import clean_version
+
+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 .config import config
+from .flash import flash_list
+from .worklist import MPRemoteBoard, WorkList, full_auto_worklist, manual_worklist, single_auto_worklist
+
+# #########################################################################################################
+# 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",
+    "board",  # single board
+    multiple=False,
+    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 supported 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):
+    # version to versions, board to boards
+    kwargs["versions"] = [kwargs.pop("version")] if kwargs["version"] != None else []
+    if kwargs["board"] is None:
+        kwargs["boards"] = []
+        kwargs.pop("board")
+    else:
+        kwargs["boards"] = [kwargs.pop("board")]
+
+    params = FlashParams(**kwargs)
+    if not params.boards or params.boards == []:
+        # nothing specified - detect connected boards
+        params.ports, params.boards = connected_ports_boards()
+        if params.boards == []:
+            # No MicroPython boards detected, but it could be unflashed or not in bootloader mode
+            # Ask for serial port and board_id to flash
+            params.serial = "?"
+            params.boards = ["?"]
+    else:
+        for board_id in params.boards:
+            if board_id == "":
+                params.boards.remove(board_id)
+                continue
+            if " " in board_id:
+                try:
+                    info = find_stored_board(board_id)
+                    if info:
+                        log.info(f"Resolved board description: {info['board']}")
+                        params.boards.remove(board_id)
+                        params.boards.append(info["board"])
+                except Exception as e:
+                    log.warning(f"unable to resolve board description: {e}")
+
+    # Ask for missing input if needed
+    params = ask_missing_params(params, action="flash")
+    if not params:  # Cancelled by user
+        exit(1)
+    # TODO: Just in time Download of firmware
+
+    assert isinstance(params, FlashParams)
+
+    if len(params.versions) > 1:
+        log.error(f"Only one version can be flashed at a time, not {params.versions}")
+        raise MPFlashError("Only one version can be flashed at a time")
+    # if len(params.boards) > 1:
+    #     log.error(f"Only one board can be flashed at a time, not {params.boards}")
+    #     raise MPFlashError("Only one board can be flashed at a time")
+
+    params.versions = [clean_version(v) for v in params.versions]
+    worklist: WorkList = []
+    # if serial port == auto and there are one or more specified/detected boards
+    if params.serial == "auto" and params.boards:
+        worklist = full_auto_worklist(version=params.versions[0], fw_folder=params.fw_folder)
+    elif params.versions[0] and params.boards[0] and params.serial:
+        # A single serial port including the board / variant
+        worklist = manual_worklist(
+            params.versions[0],
+            params.fw_folder,
+            params.serial,
+            params.boards[0],
+        )
+    else:
+        # just this serial port on auto
+        worklist = single_auto_worklist(
+            serial_port=params.serial,
+            version=params.versions[0],
+            fw_folder=params.fw_folder,
+        )
+
+    if flashed := flash_list(
+        worklist,
+        params.fw_folder,
+        params.erase,
+        params.bootloader,
+    ):
+        log.info(f"Flashed {len(flashed)} boards")
+        show_mcus(flashed, title="Updated boards after flashing")

mpflash/mpflash/cli_group.py

@@ -3,37 +3,69 @@ Main entry point for the CLI group.
 Additional comands are added in the submodules.
 """
 
-from typing import List
-
 import rich_click as click
 
 from .config import config
-from .logger import set_loglevel
+from .logger import make_quiet, set_loglevel
 
 
 def cb_verbose(ctx, param, value):
     """Callback to set the log level to DEBUG if verbose is set"""
-    if value:
+    if value and not config.quiet:
         set_loglevel("DEBUG")
+        config.verbose = True
     else:
         set_loglevel("INFO")
+        config.verbose = False
     return value
 
 
 def cb_ignore(ctx, param, value):
     if value:
         config.ignore_ports = list(value)
-        print(repr(config.ignore_ports))
+    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()
     return value
 
 
 @click.group()
+@click.version_option(package_name="mpflash")
+@click.option(
+    "--quiet",
+    "-q",
+    is_eager=True,
+    is_flag=True,
+    help="Suppresses all output.",
+    callback=cb_quiet,
+    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",
+    is_eager=True,
     is_flag=True,
     help="Enables verbose mode.",
-    is_eager=True,
     callback=cb_verbose,
 )
 @click.option(
@@ -48,9 +80,10 @@ def cb_ignore(ctx, param, value):
     show_default=True,
     metavar="SERIALPORT",
 )
-def cli(verbose: bool, ignore: List[str], **kwargs):
+def cli(**kwargs):
     """mpflash - MicroPython Tool.
 
     A CLI to download and flash MicroPython firmware to different ports and boards.
     """
+    # all functionality is added in the submodules
     pass

mpflash/mpflash/cli_list.py

@@ -0,0 +1,41 @@
+import json
+
+import rich_click as click
+from rich import print
+
+from .cli_group import cli
+from .list import list_mcus, show_mcus
+from .logger import make_quiet
+
+
+@cli.command("list", help="List the connected MCU boards.")
+@click.option(
+    "--json",
+    "-j",
+    "as_json",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="""Output in json format""",
+)
+@click.option(
+    "--progress/--no-progress",
+    "progress",
+    is_flag=True,
+    default=True,
+    show_default=True,
+    help="""Show progress""",
+)
+def cli_list_mcus(as_json: bool, progress: bool = True):
+    """List the connected MCU boards, and output in a nice table or json."""
+    if as_json:
+        # avoid noise in json output
+        make_quiet()
+
+    conn_mcus = list_mcus()
+    if as_json:
+        print(json.dumps([mcu.__dict__ for mcu in conn_mcus], indent=4))
+        progress = False
+    if progress:
+        show_mcus(conn_mcus, refresh=False)
+    return conn_mcus

mpflash/mpflash/cli_main.py

@@ -1,20 +1,25 @@
 """mpflash is a CLI to download and flash MicroPython firmware to various boards."""
 
-import rich_click as click
+# import rich_click as click
 
+from .cli_download import cli_download
+from .cli_flash import cli_flash_board
 from .cli_group import cli
-from .downloader import download
-from .flasher import flash_board
-from .list import list_boards
+from .cli_list import cli_list_mcus
 
 # from loguru import logger as log
 
 
 def mpflash():
-    # cli.add_command(flash_board)
-    # cli.add_command(list_boards)
-    # cli.add_command(download)
-    cli(auto_envvar_prefix="MPFLASH")
+    cli.add_command(cli_flash_board)
+    cli.add_command(cli_list_mcus)
+    cli.add_command(cli_download)
+    # cli(auto_envvar_prefix="MPFLASH")
+    try:
+        exit(cli())
+    except AttributeError as e:
+        print(f"Error: {e}")
+        exit(-1)
 
 
 if __name__ == "__main__":

mpflash/mpflash/common.py

@@ -1,126 +1,38 @@
-from pathlib import Path
-from typing import Dict, Union
+import os
+import time
+from typing import TypedDict
 
-import platformdirs
-from github import Github
-from loguru import logger as log
-from packaging.version import parse
+from github import Auth, Github
+from rich.progress import track
+
+from mpflash.errors import MPFlashError
+# from mpflash.mpremoteboard import MPRemoteBoard
 
 PORT_FWTYPES = {
-    "stm32": ".hex",
-    "esp32": ".bin",
-    "esp8266": ".bin",
-    "rp2": ".uf2",
-    "samd": ".uf2",
-    "mimxrt": ".hex",
-    "nrf": ".uf2",
-    "renesas-ra": ".hex",
+    "stm32": [".dfu"],  # need .dfu for pydfu.py - .hex for cube cli/GUI
+    "esp32": [".bin"],
+    "esp8266": [".bin"],
+    "rp2": [".uf2"],
+    "samd": [".uf2"],
+    "mimxrt": [".hex"],
+    "nrf": [".uf2"],
+    "renesas-ra": [".hex"],
 }
 
-DEFAULT_FW_PATH = platformdirs.user_downloads_path() / "firmware"
-# DEFAULT_FW_PATH = Path.home() / "mp_firmware"
-
-FWInfo = Dict[str, Union[str, bool]]
-
-#############################################################
-# Version handling copied from stubber/utils/versions.py
-#############################################################
-V_PREVIEW = "preview"
-"Latest preview version"
-
-SET_PREVIEW = {"preview", "latest", "master"}
-
-
-def clean_version(
-    version: str,
-    *,
-    build: bool = False,
-    patch: bool = False,
-    commit: bool = False,
-    drop_v: bool = False,
-    flat: bool = False,
-):
-    "Clean up and transform the many flavours of versions"
-    # 'v1.13.0-103-gb137d064e' --> 'v1.13-103'
-    if version in {"", "-"}:
-        return version
-    if version.lower() == "stable":
-        _v = get_stable_version()
-        if not _v:
-            log.warning("Could not determine the latest stable version")
-            return "stable"
-        version = _v
-        log.info(f"Using latest stable version: {version}")
-    is_preview = "-preview" in version
-    nibbles = version.split("-")
-    ver_ = nibbles[0].lower().lstrip("v")
-    if not patch and ver_ >= "1.10.0" and ver_ < "1.20.0" and ver_.endswith(".0"):
-        # remove the last ".0" - but only for versions between 1.10 and 1.20 (because)
-        nibbles[0] = nibbles[0][:-2]
-    if len(nibbles) == 1:
-        version = nibbles[0]
-    elif build and not is_preview:
-        version = "-".join(nibbles) if commit else "-".join(nibbles[:-1])
-    else:
-        # version = "-".join((nibbles[0], LATEST))
-        # HACK: this is not always right, but good enough most of the time
-        if is_preview:
-            version = "-".join((nibbles[0], V_PREVIEW))
-        else:
-            version = V_PREVIEW
-    if flat:
-        version = version.strip().replace(".", "_").replace("-", "_")
-    else:
-        version = version.strip().replace("_preview", "-preview").replace("_", ".")
-
-    if drop_v:
-        version = version.lstrip("v")
-    elif not version.startswith("v") and version.lower() not in SET_PREVIEW:
-        version = "v" + version
-    if version in SET_PREVIEW:
-        version = V_PREVIEW
-    return version
-
-
-def micropython_versions(minver: str = "v1.9.2"):
-    """Get the list of micropython versions from github tags"""
-    try:
-        g = Github()
-        _ = 1 / 0
-        repo = g.get_repo("micropython/micropython")
-        versions = [tag.name for tag in repo.get_tags() if parse(tag.name) >= parse(minver)]
-    except Exception:
-        versions = [
-            "v9.99.9-preview",
-            "v1.22.2",
-            "v1.22.1",
-            "v1.22.0",
-            "v1.21.1",
-            "v1.21.0",
-            "v1.20.0",
-            "v1.19.1",
-            "v1.19",
-            "v1.18",
-            "v1.17",
-            "v1.16",
-            "v1.15",
-            "v1.14",
-            "v1.13",
-            "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:
-    # read the versions from the git tags
-    all_versions = micropython_versions(minver="v1.17")
-    stable_version = [v for v in all_versions if not v.endswith(V_PREVIEW)][-1]
-    return stable_version
-
-
-#############################################################
+# 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
+    port: str
+    board: str
+    variant: str
+    preview: bool
+    version: str
+    build: str

mpflash/mpflash/config.py

@@ -1,10 +1,19 @@
 """centralized configuration for mpflash"""
 
+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"
 
 
 config = MPtoolConfig()