mpflash 0.8.8__py3-none-any.whl → 0.9.1__py3-none-any.whl

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/{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/{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/{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/{worklist.py → flash/worklist.py}

@@ -1,15 +1,17 @@
+"""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, PORT_FWTYPES
+from mpflash.common import FWInfo, filtered_comports
 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 ..downloaded import find_downloaded_firmware
+from ..list import show_mcus
+from ..mpboard_id import find_known_board
+from ..mpremoteboard import MPRemoteBoard
 
 # #########################################################################################################
 WorkList = List[Tuple[MPRemoteBoard, FWInfo]]

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/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

mpflash/mpboard_id/add_boards.py

@@ -12,11 +12,11 @@ import rich.table
 from rich.console import Console
 from rich.progress import track
 
-import mpflash.vendor.basicgit as git
+import basicgit as git
 from mpflash.logger import log
 from mpflash.mpboard_id import Board
 from mpflash.mpboard_id.store import write_boardinfo_json
-from mpflash.vendor.versions import micropython_versions
+from mpflash.versions import micropython_versions
 
 # look for all mpconfigboard.h files and extract the board name
 # from the #define MICROPY_HW_BOARD_NAME "PYBD_SF6"

mpflash/mpboard_id/board_id.py

@@ -9,7 +9,7 @@ from typing import Optional
 from mpflash.errors import MPFlashError
 from mpflash.logger import log
 from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.vendor.versions import clean_version, get_stable_mp_version
+from mpflash.versions import clean_version, get_stable_mp_version
 
 
 def find_board_id_by_description(

mpflash/mpremoteboard/__init__.py

@@ -29,7 +29,7 @@ RETRIES = 3
 class MPRemoteBoard:
     """Class to run mpremote commands"""
 
-    def __init__(self, serialport: str = "", update: bool = False):
+    def __init__(self, serialport: str = "", update: bool = False, *, location: str = ""):
         """
         Initialize MPRemoteBoard object.
 
@@ -37,7 +37,7 @@ class MPRemoteBoard:
         - serialport (str): The serial port to connect to. Default is an empty string.
         - update (bool): Whether to update the MCU information. Default is False.
         """
-        self.serialport = serialport
+        self.serialport: str = serialport
         self.firmware = {}
 
         self.connected = False
@@ -51,6 +51,7 @@ class MPRemoteBoard:
         self.arch = ""
         self.mpy = ""
         self.build = ""
+        self.location = location
         if update:
             self.get_mcu_info()
 
@@ -207,11 +208,11 @@ class MPRemoteBoard:
         """wait for the board to restart"""
         for _ in track(
             range(timeout),
-            description="Waiting for the board to restart",
+            description=f"Waiting for the board to restart ({timeout}s)",
             transient=True,
-            get_time=lambda: time.time(),
             show_speed=False,
             refresh_per_second=1,
+            total=timeout,
         ):
             time.sleep(1)
             try:

mpflash/{vendor/versions.py → versions.py}

@@ -4,12 +4,12 @@
 #############################################################
 """
 
-from functools import lru_cache
-
+from cache_to_disk import cache_to_disk, NoCacheCondition
 from loguru import logger as log
 from packaging.version import parse
 
 from mpflash.common import GH_CLIENT
+
 OLDEST_VERSION = "1.16"
 "This is the oldest MicroPython version to build the stubs on"
 
@@ -70,9 +70,10 @@ def clean_version(
     return version
 
 
-@lru_cache(maxsize=10)
+@cache_to_disk(n_days_to_cache=1)
 def micropython_versions(minver: str = "v1.20", reverse: bool = False):
     """Get the list of micropython versions from github tags"""
+    cache_it = True
     try:
         gh_client = GH_CLIENT
         repo = gh_client.get_repo("micropython/micropython")
@@ -100,10 +101,15 @@ def micropython_versions(minver: str = "v1.20", reverse: bool = False):
             "v1.11",
             "v1.10",
         ]
+        cache_it = False
     versions = [v for v in versions if parse(v) >= parse(minver)]
     # remove all but the most recent (preview) version
     versions = versions[:1] + [v for v in versions if "preview" not in v]
-    return sorted(versions, reverse=reverse)
+    versions = sorted(versions, reverse=reverse)
+    if cache_it:
+        return versions
+    # returns - but does not cache
+    raise NoCacheCondition(function_value=versions)
 
 
 def get_stable_mp_version() -> str:
@@ -116,4 +122,3 @@ def get_preview_mp_version() -> str:
     # read the versions from the git tags
     all_versions = micropython_versions(minver=OLDEST_VERSION)
     return [v for v in all_versions if v.endswith(V_PREVIEW)][-1]
-

{mpflash-0.8.8.dist-info → mpflash-0.9.1.dist-info}/METADATA

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

@@ -0,0 +1,52 @@
+mpflash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpflash/add_firmware.py,sha256=h-Nu9AnXO6ug2CurmgLoUVG1gNy6CA1NjwQl1nUoMZ4,3330
+mpflash/ask_input.py,sha256=EsPPlPS_wLC8j9f4o68yKIcqex0dV5tRH7k3rP3spG0,8710
+mpflash/bootloader/__init__.py,sha256=cRIxVRtUc4jZAgtFggRNhEn0BW-9WFpzm5xRy5B4B2U,105
+mpflash/bootloader/activate.py,sha256=sN2YuIuFGjLBd_PdG6P3N1yLuLyjnsVWDksrTMhzr_M,2301
+mpflash/bootloader/detect.py,sha256=eXL_JPcowb8g0tpZmj9DQXYbpfZFoSrzq86lScKhkT4,2608
+mpflash/bootloader/manual.py,sha256=qGInguhYil4v8EkUxPFlxzvs3m__KraPAj3LAKbV1Ts,3069
+mpflash/bootloader/micropython.py,sha256=0KDrfdZPtK7fLaxh-_4VxSO-u4IUj7qCyNVw9-LQ74M,517
+mpflash/bootloader/touch1200.py,sha256=tL2H4ERh0-YSdR8_v6aK_pDRPMjMevHWUGq4-TTFcWo,1083
+mpflash/cli_download.py,sha256=Ip5HViXCVAiG88XgJ3Lg_hhBGIF5DKFTNpL-_gQkdV0,3520
+mpflash/cli_flash.py,sha256=KFuJRNgOZ62m70I_KqxqLfLE69b4bOCj69MOfIWdZRo,7136
+mpflash/cli_group.py,sha256=JFBtp4qhakJeQkuupEoObHeSFke8eWIU1HjnOZ-JfH0,2504
+mpflash/cli_list.py,sha256=AvYq5_Z7l0Z4rkbr23TwFNzstuZsQgopFpdcrTLwUvs,1965
+mpflash/cli_main.py,sha256=cElgh8Soq3U5TEAvrrD1sj7NDi-Eb-pei3QcMI0tlwE,1094
+mpflash/common.py,sha256=h4pVuOpopn5oIy5NQdbggtOOktTL_c92cS_oUfPG4v8,5783
+mpflash/config.py,sha256=h2Oq7kSe40tOnglpo02wkpaPHxHNVqyB3uGxreIu57U,1029
+mpflash/connected.py,sha256=p6RMix-tFr0pfT9TErh0LD1nm24ApTr3CqVGcrnDHk8,3024
+mpflash/download.py,sha256=mckR3pdMFQMYBKNmKBEJm9bJnTtQEnkuQ1vWYXcRRv8,13941
+mpflash/downloaded.py,sha256=YPN0LDf8DSDvdB9gbVny61bvaJHIDbUs81XUwftTb1c,4808
+mpflash/errors.py,sha256=6lUhVtECY3syV2bBGKzegGH4pPKXhevvhYQZd74sy6o,238
+mpflash/flash/__init__.py,sha256=xX2ZJGNX9xpX2s8V7SEJ1It7eOEbl8WkdFzpRd3TLzk,2041
+mpflash/flash/esp.py,sha256=LcOgjpE4zmPawHNwSd_6WFkaIYYazA__rf3ihGXR7I0,2228
+mpflash/flash/stm32.py,sha256=W8SJ2_8FGXyMS6cRcZpfOvOM8iOC_cn4vK8xd8tKzI4,555
+mpflash/flash/stm32_dfu.py,sha256=uTn06H0ZezzCv5O0hvry8ohBtuZXHe_GX2zNUfCxu58,2986
+mpflash/flash/uf2/__init__.py,sha256=PWEVxzZEca3pfLx_Qy5c4zlHH4W5fAjd0BmDTkS7s6g,2766
+mpflash/flash/uf2/boardid.py,sha256=2s4K3QiKWK5HKFKWYsDV3hI8alfWSxEOMeurER3eZtM,408
+mpflash/flash/uf2/linux.py,sha256=4azbcx_YqLZ3RyYNWljejHG_Y6SU-wREL8hhkTYqCjI,4099
+mpflash/flash/uf2/macos.py,sha256=sncXJsc2FVfm9rvLDjcEu7ZIyrDeHmazHiNQTUaf1Y0,1187
+mpflash/flash/uf2/uf2disk.py,sha256=dQ8_U6e3qkFOyfXZDpWAsvEBIlMr-ZzLkzTDD8SADqM,286
+mpflash/flash/uf2/windows.py,sha256=k9Yv71YswPnLx-Z5rf4KjhtVkEWr8SU8EXpeRv87h3A,1290
+mpflash/flash/worklist.py,sha256=K16sbvzJCgkHNssYlBA3ezayI02RMuIcp19XAs74XeQ,5835
+mpflash/list.py,sha256=O0tX4BvclmDMnnjMxCN9Zh8hdL6vnuvS9pLNxYLBya8,3112
+mpflash/logger.py,sha256=BAVrSXMGZLfSDRFbtVBtvb7Rl0sTJxooCgBS5t-6bXo,1057
+mpflash/mpboard_id/__init__.py,sha256=rQrPCN30GP-lfB2a2deA-lQ6iKvaKPK_xbtBoIavGsM,3716
+mpflash/mpboard_id/add_boards.py,sha256=0tP-4Ibc5_BBTQx1oBFXmKo80n31BrW6E5KrWKpP2FU,9407
+mpflash/mpboard_id/board.py,sha256=yQ8IDHQS09AelvTvmPhpmsL4oX3L7IXGqHorkxDOkoE,1114
+mpflash/mpboard_id/board_id.py,sha256=wzGrxJu_ciOVT7n2861lhoKmPAjh1QjWnAdfcqNUUqc,2871
+mpflash/mpboard_id/board_info.zip,sha256=F6YowS96DAqjten4ySe4MXgZwPtE-saZOUfY5OQkqKk,19759
+mpflash/mpboard_id/store.py,sha256=lQQgHSxcaM_ZURcfZNSUv3-ZJjUKMC_xEOOSdpzVvBU,1493
+mpflash/mpremoteboard/__init__.py,sha256=7uI-5HJgNsQz_EOCW3cRy2xtqXKt9kX51gDSx6HC0Kc,7522
+mpflash/mpremoteboard/mpy_fw_info.py,sha256=BTupe4rZDTs3UHRqvs429XqWHCchSpwa05yACOiOt5U,4413
+mpflash/mpremoteboard/runner.py,sha256=YUmo5Y0aOgMaww8CXSdNdgXD-wRKncILuMZ0OB_2qRU,4646
+mpflash/vendor/click_aliases.py,sha256=K98inhtze8td1dw312kexJS7OX_0ojlptPQ5Z0SHxJY,3065
+mpflash/vendor/dfu.py,sha256=jGsiD3lbSV1Ar9qJubhoY_hy-L8FI-K55aow8vgwoYQ,5590
+mpflash/vendor/pydfu.py,sha256=1ObubGsPFrQ7T9M3JRlIPNIG2xx8uYffaEe0Y6bdf_g,19937
+mpflash/vendor/readme.md,sha256=ZVg7kuUYyXcWcrWkaSJ0CunwebCqu2SiS2sqDadwrT8,84
+mpflash/versions.py,sha256=SrXVZx6qVWcighHlg8pJ0RPRZ3gcYN7l2DnSicconAk,4098
+mpflash-0.9.1.dist-info/LICENSE,sha256=xHwgxGNkI0R2iN4KNfbPbQSzRomWyRz7bJnR1O2mln8,1057
+mpflash-0.9.1.dist-info/METADATA,sha256=81r3-DTSaPrLNwLUdQDjgnFT8WJhC-awFTW1FAC6sXU,16058
+mpflash-0.9.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mpflash-0.9.1.dist-info/entry_points.txt,sha256=Jk_visOhYOsZIcSP2Ms9hKqfKy1iorR-6dYltSoWCpY,52
+mpflash-0.9.1.dist-info/RECORD,,

mpflash/flash_stm32.py

@@ -1,23 +0,0 @@
-"""Flash STM32 boards using either STM32CubeProgrammer CLI or dfu-util"""
-
-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
-
-
-def flash_stm32(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool, stm32_dfu: bool = True):
-    # sourcery skip: lift-return-into-if
-    dfu_init()
-    updated = flash_stm32_dfu(mcu, fw_file=fw_file, erase=erase)
-    # if stm32_dfu:
-    # else:
-    #     log.info("Using STM32CubeProgrammer CLI")
-    #     updated = flash_stm32_cubecli(mcu, fw_file=fw_file, erase=erase)
-
-    mcu.wait_for_restart()
-    log.success(f"Flashed {mcu.version} to {mcu.board}")
-    return updated

mpflash/flash_stm32_cube.py

@@ -1,111 +0,0 @@
-# """
-# Flash STM32 using STM32CubeProgrammer
-# needs to be installed independenty from https://www.st.com/en/development-tools/stm32cubeprog.html
-
-# On Linux needs to be run with sudo - unless udev rules are set to allow access to the device as a regular user
-# """
-
-# import subprocess
-# import sys
-# import time
-# from pathlib import Path
-# from typing import Optional
-
-# import bincopy
-# from loguru import logger as log
-# from rich.progress import track
-# from strip_ansi import strip_ansi
-
-# from .mpremoteboard.mpremoteboard import MPRemoteBoard
-
-# STM32_CLI_WIN = "C:\\Program Files\\STMicroelectronics\\STM32Cube\\STM32CubeProgrammer\\bin\\STM32_Programmer_CLI.exe"
-# STM32_CLI_LINUX = "~/STMicroelectronics/STM32Cube/STM32CubeProgrammer/bin/STM32_Programmer_CLI"
-
-
-# def get_stm32_start_address(fw_file: Path):
-#     """
-#     Get the start address of the firmware file, to allow automatic restart from that address after flashing
-#     """
-#     try:
-#         fw_hex = bincopy.BinFile(str(fw_file))
-#         return f"0x{fw_hex.execution_start_address:08X}"
-#     except Exception:
-
-#         return ""
-
-
-# def flash_stm32_cubecli(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optional[MPRemoteBoard]:
-#     """
-#     Flash STM32 devices using STM32CubeProgrammer CLI
-#     - Enter bootloader mode
-#     - wait 2s for the device to be detected
-#     - list the connected DFU devices
-
-#     On Linux: requires udev rules to allow access to the device as a regular user
-#     """
-#     if sys.platform == "linux":
-#         STM32_CLI = Path(STM32_CLI_LINUX).expanduser().as_posix()
-#     elif sys.platform == "win32":
-#         STM32_CLI = str(Path(STM32_CLI_WIN).expanduser())
-#     else:
-#         log.error(f"OS {sys.platform} not supported")
-#         return None
-
-#     if not Path(STM32_CLI).exists():
-#         log.error(
-#             f"STM32CubeProgrammer not found at {STM32_CLI}\nPlease install it from https://www.st.com/en/development-tools/stm32cubeprog.html"
-#         )
-#         return None
-
-#     # run STM32_Programmer_CLI.exe --list
-#     cmd = [
-#         STM32_CLI,
-#         "--list",
-#     ]
-#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-#     results = [strip_ansi(line) for line in results]
-#     if not any(["Product ID             : STM32  BOOTLOADER" in l for l in results]):
-#         log.error("No STM32 BOOTLOADER detected")
-#         return None
-#     echo = False
-#     for line in results:
-#         if line.startswith("=====  DFU Interface"):
-#             echo = True
-#         if line.startswith("===== STLink"):
-#             echo = False
-#         if echo:
-#             print(line)
-#     # Try to connect - no action
-#     cmd = [
-#         STM32_CLI,
-#         "--connect",
-#         "port=USB1",
-#     ]
-#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-#     if erase:
-#         log.info("Erasing flash")
-#         cmd = [
-#             STM32_CLI,
-#             "--connect",
-#             "port=USB1",
-#             "--erase",
-#             "all",
-#         ]
-#         results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-#         results = [strip_ansi(line) for line in results]
-#     log.info(f"Flashing {fw_file.name} using STM32CubeProgrammer CLI")
-#     start_address = get_stm32_start_address(fw_file)
-
-#     log.trace(f"STM32_Programmer_CLI --connect port=USB1 --write {str(fw_file)} --go {start_address}")
-#     cmd = [
-#         STM32_CLI,
-#         "--connect",
-#         "port=USB1",
-#         "--write",
-#         str(fw_file),
-#         "--go",
-#         start_address,
-#     ]
-#     results = subprocess.run(cmd, capture_output=True, text=True).stdout.splitlines()
-#     log.success("Done flashing, resetting the board and wait for it to restart")
-#     return mcu