mpflash 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

mpflash/ask_input.py

@@ -1,15 +1,20 @@
-"""Download input handling for mpflash."""
+"""
+Interactive input for mpflash.
+
+Note: The prompts can use "{version}" and "{action}" to insert the version and action in the prompt without needing an f-string.
+The values are provided from the answers dictionary.
+"""
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Sequence, Tuple, Union
+from typing import Dict, 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.mpboard_id import known_stored_boards, local_mp_ports
 from mpflash.mpremoteboard import MPRemoteBoard
+from mpflash.vendor.versions import micropython_versions
 
 
 @dataclass
@@ -42,6 +47,16 @@ def ask_missing_params(
     params: ParamType,
     action: str = "download",
 ) -> ParamType:
+    """
+    Asks the user for parameters that have not been supplied on the commandline and returns the updated params.
+
+    Args:
+        params (ParamType): The parameters to be updated.
+        action (str, optional): The action to be performed. Defaults to "download".
+
+    Returns:
+        ParamType: The updated parameters.
+    """
     if not config.interactive:
         # no interactivity allowed
         return params
@@ -49,25 +64,33 @@ def ask_missing_params(
     import inquirer
 
     questions = []
-    if isinstance(params, FlashParams) and (not params.serial or "?" in params.versions):
-        ask_serialport(questions, action=action)
+    answers = {"action": action}
+    if isinstance(params, FlashParams):
+        if not params.serial or "?" in params.serial:
+            ask_serialport(questions, action=action)
+        else:
+            answers["serial"] = params.serial
 
     if not params.versions or "?" in params.versions:
         ask_versions(questions, action=action)
+    else:
+        # versions is used to show only the boards for the selected versions
+        answers["versions"] = params.versions  # type: ignore
 
     if not params.boards or "?" in params.boards:
         ask_port_board(questions, action=action)
 
-    answers = inquirer.prompt(questions)
+    answers = inquirer.prompt(questions, answers=answers)
     if not answers:
-        return params
+        # input cancelled by user
+        return []  # type: ignore
     # 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"]
+        params.boards = answers["boards"] if isinstance(answers["boards"], list) else [answers["boards"]]
     if "versions" in answers:
         # make sure it is a list
         params.versions = answers["versions"] if isinstance(answers["versions"], list) else [answers["versions"]]
@@ -77,20 +100,29 @@ def ask_missing_params(
     return params
 
 
-def some_boards(answers: dict) -> Sequence[Tuple[str, str]]:
+def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
+    """
+    Filters the known boards based on the selected versions and returns the filtered boards.
+
+    Args:
+        answers (dict): The user's answers.
+
+    Returns:
+        Sequence[Tuple[str, str]]: The filtered boards.
+    """
+    # if version is not asked ; then need to get the version from the inputs
     if "versions" in answers:
         _versions = list(answers["versions"])
         if "stable" in _versions:
             _versions.remove("stable")
-            _versions.append(micropython_versions()[-2])
+            _versions.append(micropython_versions()[-2])  # latest stable
         if "preview" in _versions:
             _versions.remove("preview")
-            _versions.append(micropython_versions()[-1])
-            _versions.append(micropython_versions()[-2])
+            _versions.extend((micropython_versions()[-1], micropython_versions()[-2]))  # latest preview and stable
 
-        some_boards = known_mp_boards(answers["port"], _versions)  #    or known_mp_boards(answers["port"])
+        some_boards = known_stored_boards(answers["port"], _versions)  #    or known_mp_boards(answers["port"])
     else:
-        some_boards = known_mp_boards(answers["port"])
+        some_boards = known_stored_boards(answers["port"])
 
     if some_boards:
         # Create a dictionary where the keys are the second elements of the tuples
@@ -104,21 +136,37 @@ def some_boards(answers: dict) -> Sequence[Tuple[str, str]]:
 
 
 def ask_port_board(questions: list, *, action: str):
+    """
+    Asks the user for the port and board selection.
+
+    Args:
+        questions (list): The list of questions to be asked.
+        action (str): The action to be performed.
+
+    Returns:
+        None
+    """
     # import only when needed to reduce load time
     import inquirer
 
+    # TODO: if action = flash, Use Inquirer.List for boards
+    inquirer_ux = inquirer.Checkbox if action == "download" else inquirer.List
     questions.extend(
         (
             inquirer.List(
                 "port",
-                message=f"What port do you want to {action}?",
-                choices=known_mp_ports(),
+                message="Which port do you want to {action} " + "to {serial} ?" if action == "flash" else "?",
+                choices=local_mp_ports(),
                 autocomplete=True,
             ),
-            inquirer.Checkbox(
+            inquirer_ux(
                 "boards",
-                message=f"What board do you want to {action}?",
-                choices=some_boards,
+                message=(
+                    "Which {port} board firmware do you want to {action} " + "to {serial} ?"
+                    if action == "flash"
+                    else "?"
+                ),
+                choices=filter_matching_boards,
                 validate=lambda _, x: True if x else "Please select at least one board",  # type: ignore
             ),
         )
@@ -126,6 +174,16 @@ def ask_port_board(questions: list, *, action: str):
 
 
 def ask_versions(questions: list, *, action: str):
+    """
+    Asks the user for the version selection.
+
+    Args:
+        questions (list): The list of questions to be asked.
+        action (str): The action to be performed.
+
+    Returns:
+        None
+    """
     # import only when needed to reduce load time
     import inquirer
 
@@ -136,8 +194,11 @@ def ask_versions(questions: list, *, action: str):
     mp_versions.reverse()  # newest first
     questions.append(
         input_ux(
+            # inquirer.List(
             "versions",
-            message=f"What version(s) do you want to {action}?",
+            message="Which version(s) do you want to {action} " + ("to {serial} ?" if action == "flash" else "?"),
+            # Hints would be nice , but needs a hint for each and every option
+            # hints=["Use space to select multiple options"],
             choices=mp_versions,
             autocomplete=True,
             validate=lambda _, x: True if x else "Please select at least one version",  # type: ignore
@@ -146,6 +207,16 @@ def ask_versions(questions: list, *, action: str):
 
 
 def ask_serialport(questions: list, *, action: str):
+    """
+    Asks the user for the serial port selection.
+
+    Args:
+        questions (list): The list of questions to be asked.
+        action (str): The action to be performed.
+
+    Returns:
+        None
+    """
     # import only when needed to reduce load time
     import inquirer
 
@@ -153,10 +224,10 @@ def ask_serialport(questions: list, *, action: str):
     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
+            message="Which serial port do you want to {action} ?",
             choices=serialports,
             other=True,
+            validate=lambda _, x: True if x else "Please select or enter a serial port",  # type: ignore
         )
     )
 

mpflash/cli_download.py

@@ -4,8 +4,10 @@ from pathlib import Path
 from typing import List, Tuple
 
 import rich_click as click
+from loguru import logger as log
 
-from mpflash.common import clean_version
+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
@@ -14,13 +16,6 @@ from .config import config
 from .download import download
 
 
-def connected_ports_boards() -> Tuple[List[str], List[str]]:
-    mpr_boards = list_mcus()
-    ports = list({b.port for b in mpr_boards})
-    boards = list({b.board for b in mpr_boards})
-    return ports, boards
-
-
 @cli.command(
     "download",
     help="Download MicroPython firmware for specific ports, boards and versions.",
@@ -49,7 +44,7 @@ def connected_ports_boards() -> Tuple[List[str], List[str]]:
     "-b",
     "boards",
     multiple=True,
-    default=["?"],
+    default=[],
     show_default=True,
     help="The board(s) to download the firmware for.",
     metavar="BOARD_ID or ?",
@@ -71,16 +66,21 @@ def cli_download(
     **kwargs,
 ):
     params = DownloadParams(**kwargs)
-
-    if not params.boards:
-        # nothing specified - detect connected boards
+    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()
-    # ask for any remaining parameters
+
     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)
 
-    params.versions = [clean_version(v, drop_v=True) for v in params.versions]  # remove leading v from version
-
     download(
         params.fw_folder,
         params.ports,
@@ -89,3 +89,19 @@ def cli_download(
         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/cli_flash.py

@@ -1,21 +1,19 @@
 from pathlib import Path
-from typing import List
 
 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 .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 .mpboard_id.api import find_mp_board
-from .mpremoteboard import MPRemoteBoard
+from .flash import flash_list
+from .worklist import MPRemoteBoard, WorkList, full_auto_worklist, manual_worklist, single_auto_worklist
 
 # #########################################################################################################
 # CLI
@@ -67,9 +65,8 @@ from .mpremoteboard import MPRemoteBoard
 @click.option(
     "--board",
     "-b",
-    "boards",
+    "board",  # single board
     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 ?",
 )
@@ -95,131 +92,79 @@ from .mpremoteboard import MPRemoteBoard
     help="""Enter micropython bootloader mode before flashing.""",
 )
 def cli_flash_board(**kwargs):
-    todo: WorkList = []
+    # 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")]
 
-    # 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:
+    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:
-        print(repr(params.versions))
         log.error(f"Only one version can be flashed at a time, not {params.versions}")
-        return
+        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]
-    if params.versions[0] and params.boards[0] and params.serial:
-        # update a single board
-        todo = manual_worklist(
+    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],
-            # 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,
-            )
+    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(
-        todo,
+        worklist,
         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
-        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}")
+        show_mcus(flashed, title="Updated boards after flashing")

mpflash/cli_group.py

@@ -11,7 +11,7 @@ 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:

mpflash/cli_list.py

@@ -1,16 +1,11 @@
 import json
-from typing import List
 
 import rich_click as click
 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 .list import list_mcus, show_mcus
+from .logger import make_quiet
 
 
 @cli.command("list", help="List the connected MCU boards.")
@@ -44,56 +39,3 @@ def cli_list_mcus(as_json: bool, progress: bool = True):
     if progress:
         show_mcus(conn_mcus, refresh=False)
     return conn_mcus
-
-
-def list_mcus():
-    conn_mcus = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports]
-
-    for mcu in track(conn_mcus, description="Getting board info", transient=True, update_period=0.1):
-        try:
-            mcu.get_mcu_info()
-        except ConnectionError as e:
-            print(f"Error: {e}")
-            continue
-    return conn_mcus
-
-
-def show_mcus(
-    conn_mcus: List[MPRemoteBoard],
-    title: str = "Connected boards",
-    refresh: bool = True,
-):  # sourcery skip: extract-duplicate-method
-    """Show the list of connected boards in a nice table"""
-    table = Table(
-        title=title,
-        header_style="bold blue",
-        collapse_padding=True,
-        width=110,
-        row_styles=["blue", "yellow"],
-    )
-    table.add_column("Serial", overflow="fold")
-    table.add_column("Family")
-    table.add_column("Port")
-    table.add_column("Board", overflow="fold")
-    # table.add_column("Variant") # TODO: add variant
-    table.add_column("CPU")
-    table.add_column("Version")
-    table.add_column("build", justify="right")
-
-    for mcu in track(conn_mcus, description="Updating board info", transient=True, update_period=0.1):
-        if refresh:
-            try:
-                mcu.get_mcu_info()
-            except ConnectionError:
-                continue
-        table.add_row(
-            mcu.serialport.replace("/dev/", ""),
-            mcu.family,
-            mcu.port,
-            f"{mcu.board}\n{mcu.description}".strip(),
-            # mcu.variant,
-            mcu.cpu,
-            mcu.version,
-            mcu.build,
-        )
-    console.print(table)

mpflash/cli_main.py

@@ -15,8 +15,12 @@ def mpflash():
     cli.add_command(cli_list_mcus)
     cli.add_command(cli_download)
     # cli(auto_envvar_prefix="MPFLASH")
-    cli()
+    try:
+        exit(cli())
+    except AttributeError as e:
+        print(f"Error: {e}")
+        exit(-1)
 
 
-# if __name__ == "__main__":
-mpflash()
+if __name__ == "__main__":
+    mpflash()