mpflash 0.9.0__tar.gz → 0.9.1__tar.gz

{mpflash-0.9.0 → mpflash-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpflash
-Version: 0.9.0
+Version: 0.9.1
 Summary: Flash and download tool for MicroPython firmwares
 Home-page: https://github.com/Josverl/micropython-stubber/blob/main/src/mpflash/README.md
 License: MIT
@@ -20,6 +20,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: bincopy (>=20.0.0,<21.0.0)
 Requires-Dist: blkinfo (>=0.2.0,<0.3.0)
+Requires-Dist: cache-to-disk (>=2.0.0,<3.0.0)
 Requires-Dist: cachetools (>=5.3.0,<6.0.0)
 Requires-Dist: esptool (>=4.7.0,<5.0.0)
 Requires-Dist: inquirer (>=3.2.4,<4.0.0)
@@ -52,8 +53,8 @@ This tool was initially created to be used in a CI/CD pipeline to automate the p
 `mpflash` has been tested on:  
  - OS: Windows x64, Linux X64, but not (yet) macOS.
  - Micropython (hardware) ports: 
-    - `rp2`, using `.uf2`, using filecopy (macos not tested yet)
-    - `samd`, using ` .uf2`, using filecopy (macos not tested yet)
+    - `rp2`, using `.uf2`, using filecopy 
+    - `samd`, using ` .uf2`, using filecopy 
     - `esp32`, using `.bin`, using esptool,
     - `esp8266`, using `.bin`, using esptool
     - `stm32`, using ` .dfu`, using pydfu
@@ -66,7 +67,7 @@ Not yet implemented: `nrf`, `cc3200`, `mimxrt`
  3. Flash one or all connected MicroPython boards with a specific firmware or version.  
  
 ## Installation
-To install mpflash, you can use pip: `pip install mpflash`
+To install mpflash, you can use: `pipx install mpflash` or `pip install mpflash`
 
 ## Basic usage
 You can use mpflash to perform various operations on your MicroPython boards. Here is an example of basic usage:
@@ -110,7 +111,7 @@ To download the MicroPython firmware for some boards, use the following command:
 
 These will try to download the prebuilt MicroPython firmware for the boards from https://micropython.org/download/ and save it in your downloads folder in the  `firmware` directory.
 The stable version (default) is determined based on the most recent published release,
-other versions are `--version preview` and `--version x.y.z` to download the latest preview or version x.y.z respectively.
+other options are `--version stable`, `--version preview` and `--version x.y.z` to download the latest stable, preview or version x.y.z respectively.
 
 By default the firmware will be downloaded to your OS's preferred `Downloads/firmware` folder, but you can speciy a different directory using the `--dir` option.
 
@@ -133,8 +134,18 @@ After you have downloaded a firmware you can  flash the firmware to a board usin
 This will (try to) autodetect the connected boards, and determine the correct firmware to flash to each board.
 
 - `mpflash flash` will flash the latest stable firmware to all connected boards.
+If you have a board withouth a running micropython version, you will need to specify the board and the serial port to flash.
 - `mpflash flash --serial ? --board ?` will prompt to select a specific serial port and board to flash. (the firmware must be dowloaded earlier)
 
+In order to flash the firmware some boards need to be put in bootloader mode, this is done automatically by mpflash where possible and supported by the boards hardware and current bootloader.
+The supported `--bootloader` options are:
+
+- `touch1200` bootloader is activated by connecting to the board at 1200 baud 
+- `mpy`  using  micropython to enter the bootloader
+- `manual` manual intervention is needed to enter the bootloader 
+- `none`   mpflash assumes the board is ready to flash
+
+For ESP32 and ESP8266 boards the `esptool` is used to flash the firmware, and this includes activating the bootloader.
 
 ### Flashing all connected boards with the latest stable firmware
 ```bash

{mpflash-0.9.0 → mpflash-0.9.1}/README.md

@@ -11,8 +11,8 @@ This tool was initially created to be used in a CI/CD pipeline to automate the p
 `mpflash` has been tested on:  
  - OS: Windows x64, Linux X64, but not (yet) macOS.
  - Micropython (hardware) ports: 
-    - `rp2`, using `.uf2`, using filecopy (macos not tested yet)
-    - `samd`, using ` .uf2`, using filecopy (macos not tested yet)
+    - `rp2`, using `.uf2`, using filecopy 
+    - `samd`, using ` .uf2`, using filecopy 
     - `esp32`, using `.bin`, using esptool,
     - `esp8266`, using `.bin`, using esptool
     - `stm32`, using ` .dfu`, using pydfu
@@ -25,7 +25,7 @@ Not yet implemented: `nrf`, `cc3200`, `mimxrt`
  3. Flash one or all connected MicroPython boards with a specific firmware or version.  
  
 ## Installation
-To install mpflash, you can use pip: `pip install mpflash`
+To install mpflash, you can use: `pipx install mpflash` or `pip install mpflash`
 
 ## Basic usage
 You can use mpflash to perform various operations on your MicroPython boards. Here is an example of basic usage:
@@ -69,7 +69,7 @@ To download the MicroPython firmware for some boards, use the following command:
 
 These will try to download the prebuilt MicroPython firmware for the boards from https://micropython.org/download/ and save it in your downloads folder in the  `firmware` directory.
 The stable version (default) is determined based on the most recent published release,
-other versions are `--version preview` and `--version x.y.z` to download the latest preview or version x.y.z respectively.
+other options are `--version stable`, `--version preview` and `--version x.y.z` to download the latest stable, preview or version x.y.z respectively.
 
 By default the firmware will be downloaded to your OS's preferred `Downloads/firmware` folder, but you can speciy a different directory using the `--dir` option.
 
@@ -92,8 +92,18 @@ After you have downloaded a firmware you can  flash the firmware to a board usin
 This will (try to) autodetect the connected boards, and determine the correct firmware to flash to each board.
 
 - `mpflash flash` will flash the latest stable firmware to all connected boards.
+If you have a board withouth a running micropython version, you will need to specify the board and the serial port to flash.
 - `mpflash flash --serial ? --board ?` will prompt to select a specific serial port and board to flash. (the firmware must be dowloaded earlier)
 
+In order to flash the firmware some boards need to be put in bootloader mode, this is done automatically by mpflash where possible and supported by the boards hardware and current bootloader.
+The supported `--bootloader` options are:
+
+- `touch1200` bootloader is activated by connecting to the board at 1200 baud 
+- `mpy`  using  micropython to enter the bootloader
+- `manual` manual intervention is needed to enter the bootloader 
+- `none`   mpflash assumes the board is ready to flash
+
+For ESP32 and ESP8266 boards the `esptool` is used to flash the firmware, and this includes activating the bootloader.
 
 ### Flashing all connected boards with the latest stable firmware
 ```bash

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/add_firmware.py

@@ -11,7 +11,7 @@ from mpremote.mip import _rewrite_url as rewrite_url  # type: ignore
 
 from mpflash.common import FWInfo
 from mpflash.config import config
-from mpflash.vendor.versions import get_preview_mp_version, get_stable_mp_version
+from mpflash.versions import get_preview_mp_version, get_stable_mp_version
 
 
 def add_firmware(

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/ask_input.py

@@ -14,7 +14,7 @@ from .config import config
 from .mpboard_id import (get_known_boards_for_port, get_known_ports,
                          known_stored_boards)
 from .mpremoteboard import MPRemoteBoard
-from .vendor.versions import micropython_versions
+from .versions import micropython_versions
 
 
 def ask_missing_params(

mpflash-0.9.1/mpflash/bootloader/__init__.py

@@ -0,0 +1,2 @@
+from .activate import enter_bootloader  # type: ignore
+from .detect import in_bootloader  # type: ignore

mpflash-0.9.1/mpflash/bootloader/activate.py

@@ -0,0 +1,60 @@
+import time
+
+from mpflash.bootloader.detect import in_bootloader
+from mpflash.common import BootloaderMethod
+from mpflash.errors import MPFlashError
+from mpflash.logger import log
+from mpflash.mpremoteboard import MPRemoteBoard
+
+from .manual import enter_bootloader_manual
+from .micropython import enter_bootloader_mpy
+from .touch1200 import enter_bootloader_touch_1200bps
+
+BL_OPTIONS = {
+    "stm32": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "rp2": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "samd": [BootloaderMethod.TOUCH_1200, BootloaderMethod.MPY, BootloaderMethod.MANUAL],
+    "esp32": [BootloaderMethod.NONE],
+    "esp8266": [BootloaderMethod.NONE],
+}
+
+
+def enter_bootloader(
+    mcu: MPRemoteBoard,
+    method: BootloaderMethod = BootloaderMethod.MPY,
+    timeout: int = 10,
+    wait_after: int = 2,
+):
+    """Enter the bootloader mode for the board"""
+    if method == BootloaderMethod.NONE:
+        # NO bootloader requested, so must be OK to flash
+        return True
+    elif method == BootloaderMethod.AUTO:
+        # build a list of options to try for this board
+        bl_list = BL_OPTIONS.get(mcu.port, [BootloaderMethod.MPY, BootloaderMethod.MANUAL])
+    else:
+        bl_list = [method, BootloaderMethod.MANUAL]
+    log.info(f"Entering bootloader on {mcu.serialport} using methods {[bl.value for bl in bl_list]}")
+    for method in bl_list:
+        try:
+            if method == BootloaderMethod.MPY:
+                result = enter_bootloader_mpy(mcu, timeout=timeout)
+            elif method == BootloaderMethod.MANUAL:
+                result = enter_bootloader_manual(mcu, timeout=timeout)
+            elif method == BootloaderMethod.TOUCH_1200:
+                result = enter_bootloader_touch_1200bps(mcu, timeout=timeout)
+        except MPFlashError as e:
+            log.warning(f"Failed to enter bootloader on {mcu.serialport} using {method.value}")
+            log.exception(e)
+            result = False
+        if not result:
+            # try a next method
+            continue
+
+        # todo - check every second or so for up to max wait time
+        time.sleep(wait_after)
+        # check if bootloader was entered
+        if in_bootloader(mcu):
+            return True
+
+    return result

mpflash-0.9.1/mpflash/bootloader/detect.py

@@ -0,0 +1,82 @@
+""" Detect if a board is in bootloader mode 
+"""
+
+import os
+
+from mpflash.common import PORT_FWTYPES
+from mpflash.flash.uf2 import waitfor_uf2
+from mpflash.logger import log
+from mpflash.mpremoteboard import MPRemoteBoard
+
+
+def in_bootloader(mcu: MPRemoteBoard) -> bool:
+    """Check if the board is in bootloader mode"""
+    if ".uf2" in PORT_FWTYPES[mcu.port]:
+        return in_uf2_bootloader(mcu.port.upper())
+    elif mcu.port in ["stm32"]:
+        return in_stm32_bootloader()
+    elif mcu.port in ["esp32", "esp8266"]:
+        log.debug("esp32/esp8266 does not have a bootloader mode, Assume OK to flash")
+        return True
+
+    log.error(f"Bootloader mode not supported on {mcu.board} on {mcu.serialport}")
+    return False
+
+
+def in_uf2_bootloader(board_id: str) -> bool:
+    """
+    Check if the board is in UF2 bootloader mode.
+
+    :param board_id: The board ID to check for (SAMD or RP2)
+    """
+    return bool(waitfor_uf2(board_id=board_id))
+
+
+def in_stm32_bootloader() -> bool:
+    """Check if the board is in STM32 bootloader mode"""
+    if os.name == "nt":
+        driver_installed, status = check_for_stm32_bootloader_device()
+        if not driver_installed:
+            log.warning("STM32  BOOTLOADER device not found.")
+            return False
+        print()
+        if status != "OK":
+            log.warning(f"STM32 BOOTLOADER device found, Device status: {status}")
+            log.error("Please use Zadig to install a WinUSB (libusb)  driver.\nhttps://github.com/pbatard/libwdi/wiki/Zadig")
+            return False
+    return check_dfu_devices()
+
+
+def check_dfu_devices():
+    """Check if there are any DFU devices connected"""
+    # JIT import
+    from mpflash.flash.stm32_dfu import dfu_init
+    from mpflash.vendor.pydfu import get_dfu_devices
+
+    # need to init on windows to get the right usb backend
+    dfu_init()
+    devices = get_dfu_devices()
+    return len(devices) > 0
+
+
+def check_for_stm32_bootloader_device():
+    import win32com.client
+
+    # Windows only
+    # Create a WMI interface object
+    wmi = win32com.client.GetObject("winmgmts:")
+
+    # Query for USB devices
+    for usb_device in wmi.InstancesOf("Win32_PnPEntity"):
+        try:
+            # Check if device name or description contains "STM32 BOOTLOADER"
+            if str(usb_device.Name).strip() in {
+                "STM32  BOOTLOADER",
+                "STM BOOTLOADER",
+            }:
+                # Just the first match is enough
+                return True, usb_device.Status
+        except Exception:
+            pass
+    # If no matching device was found
+    return False, "Not found."

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/bootloader/manual.py

@@ -12,13 +12,14 @@ from mpflash.mpremoteboard import MPRemoteBoard
 
 
 class MCUHighlighter(RegexHighlighter):
-    """Apply style to anything that looks like an email."""
+    """Apply style to things that should stand out."""
 
     base_style = "mcu."
     highlights = [
         r"(?P<bold>Method[\s\d\:]*)",
         r"(?P<bold> \d.)",  # numbered items
         r"(?P<bold> - )",  # bullets
+        # mcu things
         r"(?P<pad>GPIO[\d]*)",
         r"(?P<pad>GPI[\d]*)",
         r"(?P<pad>IO[\d]*)",
@@ -33,21 +34,19 @@ class MCUHighlighter(RegexHighlighter):
         r"(?P<button>reset)",
         # other
         r"(?P<cable>USB)",
-        # r"(?P<mcu>SAMD[\d]*)",
-        # r"(?P<mcu>ESP[\d]*)",
-        # r"(?P<mcu>rp2)",
-        # r"(?P<mcu>rp2040)",
+        r"(?P<cable>USB-C)",
+        r"(?P<cable>Serial)",
     ]
 
 
 # https://rich.readthedocs.io/en/stable/appendix/colors.html?highlight=colors#standard-colors
+# use 3 colors to keep things simple but clear
 mcu_theme = Theme(
     {
-        "mcu.bold": "orange3",
-        "mcu.mcu": "orange3",
-        "mcu.button": "bold green",
-        "mcu.pad": "dodger_blue2",
-        "mcu.cable": "dodger_blue2",
+        "mcu.bold": "orange3",  # readers guidance
+        "mcu.button": "bold green",  # things to press
+        "mcu.pad": "dodger_blue2",  # things to connect
+        "mcu.cable": "dodger_blue2",  # things to connect
     }
 )
 
@@ -84,7 +83,7 @@ Please put your {mcu.port.upper()} device into bootloader mode by:
 """
 
     # todo: would be nice to re-use the console instance from logger
-    console = Console(highlighter=MCUHighlighter(), theme=mcu_theme)
+    console = Console(highlighter=MCUHighlighter(), theme=mcu_theme)  # type: ignore
     message += "\nIf you are unsure how to enter bootloader mode, please refer to the device documentation."
     console.print(
         Panel(

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/bootloader/micropython.py

@@ -1,10 +1,12 @@
 """Module for handling the bootloader mode for micropython boards"""
 
+from mpflash.logger import log
 from mpflash.mpremoteboard import MPRemoteBoard
 
 
 def enter_bootloader_mpy(mcu: MPRemoteBoard, timeout: int = 10):
     """Enter the bootloader mode for the board using mpremote and micropython on the board"""
+    log.info(f"Attempting bootloader on {mcu.serialport} using 'mpremote bootloader'")
     mcu.run_command("bootloader", timeout=timeout)
     # todo: check if mpremote command was successful
     return True

mpflash-0.9.1/mpflash/bootloader/touch1200.py

@@ -0,0 +1,36 @@
+"""
+Enter bootloader using Touch 1200Bd for boards with bootloaders that support this.
+
+"""
+
+import time
+
+import serial
+
+from mpflash.errors import MPFlashError
+from mpflash.logger import log
+from mpflash.mpremoteboard import MPRemoteBoard
+
+
+def enter_bootloader_touch_1200bps(mcu: MPRemoteBoard, timeout: int = 10):
+    if not mcu.serialport:
+        raise MPFlashError("No serial port specified")
+    log.info(f"Attempting bootloader on {mcu.serialport} using 'Touch 1200Bd'")
+    # if port argument is present perform soft reset
+    # try to initiate serial port connection on PORT with 1200 baudrate
+    try:
+        com = serial.Serial(mcu.serialport, 1200, dsrdtr=True)
+        com.rts = False  # required
+        com.dtr = False  # might as well
+        time.sleep(0.2)
+        com.close()
+
+    except serial.SerialException as e:
+        log.exception(e)
+        raise MPFlashError("pySerial error: " + str(e) + "\n") from e
+    except Exception as e:
+        log.exception(e)
+        raise MPFlashError("Error: " + str(e) + "\n") from e
+
+    # be optimistic
+    return True

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/cli_download.py

@@ -8,7 +8,7 @@ from loguru import logger as log
 from mpflash.connected import connected_ports_boards
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import find_known_board
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .ask_input import ask_missing_params
 from .cli_group import cli

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/cli_flash.py

@@ -8,7 +8,7 @@ from mpflash.common import BootloaderMethod
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import find_known_board
 from mpflash.mpremoteboard import MPRemoteBoard
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .ask_input import ask_missing_params
 from .cli_download import connected_ports_boards
@@ -17,7 +17,7 @@ from .cli_list import show_mcus
 from .common import FlashParams
 from .config import config
 from .flash import flash_list
-from .worklist import (WorkList, full_auto_worklist, manual_worklist,
+from .flash.worklist import (WorkList, full_auto_worklist, manual_worklist,
                        single_auto_worklist)
 
 # #########################################################################################################
@@ -106,7 +106,7 @@ from .worklist import (WorkList, full_auto_worklist, manual_worklist,
     "-bl",
     "bootloader",
     type=click.Choice([e.value for e in BootloaderMethod]),
-    default="mpy",
+    default="auto",
     show_default=True,
     help="""How to enter the (MicroPython) bootloader before flashing.""",
 )

{mpflash-0.9.0 → mpflash-0.9.1}/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-0.9.0 → mpflash-0.9.1}/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-0.9.0 → mpflash-0.9.1}/mpflash/common.py

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

{mpflash-0.9.0 → mpflash-0.9.1}/mpflash/config.py

@@ -1,11 +1,11 @@
 """centralized configuration for mpflash"""
 
 import os
+from importlib.metadata import version
 from pathlib import Path
 from typing import List
 
 import platformdirs
-from importlib.metadata import version
 
 from mpflash.logger import log
 
@@ -20,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

{mpflash-0.9.0 → mpflash-0.9.1}/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-0.9.0 → mpflash-0.9.1}/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-0.9.0 → mpflash-0.9.1}/mpflash/downloaded.py

@@ -5,7 +5,7 @@ import jsonlines
 from loguru import logger as log
 
 from mpflash.common import PORT_FWTYPES, FWInfo
-from mpflash.vendor.versions import clean_version
+from mpflash.versions import clean_version
 
 from .config import config
 

mpflash-0.9.0/mpflash/flash.py → mpflash-0.9.1/mpflash/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
 
 # #########################################################################################################

mpflash-0.9.0/mpflash/flash_esp.py → mpflash-0.9.1/mpflash/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-0.9.0/mpflash/flash_stm32.py → mpflash-0.9.1/mpflash/flash/stm32.py

@@ -4,12 +4,13 @@ from pathlib import Path
 
 from loguru import logger as log
 
-# from .flash_stm32_cube import flash_stm32_cubecli
-from .flash_stm32_dfu import dfu_init, flash_stm32_dfu
 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, stm32_dfu: bool = True):
+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):

mpflash-0.9.0/mpflash/flash_stm32_dfu.py → mpflash-0.9.1/mpflash/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