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

mpflash/mpflash/bootloader/activate.py

@@ -1,60 +0,0 @@
-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/mpflash/bootloader/detect.py

@@ -1,82 +0,0 @@
-""" 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/mpflash/bootloader/manual.py

@@ -1,101 +0,0 @@
-"""Manual bootloader mode entry for various MCUs."""
-
-from click.exceptions import Abort
-from rich.console import Console
-from rich.highlighter import RegexHighlighter
-from rich.panel import Panel
-from rich.prompt import Confirm
-from rich.theme import Theme
-
-# from mpflash.logger import console, log
-from mpflash.mpremoteboard import MPRemoteBoard
-
-
-class MCUHighlighter(RegexHighlighter):
-    """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]*)",
-        r"(?P<pad>RUN)",
-        r"(?P<pad>GND)",
-        r"(?P<pad>VCC)",
-        r"(?P<pad>3.3V)",
-        r"(?P<pad>5V)",
-        # buttons
-        r"(?P<button>BOOTSEL)",
-        r"(?P<button>RESET)",
-        r"(?P<button>reset)",
-        # other
-        r"(?P<cable>USB)",
-        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",  # readers guidance
-        "mcu.button": "bold green",  # things to press
-        "mcu.pad": "dodger_blue2",  # things to connect
-        "mcu.cable": "dodger_blue2",  # things to connect
-    }
-)
-
-
-def enter_bootloader_manual(mcu: MPRemoteBoard, timeout: int = 10):
-
-    message: str
-    if mcu.port == "rp2":
-        message = f"""\
-Please put your {" ".join([mcu.port,mcu.board])} device into bootloader mode by either:
-Method 1:
-  1. Unplug the USB cable, 
-  2. Press and hold the BOOTSEL button on the device, 
-  3. Plug the USB cable back in.
-  4. Release the BOOTSEL button.
-    
-Method 2:
-  1. Press and hold the BOOTSEL button on the device, 
-  2. Reset the device by either: 
-    - pressing the RESET button on the device 
-    - by power-cycling the device,
-    - by briefly connecting the RUN pin to GND
-  3. Release the BOOTSEL button.
-"""
-    elif mcu.port == "samd":
-        message = f"""\
-Please put your {mcu.port.upper()} device into bootloader mode by:
-  - Pressing or sliding the RESET button twice in fast succession
-"""
-    else:
-        message = f"""\
-Please put your {mcu.port.upper()} device into bootloader mode by:
-  - Pressing the RESET button on the device
-"""
-
-    # todo: would be nice to re-use the console instance from logger
-    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(
-            message,
-            highlight=True,
-            title="Manual Bootloader",
-            title_align="left",
-            expand=False,
-        )
-    )
-    try:
-        answer = Confirm.ask("Press Enter to continue", default="y")
-    except Abort:
-        return False
-    return answer in ["y", "Y", True]

mpflash/mpflash/bootloader/micropython.py

@@ -1,12 +0,0 @@
-"""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/mpflash/bootloader/touch1200.py

@@ -1,36 +0,0 @@
-"""
-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/mpflash/cli_download.py

@@ -1,129 +0,0 @@
-"""CLI to Download MicroPython firmware for specific ports, boards and versions."""
-
-from pathlib import Path
-
-import rich_click as click
-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.versions import clean_version
-
-from .ask_input import ask_missing_params
-from .cli_group import cli
-from .common import DownloadParams
-from .config import config
-from .download import download
-
-
-@cli.command(
-    "download",
-    help="Download MicroPython firmware for specific ports, boards and versions.",
-)
-@click.option(
-    "--destination",
-    "-d",
-    "fw_folder",
-    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
-    default=config.firmware_folder,
-    show_default=True,
-    help="The folder to download the firmware to.",
-)
-@click.option(
-    "--version",
-    "-v",
-    "versions",
-    default=["stable"],
-    multiple=True,
-    show_default=True,
-    help="The version of MicroPython to to download.",
-    metavar="SEMVER, 'stable', 'preview' or '?'",
-)
-@click.option(
-    "--board",
-    "-b",
-    "boards",
-    multiple=True,
-    default=[],
-    show_default=True,
-    help="The board(s) to download the firmware for.",
-    metavar="BOARD_ID or ?",
-)
-@click.option(
-    "--serial",
-    "--serial-port",
-    "-s",
-    "serial",
-    default=["*"],
-    show_default=True,
-    multiple=True,
-    help="Which serial port(s) (or globs) to flash",
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--ignore",
-    "-i",
-    is_eager=True,
-    help="Serial port(s) to ignore. Defaults to MPFLASH_IGNORE.",
-    multiple=True,
-    default=[],
-    envvar="MPFLASH_IGNORE",
-    show_default=True,
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--clean/--no-clean",
-    default=True,
-    show_default=True,
-    help="""Remove dates and hashes from the downloaded firmware filenames.""",
-)
-@click.option(
-    "--force",
-    "-f",
-    default=False,
-    is_flag=True,
-    show_default=True,
-    help="""Force download of firmware even if it already exists.""",
-)
-def cli_download(**kwargs) -> int:
-    params = DownloadParams(**kwargs)
-    params.versions = list(params.versions)
-    params.boards = list(params.boards)
-    params.serial = list(params.serial)
-    params.ignore = list(params.ignore)
-
-    # all_boards: List[MPRemoteBoard] = []
-    if params.boards:
-        if not params.ports:
-            # no ports specified - resolve ports from specified boards by resolving board IDs
-            for board in params.boards:
-                if board != "?":
-                    try:
-                        board_ = find_known_board(board)
-                        params.ports.append(board_.port)
-                    except MPFlashError as e:
-                        log.error(f"{e}")
-    else:
-        # no boards specified - detect connected ports and boards
-        params.ports, params.boards, _ = connected_ports_boards(include=params.serial, ignore=params.ignore)
-
-    params = ask_missing_params(params)
-    if not params:  # Cancelled by user
-        return 2
-    params.versions = [clean_version(v, drop_v=True) for v in params.versions]
-    assert isinstance(params, DownloadParams)
-
-    try:
-        download(
-            params.fw_folder,
-            params.ports,
-            params.boards,
-            params.versions,
-            params.force,
-            params.clean,
-        )
-        return 0
-    except MPFlashError as e:
-        log.error(f"{e}")
-        return 1

mpflash/mpflash/cli_flash.py

@@ -1,224 +0,0 @@
-from pathlib import Path
-from typing import List
-
-import rich_click as click
-from loguru import logger as log
-
-from mpflash.ask_input import ask_missing_params
-from mpflash.cli_download import connected_ports_boards
-from mpflash.cli_group import cli
-from mpflash.cli_list import show_mcus
-from mpflash.common import BootloaderMethod, FlashParams, Params
-from mpflash.config import config
-from mpflash.errors import MPFlashError
-from mpflash.flash import flash_list
-from mpflash.flash.worklist import WorkList, full_auto_worklist, manual_worklist, single_auto_worklist
-from mpflash.mpboard_id import find_known_board
-from mpflash.mpremoteboard import MPRemoteBoard
-from mpflash.versions import clean_version
-
-# #########################################################################################################
-# CLI
-# #########################################################################################################
-
-
-@cli.command(
-    "flash",
-    short_help="Flash one or all connected MicroPython boards with a specific firmware and version.",
-)
-@click.option(
-    "--firmware",
-    "-f",
-    "fw_folder",
-    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
-    default=config.firmware_folder,
-    show_default=True,
-    help="The folder to retrieve the firmware from.",
-)
-@click.option(
-    "--version",
-    "-v",
-    "version",  # single version
-    default="stable",
-    multiple=False,
-    show_default=True,
-    help="The version of MicroPython to flash.",
-    metavar="SEMVER, 'stable', 'preview' or '?'",
-)
-@click.option(
-    "--serial",
-    "--serial-port",
-    "-s",
-    "serial",
-    default=["*"],
-    multiple=True,
-    show_default=True,
-    help="Which serial port(s) (or globs) to flash",
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--ignore",
-    "-i",
-    is_eager=True,
-    help="Serial port(s) to ignore. Defaults to MPFLASH_IGNORE.",
-    multiple=True,
-    default=[],
-    envvar="MPFLASH_IGNORE",
-    show_default=True,
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--bluetooth/--no-bluetooth",
-    "-b/-nb",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="""Include bluetooth ports in the list""",
-)
-@click.option(
-    "--port",
-    "-p",
-    "ports",
-    help="The MicroPython port to flash",
-    metavar="PORT",
-    default=[],
-    multiple=True,
-)
-@click.option(
-    "--board",
-    "-b",
-    "board",  # single board
-    multiple=False,
-    help="The MicroPython board ID to flash. If not specified will try to read the BOARD_ID from the connected MCU.",
-    metavar="BOARD_ID or ?",
-)
-@click.option(
-    "--cpu",
-    "--chip",
-    "-c",
-    "cpu",
-    help="The CPU type to flash. If not specified will try to read the CPU from the connected MCU.",
-    metavar="CPU",
-)
-@click.option(
-    "--erase/--no-erase",
-    default=True,
-    show_default=True,
-    help="""Erase flash before writing new firmware. (Not supported on UF2 boards)""",
-)
-@click.option(
-    "--bootloader",
-    "-bl",
-    "bootloader",
-    type=click.Choice([e.value for e in BootloaderMethod]),
-    default="auto",
-    show_default=True,
-    help="""How to enter the (MicroPython) bootloader before flashing.""",
-)
-def cli_flash_board(**kwargs) -> int:
-    # version to versions, board to boards
-    kwargs["versions"] = [kwargs.pop("version")] if kwargs["version"] != None else []
-    if kwargs["board"] is None:
-        kwargs["boards"] = []
-        kwargs.pop("board")
-    else:
-        kwargs["boards"] = [kwargs.pop("board")]
-
-    params = FlashParams(**kwargs)
-    params.versions = list(params.versions)
-    params.ports = list(params.ports)
-    params.boards = list(params.boards)
-    params.serial = list(params.serial)
-    params.ignore = list(params.ignore)
-    params.bootloader = BootloaderMethod(params.bootloader)
-
-    # make it simple for the user to flash one board by asking for the serial port if not specified
-    if params.boards == ["?"] and params.serial == "*":
-        params.serial = ["?"]
-
-    # Detect connected boards if not specified,
-    # and ask for input if boards cannot be detected
-    all_boards: List[MPRemoteBoard] = []
-    if not params.boards:
-        # nothing specified - detect connected boards
-        params.ports, params.boards, all_boards = connected_ports_boards(include=params.ports, ignore=params.ignore, bluetooth=params.bluetooth)
-        if params.boards == []:
-            # No MicroPython boards detected, but it could be unflashed or in bootloader mode
-            # Ask for serial port and board_id to flash
-            params.serial = ["?"]
-            params.boards = ["?"]
-            # assume manual mode if no board is detected
-            params.bootloader = BootloaderMethod("manual")
-    else:
-        resolve_board_ids(params)
-
-    # Ask for missing input if needed
-    params = ask_missing_params(params)
-    if not params:  # Cancelled by user
-        return 2
-    # TODO: Just in time Download of firmware
-
-    assert isinstance(params, FlashParams)
-
-    if len(params.versions) > 1:
-        log.error(f"Only one version can be flashed at a time, not {params.versions}")
-        raise MPFlashError("Only one version can be flashed at a time")
-
-    params.versions = [clean_version(v) for v in params.versions]
-    worklist: WorkList = []
-    # if serial port == auto and there are one or more specified/detected boards
-    if params.serial == ["*"] and params.boards:
-        if not all_boards:
-            log.trace("No boards detected yet, scanning for connected boards")
-            _, _, all_boards = connected_ports_boards(include=params.ports, ignore=params.ignore)
-        worklist = full_auto_worklist(
-            all_boards=all_boards,
-            version=params.versions[0],
-            fw_folder=params.fw_folder,
-            include=params.serial,
-            ignore=params.ignore,
-        )
-    elif params.versions[0] and params.boards[0] and params.serial:
-        # A one or more  serial port including the board / variant
-        worklist = manual_worklist(
-            params.serial[0],
-            board_id=params.boards[0],
-            version=params.versions[0],
-            fw_folder=params.fw_folder,
-        )
-    else:
-        # just this serial port on auto
-        worklist = single_auto_worklist(
-            serial=params.serial[0],
-            version=params.versions[0],
-            fw_folder=params.fw_folder,
-        )
-
-    if flashed := flash_list(
-        worklist,
-        params.fw_folder,
-        params.erase,
-        params.bootloader,
-    ):
-        log.info(f"Flashed {len(flashed)} boards")
-        show_mcus(flashed, title="Updated boards after flashing")
-        return 0
-    else:
-        log.error("No boards were flashed")
-        return 1
-
-
-def resolve_board_ids(params: Params):
-    """Resolve board descriptions to board_id, and remove empty strings from list of boards"""
-    for board_id in params.boards:
-        if board_id == "":
-            params.boards.remove(board_id)
-            continue
-        if " " in board_id:
-            try:
-                if info := find_known_board(board_id):
-                    log.info(f"Resolved board description: {info.board_id}")
-                    params.boards.remove(board_id)
-                    params.boards.append(info.board_id)
-            except Exception as e:
-                log.warning(f"Unable to resolve board description: {e}")