micropython-stubber 1.20.1__py3-none-any.whl → 1.20.2__py3-none-any.whl

mpflash/mpflash/download.py

@@ -18,9 +18,11 @@ from bs4 import BeautifulSoup
 from loguru import logger as log
 from rich.progress import track
 
-from mpflash.common import PORT_FWTYPES
+from mpflash.common import PORT_FWTYPES, FWInfo
 from mpflash.errors import MPFlashError
+from mpflash.mpboard_id import get_known_ports
 
+# avoid conflict with the ujson used by MicroPython
 jsonlines.ujson = None  # type: ignore
 # #########################################################################################################
 
@@ -50,6 +52,10 @@ def get_board_urls(page_url: str) -> List[Dict[str, str]]:
 
     Args:
         page_url (str): The url of the page to get the board urls from.
+
+    Returns:
+        List[Dict[str, str]]: A list of dictionaries containing the board name and url.
+
     """
     downloads_html = get_page(page_url)
     soup = BeautifulSoup(downloads_html, "html.parser")
@@ -88,14 +94,10 @@ def board_firmware_urls(board_url: str, base_url: str, ext: str) -> List[str]:
     return links
 
 
-# type alias for the firmware info
-FirmwareInfo = Dict[str, str]
-
-
 # boards we are interested in ( this avoids getting a lot of boards we don't care about)
 # The first run takes ~60 seconds to run for 4 ports , all boards
 # so it makes sense to cache the results and skip boards as soon as possible
-def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[FirmwareInfo]:
+def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[FWInfo]:
     """
     Retrieves a list of firmware information for the specified ports and boards.
 
@@ -105,57 +107,68 @@ def get_boards(ports: List[str], boards: List[str], clean: bool) -> List[Firmwar
         clean (bool): A flag indicating whether to perform a clean retrieval.
 
     Returns:
-        List[FirmwareInfo]: A list of firmware information for the specified ports and boards.
+        List[FWInfo]: A list of firmware information for the specified ports and boards.
 
     """
-    board_urls: List[FirmwareInfo] = []
+    board_urls: List[FWInfo] = []
+    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)
+        urls = get_board_urls(download_page_url)
         # filter out boards we don't care about
-        _urls = [board for board in _urls if board["board"] in boards]
+        urls = [board for board in urls if board["board"] in boards]
         # add the port to the board urls
-        for board in _urls:
+        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 = []
+            firmware_urls: List[str] = []
             for ext in PORT_FWTYPES[port]:
-                firmwares += board_firmware_urls(board["url"], MICROPYTHON_ORG_URL, ext)
-
-            for _url in firmwares:
+                firmware_urls += board_firmware_urls(board["url"], MICROPYTHON_ORG_URL, ext)
+            for _url in firmware_urls:
                 board["firmware"] = _url
-                board["preview"] = "preview" in _url  # type: ignore
-                if ver_match := re.search(RE_VERSION_PREVIEW, _url):
-                    board["version"] = ver_match[1]
-                else:
-                    board["version"] = ""
-                if "preview." in board["version"]:
-                    board["build"] = board["version"].split("preview.")[-1]
-                else:
-                    board["build"] = "0"
                 fname = Path(board["firmware"]).name
                 if clean:
                     # remove date from firmware name
                     fname = re.sub(RE_DATE, "-", fname)
                     # remove hash from firmware name
                     fname = re.sub(RE_HASH, ".", fname)
-                board["filename"] = fname
-                board["ext"] = Path(board["firmware"]).suffix
-                board["variant"] = board["filename"].split("-v")[0] if "-v" in board["filename"] else ""
-                board_urls.append(board.copy())
+                fw_info = FWInfo(
+                    filename=fname,
+                    port=port,
+                    board=board["board"],
+                    preview="preview" in _url,
+                    firmware=_url,
+                    version="",
+                )
+                # board["firmware"] = _url
+                # board["preview"] = "preview" in _url  # type: ignore
+                if ver_match := re.search(RE_VERSION_PREVIEW, _url):
+                    fw_info.version = ver_match[1]
+                # else:
+                #     board.$1= ""
+                if "preview." in fw_info.version:
+                    fw_info.build = fw_info.version.split("preview.")[-1]
+                else:
+                    fw_info.build = "0"
+
+                fw_info.ext = Path(fw_info.firmware).suffix
+                fw_info.variant = fw_info.filename.split("-v")[0] if "-v" in fw_info.filename else ""
+
+                board_urls.append(fw_info)
     return board_urls
 
 
-def key_fw_ver_pre_ext_bld(x: FirmwareInfo):
+def key_fw_ver_pre_ext_bld(x: FWInfo):
     "sorting key for the retrieved board urls"
-    return x["variant"], x["version"], x["preview"], x["ext"], x["build"]
+    return x.variant, x.version, x.preview, x.ext, x.build
 
 
-def key_fw_var_pre_ext(x: FirmwareInfo):
+def key_fw_var_pre_ext(x: FWInfo):
     "Grouping key for the retrieved board urls"
-    return x["variant"], x["preview"], x["ext"]
+    return x.variant, x.preview, x.ext
 
 
 def download_firmwares(
@@ -170,10 +183,11 @@ 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:
-        log.debug(b["filename"])
+        log.debug(b.filename)
     # relevant
 
     log.info(f"Found {len(unique_boards)} relevant unique firmwares")
@@ -182,23 +196,23 @@ def download_firmwares(
 
     with jsonlines.open(firmware_folder / "firmware.jsonl", "a") as writer:
         for board in unique_boards:
-            filename = firmware_folder / board["port"] / board["filename"]
+            filename = firmware_folder / board.port / board.filename
             filename.parent.mkdir(exist_ok=True)
             if filename.exists() and not force:
                 skipped += 1
                 log.debug(f" {filename} already exists, skip download")
                 continue
-            log.info(f"Downloading {board['firmware']}")
+            log.info(f"Downloading {board.firmware}")
             log.info(f"         to {filename}")
             try:
-                r = requests.get(board["firmware"], allow_redirects=True)
+                r = requests.get(board.firmware, allow_redirects=True)
                 with open(filename, "wb") as fw:
                     fw.write(r.content)
-                board["filename"] = str(filename.relative_to(firmware_folder))
+                board.filename = str(filename.relative_to(firmware_folder))
             except requests.RequestException as e:
                 log.exception(e)
                 continue
-            writer.write(board)
+            writer.write(board.to_dict())
             downloaded += 1
     log.info(f"Downloaded {downloaded} firmwares, skipped {skipped} existing files.")
     return downloaded + skipped
@@ -215,7 +229,7 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
         clean : A flag indicating whether to perform a clean check.
 
     Returns:
-        List[FirmwareInfo]: A list of unique firmware information.
+        List[FWInfo]: A list of unique firmware information.
 
     """
 
@@ -227,12 +241,12 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
     relevant = [
         board
         for board in board_urls
-        if board["board"] in boards and (board["version"] in versions or board["preview"] and preview)
+        if board.board in boards and (board.version in versions or board.preview and preview)
         # and b["port"] in ["esp32", "rp2"]
     ]
     log.debug(f"Matching firmwares: {len(relevant)}")
     # select the unique boards
-    unique_boards: List[FirmwareInfo] = []
+    unique_boards: List[FWInfo] = []
     for _, g in itertools.groupby(relevant, key=key_fw_var_pre_ext):
         # list is aleady sorted by build so we can just get the last item
         sub_list = list(g)

mpflash/mpflash/downloaded.py

@@ -16,11 +16,11 @@ def downloaded_firmwares(fw_folder: Path) -> List[FWInfo]:
     firmwares: List[FWInfo] = []
     try:
         with jsonlines.open(fw_folder / "firmware.jsonl") as reader:
-            firmwares.extend(iter(reader))
+            firmwares = [FWInfo.from_dict(item) for item in reader]
     except FileNotFoundError:
         log.error(f"No firmware.jsonl found in {fw_folder}")
     # sort by filename
-    firmwares.sort(key=lambda x: x["filename"])
+    firmwares.sort(key=lambda x: x.filename)
     return firmwares
 
 
@@ -68,7 +68,7 @@ def find_downloaded_firmware(
         )
         # hope we have a match now for the board
     # sort by filename
-    fw_list.sort(key=lambda x: x["filename"])
+    fw_list.sort(key=lambda x: x.filename)
     return fw_list
 
 
@@ -84,23 +84,23 @@ def filter_downloaded_fwlist(
     """Filter the downloaded firmware list based on the provided parameters"""
     if "preview" in version:
         # never get a preview for an older version
-        fw_list = [fw for fw in fw_list if fw["preview"]]
+        fw_list = [fw for fw in fw_list if fw.preview]
     else:
-        fw_list = [fw for fw in fw_list if fw["version"] == version]
+        fw_list = [fw for fw in fw_list if fw.version == version]
 
     # 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]
 
     if board_id:
         if variants:
             # any variant of this board_id
-            fw_list = [fw for fw in fw_list if fw["board"] == board_id]
+            fw_list = [fw for fw in fw_list if fw.board == board_id]
         else:
             # the firmware variant should match exactly the board_id
-            fw_list = [fw for fw in fw_list if fw["variant"] == board_id]
+            fw_list = [fw for fw in fw_list if fw.variant == board_id]
     if selector and port in selector:
-        fw_list = [fw for fw in fw_list if fw["filename"].endswith(selector[port])]
+        fw_list = [fw for fw in fw_list if fw.filename.endswith(selector[port])]
     return fw_list
 
 

mpflash/mpflash/flash.py

@@ -23,11 +23,11 @@ def flash_list(
     """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
+        fw_file = fw_folder / fw_info.filename
         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']}")
+        log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info.version}")
         updated = None
         # try:
         if mcu.port in [port for port, exts in PORT_FWTYPES.items() if ".uf2" in exts] and fw_file.suffix == ".uf2":

mpflash/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/mpflash/flash_uf2.py

@@ -14,7 +14,9 @@ from rich.progress import track
 from mpflash.mpremoteboard import MPRemoteBoard
 
 from .common import PORT_FWTYPES
-from .flash_uf2_linux import dismount_uf2, wait_for_UF2_linux
+from .config import config
+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
 
 
@@ -27,9 +29,9 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     - copy the firmware file to the drive
     - wait for the device to restart (5s)
 
-    for Lunix :
-    pmount and pumount are used to mount and unmount the drive
-    as this is not done automatically by the OS in headless mode.
+    for Linux - to support headless operation ( GH Actions ) :
+        pmount and pumount are used to mount and unmount the drive
+        as this is not done automatically by the OS in headless mode.
     """
     if ".uf2" not in PORT_FWTYPES[mcu.port]:
         log.error(f"UF2 not supported on {mcu.board} on {mcu.serialport}")
@@ -41,9 +43,15 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
         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")
+        # TODO: test which of the options is best
+        if "macos_uf2" in config.tests:
+            destination = wait_for_UF2_macos()
+        else:
+            destination = wait_for_UF2_linux()
     else:
         log.warning(f"OS {sys.platform} not tested/supported")
-        destination = wait_for_UF2_linux()
         return None
 
     if not destination or not destination.exists() or not (destination / "INFO_UF2.TXT").exists():
@@ -54,8 +62,8 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
     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")
-    if sys.platform in ["linux", "darwin"]:
-        dismount_uf2()
-    for _ in track(range(5 + 2), description="Waiting for the board to restart", transient=True):
+    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
     return mcu

mpflash/mpflash/flash_uf2_linux.py

@@ -13,28 +13,15 @@ from loguru import logger as log
 from rich.progress import track
 
 from .flash_uf2_boardid import get_board_id
+from .uf2disk import UF2Disk
 
 glb_dismount_me: List[UF2Disk] = []
 
 
-class UF2Disk:
-    """Info to support mounting and unmounting of UF2 drives on linux"""
-
-    device_path: str
-    label: str
-    mountpoint: str
-
-    def __repr__(self):
-        return repr(self.__dict__)
-
-
 def get_uf2_drives():
     """
     Get a list of all the (un)mounted UF2 drives
     """
-    if sys.platform != "linux":
-        log.error("pumount only works on Linux")
-        return
     # import blkinfo only on linux
     from blkinfo import BlkDiskInfo
 
@@ -101,7 +88,7 @@ def pumount(disk: UF2Disk):
         log.warning(f"{disk.label} already dismounted")
 
 
-def dismount_uf2():
+def dismount_uf2_linux():
     global glb_dismount_me
     for disk in glb_dismount_me:
         pumount(disk)
@@ -113,7 +100,9 @@ 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/mpflash/flash_uf2_macos.py

@@ -0,0 +1,78 @@
+""" Flashing UF2 based MCU on macos"""
+
+# sourcery skip: snake-case-functions
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+from loguru import logger as log
+from rich.progress import track
+
+from .flash_uf2_boardid import get_board_id
+from .uf2disk import UF2Disk
+
+
+def get_uf2_drives():
+    """
+    Get a list of all the (un)mounted UF2 drives
+    """
+    if sys.platform != "linux":
+        log.error("pumount only works on Linux")
+        return
+    # import blkinfo only on linux
+    from blkinfo import BlkDiskInfo
+
+    myblkd = BlkDiskInfo()
+    filters = {
+        "tran": "usb",
+    }
+    usb_disks = myblkd.get_disks(filters)
+    for disk in usb_disks:
+        if disk["fstype"] == "vfat":
+            uf2_part = disk
+            # unpartioned usb disk or partition (e.g. /dev/sdb )
+            # SEEED WIO Terminal is unpartioned
+            # print( json.dumps(uf2_part, indent=4))
+            uf2 = UF2Disk()
+            uf2.device_path = "/dev/" + uf2_part["name"]
+            uf2.label = uf2_part["label"]
+            uf2.mountpoint = uf2_part["mountpoint"]
+            yield uf2
+        elif disk["type"] == "disk" and disk.get("children") and len(disk.get("children")) > 0:
+            if disk.get("children")[0]["type"] == "part" and disk.get("children")[0]["fstype"] == "vfat":
+                uf2_part = disk.get("children")[0]
+                # print( json.dumps(uf2_part, indent=4))
+                uf2 = UF2Disk()
+                uf2.device_path = "/dev/" + uf2_part["name"]
+                uf2.label = uf2_part["label"]
+                uf2.mountpoint = uf2_part["mountpoint"]
+                yield uf2
+
+
+def wait_for_UF2_macos(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
+    ):
+        # 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():
+            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
+            except PermissionError:
+                log.debug(f"Permission error on {drive.mountpoint}")
+                continue
+        if destination:
+            break
+        time.sleep(1)
+        wait -= 1
+    return destination

mpflash/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/mpflash/list.py

@@ -1,89 +1,89 @@
 from typing import List
 
-from rich import print
-from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, track
-from rich.table import Column, Table
+from rich.progress import track
+from rich.table import Table
 
 from mpflash.mpremoteboard import MPRemoteBoard
 from mpflash.vendor.versions import clean_version
 
-from .config import config
 from .logger import console
 
-rp_spinner = SpinnerColumn(finished_text="✅")
-rp_text = TextColumn("{task.description} {task.fields[device]}", table_column=Column())
-rp_bar = BarColumn(bar_width=None, table_column=Column())
 
+def show_mcus(
+    conn_mcus: List[MPRemoteBoard],
+    title: str = "Connected boards",
+    refresh: bool = True,
+):
+    console.print(mcu_table(conn_mcus, title, refresh))
 
-def list_mcus(bluetooth: bool = False):
-    """
-    Retrieves information about connected microcontroller boards.
-
-    Returns:
-        List[MPRemoteBoard]: A list of MPRemoteBoard instances with board information.
-    Raises:
-        ConnectionError: If there is an error connecting to a board.
-    """
-    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:
-        tsk_scan = progress.add_task("[green]Scanning", visible=False, total=None)
-        progress.tasks[tsk_scan].fields["device"] = "..."
-        progress.tasks[tsk_scan].visible = True
-        progress.start_task(tsk_scan)
-        try:
-            for mcu in conn_mcus:
-                progress.update(tsk_scan, device=mcu.serialport.replace("/dev/", ""))
-                try:
-                    mcu.get_mcu_info()
-                except ConnectionError as e:
-                    print(f"Error: {e}")
-                    continue
-        finally:
-            # transient
-            progress.stop_task(tsk_scan)
-            progress.tasks[tsk_scan].visible = False
-    return conn_mcus
+def abbrv_family(family: str, is_wide: bool) -> str:
+    if not is_wide:
+        ABRV = {"micropython": "upy", "circuitpython": "cpy", "unknown": "?"}
+        return ABRV.get(family, family[:4])
+    return family
 
 
-def show_mcus(
+def mcu_table(
     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"""
+):
+    """
+    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