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

mpflash/mpflash/download.py

@@ -18,9 +18,13 @@ 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.downloaded import clean_downloaded_firmwares
 from mpflash.errors import MPFlashError
+from mpflash.mpboard_id import get_known_ports
+from mpflash.vendor.versions import clean_version
 
+# avoid conflict with the ujson used by MicroPython
 jsonlines.ujson = None  # type: ignore
 # #########################################################################################################
 
@@ -30,8 +34,18 @@ MICROPYTHON_ORG_URL = "https://micropython.org/"
 # Regexes to remove dates and hashes in the filename that just get in the way
 RE_DATE = r"(-\d{8}-)"
 RE_HASH = r"(.g[0-9a-f]+\.)"
-# regex to extract the version from the firmware filename
-RE_VERSION_PREVIEW = r"(\d+\.\d+(\.\d+)?(-\w+.\d+)?)"
+# regex to extract the version and the build from the firmware filename
+# group 1 is the version, group 2 is the build
+RE_VERSION_PREVIEW = r"v([\d\.]+)-?(?:preview\.)?(\d+)?\."
+# 'RPI_PICO_W-v1.23.uf2'
+# 'RPI_PICO_W-v1.23.0.uf2'
+# 'RPI_PICO_W-v1.23.0-406.uf2'
+# 'RPI_PICO_W-v1.23.0-preview.406.uf2'
+# 'RPI_PICO_W-v1.23.0-preview.4.uf2'
+# 'RPI_PICO_W-v1.23.0.uf2'
+# 'https://micropython.org/resources/firmware/RPI_PICO_W-20240531-v1.24.0-preview.10.gc1a6b95bf.uf2'
+# 'https://micropython.org/resources/firmware/RPI_PICO_W-20240531-v1.24.0-preview.10.uf2'
+# 'RPI_PICO_W-v1.24.0-preview.10.gc1a6b95bf.uf2'
 
 
 # use functools.lru_cache to avoid needing to download pages multiple times
@@ -50,6 +64,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 +106,11 @@ 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]:
+    # sourcery skip: use-getitem-for-re-match-groups
     """
     Retrieves a list of firmware information for the specified ports and boards.
 
@@ -105,57 +120,70 @@ 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 = clean_version(ver_match.group(1))
+                    fw_info.build = ver_match.group(2) or "0"
+                fw_info.preview = fw_info.build != "0"
+                # # 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(
@@ -167,40 +195,60 @@ def download_firmwares(
     force: bool = False,
     clean: bool = True,
 ) -> int:
+    """
+    Downloads firmware files based on the specified firmware folder, ports, boards, versions, force flag, and clean flag.
+
+    Args:
+        firmware_folder : The folder to save the downloaded firmware files.
+        ports : The list of ports to check for firmware.
+        boards : The list of boards to download firmware for.
+        versions : The list of versions to download firmware for.
+        force : A flag indicating whether to force the download even if the firmware file already exists.
+        clean : A flag indicating to clean the date from the firmware filename.
+    """
     skipped = downloaded = 0
-    if versions is None:
-        versions = []
+    versions = [] if versions is None else [clean_version(v) for v in versions]
+    # handle renamed boards
+    boards = add_renamed_boards(boards)
+
     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")
+    if not unique_boards:
+        log.error("No relevant firmwares could be found on https://micropython.org/download")
+        log.info(f"{versions=} {ports=} {boards=}")
+        log.info("Please check the website for the latest firmware files or try the preview version.")
+        return 0
 
     firmware_folder.mkdir(exist_ok=True)
 
     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.")
+    if downloaded > 0:
+        clean_downloaded_firmwares(firmware_folder)
+    log.success(f"Downloaded {downloaded} firmwares, skipped {skipped} existing files.")
     return downloaded + skipped
 
 
@@ -215,7 +263,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.
 
     """
 
@@ -224,15 +272,18 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
     board_urls = sorted(get_boards(ports, boards, clean), key=key_fw_ver_pre_ext_bld)
 
     log.debug(f"Total {len(board_urls)} firmwares")
+
     relevant = [
         board
         for board in board_urls
-        if board["board"] in boards and (board["version"] in versions or board["preview"] and preview)
-        # and b["port"] in ["esp32", "rp2"]
+        if board.version in versions and board.build == "0" and board.board in boards and not board.preview
     ]
+
+    if preview:
+        relevant.extend([board for board in board_urls if board.board in boards and board.preview])
     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)
@@ -258,7 +309,7 @@ def download(
         boards : The list of boards to download firmware for.
         versions : The list of versions to download firmware for.
         force : A flag indicating whether to force the download even if the firmware file already exists.
-        clean : A flag indicating whether to perform a clean download.
+        clean : A flag indicating whether to clean the date from the firmware filename.
 
     Returns:
         int: The number of downloaded firmware files.
@@ -270,11 +321,41 @@ def download(
     if not boards:
         log.critical("No boards found, please connect a board or specify boards to download firmware for.")
         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}")
         raise MPFlashError(f"Could not create folder {destination}") from e
+    try:
+        result = download_firmwares(destination, ports, boards, versions, force=force, clean=clean)
+    except requests.exceptions.RequestException as e:
+        log.exception(e)
+        raise MPFlashError("Could not connect to micropython.org") from e
+
+    return result
+
 
-    return download_firmwares(destination, ports, boards, versions, force=force, clean=clean)
+def add_renamed_boards(boards: List[str]) -> List[str]:
+    """
+    Adds the renamed boards to the list of boards.
+
+    Args:
+        boards : The list of boards to add the renamed boards to.
+
+    Returns:
+        List[str]: The list of boards with the renamed boards added.
+
+    """
+    renamed = {
+        "PICO": ["RPI_PICO"],
+        "PICO_W": ["RPI_PICO_W"],
+        "GENERIC": ["ESP32_GENERIC", "ESP8266_GENERIC"],  # just add both of them
+    }
+    _boards = boards.copy()
+    for board in boards:
+        if board in renamed and renamed[board] not in boards:
+            _boards.extend(renamed[board])
+        if board != board.upper() and board.upper() not in boards:
+            _boards.append(board.upper())
+    return _boards

mpflash/mpflash/downloaded.py

@@ -16,18 +16,34 @@ 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
 
 
+def clean_downloaded_firmwares(fw_folder: Path) -> None:
+    """
+    Remove duplicate entries from the firmware.jsonl file, keeping the latest one
+    uniqueness is based on the filename
+    """
+    firmwares = downloaded_firmwares(fw_folder)
+    if not firmwares:
+        return
+    # keep the latest entry
+    unique_fw = {fw.filename: fw for fw in firmwares}
+    with jsonlines.open(fw_folder / "firmware.jsonl", "w") as writer:
+        for fw in unique_fw.values():
+            writer.write(fw.to_dict())
+    log.info(f"Removed duplicate entries from firmware.jsonl in {fw_folder}")
+
+
 def find_downloaded_firmware(
     *,
     board_id: str,
-    version: str = "",
+    version: str = "",  # v1.2.3
     port: str = "",
     variants: bool = False,
     fw_folder: Optional[Path] = None,
@@ -38,21 +54,22 @@ def find_downloaded_firmware(
         selector = {}
     fw_folder = fw_folder or config.firmware_folder
     # Use the information in firmwares.jsonl to find the firmware file
+    log.debug(f"{trie}] Looking for firmware for {board_id} {version} ")
     fw_list = downloaded_firmwares(fw_folder)
     if not fw_list:
         log.error("No firmware files found. Please download the firmware first.")
         return []
     # filter by version
-    version = clean_version(version, drop_v=True)
+    version = clean_version(version)
     fw_list = filter_downloaded_fwlist(fw_list, board_id, version, port, variants, selector)
 
     if not fw_list and trie < 3:
         log.info(f"Try ({trie+1}) to find a firmware for the board {board_id}")
         if trie == 1:
-            # ESP board naming conventions have changed by adding a PORT refix
+            # ESP board naming conventions have changed by adding a PORT prefix
             if port.startswith("esp") and not board_id.startswith(port.upper()):
                 board_id = f"{port.upper()}_{board_id}"
-            # RP2 board naming conventions have changed by adding a _RPIprefix
+            # RP2 board naming conventions have changed by adding a _RPI prefix
             if port == "rp2" and not board_id.startswith("RPI_"):
                 board_id = f"RPI_{board_id}"
         elif trie == 2:
@@ -68,14 +85,14 @@ 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
 
 
 def filter_downloaded_fwlist(
     fw_list: List[FWInfo],
     board_id: str,
-    version: str,
+    version: str,  # v1.2.3
     port: str,
     # preview: bool,
     variants: bool,
@@ -84,23 +101,27 @@ 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]
-
+        # FWInfo version has no v1.2.3 prefix
+        _version = {clean_version(version, drop_v=True), clean_version(version, drop_v=False)}
+        fw_list = [fw for fw in fw_list if fw.version in _version]
+    log.trace(f"Filtering firmware for {version} : {len(fw_list)} found.")
     # filter by port
     if port:
-        fw_list = [fw for fw in fw_list if fw["port"] == port]
+        fw_list = [fw for fw in fw_list if fw.port == port]
+        log.trace(f"Filtering firmware for {port} : {len(fw_list)} found.")
 
     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]
+        log.trace(f"Filtering firmware for {board_id} : {len(fw_list)} found.")
     if selector and port in selector:
-        fw_list = [fw for fw in fw_list if fw["filename"].endswith(selector[port])]
+        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 .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
 
 
@@ -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,11 @@ 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")
+        destination = wait_for_UF2_macos()
     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():
@@ -51,11 +55,13 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
         return None
 
     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")
-    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_boardid.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+
 from loguru import logger as log
 
 
@@ -10,5 +11,5 @@ def get_board_id(path: Path):
     for line in data:
         if line.startswith("Board-ID"):
             board_id = line[9:].strip()
-    log.trace(f"Found Board-ID={board_id}")
+    log.debug(f"INFO_UF2.TXT Board-ID={board_id}")
     return board_id

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,37 @@
+""" Flashing UF2 based MCU on macos"""
+
+# sourcery skip: snake-case-functions
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger as log
+from rich.progress import track
+
+from .flash_uf2_boardid import get_board_id
+
+
+def wait_for_UF2_macos(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")
+        vol_mounts = Path("/Volumes").iterdir()
+        for vol in vol_mounts:
+            try:
+                if Path(vol, "INFO_UF2.TXT").exists():
+                    destination = Path(vol)
+                    break
+            except OSError:
+                pass
+        if destination:
+            break
+        time.sleep(1)
+    return destination

mpflash/mpflash/flash_uf2_windows.py

@@ -5,25 +5,25 @@ from __future__ import annotations
 
 import time
 from pathlib import Path
+from typing import Optional
 
 import psutil
 from rich.progress import track
 
-from .flash_uf2_boardid import get_board_id
 
 
-def wait_for_UF2_windows(s_max: int = 10):
+
+def wait_for_UF2_windows(s_max: int = 10) -> Optional[Path]:
     """Wait for the MCU to mount as a drive"""
     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):
+    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")
         drives = [drive.device for drive in psutil.disk_partitions()]
         for drive in drives:
             try:
                 if Path(drive, "INFO_UF2.TXT").exists():
-                    board_id = get_board_id(Path(drive))  # type: ignore
                     destination = Path(drive)
                     break
             except OSError: