mpflash 0.4.0.post3__py3-none-any.whl → 0.5.0__py3-none-any.whl

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/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/cli_flash.py

@@ -1,21 +1,22 @@
-
 from pathlib import Path
-from typing import  Optional
-
+from typing import List
 
 import rich_click as click
 from loguru import logger as log
 
+from .ask_input import FlashParams, ask_missing_params
+from .cli_download import connected_ports_boards
 from .cli_group import cli
-
-from .flash_esp import flash_esp
-from .flash_stm32 import flash_stm32
-from .flash_uf2 import flash_uf2
 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 .common import clean_version
+from .flash_esp import flash_esp
+from .flash_stm32 import flash_stm32
+from .flash_uf2 import flash_uf2
+from .mpboard_id.api import find_mp_board
 from .mpremoteboard import MPRemoteBoard
+
 # #########################################################################################################
 # CLI
 # #########################################################################################################
@@ -37,17 +38,18 @@ from .mpremoteboard import MPRemoteBoard
 @click.option(
     "--version",
     "-v",
-    "target_version",
+    "version",  # single version
     default="stable",
+    multiple=False,
     show_default=True,
     help="The version of MicroPython to flash.",
-    metavar="SEMVER, stable or preview",
+    metavar="SEMVER, 'stable', 'preview' or '?'",
 )
 @click.option(
     "--serial",
     "--serial-port",
     "-s",
-    "serial_port",
+    "serial",
     default="auto",
     show_default=True,
     help="Which serial port(s) to flash",
@@ -56,18 +58,20 @@ from .mpremoteboard import MPRemoteBoard
 @click.option(
     "--port",
     "-p",
-    "port",
+    "ports",
     help="The MicroPython port to flash",
     metavar="PORT",
-    default="",
+    default=[],
+    multiple=True,
 )
 @click.option(
     "--board",
     "-b",
-    "board",
+    "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",
-    default="",
+    metavar="BOARD_ID or ?",
 )
 @click.option(
     "--cpu",
@@ -81,7 +85,7 @@ from .mpremoteboard import MPRemoteBoard
     "--erase/--no-erase",
     default=True,
     show_default=True,
-    help="""Erase flash before writing new firmware. (not on UF2 boards)""",
+    help="""Erase flash before writing new firmware. (Not supported on UF2 boards)""",
 )
 @click.option(
     "--bootloader/--no-bootloader",
@@ -90,57 +94,108 @@ from .mpremoteboard import MPRemoteBoard
     show_default=True,
     help="""Enter micropython bootloader mode before flashing.""",
 )
-def cli_flash_board(
-    target_version: str,
-    fw_folder: Path,
-    serial_port: Optional[str] = None,
-    board: Optional[str] = None,
-    port: Optional[str] = None,
-    variant: Optional[str] = None,
-    cpu: Optional[str] = None,
-    erase: bool = False,
-    # stm32_dfu: bool = True,
-    bootloader: bool = True,
-):
+def cli_flash_board(**kwargs):
     todo: WorkList = []
-    # firmware type selector
-    selector = {
-        "stm32": ".dfu",  # if stm32_dfu else ".hex",
-    }
-    target_version = clean_version(target_version)
-    preview = target_version == "preview"
-    # Update all micropython boards to the latest version
-    if target_version and port and board and serial_port:
-        # TODO : Find a way to avoid needing to specify the port
-        mcu = MPRemoteBoard(serial_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=target_version,
-            preview=target_version.lower() == "preview",
-            port=port,
-            selector=selector,
+
+    # 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],
         )
-        if not firmwares:
-            log.error(f"No firmware found for {port} {board} version {target_version}")
-            return
-        # use the most recent matching firmware
-        todo = [(mcu, firmwares[-1])]
-    elif serial_port:
-        if serial_port == "auto":
-            # update all connected boards
-            conn_boards = [
-                MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports
-            ]
+    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
-            conn_boards = [MPRemoteBoard(serial_port)]
-        show_mcus(conn_boards)
-        todo = auto_update(conn_boards, target_version, fw_folder, preview=preview, selector=selector)
+            # 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)  # type: ignore # List / list
+    show_mcus(conn_boards)  # type: ignore
+    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)  # type: ignore
+
+
+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])]  # type: ignore
+
+
+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
@@ -148,20 +203,19 @@ def cli_flash_board(
             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"]:
+        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 ["esp32", "esp8266"]:
-            #  bootloader is handles by esptool for esp32/esp8266
-            updated = flash_esp(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}")
 
@@ -169,7 +223,3 @@ def cli_flash_board(
             flashed.append(updated)
         else:
             log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
-
-    if flashed:
-        log.info(f"Flashed {len(flashed)} boards")
-        show_mcus(flashed, title="Connected boards after flashing")

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/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/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()