micropython-stubber 1.20.6__py3-none-any.whl → 1.23.1__py3-none-any.whl

mpflash/mpflash/cli_group.py

@@ -27,7 +27,7 @@ def cb_verbose(ctx, param, value):
     return value
 
 
-def cb_interactive(ctx, param, value:bool):
+def cb_interactive(ctx, param, value: bool):
     log.trace(f"Setting interactive mode to {value}")
     config.interactive = value
     return value
@@ -39,6 +39,10 @@ def cb_test(ctx, param, value):
         config.tests = value
     return value
 
+def cb_usb(ctx, param, value: bool):
+    config.usb = bool(value)
+    return value
+
 
 def cb_quiet(ctx, param, value):
     log.trace(f"Setting quiet mode to {value}")
@@ -78,19 +82,28 @@ def cb_quiet(ctx, param, value):
     help="Enables verbose mode.",
     callback=cb_verbose,
 )
+@click.option(
+    "--usb",
+    "-u",
+    is_eager=True,
+    is_flag=True,
+    default=False,
+    help="Shows USB location of the connected boards.",
+    callback=cb_usb,
+    show_default=True,
+)
 @click.option(
     "--test",
     is_eager=True,
-    help="test a specific feature",
+    help="Test a specific feature.",
     callback=cb_test,
     multiple=True,
     default=[],
     envvar="MPFLASH_TEST",
-    show_default=True,
-    metavar="TEST",
+    metavar="FLAG",
 )
 def cli(**kwargs):
-    """mpflash - MicroPython Tool.
+    """mpflash - MicroPython flashing tool.
 
     A CLI to download and flash MicroPython firmware to different ports and boards.
     """

mpflash/mpflash/cli_main.py

@@ -1,10 +1,8 @@
 """mpflash is a CLI to download and flash MicroPython firmware to various boards."""
 
-# import rich_click as click
-
 import os
 
-import click
+import click.exceptions as click_exceptions
 from loguru import logger as log
 
 from .cli_download import cli_download
@@ -29,10 +27,10 @@ def mpflash():
         except AttributeError as e:
             log.error(f"Error: {e}")
             exit(-1)
-        except click.exceptions.ClickException as e:
+        except click_exceptions.ClickException as e:
             log.error(f"Error: {e}")
             exit(-2)
-        except click.exceptions.Abort as e:
+        except click_exceptions.Abort as e:
             # Aborted - Ctrl-C
             exit(-3)
 

mpflash/mpflash/common.py

@@ -92,6 +92,7 @@ class DownloadParams(Params):
 
 
 class BootloaderMethod(Enum):
+    AUTO = "auto"
     MANUAL = "manual"
     MPY = "mpy"
     TOUCH_1200 = "touch1200"

mpflash/mpflash/config.py

@@ -1,10 +1,10 @@
 """centralized configuration for mpflash"""
 
 import os
+from importlib.metadata import version
 from pathlib import Path
 from typing import List
 
-import pkg_resources
 import platformdirs
 
 from mpflash.logger import log
@@ -12,10 +12,7 @@ from mpflash.logger import log
 
 def get_version():
     name = __package__ or "mpflash"
-    try:
-        return pkg_resources.get_distribution(name).version
-    except pkg_resources.DistributionNotFound:
-        return "Package not found"
+    return version(name)
 
 
 class MPtoolConfig:
@@ -23,6 +20,7 @@ class MPtoolConfig:
 
     quiet: bool = False
     verbose: bool = False
+    usb: bool = False
     ignore_ports: List[str] = []
     firmware_folder: Path = platformdirs.user_downloads_path() / "firmware"
     # test options specified on the commandline
@@ -32,16 +30,15 @@ class MPtoolConfig:
     @property
     def interactive(self):
         # No interactions in CI
-        if os.getenv('GITHUB_ACTIONS') == 'true':
+        if os.getenv("GITHUB_ACTIONS") == "true":
             log.warning("Disabling interactive mode in CI")
             return False
         return self._interactive
-    
+
     @interactive.setter
-    def interactive(self, value:bool):
+    def interactive(self, value: bool):
         self._interactive = value
 
 
-
 config = MPtoolConfig()
 __version__ = get_version()

mpflash/mpflash/connected.py

@@ -9,9 +9,7 @@ from mpflash.mpremoteboard import MPRemoteBoard
 from .common import filtered_comports
 
 
-def connected_ports_boards(
-    *, include: List[str], ignore: List[str]
-) -> Tuple[List[str], List[str], List[MPRemoteBoard]]:
+def connected_ports_boards(*, include: List[str], ignore: List[str]) -> Tuple[List[str], List[str], List[MPRemoteBoard]]:
     """
     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.
@@ -50,11 +48,17 @@ def list_mcus(*, ignore: List[str], include: List[str], bluetooth: bool = False)
         include=include,
         bluetooth=bluetooth,
     )
-    conn_mcus = [MPRemoteBoard(c.device) for c in comports]
+    conn_mcus = [MPRemoteBoard(c.device, location=c.location or "?") for c in comports]
 
     # 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:
+    with Progress(
+        rp_spinner,
+        rp_text,
+        rp_bar,
+        TimeElapsedColumn(),
+        refresh_per_second=1,
+    ) 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

mpflash/mpflash/download.py

@@ -21,7 +21,7 @@ from rich.progress import track
 from mpflash.common import PORT_FWTYPES, FWInfo
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import get_known_ports
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 # avoid conflict with the ujson used by MicroPython
 jsonlines.ujson = None  # type: ignore
@@ -134,7 +134,13 @@ def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[FWInfo]
         for board in urls:
             board["port"] = port
 
-        for board in track(urls, description=f"Checking {port} download pages", transient=True, refresh_per_second=2):
+        for board in track(
+            urls,
+            description=f"Checking {port} download pages",
+            transient=True,
+            refresh_per_second=1,
+            show_speed=False,
+        ):
             # add a board to the list for each firmware found
             firmware_urls: List[str] = []
             for ext in PORT_FWTYPES[port]:
@@ -273,9 +279,7 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
     log.debug(f"Total {len(board_urls)} firmwares")
 
     relevant = [
-        board
-        for board in board_urls
-        if board.version in versions and board.build == "0" and board.board in boards and not board.preview
+        board for board in board_urls if board.version in versions and board.build == "0" and board.board in boards and not board.preview
     ]
 
     if preview:

mpflash/mpflash/downloaded.py

@@ -4,8 +4,8 @@ from typing import Dict, List, Optional
 import jsonlines
 from loguru import logger as log
 
-from mpflash.common import FWInfo
-from mpflash.vendor.versions import clean_version
+from mpflash.common import PORT_FWTYPES, FWInfo
+from mpflash.versions import clean_version
 
 from .config import config
 
@@ -109,7 +109,7 @@ def filter_downloaded_fwlist(
     log.trace(f"Filtering firmware for {version} : {len(fw_list)} found.")
     # filter by port
     if port:
-        fw_list = [fw for fw in fw_list if fw.port == port]
+        fw_list = [fw for fw in fw_list if fw.port == port and Path(fw.firmware).suffix in PORT_FWTYPES[port]]
         log.trace(f"Filtering firmware for {port} : {len(fw_list)} found.")
 
     if board_id:
@@ -120,6 +120,7 @@ def filter_downloaded_fwlist(
             # the firmware variant should match exactly the board_id
             fw_list = [fw for fw in fw_list if fw.variant == board_id]
         log.trace(f"Filtering firmware for {board_id} : {len(fw_list)} found.")
+        
     if selector and port in selector:
         fw_list = [fw for fw in fw_list if fw.filename.endswith(selector[port])]
     return fw_list

mpflash/mpflash/{flash.py → flash/__init__.py}

@@ -5,9 +5,9 @@ from loguru import logger as log
 from mpflash.bootloader import enter_bootloader
 from mpflash.common import PORT_FWTYPES, BootloaderMethod
 
-from .flash_esp import flash_esp
-from .flash_stm32 import flash_stm32
-from .flash_uf2 import flash_uf2
+from .esp import flash_esp
+from .stm32 import flash_stm32
+from .uf2 import flash_uf2
 from .worklist import WorkList
 
 # #########################################################################################################
@@ -30,20 +30,23 @@ def flash_list(
             continue
         log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info.version}")
         updated = None
-        # try:
-        if mcu.port in UF2_PORTS and fw_file.suffix == ".uf2":
-            if not enter_bootloader(mcu, bootloader):
-                continue
-            updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
-        elif mcu.port in ["stm32"]:
-            if not enter_bootloader(mcu, bootloader):
-                continue
-            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}")
+        try:
+            if mcu.port in UF2_PORTS and fw_file.suffix == ".uf2":
+                if not enter_bootloader(mcu, bootloader):
+                    continue
+                updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
+            elif mcu.port in ["stm32"]:
+                if not enter_bootloader(mcu, bootloader):
+                    continue
+                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}")
+        except Exception as e:
+            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
+            log.exception(e)
 
         if updated:
             flashed.append(updated)

mpflash/mpflash/{flash_esp.py → flash/esp.py}

@@ -53,7 +53,7 @@ def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optio
         log.error(f"Failed to flash {mcu.board} on {mcu.serialport} : {e}")
         return None
 
-    log.info("Done flashing, resetting the board and wait for it to restart")
+    log.info("Done flashing, resetting the board...")
     mcu.wait_for_restart()
     log.success(f"Flashed {mcu.serialport} to {mcu.board} {mcu.version}")
     return mcu

mpflash/mpflash/flash/stm32.py

@@ -0,0 +1,19 @@
+"""Flash STM32 boards using pydfu"""
+
+from pathlib import Path
+
+from loguru import logger as log
+
+from mpflash.mpremoteboard import MPRemoteBoard
+
+# from .flash_stm32_cube import flash_stm32_cubecli
+from .stm32_dfu import dfu_init, flash_stm32_dfu
+
+
+def flash_stm32(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool):
+    # sourcery skip: lift-return-into-if
+    dfu_init()
+    if updated := flash_stm32_dfu(mcu, fw_file=fw_file, erase=erase):
+        mcu.wait_for_restart()
+        log.success(f"Flashed {mcu.version} to {mcu.board}")
+    return updated

mpflash/mpflash/{flash_stm32_dfu.py → flash/stm32_dfu.py}

@@ -26,7 +26,7 @@ def init_libusb_windows() -> bool:
 
 
 try:
-    from .vendor import pydfu as pydfu
+    from ..vendor import pydfu as pydfu
 except ImportError:
     pydfu = None
 
@@ -39,6 +39,7 @@ def dfu_init():
         log.error("pydfu not found")
         return None
     if platform.system() == "Windows":
+        log.debug("Initializing libusb backend on Windows...")
         init_libusb_windows()
 
 
@@ -59,6 +60,8 @@ def flash_stm32_dfu(
     Returns:
         Optional[MPRemoteBoard]: The flashed remote board if successful, None otherwise.
     """
+    log.info("Using pydfu to flash STM32 boards")
+
     if not pydfu:
         log.error("pydfu not found, please install it with 'pip install pydfu' if supported")
         return None

mpflash/mpflash/{flash_uf2.py → flash/uf2/__init__.py}

@@ -4,20 +4,21 @@ Flash SAMD and RP2 via UF2
 
 import shutil
 import sys
-import time
 from pathlib import Path
 from typing import Optional
 
+import tenacity
 from loguru import logger as log
-from rich.progress import track
+
+from tenacity import stop_after_attempt, wait_fixed
 
 from mpflash.mpremoteboard import MPRemoteBoard
 
-from .common import PORT_FWTYPES
-from .flash_uf2_boardid import get_board_id
-from .flash_uf2_linux import dismount_uf2_linux, wait_for_UF2_linux
-from .flash_uf2_macos import wait_for_UF2_macos
-from .flash_uf2_windows import wait_for_UF2_windows
+from mpflash.common import PORT_FWTYPES
+from .boardid import get_board_id
+from .linux import dismount_uf2_linux, wait_for_UF2_linux
+from .macos import wait_for_UF2_macos
+from .windows import wait_for_UF2_windows
 
 
 def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemoteBoard]:
@@ -37,18 +38,9 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
         log.error(f"UF2 not supported on {mcu.board} on {mcu.serialport}")
         return None
     if erase:
-        log.info("Erasing not yet implemented for UF2 flashing.")
+        log.warning("Erase not (yet) supported on .UF2, skipping erase.")
 
-    if sys.platform == "linux":
-        destination = wait_for_UF2_linux()
-    elif sys.platform == "win32":
-        destination = wait_for_UF2_windows()
-    elif sys.platform == "darwin":
-        log.warning(f"OS {sys.platform} not tested/supported")
-        destination = wait_for_UF2_macos()
-    else:
-        log.warning(f"OS {sys.platform} not tested/supported")
-        return None
+    destination = waitfor_uf2(board_id=mcu.port.upper())
 
     if not destination or not destination.exists() or not (destination / "INFO_UF2.TXT").exists():
         log.error("Board is not in bootloader mode")
@@ -57,11 +49,40 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     log.info("Board is in bootloader mode")
     board_id = get_board_id(destination)  # type: ignore
     log.info(f"Board ID: {board_id}")
-    log.info(f"Copying {fw_file} to {destination}.")
-    shutil.copy(fw_file, destination)
-    log.success("Done copying, resetting the board and wait for it to restart")
+    try:
+        copy_firmware_to_uf2(fw_file, destination)
+        log.success("Done copying, resetting the board.")
+    except tenacity.RetryError:
+        log.error("Failed to copy the firmware file to the board.")
+        return None
+
     if sys.platform in ["linux"]:
         dismount_uf2_linux()
-    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
+
+    mcu.wait_for_restart()
     return mcu
+
+
+def waitfor_uf2(board_id: str):
+    """
+    Wait for the UF2 drive to mount
+    """
+    if sys.platform == "linux":
+        return wait_for_UF2_linux(board_id=board_id)
+    elif sys.platform == "win32":
+        return wait_for_UF2_windows(board_id=board_id)
+    elif sys.platform == "darwin":
+        return wait_for_UF2_macos(board_id=board_id)
+    else:
+        log.warning(f"OS {sys.platform} not tested/supported")
+        return None
+
+
+@tenacity.retry(stop=stop_after_attempt(3), wait=wait_fixed(1), reraise=False)
+def copy_firmware_to_uf2(fw_file: Path, destination: Path):
+    """
+    Copy the firmware file to the destination,
+    Retry 3 times with 1s delay
+    """
+    log.info(f"Copying {fw_file} to {destination}.")
+    return shutil.copy(fw_file, destination)

mpflash/mpflash/{flash_uf2_linux.py → flash/uf2/linux.py}

@@ -12,7 +12,7 @@ from typing import List
 from loguru import logger as log
 from rich.progress import track
 
-from .flash_uf2_boardid import get_board_id
+from .boardid import get_board_id
 from .uf2disk import UF2Disk
 
 glb_dismount_me: List[UF2Disk] = []
@@ -70,7 +70,7 @@ def pmount(disk: UF2Disk):
         log.debug(f"Mounted {disk.label} at {disk.mountpoint}")
         glb_dismount_me.append(disk)
     else:
-        log.debug(f"\n{disk.label} already mounted at {disk.mountpoint}")
+        log.trace(f"\n{disk.label} already mounted at {disk.mountpoint}")
 
 
 def pumount(disk: UF2Disk):
@@ -95,24 +95,31 @@ def dismount_uf2_linux():
     glb_dismount_me = []
 
 
-def wait_for_UF2_linux(s_max: int = 10):
+def wait_for_UF2_linux(board_id: str, s_max: int = 10):
     destination = ""
     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, refresh_per_second=2
+        range(s_max),
+        description=f"Waiting for mcu to mount as a drive ({s_max}s)",
+        transient=True,
+        show_speed=False,
+        refresh_per_second=1,
+        total=s_max,
     ):
-        # 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():
             pmount(drive)
             time.sleep(1)
             try:
                 if Path(drive.mountpoint, "INFO_UF2.TXT").exists():
-                    board_id = get_board_id(Path(drive.mountpoint))  # type: ignore
-                    destination = Path(drive.mountpoint)
-                    break
+                    this_board_id = get_board_id(Path(drive.mountpoint))
+                    if not board_id or board_id.upper() in this_board_id.upper():
+                        # is it the correct board?
+                        destination = Path(drive.mountpoint)
+                        break
+                    continue
             except PermissionError:
                 log.debug(f"Permission error on {drive.mountpoint}")
                 continue

mpflash/mpflash/{flash_uf2_macos.py → flash/uf2/macos.py}

@@ -9,23 +9,31 @@ from typing import Optional
 
 from rich.progress import track
 
+from .boardid import get_board_id
 
 
-def wait_for_UF2_macos(s_max: int = 10) -> Optional[Path]:
+def wait_for_UF2_macos(board_id: str, s_max: int = 10) -> Optional[Path]:
     """Wait for the MCU to mount as a drive"""
     if s_max < 1:
         s_max = 10
     destination = None
     for _ in track(
-        range(s_max), description="Waiting for mcu to mount as a drive", transient=True, refresh_per_second=2
+        range(s_max),
+        description=f"Waiting for mcu to mount as a drive ({s_max}s)",
+        transient=True,
+        show_speed=False,
+        refresh_per_second=1,
+        total=s_max,
     ):
-        # log.info(f"Waiting for mcu to mount as a drive : {n} seconds left")
         vol_mounts = Path("/Volumes").iterdir()
         for vol in vol_mounts:
             try:
                 if Path(vol, "INFO_UF2.TXT").exists():
-                    destination = Path(vol)
-                    break
+                    this_board_id = get_board_id(Path(vol))
+                    if not board_id or board_id.upper() in this_board_id.upper():
+                        destination = Path(vol)
+                        break
+                    continue
             except OSError:
                 pass
         if destination:

mpflash/mpflash/{flash_uf2_windows.py → flash/uf2/windows.py}

@@ -7,25 +7,34 @@ import time
 from pathlib import Path
 from typing import Optional
 
+from .boardid import get_board_id
 import psutil
 from rich.progress import track
 
 
-
-
-def wait_for_UF2_windows(s_max: int = 10) -> Optional[Path]:
+def wait_for_UF2_windows(board_id: str, s_max: int = 10)-> Optional[Path]:
     """Wait for the MCU to mount as a drive"""
     if s_max < 1:
         s_max = 10
     destination = None
-    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")
+    for _ in track(
+        range(s_max),
+        description=f"Waiting for mcu to mount as a drive ({s_max}s)",
+        transient=True,
+        show_speed=False,
+        refresh_per_second=1,
+        total=s_max,
+    ):
         drives = [drive.device for drive in psutil.disk_partitions()]
         for drive in drives:
             try:
                 if Path(drive, "INFO_UF2.TXT").exists():
-                    destination = Path(drive)
-                    break
+                    this_board_id = get_board_id(Path(drive))
+                    if not board_id or board_id.upper() in this_board_id.upper():
+                        # is it the correct board?
+                        destination = Path(drive)
+                        break
+                    continue
             except OSError:
                 pass
         if destination:

mpflash/mpflash/{worklist.py → flash/worklist.py}

@@ -1,15 +1,16 @@
+"""Worklist for updating boards"""
+
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 from loguru import logger as log
 
 from mpflash.common import FWInfo, filtered_comports
+from mpflash.downloaded import find_downloaded_firmware
 from mpflash.errors import MPFlashError
-
-from .downloaded import find_downloaded_firmware
-from .list import show_mcus
-from .mpboard_id import find_known_board
-from .mpremoteboard import MPRemoteBoard
+from mpflash.list import show_mcus
+from mpflash.mpboard_id import find_known_board
+from mpflash.mpremoteboard import MPRemoteBoard
 
 # #########################################################################################################
 WorkList = List[Tuple[MPRemoteBoard, FWInfo]]
@@ -39,9 +40,7 @@ def auto_update(
     wl: WorkList = []
     for mcu in conn_boards:
         if mcu.family not in ("micropython", "unknown"):
-            log.warning(
-                f"Skipping flashing {mcu.family} {mcu.port} {mcu.board} on {mcu.serialport} as it is not a MicroPython firmware"
-            )
+            log.warning(f"Skipping flashing {mcu.family} {mcu.port} {mcu.board} on {mcu.serialport} as it is not a MicroPython firmware")
             continue
         board_firmwares = find_downloaded_firmware(
             fw_folder=fw_folder,
@@ -54,8 +53,9 @@ def auto_update(
         if not board_firmwares:
             log.error(f"No {target_version} firmware found for {mcu.board} on {mcu.serialport}.")
             continue
+
         if len(board_firmwares) > 1:
-            log.debug(f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}.")
+            log.warning(f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}.")
 
         # just use the last firmware
         fw_info = board_firmwares[-1]

mpflash/mpflash/list.py

@@ -3,8 +3,9 @@ from typing import List
 from rich.progress import track
 from rich.table import Table
 
+from mpflash.config import config
 from mpflash.mpremoteboard import MPRemoteBoard
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .logger import console
 
@@ -64,8 +65,15 @@ def mcu_table(
     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, refresh_per_second=2):
+    if config.usb:
+        table.add_column("Location", overflow="fold", max_width=40)
+    for mcu in track(
+        conn_mcus,
+        description="Updating board info",
+        transient=True,
+        show_speed=False,
+        refresh_per_second=1,
+    ):
         if refresh:
             try:
                 mcu.get_mcu_info()
@@ -84,6 +92,8 @@ def mcu_table(
         row.append(clean_version(mcu.version))
         if needs_build:
             row.append(mcu.build)
+        if config.usb:
+            row.append(mcu.location)
 
         table.add_row(*row)
     return table

mpflash/mpflash/mpboard_id/__init__.py

@@ -10,7 +10,7 @@ from typing import List, Optional, Tuple
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id.board import Board
 from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 # KNOWN ports and boards are sourced from the micropython repo,
 # this info is stored in the board_info.json file