mpflash 1.26.3__py3-none-any.whl → 1.26.4__py3-none-any.whl

mpflash/__init__.py

@@ -1,5 +1 @@
 """MPFlash - MicroPython firmware flashing tool."""
-
-from .logger import configure_safe_logging, setup_external_logger_safety
-
-__all__ = ["configure_safe_logging", "setup_external_logger_safety"]

mpflash/ask_input.py

@@ -5,7 +5,7 @@ Note: The prompts can use "{version}" and "{action}" to insert the version and a
 The values are provided from the answers dictionary.
 """
 
-from typing import List, Sequence, Tuple, Union
+from typing import Dict, List, Sequence, Tuple, Union
 
 from loguru import logger as log
 
@@ -43,7 +43,7 @@ def ask_missing_params(
     action = "download" if isinstance(params, DownloadParams) else "flash"
 
     questions = []
-    answers: dict[str, Union[str, List]] = {"action": action}
+    answers: Dict[str, Union[str, List]] = {"action": action}
     if not multi_select:
         if not params.serial or "?" in params.serial:
             questions.append(ask_serialport(multi_select=False, bluetooth=False))
@@ -59,7 +59,14 @@ def ask_missing_params(
     if not params.boards or "?" in params.boards:
         questions.extend(ask_port_board(multi_select=multi_select, action=action))
     if questions:
-        answers = inquirer.prompt(questions, answers=answers)  # type: ignore
+        # Store the pre-existing answers before prompting
+        pre_existing_answers = dict(answers)
+        prompted_answers = inquirer.prompt(questions, answers=answers)  # type: ignore
+        if not prompted_answers:
+            # input cancelled by user
+            return []  # type: ignore
+        # Merge pre-existing answers with prompted answers
+        answers = {**pre_existing_answers, **prompted_answers}
     if not answers:
         # input cancelled by user
         return []  # type: ignore
@@ -226,7 +233,7 @@ def ask_serialport(*, multi_select: bool = False, bluetooth: bool = False):
     # import only when needed to reduce load time
     import inquirer
 
-    comports = MPRemoteBoard.connected_boards(bluetooth=bluetooth, description=True) + ["auto"]
+    comports = MPRemoteBoard.connected_comports(bluetooth=bluetooth, description=True) + ["auto"]
     return inquirer.List(
         "serial",
         message="Which serial port do you want to {action} ?",

mpflash/cli_flash.py

@@ -11,8 +11,8 @@ from mpflash.cli_group import cli
 from mpflash.cli_list import show_mcus
 from mpflash.common import BootloaderMethod, FlashParams, filtered_comports
 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.flash import flash_tasks
+from mpflash.flash.worklist import FlashTaskList, create_worklist
 from mpflash.mpremoteboard import MPRemoteBoard
 from mpflash.versions import clean_version
 
@@ -193,10 +193,10 @@ def cli_flash_board(**kwargs) -> int:
         raise MPFlashError("Only one version can be flashed at a time")
 
     params.versions = [clean_version(v) for v in params.versions]
-    worklist: WorkList = []
+    tasks: FlashTaskList = []
 
     if len(params.versions) == 1 and len(params.boards) == 1 and params.serial == ["*"]:
-        # A one or more serial port including the board / variant
+        # One or more serial ports including the board / variant (auto-detect ports)
         comports = filtered_comports(
             ignore=params.ignore,
             include=params.serial,
@@ -205,50 +205,49 @@ def cli_flash_board(**kwargs) -> int:
         board_id = f"{params.boards[0]}-{params.variant}" if params.variant else params.boards[0]
         log.info(f"Flashing {board_id} {params.versions[0]} to {len(comports)} serial ports")
         log.info(f"Target ports: {', '.join(comports)}")
-        worklist = manual_worklist(
-            comports,
+        tasks = create_worklist(
+            params.versions[0],
+            serial_ports=comports,
             board_id=board_id,
-            version=params.versions[0],
-            custom=params.custom,
+            custom_firmware=params.custom,
         )
-    # if serial port == auto and there are one or more specified/detected boards
     elif params.serial == ["*"] and params.boards:
+        # Auto mode on detected boards with optional include/ignore filtering
         if not all_boards:
             log.trace("No boards detected yet, scanning for connected boards")
             _, _, _, all_boards = connected_ports_boards_variants(include=params.ports, ignore=params.ignore)
-        # if variant id provided on the cmdline, treat is as an override
         if params.variant:
             for b in all_boards:
                 b.variant = params.variant if (params.variant.lower() not in {"-", "none"}) else ""
-
-        worklist = full_auto_worklist(
-            all_boards=all_boards,
-            version=params.versions[0],
-            include=params.serial,
-            ignore=params.ignore,
+        tasks = create_worklist(
+            params.versions[0],
+            connected_comports=all_boards,
+            include_ports=params.serial,
+            ignore_ports=params.ignore,
         )
-    elif params.versions[0] and params.boards[0] and params.serial:
-        # A one or more serial port including the board / variant
+    elif params.versions[0] and params.boards and params.serial:
+        # Manual specification of serial ports + board
         comports = filtered_comports(
             ignore=params.ignore,
-            include=params.ports,
+            include=params.serial,
             bluetooth=params.bluetooth,
         )
-        worklist = manual_worklist(
-            comports,
+        tasks = create_worklist(
+            params.versions[0],
+            serial_ports=comports,
             board_id=params.boards[0],
-            version=params.versions[0],
         )
     else:
-        # just this serial port on auto
-        worklist = single_auto_worklist(
-            serial=params.serial[0],
-            version=params.versions[0],
+        # Single serial port auto-detection
+        connected_comports = [MPRemoteBoard(params.serial[0])]
+        tasks = create_worklist(
+            params.versions[0],
+            connected_comports=connected_comports,
         )
     if not params.custom:
-        jid.ensure_firmware_downloaded(worklist, version=params.versions[0], force=params.force)
-    if flashed := flash_list(
-        worklist,
+        jid.ensure_firmware_downloaded_tasks(tasks, version=params.versions[0], force=params.force)
+    if flashed := flash_tasks(
+        tasks,
         params.erase,
         params.bootloader,
         flash_mode=params.flash_mode,

mpflash/connected.py

@@ -47,8 +47,6 @@ def list_mcus(*, ignore: List[str], include: List[str], bluetooth: bool = False)
     Raises:
         ConnectionError: If there is an error connecting to a board.
     """
-    # conn_mcus = [MPRemoteBoard(sp) for sp in MPRemoteBoard.connected_boards(bluetooth) if sp not in config.ignore_ports]
-    vid_pid = True
     comports = filtered_portinfos(
         ignore=ignore,
         include=include,

mpflash/db/boards_version.txt

@@ -0,0 +1 @@
+v1.27.0-preview

mpflash/db/core.py

@@ -9,7 +9,6 @@ from sqlalchemy.orm import sessionmaker
 from mpflash.config import config
 from mpflash.errors import MPFlashError
 
-# TODO:  lazy import to avoid slowdowns ?
 from .models import Base
 
 TRACE = False

mpflash/db/gather_boards.py

@@ -1,6 +1,9 @@
 from os import path
 from pathlib import Path
-from typing import List
+from typing import List, Optional, Tuple
+
+import click
+from typing_extensions import TypeAlias
 
 import mpflash.basicgit as git
 from mpflash.logger import log
@@ -8,6 +11,8 @@ from mpflash.mpremoteboard import HERE
 from mpflash.vendor.board_database import Database
 from mpflash.versions import micropython_versions
 
+BoardList: TypeAlias = List[Tuple[str, ...]]
+
 HERE = Path(__file__).parent.resolve()
 
 
@@ -47,7 +52,7 @@ def boardlist_from_repo(
     versions: List[str],
     mpy_dir: Path,
 ):
-    longlist = []
+    longlist: BoardList = []
     if not mpy_dir.is_dir():
         log.error(f"Directory {mpy_dir} not found")
         return longlist
@@ -71,38 +76,63 @@ def boardlist_from_repo(
         log.info(f"{git.get_git_describe(mpy_dir)} - {build_nr}")
         # un-cached database
         db = Database(mpy_dir)
-        shortlist = list(iter_boards(db, version=version))
+        shortlist: BoardList = list(iter_boards(db, version=version))
         log.info(f"boards found {len(db.boards.keys())}")
         log.info(f"boards-variants found {len(shortlist) - len(db.boards.keys())}")
         longlist.extend(shortlist)
     return longlist
 
 
-def create_zip_file(longlist, zip_file: Path):
-    """Create a ZIP file containing the CSV data."""
-    # lazy import
-    import zipfile
+def create_zip_file(longlist: BoardList, zip_file: Path):
+    """Create a ZIP file containing the CSV data without external deps.
 
-    import pandas as pd
+    Uses the standard library csv module to minimize dependencies while
+    preserving identical column ordering to the prior pandas implementation.
+    """
+    import csv
+    import io
+    import zipfile  # lazy import
 
     csv_filename = "micropython_boards.csv"
+    columns = [
+        "version",
+        "board_id",
+        "board_name",
+        "mcu",
+        "variant",
+        "port",
+        "path",
+        "description",
+        "family",
+    ]
+
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(columns)
+    # rows already in correct order matching columns
+    for row in longlist:
+        writer.writerow(row)
+    csv_data = buf.getvalue()
 
-    columns = ["version", "board_id", "board_name", "mcu", "variant", "port", "path", "description", "family"]
-    df = pd.DataFrame(longlist, columns=columns)
-
-    # Create the ZIP file and add the CSV data directly without creating an intermediate file
     with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
-        # Create a temporary in-memory CSV string
-        csv_data = df.to_csv(index=False)
-        # Write the CSV data directly to the zip file
         zipf.writestr(csv_filename, csv_data)
 
 
+def write_version_file(version: str, output_path: Path):
+    version_file = output_path / "boards_version.txt"
+    with version_file.open("w", encoding="utf-8") as vf:
+        vf.write(version + "\n")
+    log.info(f"Wrote version file {version_file}")
+
+
 def package_repo(mpy_path: Path):
     mpy_path = mpy_path or Path("../repos/micropython")
     log.info(f"Packaging Micropython boards from {mpy_path}")
     mp_versions = micropython_versions(minver="1.18")
-    # checkput
+    if not mp_versions:
+        log.error("No Micropython versions found")
+        return
+    # checkout
     longlist = boardlist_from_repo(
         versions=mp_versions,
         mpy_dir=mpy_path,
@@ -110,9 +140,29 @@ def package_repo(mpy_path: Path):
     log.info(f"Total boards-variants: {len(longlist)}")
     zip_file = HERE / "micropython_boards.zip"
     create_zip_file(longlist, zip_file=zip_file)
+    log.info(f"Created {zip_file} with {len(longlist)} entries")
+    boards_version = mp_versions[-1]
+    write_version_file(boards_version, HERE)
 
     assert zip_file.is_file(), f"Failed to create {zip_file}"
 
 
+@click.command()
+@click.option(
+    "--mpy-path",
+    "mpy_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Path to local micropython repo (default: ../repos/micropython).",
+)
+def cli(mpy_path: Optional[Path]):
+    """Package board metadata into a compressed archive.
+
+    Enumerates boards and variants from a Micropython repo, builds CSV, and
+    writes it into a zip archive for fast loading and distribution.
+    """
+    package_repo(mpy_path if mpy_path else Path("../repos/micropython"))
+
+
 if __name__ == "__main__":
-    package_repo(Path("D:\\mypython\\mpflash\\repos\\micropython"))
+    cli()

mpflash/db/loader.py

@@ -4,7 +4,6 @@ import json
 import re
 import zipfile
 from pathlib import Path
-from turtle import up
 
 from loguru import logger as log
 
@@ -108,8 +107,22 @@ def load_jsonl_to_db(jsonl_path: Path):
     return num_records
 
 
+def get_boards_version() -> str:
+    version_file = HERE / "boards_version.txt"
+    if version_file.is_file():
+        with version_file.open("r", encoding="utf-8") as vf:
+            version = vf.read().strip()
+            log.debug(f"Boards version from file: {version}")
+            return version
+    log.warning(f"Boards version file not found: {version_file}")
+    return "unknown"
+
+
 def update_boards():
-    boards_version = "v1.25.2"
+    # todo: check if update is needed
+    # load board_versions.txt
+
+    boards_version = get_boards_version()
     try:
         meta = get_metadata()
         log.debug(f"Metadata: {meta}")

mpflash/download/__init__.py

@@ -12,16 +12,16 @@ from typing import Dict, List, Optional
 # make sure that jsonlines does not mistake the MicroPython ujson for the CPython ujson
 import jsonlines
 from loguru import logger as log
-from rich.progress import track
-
 from mpflash.common import PORT_FWTYPES
 from mpflash.config import config
-from mpflash.db.core import Session
-from mpflash.db.models import Firmware, Board
 from mpflash.downloaded import clean_downloaded_firmwares
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id.alternate import add_renamed_boards
 from mpflash.versions import clean_version
+from rich.progress import track
+
+from mpflash.db.core import Session
+from mpflash.db.models import Board, Firmware
 
 from .from_web import fetch_firmware_files, get_boards
 from .fwinfo import FWInfo
@@ -111,11 +111,7 @@ def download_firmwares(
 
     downloaded = 0
     versions = [] if versions is None else [clean_version(v) for v in versions]
-    
-    # remove the known variant suffixes from the boards
-    # TODO: IS THIS REALLY NEEDED ?
-    # boards = [strip_variant(b) for b in boards]
-    
+
     # handle downloading firmware for renamed boards
     boards = add_renamed_boards(boards)
 

mpflash/download/jid.py

@@ -1,56 +1,50 @@
 # Just In-time Download of firmware if not already available
+import warnings
+
 from loguru import logger as log
 
-from mpflash.common import Params
 from mpflash.download import download
 from mpflash.downloaded import find_downloaded_firmware
 from mpflash.errors import MPFlashError
-from mpflash.flash.worklist import WorkList
+from mpflash.flash.worklist import FlashTaskList
 from mpflash.mpboard_id.alternate import alternate_board_names
 
 
-def ensure_firmware_downloaded(worklist: WorkList, version: str, force: bool) -> None:
-    """
-    Ensure all firmware in the worklist is downloaded for the given version.
-
-    Iterates over the worklist, downloads missing firmware, and updates the worklist
-    with the downloaded firmware.
+def ensure_firmware_downloaded_tasks(tasks: FlashTaskList, version: str, force: bool) -> None:
+    """Ensure firmware present for each FlashTask, updating in-place.
 
-    Raises MPFlashError if download fails.
+    Mirrors ensure_firmware_downloaded logic but works directly on FlashTaskList.
     """
-    # iterate over the worklist ann update missing firmware
-    newlist: WorkList = []
-    for mcu, firmware in worklist:
-        if force:
-            board_firmwares = []
-        else:
-            if firmware:
-                # firmware is already downloaded
-                newlist.append((mcu, firmware))
-                continue
-            # check if the firmware is already downloaded
-            board_firmwares = find_downloaded_firmware(
-                board_id=f"{mcu.board}-{mcu.variant}" if mcu.variant else mcu.board,
-                version=version,
-                port=mcu.port,
+    updated: FlashTaskList = []
+    for task in tasks:
+        mcu = task.board
+        fw = task.firmware
+        if not force and fw:
+            updated.append(task)
+            continue
+        # find already downloaded firmware unless forcing
+        if force or not fw:
+            found = (
+                find_downloaded_firmware(
+                    board_id=f"{mcu.board}-{mcu.variant}" if mcu.variant else mcu.board,
+                    version=version,
+                    port=mcu.port,
+                )
+                if not force
+                else []
             )
-        if not board_firmwares:
-            # download the firmware
-            log.info(f"Downloading {version} firmware for {mcu.board} on {mcu.serialport}.")
-            download(ports=[mcu.port], boards=alternate_board_names(mcu.board, mcu.port), versions=[version], force=True, clean=True)
-            new_firmware = find_downloaded_firmware(
-                board_id=f"{mcu.board}-{mcu.variant}" if mcu.variant else mcu.board,
-                version=version,
-                port=mcu.port,
-            )
-            if not new_firmware:
-                raise MPFlashError(f"Failed to download {version} firmware for {mcu.board} on {mcu.serialport}.")
-            newlist.append((mcu, new_firmware[0]))
-        else:
-            log.info(f"Found {version} firmware {board_firmwares[-1].firmware_file} for {mcu.board} on {mcu.serialport}.")
-            newlist.append((mcu, board_firmwares[0]))
-
-    worklist.clear()
-    worklist.extend(newlist)
-
-    pass
+            if not found:
+                log.info(f"Downloading {version} firmware for {mcu.board} on {mcu.serialport}.")
+                download(ports=[mcu.port], boards=alternate_board_names(mcu.board, mcu.port), versions=[version], force=True, clean=True)
+                found = find_downloaded_firmware(
+                    board_id=f"{mcu.board}-{mcu.variant}" if mcu.variant else mcu.board,
+                    version=version,
+                    port=mcu.port,
+                )
+                if not found:
+                    raise MPFlashError(f"Failed to download {version} firmware for {mcu.board} on {mcu.serialport}.")
+            # choose last/newest
+            task.firmware = found[-1]
+        updated.append(task)
+    tasks.clear()
+    tasks.extend(updated)

mpflash/flash/__init__.py

@@ -1,8 +1,6 @@
 from pathlib import Path
 
 from loguru import logger as log
-
-from mpflash.bootloader.activate import enter_bootloader
 from mpflash.common import PORT_FWTYPES, UF2_PORTS, BootloaderMethod
 from mpflash.config import config
 from mpflash.errors import MPFlashError
@@ -10,28 +8,29 @@ from mpflash.errors import MPFlashError
 from .esp import flash_esp
 from .stm32 import flash_stm32
 from .uf2 import flash_uf2
-from .worklist import WorkList
+from .worklist import FlashTaskList
 
 # #########################################################################################################
 
-def flash_list(
-    todo: WorkList,
+
+def flash_tasks(
+    tasks: FlashTaskList,
     erase: bool,
     bootloader: BootloaderMethod,
-    **kwargs
-):  # sourcery skip: use-named-expression
-    """Flash a list of boards with the specified firmware."""
+    **kwargs,
+):
+    """Flash a list of FlashTask items directly."""
     flashed = []
-    for mcu, fw_info in todo:
+    for task in tasks:
+        mcu = task.board
+        fw_info = task.firmware
         if not fw_info:
             log.error(f"Firmware not found for {mcu.board} on {mcu.serialport}, skipping")
             continue
-
         fw_file = config.firmware_folder / fw_info.firmware_file
         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}")
         try:
             updated = flash_mcu(mcu, fw_file=fw_file, erase=erase, bootloader=bootloader, **kwargs)
@@ -40,14 +39,13 @@ def flash_list(
             continue
         if updated:
             if fw_info.custom:
-                # Add / Update board_info.toml with the custom_id and Description
                 mcu.get_board_info_toml()
                 if fw_info.description:
                     mcu.toml["description"] = fw_info.description
+                mcu.toml.setdefault("mpflash", {})
                 mcu.toml["mpflash"]["board_id"] = fw_info.board_id
                 mcu.toml["mpflash"]["custom_id"] = fw_info.custom_id
                 mcu.set_board_info_toml()
-
             flashed.append(updated)
         else:
             log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
@@ -63,6 +61,8 @@ def flash_mcu(
         **kwargs
     ):
         """Flash a single MCU with the specified firmware."""
+        from mpflash.bootloader.activate import enter_bootloader
+        
         updated = None
         try:
             if mcu.port in UF2_PORTS and fw_file.suffix == ".uf2":