micropython-stubber 1.24.1__py3-none-any.whl → 1.24.4__py3-none-any.whl

mpflash/mpflash/flash/stm32_dfu.py

@@ -1,104 +0,0 @@
-import platform
-from pathlib import Path
-from typing import Optional
-
-from loguru import logger as log
-
-from mpflash.mpremoteboard import MPRemoteBoard
-
-
-def init_libusb_windows() -> bool:
-    """
-    Initializes the libusb backend on Windows.
-
-    Returns:
-        bool: True if the initialization is successful, False otherwise.
-    """
-    import libusb  # type: ignore
-    import usb.backend.libusb1 as libusb1
-
-    arch = "x64" if platform.architecture()[0] == "64bit" else "x86"
-    libusb1_dll = Path(libusb.__file__).parent / f"_platform\\_windows\\{arch}\\libusb-1.0.dll"
-    if not libusb1_dll.exists():
-        raise FileNotFoundError(f"libusb1.dll not found at {libusb1_dll}")
-    backend = libusb1.get_backend(find_library=lambda x: libusb1_dll.as_posix())
-    return backend is not None
-
-
-try:
-    from ..vendor import pydfu as pydfu
-except ImportError:
-    pydfu = None
-
-
-def dfu_init():
-    """
-    Initializes the DFU (Device Firmware Upgrade) process.
-    """
-    if not pydfu:
-        log.error("pydfu not found")
-        return None
-    if platform.system() == "Windows":
-        log.debug("Initializing libusb backend on Windows...")
-        init_libusb_windows()
-
-
-def flash_stm32_dfu(
-    mcu: MPRemoteBoard,
-    fw_file: Path,
-    *,
-    erase: bool = True,
-) -> Optional[MPRemoteBoard]:
-    """
-    Flashes the STM32 microcontroller using DFU (Device Firmware Upgrade).
-
-    Args:
-        mcu (MPRemoteBoard): The remote board to flash.
-        fw_file (Path): The path to the firmware file (.dfu).
-        erase (bool, optional): Whether to erase the memory before flashing. Defaults to True.
-
-    Returns:
-        Optional[MPRemoteBoard]: The flashed remote board if successful, None otherwise.
-    """
-    log.info("Using pydfu to flash STM32 boards")
-
-    if not pydfu:
-        log.error("pydfu not found, please install it with 'pip install pydfu' if supported")
-        return None
-
-    if not fw_file.exists():
-        log.error(f"File {fw_file} not found")
-        return None
-
-    if fw_file.suffix != ".dfu":
-        log.error(f"File {fw_file} is not a .dfu file")
-        return None
-
-    kwargs = {"idVendor": 0x0483, "idProduct": 0xDF11}
-    log.debug("List SPECIFIED DFU devices...")
-    try:
-        pydfu.list_dfu_devices(**kwargs)
-    except ValueError as e:
-        log.error(f"Insuffient permissions to access usb DFU devices: {e}")
-        return None
-
-    # Needs to be a list of serial ports
-    log.debug("Inititialize pydfu...")
-    pydfu.init(**kwargs)
-
-    if erase:
-        log.info("Mass erase...")
-        pydfu.mass_erase()
-
-    log.debug("Read DFU file...")
-    elements = pydfu.read_dfu_file(fw_file)
-    if not elements:
-        print("No data in dfu file")
-        return
-    log.info("Writing memory...")
-    pydfu.write_elements(elements, False, progress=pydfu.cli_progress)
-
-    log.debug("Exiting DFU...")
-    pydfu.exit_dfu()
-    log.success("Done flashing, resetting the board and wait for it to restart")
-    return mcu

mpflash/mpflash/flash/uf2/__init__.py

@@ -1,88 +0,0 @@
-"""
-Flash SAMD and RP2 via UF2
-"""
-
-import shutil
-import sys
-from pathlib import Path
-from typing import Optional
-
-import tenacity
-from loguru import logger as log
-
-from tenacity import stop_after_attempt, wait_fixed
-
-from mpflash.mpremoteboard import MPRemoteBoard
-
-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]:
-    """
-    Flash .UF2 devices via bootloader and filecopy
-    - mpremote bootloader
-    - Wait for the device to mount as a drive (up to 5s)
-    - detect new drive with INFO_UF2.TXT
-    - copy the firmware file to the drive
-    - wait for the device to restart (5s)
-
-    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}")
-        return None
-    if erase:
-        log.warning("Erase not (yet) supported on .UF2, skipping erase.")
-
-    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")
-        return None
-
-    log.info("Board is in bootloader mode")
-    board_id = get_board_id(destination)  # type: ignore
-    log.info(f"Board ID: {board_id}")
-    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()
-
-    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/mpflash/flash/uf2/boardid.py

@@ -1,15 +0,0 @@
-from pathlib import Path
-
-from loguru import logger as log
-
-
-def get_board_id(path: Path):
-    # Option : read Board-ID from INFO_UF2.TXT
-    board_id = "Unknown"
-    with open(path / "INFO_UF2.TXT") as f:
-        data = f.readlines()
-    for line in data:
-        if line.startswith("Board-ID"):
-            board_id = line[9:].strip()
-    log.debug(f"INFO_UF2.TXT Board-ID={board_id}")
-    return board_id

mpflash/mpflash/flash/uf2/linux.py

@@ -1,136 +0,0 @@
-""" Flashing UF2 based MCU on Linux"""
-
-# sourcery skip: snake-case-functions
-from __future__ import annotations
-
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import List
-
-from loguru import logger as log
-from rich.progress import track
-
-from .boardid import get_board_id
-from .uf2disk import UF2Disk
-
-glb_dismount_me: List[UF2Disk] = []
-
-
-def get_uf2_drives():
-    """
-    Get a list of all the (un)mounted UF2 drives
-    """
-    # import blkinfo only on linux
-    from blkinfo import BlkDiskInfo
-
-    myblkd = BlkDiskInfo()
-    filters = {
-        "tran": "usb",
-    }
-    usb_disks = myblkd.get_disks(filters)
-    for disk in usb_disks:
-        if disk["fstype"] == "vfat":
-            uf2_part = disk
-            # unpartioned usb disk or partition (e.g. /dev/sdb )
-            # SEEED WIO Terminal is unpartioned
-            # print( json.dumps(uf2_part, indent=4))
-            uf2 = UF2Disk()
-            uf2.device_path = "/dev/" + uf2_part["name"]
-            uf2.label = uf2_part["label"]
-            uf2.mountpoint = uf2_part["mountpoint"]
-            yield uf2
-        elif disk["type"] == "disk" and disk.get("children") and len(disk.get("children")) > 0:
-            if (
-                disk.get("children")[0]["type"] == "part"
-                and disk.get("children")[0]["fstype"] == "vfat"
-            ):
-                uf2_part = disk.get("children")[0]
-                # print( json.dumps(uf2_part, indent=4))
-                uf2 = UF2Disk()
-                uf2.device_path = "/dev/" + uf2_part["name"]
-                uf2.label = uf2_part["label"]
-                uf2.mountpoint = uf2_part["mountpoint"]
-                yield uf2
-
-
-def pmount(disk: UF2Disk):
-    """
-    Mount a UF2 drive if there is no mountpoint yet.
-    """
-    global glb_dismount_me
-    if not disk.mountpoint:
-        if not disk.label:
-            disk.label = "UF2BOOT"
-        disk.mountpoint = f"/media/{disk.label}"
-        # capture error if pmount is not installed
-        try:
-            # drive is always vfat - so specify to have quicker results
-            subprocess.run(["pmount", "-t", "vfat", disk.device_path, disk.mountpoint])
-        except FileNotFoundError:
-            log.error(
-                "pmount not found, please install it using 'sudo apt install pmount', and add this user to the plugdev group."
-            )
-            return
-        log.debug(f"Mounted {disk.label} at {disk.mountpoint}")
-        glb_dismount_me.append(disk)
-    else:
-        log.trace(f"\n{disk.label} already mounted at {disk.mountpoint}")
-
-
-def pumount(disk: UF2Disk):
-    """
-    Unmount a UF2 drive
-    """
-    if sys.platform != "linux":
-        log.error("pumount only works on Linux")
-        return
-    if disk.mountpoint:
-        subprocess.run(["pumount", disk.mountpoint])  # ), f"/media/{disk.label}"])
-        log.info(f"Unmounted {disk.label} from {disk.mountpoint}")
-        disk.mountpoint = f""
-    else:
-        log.warning(f"{disk.label} already dismounted")
-
-
-def dismount_uf2_linux():
-    global glb_dismount_me
-    for disk in glb_dismount_me:
-        pumount(disk)
-    glb_dismount_me = []
-
-
-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=f"Waiting for mcu to mount as a drive ({s_max}s)",
-        transient=True,
-        show_speed=False,
-        refresh_per_second=1,
-        total=s_max,
-    ):
-        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():
-                    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
-        if destination:
-            break
-        time.sleep(1)
-        wait -= 1
-    return destination

mpflash/mpflash/flash/uf2/macos.py

@@ -1,42 +0,0 @@
-""" Flashing UF2 based MCU on macos"""
-
-# sourcery skip: snake-case-functions
-from __future__ import annotations
-
-import time
-from pathlib import Path
-from typing import Optional
-
-from rich.progress import track
-
-from .boardid import get_board_id
-
-
-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=f"Waiting for mcu to mount as a drive ({s_max}s)",
-        transient=True,
-        show_speed=False,
-        refresh_per_second=1,
-        total=s_max,
-    ):
-        vol_mounts = Path("/Volumes").iterdir()
-        for vol in vol_mounts:
-            try:
-                if Path(vol, "INFO_UF2.TXT").exists():
-                    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:
-            break
-        time.sleep(1)
-    return destination

mpflash/mpflash/flash/uf2/uf2disk.py

@@ -1,12 +0,0 @@
-"""Info to support mounting and unmounting of UF2 drives on linux and macos"""
-
-
-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__)

mpflash/mpflash/flash/uf2/windows.py

@@ -1,43 +0,0 @@
-# sourcery skip: snake-case-functions
-"""Flash a MCU with a UF2 bootloader on Windows"""
-
-from __future__ import annotations
-
-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(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=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():
-                    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:
-            break
-        time.sleep(1)
-    return destination

mpflash/mpflash/flash/worklist.py

@@ -1,170 +0,0 @@
-"""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
-from mpflash.downloaded import find_downloaded_firmware
-from mpflash.errors import MPFlashError
-from mpflash.list import show_mcus
-from mpflash.mpboard_id import find_known_board
-from mpflash.mpremoteboard import MPRemoteBoard
-
-# #########################################################################################################
-WorkList = List[Tuple[MPRemoteBoard, FWInfo]]
-# #########################################################################################################
-
-
-def auto_update(
-    conn_boards: List[MPRemoteBoard],
-    target_version: str,
-    fw_folder: Path,
-    *,
-    selector: Optional[Dict[str, str]] = None,
-) -> WorkList:
-    """Builds a list of boards to update based on the connected boards and the firmwares available locally in the firmware folder.
-
-    Args:
-        conn_boards (List[MPRemoteBoard]): List of connected boards
-        target_version (str): Target firmware version
-        fw_folder (Path): Path to the firmware folder
-        selector (Optional[Dict[str, str]], optional): Selector for filtering firmware. Defaults to None.
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    if selector is None:
-        selector = {}
-    wl: WorkList = []
-    for mcu in conn_boards:
-        if mcu.family not in ("micropython", "unknown"):
-            log.warning(f"Skipping flashing {mcu.family} {mcu.port} {mcu.board} on {mcu.serialport} as it is not a MicroPython firmware")
-            continue
-        board_firmwares = find_downloaded_firmware(
-            fw_folder=fw_folder,
-            board_id=mcu.board,
-            version=target_version,
-            port=mcu.port,
-            selector=selector,
-        )
-
-        if not board_firmwares:
-            log.error(f"No {target_version} firmware found for {mcu.board} on {mcu.serialport}.")
-            continue
-
-        if len(board_firmwares) > 1:
-            log.warning(f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}.")
-
-        # just use the last firmware
-        fw_info = board_firmwares[-1]
-        log.info(f"Found {target_version} firmware {fw_info.filename} for {mcu.board} on {mcu.serialport}.")
-        wl.append((mcu, fw_info))
-    return wl
-
-
-def manual_worklist(
-    serial: str,
-    *,
-    board_id: str,
-    version: str,
-    fw_folder: Path,
-) -> WorkList:
-    """Create a worklist for a single board specified manually.
-
-    Args:
-        serial (str): Serial port of the board
-        board (str): Board_ID
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Manual updating {serial} to {board_id} {version}")
-    mcu = MPRemoteBoard(serial)
-    # Lookup the matching port and cpu in board_info based in the board name
-    try:
-        info = find_known_board(board_id)
-        mcu.port = info.port
-        # need the CPU type for the esptool
-        mcu.cpu = info.cpu
-    except (LookupError, MPFlashError) as e:
-        log.error(f"Board {board_id} not found in board_info.zip")
-        log.exception(e)
-        return []
-    mcu.board = board_id
-    firmwares = find_downloaded_firmware(fw_folder=fw_folder, board_id=board_id, version=version, port=mcu.port)
-    if not firmwares:
-        log.error(f"No firmware found for {mcu.port} {board_id} version {version}")
-        return []
-    # use the most recent matching firmware
-    return [(mcu, firmwares[-1])]  # type: ignore
-
-
-def single_auto_worklist(
-    serial: str,
-    *,
-    version: str,
-    fw_folder: Path,
-) -> WorkList:
-    """Create a worklist for a single serial-port.
-
-    Args:
-        serial_port (str): Serial port of the board
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Auto updating {serial} to {version}")
-    conn_boards = [MPRemoteBoard(serial)]
-    todo = auto_update(conn_boards, version, fw_folder)  # type: ignore # List / list
-    show_mcus(conn_boards)  # type: ignore
-    return todo
-
-
-def full_auto_worklist(
-    all_boards: List[MPRemoteBoard], *, include: List[str], ignore: List[str], version: str, fw_folder: Path
-) -> WorkList:
-    """
-    Create a worklist for all connected micropython boards based on the information retrieved from the board.
-    This allows the firmware version of one or moae boards to be changed without needing to specify the port or board_id manually.
-
-    Args:
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Auto updating all boards to {version}")
-    if selected_boards := filter_boards(all_boards, include=include, ignore=ignore):
-        return auto_update(selected_boards, version, fw_folder)
-    else:
-        return []
-
-
-def filter_boards(
-    all_boards: List[MPRemoteBoard],
-    *,
-    include: List[str],
-    ignore: List[str],
-):
-    try:
-        comports = [
-            p.device
-            for p in filtered_comports(
-                ignore=ignore,
-                include=include,
-                bluetooth=False,
-            )
-        ]
-        selected_boards = [b for b in all_boards if b.serialport in comports]
-        # [MPRemoteBoard(port.device, update=True) for port in comports]
-    except ConnectionError as e:
-        log.error(f"Error connecting to boards: {e}")
-        return []
-    return selected_boards  # type: ignore