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

mpflash/libusb_flash.ipynb

@@ -1,203 +1,203 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<DEVICE ID 0a05:7211 on Bus 002 Address 054>,\n",
-       " <DEVICE ID 0a05:7211 on Bus 002 Address 032>,\n",
-       " <DEVICE ID 045e:0c1e on Bus 002 Address 002>,\n",
-       " <DEVICE ID 045e:07b2 on Bus 002 Address 028>,\n",
-       " <DEVICE ID 045e:0904 on Bus 002 Address 015>,\n",
-       " <DEVICE ID 043e:9a39 on Bus 002 Address 057>,\n",
-       " <DEVICE ID 045e:0901 on Bus 002 Address 006>,\n",
-       " <DEVICE ID 05e3:0610 on Bus 002 Address 010>,\n",
-       " <DEVICE ID 2109:0817 on Bus 001 Address 001>,\n",
-       " <DEVICE ID 045e:0902 on Bus 002 Address 008>,\n",
-       " <DEVICE ID 1000:2000 on Bus 002 Address 016>,\n",
-       " <DEVICE ID 1189:8890 on Bus 002 Address 027>,\n",
-       " <DEVICE ID 2109:0817 on Bus 001 Address 002>,\n",
-       " <DEVICE ID 2109:2812 on Bus 002 Address 025>,\n",
-       " <DEVICE ID 046d:085e on Bus 002 Address 017>,\n",
-       " <DEVICE ID 045e:07c6 on Bus 002 Address 056>,\n",
-       " <DEVICE ID 0bda:5401 on Bus 002 Address 009>,\n",
-       " <DEVICE ID 10c4:ea60 on Bus 002 Address 055>,\n",
-       " <DEVICE ID 2109:2817 on Bus 002 Address 004>,\n",
-       " <DEVICE ID 0bda:5411 on Bus 002 Address 005>,\n",
-       " <DEVICE ID 045e:0900 on Bus 002 Address 003>,\n",
-       " <DEVICE ID 04e8:61f5 on Bus 002 Address 023>,\n",
-       " <DEVICE ID 045e:0903 on Bus 002 Address 020>,\n",
-       " <DEVICE ID 2109:2812 on Bus 002 Address 026>,\n",
-       " <DEVICE ID 8086:a0ed on Bus 002 Address 000>,\n",
-       " <DEVICE ID 2109:2817 on Bus 002 Address 013>,\n",
-       " <DEVICE ID 8087:0029 on Bus 002 Address 001>,\n",
-       " <DEVICE ID 8086:9a13 on Bus 001 Address 000>]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import usb.core\n",
-    "import usb.util\n",
-    "import usb.backend.libusb1 as libusb1\n",
-    "from usb.core import USBError, Device\n",
-    "\n",
-    "from pathlib import Path\n",
-    "import platform\n",
-    "\n",
-    "if platform.system() == \"Windows\":\n",
-    "    # on windows you need to use the libusb1 backend\n",
-    "    import libusb\n",
-    "\n",
-    "    arch = \"x64\" if platform.architecture()[0] == \"64bit\" else \"x86\"\n",
-    "    libusb1_dll = Path(libusb.__file__).parent / f\"_platform\\\\_windows\\\\{arch}\\\\libusb-1.0.dll\"\n",
-    "\n",
-    "    backend = libusb1.get_backend(find_library=lambda x: libusb1_dll.as_posix())\n",
-    "usb_devices = usb.core.find(backend=backend, find_all=True)\n",
-    "\n",
-    "list(usb_devices)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for d in usb.core.find(backend=backend, find_all=True):\n",
-    "    print(f\"Device {d.idVendor:04x}:{d.idProduct:04x}\")\n",
-    "    print(f\"{d.iManufacturer=}\")\n",
-    "    print(f\"{d.iProduct=}\")\n",
-    "    print(f\"{d.bDeviceClass=}\")\n",
-    "    print(f\"{d.bDescriptorType=}\")\n",
-    "    print(f\"{d.bcdDevice=}\")\n",
-    "    print(f\"{d.bcdUSB=}\")\n",
-    "    # print(dir(d))\n",
-    "    # print(f\"  Manufacturer: {usb.util.get_string(dev, dev.iManufacturer)}\")\n",
-    "\n",
-    "    print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import serial.tools.list_ports\n",
-    "\n",
-    "ports = serial.tools.list_ports.comports()\n",
-    "\n",
-    "for port in ports:\n",
-    "    print(f\"Port: {port.device}\")\n",
-    "    print(f\"Description: {port.description}\")\n",
-    "    print(f\"Hardware ID: {port.hwid}\")\n",
-    "    print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from mpflash.vendor import pydfu as pydfu\n",
-    "\n",
-    "try:\n",
-    "    pydfu.list_dfu_devices()\n",
-    "except SystemExit:\n",
-    "    print(\"No DFU devices found\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pydfu.init()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dfu_file = Path(\"C:\\\\Users\\\\josverl\\\\Downloads\\\\firmware\\\\stm32\\\\PYBV11-THREAD-v1.23.0-preview.203.dfu\")\n",
-    "\n",
-    "print(\"Read DFU file...\")\n",
-    "elements = pydfu.read_dfu_file(dfu_file)\n",
-    "if not elements:\n",
-    "    print(\"No data in dfu file\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Writing memory...\n"
-     ]
-    },
-    {
-     "ename": "NameError",
-     "evalue": "name 'pydfu' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWriting memory...\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m----> 2\u001b[0m \u001b[43mpydfu\u001b[49m\u001b[38;5;241m.\u001b[39mwrite_elements(elements, \u001b[38;5;28;01mFalse\u001b[39;00m, progress\u001b[38;5;241m=\u001b[39mpydfu\u001b[38;5;241m.\u001b[39mcli_progress)\n",
-      "\u001b[1;31mNameError\u001b[0m: name 'pydfu' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Writing memory...\")\n",
-    "pydfu.write_elements(elements, False, progress=pydfu.cli_progress)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"Exiting DFU...\")\n",
-    "pydfu.exit_dfu()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<DEVICE ID 0a05:7211 on Bus 002 Address 054>,\n",
+       " <DEVICE ID 0a05:7211 on Bus 002 Address 032>,\n",
+       " <DEVICE ID 045e:0c1e on Bus 002 Address 002>,\n",
+       " <DEVICE ID 045e:07b2 on Bus 002 Address 028>,\n",
+       " <DEVICE ID 045e:0904 on Bus 002 Address 015>,\n",
+       " <DEVICE ID 043e:9a39 on Bus 002 Address 057>,\n",
+       " <DEVICE ID 045e:0901 on Bus 002 Address 006>,\n",
+       " <DEVICE ID 05e3:0610 on Bus 002 Address 010>,\n",
+       " <DEVICE ID 2109:0817 on Bus 001 Address 001>,\n",
+       " <DEVICE ID 045e:0902 on Bus 002 Address 008>,\n",
+       " <DEVICE ID 1000:2000 on Bus 002 Address 016>,\n",
+       " <DEVICE ID 1189:8890 on Bus 002 Address 027>,\n",
+       " <DEVICE ID 2109:0817 on Bus 001 Address 002>,\n",
+       " <DEVICE ID 2109:2812 on Bus 002 Address 025>,\n",
+       " <DEVICE ID 046d:085e on Bus 002 Address 017>,\n",
+       " <DEVICE ID 045e:07c6 on Bus 002 Address 056>,\n",
+       " <DEVICE ID 0bda:5401 on Bus 002 Address 009>,\n",
+       " <DEVICE ID 10c4:ea60 on Bus 002 Address 055>,\n",
+       " <DEVICE ID 2109:2817 on Bus 002 Address 004>,\n",
+       " <DEVICE ID 0bda:5411 on Bus 002 Address 005>,\n",
+       " <DEVICE ID 045e:0900 on Bus 002 Address 003>,\n",
+       " <DEVICE ID 04e8:61f5 on Bus 002 Address 023>,\n",
+       " <DEVICE ID 045e:0903 on Bus 002 Address 020>,\n",
+       " <DEVICE ID 2109:2812 on Bus 002 Address 026>,\n",
+       " <DEVICE ID 8086:a0ed on Bus 002 Address 000>,\n",
+       " <DEVICE ID 2109:2817 on Bus 002 Address 013>,\n",
+       " <DEVICE ID 8087:0029 on Bus 002 Address 001>,\n",
+       " <DEVICE ID 8086:9a13 on Bus 001 Address 000>]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import usb.core\n",
+    "import usb.util\n",
+    "import usb.backend.libusb1 as libusb1\n",
+    "from usb.core import USBError, Device\n",
+    "\n",
+    "from pathlib import Path\n",
+    "import platform\n",
+    "\n",
+    "if platform.system() == \"Windows\":\n",
+    "    # on windows you need to use the libusb1 backend\n",
+    "    import libusb\n",
+    "\n",
+    "    arch = \"x64\" if platform.architecture()[0] == \"64bit\" else \"x86\"\n",
+    "    libusb1_dll = Path(libusb.__file__).parent / f\"_platform\\\\_windows\\\\{arch}\\\\libusb-1.0.dll\"\n",
+    "\n",
+    "    backend = libusb1.get_backend(find_library=lambda x: libusb1_dll.as_posix())\n",
+    "usb_devices = usb.core.find(backend=backend, find_all=True)\n",
+    "\n",
+    "list(usb_devices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for d in usb.core.find(backend=backend, find_all=True):\n",
+    "    print(f\"Device {d.idVendor:04x}:{d.idProduct:04x}\")\n",
+    "    print(f\"{d.iManufacturer=}\")\n",
+    "    print(f\"{d.iProduct=}\")\n",
+    "    print(f\"{d.bDeviceClass=}\")\n",
+    "    print(f\"{d.bDescriptorType=}\")\n",
+    "    print(f\"{d.bcdDevice=}\")\n",
+    "    print(f\"{d.bcdUSB=}\")\n",
+    "    # print(dir(d))\n",
+    "    # print(f\"  Manufacturer: {usb.util.get_string(dev, dev.iManufacturer)}\")\n",
+    "\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import serial.tools.list_ports\n",
+    "\n",
+    "ports = serial.tools.list_ports.comports()\n",
+    "\n",
+    "for port in ports:\n",
+    "    print(f\"Port: {port.device}\")\n",
+    "    print(f\"Description: {port.description}\")\n",
+    "    print(f\"Hardware ID: {port.hwid}\")\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mpflash.vendor import pydfu as pydfu\n",
+    "\n",
+    "try:\n",
+    "    pydfu.list_dfu_devices()\n",
+    "except SystemExit:\n",
+    "    print(\"No DFU devices found\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pydfu.init()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dfu_file = Path(\"C:\\\\Users\\\\josverl\\\\Downloads\\\\firmware\\\\stm32\\\\PYBV11-THREAD-v1.23.0-preview.203.dfu\")\n",
+    "\n",
+    "print(\"Read DFU file...\")\n",
+    "elements = pydfu.read_dfu_file(dfu_file)\n",
+    "if not elements:\n",
+    "    print(\"No data in dfu file\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing memory...\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'pydfu' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWriting memory...\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m----> 2\u001b[0m \u001b[43mpydfu\u001b[49m\u001b[38;5;241m.\u001b[39mwrite_elements(elements, \u001b[38;5;28;01mFalse\u001b[39;00m, progress\u001b[38;5;241m=\u001b[39mpydfu\u001b[38;5;241m.\u001b[39mcli_progress)\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'pydfu' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Writing memory...\")\n",
+    "pydfu.write_elements(elements, False, progress=pydfu.cli_progress)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Exiting DFU...\")\n",
+    "pydfu.exit_dfu()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

mpflash/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 known_stored_boards, local_mp_ports
+from mpflash.mpboard_id import get_stored_boards_for_port, known_stored_boards, local_mp_ports
 from mpflash.mpremoteboard import MPRemoteBoard
 from mpflash.vendor.versions import micropython_versions
 
@@ -131,7 +131,7 @@ def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
         # Get the values of the dictionary, which are the unique items from the original list
         some_boards = list(unique_dict.values())
     else:
-        some_boards = [("No boards found", "")]
+        some_boards = [(f"No {answers['port']} boards found for version(s) {_versions}", "")]
     return some_boards
 
 
@@ -186,12 +186,27 @@ def ask_versions(questions: list, *, action: str):
     """
     # import only when needed to reduce load time
     import inquirer
+    import inquirer.errors
 
     input_ux = inquirer.Checkbox if action == "download" else inquirer.List
     mp_versions: List[str] = micropython_versions()
     mp_versions = [v for v in mp_versions if "preview" not in v]
+
+    # 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.append("preview")
     mp_versions.reverse()  # newest first
+
+    def at_least_one_validation(answers, current) -> bool:
+        if not current:
+            raise inquirer.errors.ValidationError("", reason="Please select at least one version")
+        if isinstance(current, list):
+            if not any(current):
+                raise inquirer.errors.ValidationError("", reason="Please select at least one version")
+        return True
+
     questions.append(
         input_ux(
             # inquirer.List(
@@ -201,7 +216,7 @@ def ask_versions(questions: list, *, action: str):
             # 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
+            validate=at_least_one_validation,
         )
     )
 

mpflash/mpflash/cli_download.py

@@ -6,6 +6,7 @@ from typing import List, Tuple
 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
 
@@ -62,9 +63,7 @@ from .download import download
     show_default=True,
     help="""Force download of firmware even if it already exists.""",
 )
-def cli_download(
-    **kwargs,
-):
+def cli_download(**kwargs) -> int:
     params = DownloadParams(**kwargs)
     params.versions = list(params.versions)
     params.boards = list(params.boards)
@@ -77,18 +76,23 @@ def cli_download(
 
     params = ask_missing_params(params, action="download")
     if not params:  # Cancelled by user
-        exit(1)
+        return 2
     params.versions = [clean_version(v, drop_v=True) for v in params.versions]
     assert isinstance(params, DownloadParams)
 
-    download(
-        params.fw_folder,
-        params.ports,
-        params.boards,
-        params.versions,
-        params.force,
-        params.clean,
-    )
+    try:
+        download(
+            params.fw_folder,
+            params.ports,
+            params.boards,
+            params.versions,
+            params.force,
+            params.clean,
+        )
+        return 0
+    except MPFlashError as e:
+        log.error(f"{e}")
+        return 1
 
 
 def connected_ports_boards() -> Tuple[List[str], List[str]]:

mpflash/mpflash/cli_flash.py

@@ -28,7 +28,7 @@ from .worklist import MPRemoteBoard, WorkList, full_auto_worklist, manual_workli
     "--firmware",
     "-f",
     "fw_folder",
-    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
     default=config.firmware_folder,
     show_default=True,
     help="The folder to retrieve the firmware from.",
@@ -91,7 +91,7 @@ from .worklist import MPRemoteBoard, WorkList, full_auto_worklist, manual_workli
     show_default=True,
     help="""Enter micropython bootloader mode before flashing.""",
 )
-def cli_flash_board(**kwargs):
+def cli_flash_board(**kwargs) -> int:
     # version to versions, board to boards
     kwargs["versions"] = [kwargs.pop("version")] if kwargs["version"] != None else []
     if kwargs["board"] is None:
@@ -127,7 +127,7 @@ def cli_flash_board(**kwargs):
     # Ask for missing input if needed
     params = ask_missing_params(params, action="flash")
     if not params:  # Cancelled by user
-        exit(1)
+        return 2
     # TODO: Just in time Download of firmware
 
     assert isinstance(params, FlashParams)
@@ -168,3 +168,7 @@ def cli_flash_board(**kwargs):
     ):
         log.info(f"Flashed {len(flashed)} boards")
         show_mcus(flashed, title="Updated boards after flashing")
+        return 0
+    else:
+        log.error("No boards were flashed")
+        return 1

mpflash/mpflash/cli_list.py

@@ -26,7 +26,7 @@ from .logger import make_quiet
     show_default=True,
     help="""Show progress""",
 )
-def cli_list_mcus(as_json: bool, progress: bool = True):
+def cli_list_mcus(as_json: bool, progress: bool = True) -> int:
     """List the connected MCU boards, and output in a nice table or json."""
     if as_json:
         # avoid noise in json output
@@ -38,4 +38,4 @@ def cli_list_mcus(as_json: bool, progress: bool = True):
         progress = False
     if progress:
         show_mcus(conn_mcus, refresh=False)
-    return conn_mcus
+    return 0 if conn_mcus else 1

mpflash/mpflash/cli_main.py

@@ -2,13 +2,13 @@
 
 # import rich_click as click
 
+import click
+
 from .cli_download import cli_download
 from .cli_flash import cli_flash_board
 from .cli_group import cli
 from .cli_list import cli_list_mcus
 
-# from loguru import logger as log
-
 
 def mpflash():
     cli.add_command(cli_flash_board)
@@ -16,7 +16,8 @@ def mpflash():
     cli.add_command(cli_download)
     # cli(auto_envvar_prefix="MPFLASH")
     try:
-        exit(cli())
+        result = cli(standalone_mode=False)
+        exit(result)
     except AttributeError as e:
         print(f"Error: {e}")
         exit(-1)

mpflash/mpflash/download.py

@@ -19,6 +19,7 @@ from loguru import logger as log
 from rich.progress import track
 
 from mpflash.common import PORT_FWTYPES
+from mpflash.errors import MPFlashError
 
 jsonlines.ujson = None  # type: ignore
 # #########################################################################################################
@@ -165,7 +166,7 @@ def download_firmwares(
     *,
     force: bool = False,
     clean: bool = True,
-):
+) -> int:
     skipped = downloaded = 0
     if versions is None:
         versions = []
@@ -200,6 +201,7 @@ def download_firmwares(
             writer.write(board)
             downloaded += 1
     log.info(f"Downloaded {downloaded} firmwares, skipped {skipped} existing files.")
+    return downloaded + skipped
 
 
 def get_firmware_list(ports: List[str], boards: List[str], versions: List[str], clean: bool):
@@ -246,7 +248,7 @@ def download(
     versions: List[str],
     force: bool,
     clean: bool,
-):
+) -> int:
     """
     Downloads firmware files based on the specified destination, ports, boards, versions, force flag, and clean flag.
 
@@ -259,19 +261,20 @@ def download(
         clean : A flag indicating whether to perform a clean download.
 
     Returns:
-        None
+        int: The number of downloaded firmware files.
 
     Raises:
-        SystemExit: If no boards are found or specified.
+        MPFlashError : If no boards are found or specified.
 
     """
     if not boards:
         log.critical("No boards found, please connect a board or specify boards to download firmware for.")
-        exit(1)
+        raise MPFlashError("No boards found")
     # versions = [clean_version(v, drop_v=True) for v in versions]  # remove leading v from version
     try:
         destination.mkdir(exist_ok=True, parents=True)
     except (PermissionError, FileNotFoundError) as e:
-        log.critical(f"Could not create folder {destination}\n{e}")
-        exit(1)
-    download_firmwares(destination, ports, boards, versions, force=force, clean=clean)
+        log.critical(f"Could not create folder {destination}")
+        raise MPFlashError(f"Could not create folder {destination}") from e
+
+    return download_firmwares(destination, ports, boards, versions, force=force, clean=clean)

mpflash/mpflash/list.py

@@ -5,6 +5,7 @@ from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeEl
 from rich.table import Column, Table
 
 from mpflash.mpremoteboard import MPRemoteBoard
+from mpflash.vendor.versions import clean_version
 
 from .config import config
 from .logger import console
@@ -82,7 +83,7 @@ def show_mcus(
             f"{mcu.board}\n{description}".strip(),
             # mcu.variant,
             mcu.cpu,
-            mcu.version,
+            clean_version(mcu.version),
             mcu.build,
         )
     console.print(table)