mpflash 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

mpflash/ask_input.py

@@ -12,7 +12,7 @@ from typing import Dict, List, Sequence, Tuple, Union
 from loguru import logger as log
 
 from mpflash.config import config
-from mpflash.mpboard_id import get_stored_boards_for_port, known_stored_boards, local_mp_ports
+from mpflash.mpboard_id import get_known_boards_for_port, get_known_ports, known_stored_boards
 from mpflash.mpremoteboard import MPRemoteBoard
 from mpflash.vendor.versions import micropython_versions
 
@@ -45,7 +45,7 @@ ParamType = Union[DownloadParams, FlashParams]
 
 def ask_missing_params(
     params: ParamType,
-    action: str = "download",
+    # action: str = "download",
 ) -> ParamType:
     """
     Asks the user for parameters that have not been supplied on the commandline and returns the updated params.
@@ -57,6 +57,10 @@ def ask_missing_params(
     Returns:
         ParamType: The updated parameters.
     """
+    # if action flash,  single input
+    # if action download, multiple input
+    multi_select = isinstance(params, DownloadParams)
+    action = "download" if isinstance(params, DownloadParams) else "flash"
     if not config.interactive:
         # no interactivity allowed
         return params
@@ -64,37 +68,46 @@ def ask_missing_params(
     import inquirer
 
     questions = []
-    answers = {"action": action}
-    if isinstance(params, FlashParams):
+    answers = {"action": "download" if isinstance(params, DownloadParams) else "flash"}
+    if not multi_select:
         if not params.serial or "?" in params.serial:
-            ask_serialport(questions, action=action)
+            ask_serialport(questions)
         else:
             answers["serial"] = params.serial
 
     if not params.versions or "?" in params.versions:
-        ask_versions(questions, action=action)
+        ask_versions(questions, multi_select=multi_select, 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=answers)
+        ask_port_board(questions, multi_select=multi_select, action=action)
+    if questions:
+        answers = inquirer.prompt(questions, answers=answers)
     if not answers:
         # input cancelled by user
         return []  # type: ignore
     # print(repr(answers))
     if isinstance(params, FlashParams) and "serial" in answers:
-        params.serial = answers["serial"]
+        params.serial = answers["serial"].split()[0]  # split to remove the description
     if "port" in answers:
-        params.ports = [answers["port"]]
+        params.ports = [p for p in params.ports if p != "?"]  # remove the "?" if present
+        params.ports.append(answers["port"])
     if "boards" in answers:
-        params.boards = answers["boards"] if isinstance(answers["boards"], list) else [answers["boards"]]
+        params.boards = [b for b in params.boards if b != "?"]  # remove the "?" if present
+        params.boards.extend(answers["boards"] if isinstance(answers["boards"], list) else [answers["boards"]])
     if "versions" in answers:
+        params.versions = [v for v in params.versions if v != "?"]  # remove the "?" if present
         # make sure it is a list
-        params.versions = answers["versions"] if isinstance(answers["versions"], list) else [answers["versions"]]
-
+        if isinstance(answers["versions"], (list, tuple)):
+            params.versions.extend(answers["versions"])
+        else:
+            params.versions.append(answers["versions"])
+    # remove duplicates
+    params.ports = list(set(params.ports))
+    params.boards = list(set(params.boards))
+    params.versions = list(set(params.versions))
     log.debug(repr(params))
 
     return params
@@ -135,7 +148,7 @@ def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
     return some_boards
 
 
-def ask_port_board(questions: list, *, action: str):
+def ask_port_board(questions: list, *, multi_select: bool, action: str):
     """
     Asks the user for the port and board selection.
 
@@ -149,14 +162,15 @@ def ask_port_board(questions: list, *, action: str):
     # 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
+    # if action flash,  single input
+    # if action download, multiple input
+    inquirer_ux = inquirer.Checkbox if multi_select else inquirer.List
     questions.extend(
         (
             inquirer.List(
                 "port",
                 message="Which port do you want to {action} " + "to {serial} ?" if action == "flash" else "?",
-                choices=local_mp_ports(),
+                choices=get_known_ports(),
                 autocomplete=True,
             ),
             inquirer_ux(
@@ -173,7 +187,7 @@ def ask_port_board(questions: list, *, action: str):
     )
 
 
-def ask_versions(questions: list, *, action: str):
+def ask_versions(questions: list, *, multi_select: bool, action: str):
     """
     Asks the user for the version selection.
 
@@ -188,13 +202,13 @@ def ask_versions(questions: list, *, action: str):
     import inquirer
     import inquirer.errors
 
-    input_ux = inquirer.Checkbox if action == "download" else inquirer.List
+    input_ux = inquirer.Checkbox if multi_select else inquirer.List
     mp_versions: List[str] = micropython_versions()
     mp_versions = [v for v in mp_versions if "preview" not in v]
 
     # remove the versions for which there are no known boards in the board_info.json
     # todo: this may be a little slow
-    mp_versions = [v for v in mp_versions if get_stored_boards_for_port("stm32", [v])]
+    mp_versions = [v for v in mp_versions if get_known_boards_for_port("stm32", [v])]
 
     mp_versions.append("preview")
     mp_versions.reverse()  # newest first
@@ -216,12 +230,12 @@ def ask_versions(questions: list, *, action: str):
             # hints=["Use space to select multiple options"],
             choices=mp_versions,
             autocomplete=True,
-            validate=at_least_one_validation,
+            validate=at_least_one_validation,  # type: ignore
         )
     )
 
 
-def ask_serialport(questions: list, *, action: str):
+def ask_serialport(questions: list, *, multi_select: bool = False, bluetooth: bool = False):
     """
     Asks the user for the serial port selection.
 
@@ -235,12 +249,12 @@ def ask_serialport(questions: list, *, action: str):
     # import only when needed to reduce load time
     import inquirer
 
-    serialports = MPRemoteBoard.connected_boards()
+    comports = MPRemoteBoard.connected_boards(bluetooth=bluetooth, description=True)
     questions.append(
         inquirer.List(
             "serial",
             message="Which serial port do you want to {action} ?",
-            choices=serialports,
+            choices=comports,
             other=True,
             validate=lambda _, x: True if x else "Please select or enter a serial port",  # type: ignore
         )

mpflash/cli_download.py

@@ -7,7 +7,7 @@ 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.mpboard_id import find_known_board
 from mpflash.vendor.versions import clean_version
 
 from .ask_input import DownloadParams, ask_missing_params
@@ -68,13 +68,20 @@ def cli_download(**kwargs) -> int:
     params.versions = list(params.versions)
     params.boards = list(params.boards)
     if params.boards:
-        pass
-        # TODO Clean board - same as in cli_flash.py
+        if not params.ports:
+            # no ports specified - resolve ports from specified boards by resolving board IDs
+            for board in params.boards:
+                if board != "?":
+                    try:
+                        board_ = find_known_board(board)
+                        params.ports.append(board_["port"])
+                    except MPFlashError as e:
+                        log.error(f"{e}")
     else:
-        # no boards specified - detect connected boards
+        # no boards specified - detect connected ports and boards
         params.ports, params.boards = connected_ports_boards()
 
-    params = ask_missing_params(params, action="download")
+    params = ask_missing_params(params)
     if not params:  # Cancelled by user
         return 2
     params.versions = [clean_version(v, drop_v=True) for v in params.versions]

mpflash/cli_flash.py

@@ -4,7 +4,7 @@ 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.mpboard_id import find_known_board
 from mpflash.vendor.versions import clean_version
 
 from .ask_input import FlashParams, ask_missing_params
@@ -101,6 +101,14 @@ def cli_flash_board(**kwargs) -> int:
         kwargs["boards"] = [kwargs.pop("board")]
 
     params = FlashParams(**kwargs)
+
+    # make it simple for the user to flash one board
+    # by asking for the serial port if not specified
+    if params.boards == ["?"] and params.serial == "auto":
+        params.serial = "?"
+
+    # Detect connected boards if not specified,
+    # and ask for input if boards cannot be detected
     if not params.boards or params.boards == []:
         # nothing specified - detect connected boards
         params.ports, params.boards = connected_ports_boards()
@@ -116,7 +124,7 @@ def cli_flash_board(**kwargs) -> int:
                 continue
             if " " in board_id:
                 try:
-                    info = find_stored_board(board_id)
+                    info = find_known_board(board_id)
                     if info:
                         log.info(f"Resolved board description: {info['board']}")
                         params.boards.remove(board_id)
@@ -125,7 +133,7 @@ def cli_flash_board(**kwargs) -> int:
                     log.warning(f"unable to resolve board description: {e}")
 
     # Ask for missing input if needed
-    params = ask_missing_params(params, action="flash")
+    params = ask_missing_params(params)
     if not params:  # Cancelled by user
         return 2
     # TODO: Just in time Download of firmware

mpflash/cli_main.py

@@ -3,6 +3,7 @@
 # import rich_click as click
 
 import click
+from loguru import logger as log
 
 from .cli_download import cli_download
 from .cli_flash import cli_flash_board
@@ -19,8 +20,11 @@ def mpflash():
         result = cli(standalone_mode=False)
         exit(result)
     except AttributeError as e:
-        print(f"Error: {e}")
+        log.error(f"Error: {e}")
         exit(-1)
+    except click.exceptions.ClickException as e:
+        log.error(f"Error: {e}")
+        exit(-2)
 
 
 if __name__ == "__main__":

mpflash/download.py

@@ -20,6 +20,7 @@ from rich.progress import track
 
 from mpflash.common import PORT_FWTYPES
 from mpflash.errors import MPFlashError
+from mpflash.mpboard_id import get_known_ports
 
 jsonlines.ujson = None  # type: ignore
 # #########################################################################################################
@@ -109,6 +110,8 @@ def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[Firmwar
 
     """
     board_urls: List[FirmwareInfo] = []
+    if ports is None:
+        ports = get_known_ports()
     for port in ports:
         download_page_url = f"{MICROPYTHON_ORG_URL}download/?port={port}"
         _urls = get_board_urls(download_page_url)
@@ -118,7 +121,7 @@ def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[Firmwar
         for board in _urls:
             board["port"] = port
 
-        for board in track(_urls, description=f"Checking {port} download pages", transient=True):
+        for board in track(_urls, description=f"Checking {port} download pages", transient=True,refresh_per_second=2):
             # add a board to the list for each firmware found
             firmwares = []
             for ext in PORT_FWTYPES[port]:
@@ -170,6 +173,7 @@ def download_firmwares(
     skipped = downloaded = 0
     if versions is None:
         versions = []
+
     unique_boards = get_firmware_list(ports, boards, versions, clean)
 
     for b in unique_boards:

mpflash/flash_esp.py

@@ -10,7 +10,7 @@ from typing import List, Optional
 import esptool
 from loguru import logger as log
 
-from mpflash.mpboard_id import find_stored_board
+from mpflash.mpboard_id import find_known_board
 from mpflash.mpremoteboard import MPRemoteBoard
 
 
@@ -22,7 +22,7 @@ def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optio
     log.info(f"Flashing {fw_file} on {mcu.board} on {mcu.serialport}")
     if not mcu.cpu:
         # Lookup CPU based on the board name
-        mcu.cpu = find_stored_board(mcu.board)["cpu"]
+        mcu.cpu = find_known_board(mcu.board)["cpu"]
 
     cmds: List[List[str]] = []
     if erase:

mpflash/flash_uf2.py

@@ -56,6 +56,6 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     log.success("Done copying, resetting the board and wait for it to restart")
     if sys.platform in ["linux", "darwin"]:
         dismount_uf2()
-    for _ in track(range(5 + 2), description="Waiting for the board to restart", transient=True):
+    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

@@ -113,7 +113,7 @@ def wait_for_UF2_linux(s_max: int = 10):
     wait = 10
     uf2_drives = []
     # while not destination and wait > 0:
-    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True):
+    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True,refresh_per_second=2):
         # log.info(f"Waiting for mcu to mount as a drive : {wait} seconds left")
         uf2_drives += list(get_uf2_drives())
         for drive in get_uf2_drives():

mpflash/flash_uf2_windows.py

@@ -17,7 +17,7 @@ def wait_for_UF2_windows(s_max: int = 10):
     if s_max < 1:
         s_max = 10
     destination = ""
-    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True):
+    for _ in track(range(s_max), description="Waiting for mcu to mount as a drive", transient=True,refresh_per_second=2):
         # log.info(f"Waiting for mcu to mount as a drive : {n} seconds left")
         drives = [drive.device for drive in psutil.disk_partitions()]
         for drive in drives:

mpflash/list.py

@@ -26,8 +26,9 @@ def list_mcus(bluetooth: bool = False):
     """
     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 currenlty scanned
-    with Progress(rp_spinner, rp_text, rp_bar, TimeElapsedColumn()) as progress:
+    # 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
@@ -51,39 +52,79 @@ 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"""
+):
+    console.print(mcu_table(conn_mcus, title, refresh))
+
+
+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]
+    return family
+
+
+def mcu_table(
+    conn_mcus: List[MPRemoteBoard],
+    title: str = "Connected boards",
+    refresh: bool = True,
+):
+    """
+    builds a rich table with the connected boards information
+    The columns of the table are adjusted to the terminal width
+    the columns are :
+                Narrow      Wide
+    - Serial    Yes         Yes
+    - Family    abbrv.      Yes
+    - Port      -           yes
+    - Board     Yes         Yes     BOARD_ID and Description
+    - CPU       -           Yes
+    - Version   Yes         Yes
+    - Build     *           *       only if any of the mcus have a build
+    """
     table = Table(
         title=title,
         title_style="magenta",
         header_style="bold magenta",
         collapse_padding=True,
-        width=110,
+        padding=(0, 0),
     )
-    table.add_column("Serial", overflow="fold")
-    table.add_column("Family")
-    table.add_column("Port")
+    # check if the terminal is wide enough to show all columns or if we need to collapse some
+    is_wide = console.width > 99
+    needs_build = any(mcu.build for mcu in conn_mcus)
+
+    table.add_column("Serial" if is_wide else "Ser.", overflow="fold")
+    table.add_column("Family" if is_wide else "Fam.", overflow="crop", max_width=None if is_wide else 4)
+    if is_wide:
+        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")
+    if is_wide:
+        table.add_column("CPU")
+    table.add_column("Version", overflow="fold", min_width=5, max_width=16)
+    if needs_build:
+        table.add_column("Build" if is_wide else "Bld", justify="right")
 
-    for mcu in track(conn_mcus, description="Updating board info", transient=True, update_period=0.1):
+    for mcu in track(conn_mcus, description="Updating board info", transient=True, refresh_per_second=2):
         if refresh:
             try:
                 mcu.get_mcu_info()
             except ConnectionError:
                 continue
         description = f"[italic bright_cyan]{mcu.description}" if mcu.description else ""
-        table.add_row(
+        row = [
             mcu.serialport.replace("/dev/", ""),
-            mcu.family,
-            mcu.port,
-            f"{mcu.board}\n{description}".strip(),
-            # mcu.variant,
-            mcu.cpu,
-            clean_version(mcu.version),
-            mcu.build,
-        )
-    console.print(table)
+            abbrv_family(mcu.family, is_wide),
+        ]
+        if is_wide:
+            row.append(mcu.port)
+        row.append(f"{mcu.board}\n{description}".strip())
+        if is_wide:
+            row.append(mcu.cpu)
+        row.append(clean_version(mcu.version))
+        if needs_build:
+            row.append(mcu.build)
+
+        table.add_row(*row)
+    return table

mpflash/mpboard_id/__init__.py

@@ -9,10 +9,13 @@ from functools import lru_cache
 from pathlib import Path
 from typing import List, Optional, Tuple, TypedDict, Union
 
-from mpflash.errors import MPFlashError
 from mpflash.common import PORT_FWTYPES
+from mpflash.errors import MPFlashError
 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
@@ -30,27 +33,27 @@ class Board(TypedDict):
 
 
 @lru_cache(maxsize=None)
-def read_stored_boardinfo() -> List[Board]:
+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 local_mp_ports() -> List[str]:
+def get_known_ports() -> List[str]:
     # TODO: Filter for Version
-    mp_boards = read_stored_boardinfo()
+    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()})
     return sorted(list(ports))
 
 
-def get_stored_boards_for_port(port: str, versions: Optional[List[str]] = None):
+def get_known_boards_for_port(port: str, versions: Optional[List[str]] = None):
     """
     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)"""
-    mp_boards = read_stored_boardinfo()
+    mp_boards = read_known_boardinfo()
 
     # filter for 'preview' as they are not in the board_info.json
     # instead use stable version
@@ -75,16 +78,16 @@ def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List
     port : str : The Micropython port to filter for
     versions : List[str] : The Micropython versions to filter for (actual versions required)
     """
-    mp_boards = get_stored_boards_for_port(port, versions)
+    mp_boards = get_known_boards_for_port(port, versions)
 
     boards = set({(f'{board["version"]} {board["description"]}', board["board"]) for board in mp_boards})
     return sorted(list(boards))
 
 
 @lru_cache(maxsize=20)
-def find_stored_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_stored_boardinfo()
+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"]:

mpflash/mpboard_id/board_id.py

@@ -8,23 +8,28 @@ from pathlib import Path
 from typing import Optional
 
 from mpflash.errors import MPFlashError
-from mpflash.vendor.versions import clean_version
+from mpflash.vendor.versions import clean_version, get_stable_mp_version
 
 ###############################################################################################
 HERE = Path(__file__).parent
 ###############################################################################################
 
 
-def find_board_id(
-    descr: str, short_descr: str, board_info: Optional[Path] = None, version: str = "stable"
+def find_board_id_by_description(
+    descr: str,
+    short_descr: str,
+    *,
+    version: str,
+    board_info: Optional[Path] = None,
 ) -> Optional[str]:
     """Find the MicroPython BOARD_ID based on the description in the firmware"""
+
     try:
-        boards = find_board_id_by_description(
+        boards = _find_board_id_by_description(
             descr=descr,
             short_descr=short_descr,
             board_info=board_info,
-            version=clean_version(version),
+            version=clean_version(version) if version else None,
         )
         return boards[-1]["board"]
     except MPFlashError:
@@ -32,7 +37,9 @@ def find_board_id(
 
 
 @functools.lru_cache(maxsize=20)
-def find_board_id_by_description(*, descr: str, short_descr: str, version="v1.21.0", board_info: Optional[Path] = None):
+def _find_board_id_by_description(
+    *, 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
@@ -42,18 +49,20 @@ def find_board_id_by_description(*, descr: str, short_descr: str, version="v1.21
     if not board_info.exists():
         raise FileNotFoundError(f"Board info file not found: {board_info}")
 
-    info = _read_board_info(board_info)
+    candidate_boards = _read_board_info(board_info)
 
-    # filter for matching version
-    if version == "preview":
-        # TODO: match last stable
-        version = "v1.22.2"
-    version_matches = [b for b in info if b["version"].startswith(version)]
-    if not version_matches:
-        raise MPFlashError(f"No board info found for version {version}")
-    matches = [b for b in version_matches if b["description"] == descr]
+    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)]
+        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]
     if not matches and short_descr:
-        matches = [b for b in version_matches 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"])

mpflash/mpremoteboard/__init__.py

@@ -13,7 +13,7 @@ from rich.progress import track
 from tenacity import retry, stop_after_attempt, wait_fixed
 
 from mpflash.errors import MPFlashError
-from mpflash.mpboard_id.board_id import find_board_id
+from mpflash.mpboard_id.board_id import find_board_id_by_description
 from mpflash.mpremoteboard.runner import run
 
 ###############################################################################################
@@ -64,7 +64,7 @@ class MPRemoteBoard:
         return f"MPRemoteBoard({self.serialport}, {self.family} {self.port}, {self.board}, {self.version})"
 
     @staticmethod
-    def connected_boards(bluetooth: bool = False) -> List[str]:
+    def connected_boards(bluetooth: bool = False, description: bool = False) -> List[str]:
         # TODO: rename to connected_comports
         """
         Get a list of connected comports.
@@ -81,8 +81,19 @@ class MPRemoteBoard:
             # filter out bluetooth ports
             comports = [p for p in comports if "bluetooth" not in p.description.lower()]
             comports = [p for p in comports if "BTHENUM" not in p.hwid]
-
-        return sorted([p.device for p in comports])
+        if description:
+            output = [
+                f"{p.device} {(p.manufacturer + ' ') if p.manufacturer and not p.description.startswith(p.manufacturer) else ''}{p.description}"
+                for p in comports
+            ]
+        else:
+            output = [p.device for p in comports]
+
+        if sys.platform == "win32":
+            # Windows sort of comports by number - but fallback to device name
+            return sorted(output, key=lambda x: int(x.split()[0][3:]) if x.split()[0][3:].isdigit() else x)
+        # sort by device name
+        return sorted(output)
 
     @retry(stop=stop_after_attempt(RETRIES), wait=wait_fixed(1), reraise=True)  # type: ignore ## retry_error_cls=ConnectionError,
     def get_mcu_info(self, timeout: int = 2):
@@ -116,10 +127,10 @@ class MPRemoteBoard:
             self.description = descr = info["board"]
             pos = descr.rfind(" with")
             short_descr = descr[:pos].strip() if pos != -1 else ""
-            if board_name := find_board_id(descr, short_descr):
+            if board_name := find_board_id_by_description(descr, short_descr, version=self.version):
                 self.board = board_name
             else:
-                self.board = "UNKNOWN"
+                self.board = "UNKNOWN_BOARD"
 
     def disconnect(self) -> bool:
         """
@@ -200,6 +211,7 @@ class MPRemoteBoard:
             transient=True,
             get_time=lambda: time.time(),
             show_speed=False,
+            refresh_per_second=1,
         ):
             time.sleep(1)
             try:

mpflash/worklist.py

@@ -9,7 +9,7 @@ from mpflash.errors import MPFlashError
 from .config import config
 from .downloaded import find_downloaded_firmware
 from .list import show_mcus
-from .mpboard_id import find_stored_board
+from .mpboard_id import find_known_board
 from .mpremoteboard import MPRemoteBoard
 
 # #########################################################################################################
@@ -131,7 +131,7 @@ def manual_worklist(
     # 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
     try:
-        info = find_stored_board(board)
+        info = find_known_board(board)
         mcu.port = info["port"]
         # need the CPU type for the esptool
         mcu.cpu = info["cpu"]

{mpflash-0.7.4.dist-info → mpflash-0.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpflash
-Version: 0.7.4
+Version: 0.7.6
 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.7.4.dist-info → mpflash-0.7.6.dist-info}/RECORD

@@ -1,40 +1,40 @@
 mpflash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mpflash/ask_input.py,sha256=_LlatVyrWbY1Q4TDn8TWXJO5s22q_bGl3NXmdt13jxU,8442
-mpflash/cli_download.py,sha256=RNEsk1eMqzKCf9_sUPZQkDnzw6w-8L0Jnl6gDQup2Tc,3266
-mpflash/cli_flash.py,sha256=DTZ1mQSL31aEr3ROGIGWzzkiir4MRSqXdwq2p4ArDWE,5847
+mpflash/ask_input.py,sha256=XxYbO2DwB59pyv1uec9fN7nDxQcHLPnp55LSU8eOMg8,9459
+mpflash/cli_download.py,sha256=YHoQOaY5Cg0-jKkEHNa9jvlTr9AfVw9xNm33eWahfdI,3623
+mpflash/cli_flash.py,sha256=yh8JH88LduSRW0gUvCpTUVmY6PaojciPZeEdHqtxq6M,6133
 mpflash/cli_group.py,sha256=nL3H06PHm_XUDlMuRyjgmTYeLnkrLa9mKDdahYw-KRo,1967
 mpflash/cli_list.py,sha256=KIlEeqcIIBf0g-emS43fzKspUy6fn9TUuFl0u00XaK8,1024
-mpflash/cli_main.py,sha256=BgqkDeEV0LBdT_Xn_Ay3zQOVJ-73pWSA4ngRf9KxGpw,656
+mpflash/cli_main.py,sha256=GJzA4_WTiwAzQP0b2tCXwfyNId1TeBnrzU1GP5xZans,796
 mpflash/common.py,sha256=lucFGMLl03qz-5Ic2XVv4g5XVt6hloUU6N5v0tSaUYE,1049
 mpflash/config.py,sha256=G6TxliEGxoYXy1SHQYBKgywnKccz9QzD3mGq_Vv1frg,419
-mpflash/download.py,sha256=_yYENI7oew4tD51xEer1Ohv2B3LHrGg1lIF98LWDMCY,10991
+mpflash/download.py,sha256=HMYpLVIcy_FaZGHIuucsmJ4fceYhf5DFJgG8f7r-mcA,11120
 mpflash/downloaded.py,sha256=ADMJqZn7WVcU-Rm2X6RqA8ejtBNBYXcpwxVyT3v7r6s,3803
 mpflash/errors.py,sha256=Q5LR12Wo8iUCg5n_qq4GjdBdBflbvCOdKsRJ5InYRfI,96
 mpflash/flash.py,sha256=YGYXuNNbjro4QvZmpwpLCo86nFsh4UxWrOJHOowUYDY,2490
-mpflash/flash_esp.py,sha256=TjBOk2y1eLrcE8T3iYGypsiskPX7BFNfxYmCuUo_3v4,2316
+mpflash/flash_esp.py,sha256=1_jtZnmJl_aGznJZR1X9N2sK7ys8s_3N21LWllRB-lI,2314
 mpflash/flash_stm32.py,sha256=d4BoQl3a9Tchnvn2ZTuq2MpYBB4MTaRukwtEncI95k0,823
 mpflash/flash_stm32_cube.py,sha256=w7aGWjReeWUKl0Q3ZjXH8BRqNO1Tk9AO7gtRNUg1c9Y,3970
 mpflash/flash_stm32_dfu.py,sha256=G70EZodWb-aRi507Jxbys-VEwbBGU1oZacow3_nq-d4,2972
-mpflash/flash_uf2.py,sha256=KvNPk1zDwQexJfPI5MlIoR7zTD0u-pQQwSHuFQjuMXg,2093
+mpflash/flash_uf2.py,sha256=ps2gUXZ4bdsgMqQzveYLLoXOmSC-aCmIG9L_tJjQ7Sk,2115
 mpflash/flash_uf2_boardid.py,sha256=WZKucGu_hJ8ymb236uuZbiR6pD6AA_l4LA-7LwtQhq8,414
-mpflash/flash_uf2_linux.py,sha256=LAGkzTImVq-wKo7LGUNlwkUHv1L4rGO7igR5dwxY07o,4298
-mpflash/flash_uf2_windows.py,sha256=dcmA-koavH7duOuNwI0n2aDDbhF1_5ZZ-mXFAXgj8z4,1072
-mpflash/list.py,sha256=R3upYux3mEltpqfrt467Ufs4hVatW1NE40jjhN7Ei1g,3252
+mpflash/flash_uf2_linux.py,sha256=jMnoW-Mmj33RJFQkqQMs9iKmAAtH4QoD7gYGztkvhH8,4319
+mpflash/flash_uf2_windows.py,sha256=94YoO2UIzfyJs4CPJ9sjG_WY26SX8aUPl9mf9R9W5xk,1093
+mpflash/list.py,sha256=IpDhYrr5dXWY88PiKkvhqt3ioNF9tlsakTZVD05YBfQ,4713
 mpflash/logger.py,sha256=dI_H_a7EOdQJyvoeRHQuYeZuTKYVUS3DUPTLhE9rkdM,1098
-mpflash/mpboard_id/__init__.py,sha256=JYGe7VwpBV4ig2M9a6vJUQrMtgdNjZKHt_Z5N13Ycrs,3509
-mpflash/mpboard_id/board_id.py,sha256=G2oW969pqDuLbQS7UrFNmbWNdDIXfWBAoZMt1EWHLak,2361
+mpflash/mpboard_id/__init__.py,sha256=LT52MV3tIHgBu_bFdvae2csahzonsCwno2ardU5ivsE,3621
+mpflash/mpboard_id/board_id.py,sha256=vGPfxMVmQCBRlsZJAhsbhZStlDl21zLC0sqXcaBrSXc,2592
 mpflash/mpboard_id/board_info.csv,sha256=KPWDo-zHWfrPGQn9oInsDH-5IdCzhBCs6K_YAmqqSpQ,96983
 mpflash/mpboard_id/board_info.json,sha256=JtVyOMIO1O7vLKzJ0hyXQ4JSxXiQBJyay2hjdNLnZM0,674442
-mpflash/mpremoteboard/__init__.py,sha256=DxlO_7LiyWDz5hNRI77fzp3sI3fZQ9Sd23dnGLx4Zl0,7017
+mpflash/mpremoteboard/__init__.py,sha256=fJ_N1F6R3CfP9F7pmocb5l8yRvzmSmtHi4u_uTQHR1w,7683
 mpflash/mpremoteboard/mpy_fw_info.py,sha256=6AQbN3jtQgllqWQYl4e-63KeEtV08EXk8_JnM6XBkvo,4554
 mpflash/mpremoteboard/runner.py,sha256=-PgzAeBGbyXaAUlwyiw4mcINsP2U1XRRjP1_QdBrxpg,4786
 mpflash/vendor/dfu.py,sha256=oK_MRSOyDJrUuS6D24IMIsfL7oLcrvUq0yp_h4WIY2U,5739
 mpflash/vendor/pydfu.py,sha256=_MdBRo1EeNeKDqFPSTB5tNL1jGSBJgsVeVjE5e7Pb8s,20542
 mpflash/vendor/readme.md,sha256=iIIZxuLUIGHQ0KODzYVtMezsztvyxCXcNJp_AzwTIPk,86
 mpflash/vendor/versions.py,sha256=ooRZjeeYepQHwp12hMu2m0p8nZXQ5s942w5mGkKmgeI,3629
-mpflash/worklist.py,sha256=qZsqF3Lf5Bl7QQ31ZLVHewP6WC8fmwQPMbyNgbG7LB4,5299
-mpflash-0.7.4.dist-info/entry_points.txt,sha256=Jk_visOhYOsZIcSP2Ms9hKqfKy1iorR-6dYltSoWCpY,52
-mpflash-0.7.4.dist-info/LICENSE,sha256=mWpNhsIxWzetYNnTpr4eb3HtgsxGIC8KcYWxXEcxQvE,1077
-mpflash-0.7.4.dist-info/METADATA,sha256=yuYr4EWKmSRD8yg7M6tyfP-EYSt-4UrZjGEycTSUH4o,14633
-mpflash-0.7.4.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-mpflash-0.7.4.dist-info/RECORD,,
+mpflash/worklist.py,sha256=izHCPR39OYMXydXpLjtjsgaYlNAfrlQz0_joDPmhDJM,5297
+mpflash-0.7.6.dist-info/entry_points.txt,sha256=Jk_visOhYOsZIcSP2Ms9hKqfKy1iorR-6dYltSoWCpY,52
+mpflash-0.7.6.dist-info/LICENSE,sha256=mWpNhsIxWzetYNnTpr4eb3HtgsxGIC8KcYWxXEcxQvE,1077
+mpflash-0.7.6.dist-info/METADATA,sha256=ci7Uf09buIB9AfiBv5NVsO-LFb__tlkF295aZhTtjyU,14633
+mpflash-0.7.6.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+mpflash-0.7.6.dist-info/RECORD,,