micropython-stubber 1.20.5__py3-none-any.whl → 1.20.6__py3-none-any.whl

mpflash/mpflash/flash_stm32_cube.py

@@ -1,111 +1,111 @@
-# """
-# 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
+# """
+# 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

mpflash/mpflash/flash_stm32_dfu.py

@@ -1,101 +1,101 @@
-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":
-        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.
-    """
-    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
+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":
+        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.
+    """
+    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.py

@@ -1,67 +1,67 @@
-"""
-Flash SAMD and RP2 via UF2
-"""
-
-import shutil
-import sys
-import time
-from pathlib import Path
-from typing import Optional
-
-from loguru import logger as log
-from rich.progress import track
-
-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
-
-
-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.info("Erasing not yet implemented for UF2 flashing.")
-
-    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
-
-    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}")
-    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"]:
-        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
+"""
+Flash SAMD and RP2 via UF2
+"""
+
+import shutil
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger as log
+from rich.progress import track
+
+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
+
+
+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.info("Erasing not yet implemented for UF2 flashing.")
+
+    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
+
+    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}")
+    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"]:
+        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,15 +1,15 @@
-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
+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