micropython-stubber 1.17.5__py3-none-any.whl → 1.19.0__py3-none-any.whl

mpflash/mpflash/vendor/versions.py

@@ -0,0 +1,113 @@
+"""
+#############################################################
+# Version handling copied from stubber/utils/versions.py
+#############################################################
+"""
+
+from functools import lru_cache
+
+from loguru import logger as log
+from packaging.version import parse
+
+V_PREVIEW = "preview"
+"Latest preview version"
+
+SET_PREVIEW = {"preview", "latest", "master"}
+
+
+def clean_version(
+    version: str,
+    *,
+    build: bool = False,
+    patch: bool = False,
+    commit: bool = False,
+    drop_v: bool = False,
+    flat: bool = False,
+):
+    "Clean up and transform the many flavours of versions"
+    # 'v1.13.0-103-gb137d064e' --> 'v1.13-103'
+    if version in {"", "-"}:
+        return version
+    if version.lower() == "stable":
+        _v = get_stable_mp_version()
+        if not _v:
+            log.warning("Could not determine the latest stable version")
+            return "stable"
+        version = _v
+        log.trace(f"Using latest stable version: {version}")
+    is_preview = "-preview" in version
+    nibbles = version.split("-")
+    ver_ = nibbles[0].lower().lstrip("v")
+    if not patch and ver_ >= "1.10.0" and ver_ < "1.20.0" and ver_.endswith(".0"):
+        # remove the last ".0" - but only for versions between 1.10 and 1.20 (because)
+        nibbles[0] = nibbles[0][:-2]
+    if len(nibbles) == 1:
+        version = nibbles[0]
+    elif build and not is_preview:
+        version = "-".join(nibbles) if commit else "-".join(nibbles[:-1])
+    else:
+        # version = "-".join((nibbles[0], LATEST))
+        # HACK: this is not always right, but good enough most of the time
+        if is_preview:
+            version = "-".join((nibbles[0], V_PREVIEW))
+        else:
+            version = V_PREVIEW
+    if flat:
+        version = version.strip().replace(".", "_").replace("-", "_")
+    else:
+        version = version.strip().replace("_preview", "-preview").replace("_", ".")
+
+    if drop_v:
+        version = version.lstrip("v")
+    elif not version.startswith("v") and version.lower() not in SET_PREVIEW:
+        version = "v" + version
+    if version in SET_PREVIEW:
+        version = V_PREVIEW
+    return version
+
+
+@lru_cache(maxsize=10)
+def micropython_versions(minver: str = "v1.20"):
+    """Get the list of micropython versions from github tags"""
+    try:
+        gh_client = GH_CLIENT
+        repo = gh_client.get_repo("micropython/micropython")
+        versions = [tag.name for tag in repo.get_tags() if parse(tag.name) >= parse(minver)]
+    except Exception:
+        versions = [
+            "v9.99.9-preview",
+            "v1.22.2",
+            "v1.22.1",
+            "v1.22.0",
+            "v1.21.1",
+            "v1.21.0",
+            "v1.20.0",
+            "v1.19.1",
+            "v1.19",
+            "v1.18",
+            "v1.17",
+            "v1.16",
+            "v1.15",
+            "v1.14",
+            "v1.13",
+            "v1.12",
+            "v1.11",
+            "v1.10",
+        ]
+        versions = [v for v in versions if parse(v) >= parse(minver)]
+    return sorted(versions)
+
+
+def get_stable_mp_version() -> str:
+    # read the versions from the git tags
+    all_versions = micropython_versions(minver="v1.17")
+    return [v for v in all_versions if not v.endswith(V_PREVIEW)][-1]
+
+
+def get_preview_mp_version() -> str:
+    # read the versions from the git tags
+    all_versions = micropython_versions(minver="v1.17")
+    return [v for v in all_versions if v.endswith(V_PREVIEW)][-1]
+
+
+#############################################################

mpflash/mpflash/worklist.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from loguru import logger as log
+
+from mpflash.common import FWInfo
+from mpflash.errors import MPFlashError
+
+from .config import config
+from .downloaded import find_downloaded_firmware
+from .list import show_mcus
+from .mpboard_id import find_stored_board
+from .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 firmware available
+
+    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.debug(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 single_auto_worklist(
+    *,
+    serial_port: 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
+    """
+    conn_boards = [MPRemoteBoard(serial_port)]
+    todo = auto_update(conn_boards, version, fw_folder)  # type: ignore # List / list
+    show_mcus(conn_boards)  # type: ignore
+    return todo
+
+
+def full_auto_worklist(*, 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
+    """
+    try:
+        conn_boards = [
+            MPRemoteBoard(sp, update=True) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports
+        ]
+    except ConnectionError as e:
+        log.error(f"Error connecting to boards: {e}")
+        return []
+    return auto_update(conn_boards, version, fw_folder)  # type: ignore
+
+
+def manual_worklist(
+    version: str,
+    fw_folder: Path,
+    serial_port: str,
+    board: str,
+    # port: str,
+) -> WorkList:
+    """Create a worklist for a single board specified manually.
+
+    Args:
+        version (str): Firmware version
+        fw_folder (Path): Path to the firmware folder
+        serial_port (str): Serial port of the board
+        board (str): Board name
+
+    Returns:
+        WorkList: List of boards and firmware information to update
+    """
+    mcu = MPRemoteBoard(serial_port)
+    # TODO : Find a way to avoid needing to specify the port
+    # Lookup the matching port and cpu in board_info based in the board name
+    try:
+        info = find_stored_board(board)
+        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} not found in board_info.json")
+        return []
+    mcu.board = board
+    firmwares = find_downloaded_firmware(fw_folder=fw_folder, board_id=board, version=version, port=mcu.port)
+    if not firmwares:
+        log.error(f"No firmware found for {mcu.port} {board} version {version}")
+        return []
+        # use the most recent matching firmware
+    return [(mcu, firmwares[-1])]  # type: ignore