mpflash 1.24.7__py3-none-any.whl → 1.25.0__py3-none-any.whl

mpflash/flash/esp.py

@@ -5,7 +5,7 @@
 """
 
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 import esptool
 from loguru import logger as log
@@ -13,8 +13,16 @@ from loguru import logger as log
 from mpflash.mpboard_id import find_known_board
 from mpflash.mpremoteboard import MPRemoteBoard
 
+FlashMode = Literal["keep", "qio", "qout", "dio", "dout"]
 
-def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optional[MPRemoteBoard]:
+def flash_esp(
+    mcu: MPRemoteBoard,
+    fw_file: Path,
+    *,
+    erase: bool = True,
+    flash_mode: FlashMode = "keep",  # keep, qio, qout, dio, dout
+    flash_size: str = "detect",
+) -> Optional[MPRemoteBoard]:
     if mcu.port not in ["esp32", "esp8266"] or mcu.board.startswith("ARDUINO_"):
         log.error(f"esptool not supported for {mcu.port} {mcu.board} on {mcu.serialport}")
         return None
@@ -25,26 +33,49 @@ def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optio
         mcu.cpu = find_known_board(mcu.board).cpu
 
     cmds: List[List[str]] = []
-    if erase:
-        cmds.append(f"esptool --chip {mcu.cpu} --port {mcu.serialport} erase_flash".split())
 
+    chip = "auto"
+    start_addr = "0x0"
     if mcu.cpu.upper().startswith("ESP32"):
+        start_addr = "0x0"
+
         baud_rate = str(921_600)
-        if mcu.cpu.upper() in ("ESP32", "ESP32S2"):
+        if mcu.cpu.upper() == "ESP32":
+            start_addr = "0x1000"
+            chip = "esp32"
+        elif "C2" in mcu.cpu.upper():
+            start_addr = "0x1000"
+            chip = "esp32c2"
+        elif "S2" in mcu.cpu.upper():
             start_addr = "0x1000"
-        elif mcu.cpu.upper() in ("ESP32S3", "ESP32C3"):
+            chip = "esp32s2"
+            baud_rate = str(460_800)
+        elif "S3" in mcu.cpu.upper():
             start_addr = "0x0"
+            chip = "esp32s3"
+        elif "C3" in mcu.cpu.upper():
+            start_addr = "0x0"
+            chip = "esp32c3"
+        elif "C6" in mcu.cpu.upper():
+            start_addr = "0x0"
+            chip = "esp32c6"
+            baud_rate = str(460_800)
+
         cmds.append(
-            f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --compress {start_addr}".split()
+            f"esptool --chip {chip} --port {mcu.serialport} -b {baud_rate} write_flash --flash_mode {flash_mode} --flash_size {flash_size} --compress {start_addr}".split()
             + [str(fw_file)]
         )
     elif mcu.cpu.upper() == "ESP8266":
         baud_rate = str(460_800)
         start_addr = "0x0"
+        chip = "esp8266"
         cmds.append(
-            f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --flash_size=detect {start_addr}".split()
+            f"esptool --chip {chip} --port {mcu.serialport} -b {baud_rate} write_flash --flash_mode {flash_mode} --flash_size=detect {start_addr}".split()
             + [str(fw_file)]
         )
+    # now that we have the chip, we can do the erare properly
+    if erase:
+        cmds.insert(0, f"esptool --chip {chip} --port {mcu.serialport} erase_flash".split())
     try:
         for cmd in cmds:
             log.info(f"Running {' '.join(cmd)} ")

mpflash/flash/uf2/linux.py

@@ -1,4 +1,4 @@
-""" Flashing UF2 based MCU on Linux"""
+"""Flashing UF2 based MCU on Linux"""
 
 # sourcery skip: snake-case-functions
 from __future__ import annotations
@@ -42,10 +42,7 @@ def get_uf2_drives():
             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"
-            ):
+            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()
@@ -69,9 +66,7 @@ def pmount(disk: UF2Disk):
             # 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."
-            )
+            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)
@@ -89,7 +84,7 @@ def pumount(disk: UF2Disk):
     if disk.mountpoint:
         subprocess.run(["pumount", disk.mountpoint])  # ), f"/media/{disk.label}"])
         log.info(f"Unmounted {disk.label} from {disk.mountpoint}")
-        disk.mountpoint = f""
+        disk.mountpoint = ""
     else:
         log.warning(f"{disk.label} already dismounted")
 

mpflash/flash/uf2/macos.py

@@ -1,4 +1,4 @@
-""" Flashing UF2 based MCU on macos"""
+"""Flashing UF2 based MCU on macos"""
 
 # sourcery skip: snake-case-functions
 from __future__ import annotations

mpflash/flash/uf2/windows.py

@@ -12,7 +12,7 @@ import psutil
 from rich.progress import track
 
 
-def wait_for_UF2_windows(board_id: str, s_max: int = 10)-> Optional[Path]:
+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

mpflash/flash/worklist.py

@@ -43,8 +43,8 @@ def auto_update(
             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,
+            db_path=fw_folder,
+            board_id=mcu.board if not mcu.variant else f"{mcu.board}-{mcu.variant}",
             version=target_version,
             port=mcu.port,
             selector=selector,
@@ -91,11 +91,11 @@ def manual_worklist(
         # 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.error(f"Board {board_id} not found in board database")
         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)
+    firmwares = find_downloaded_firmware(db_path=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 []
@@ -127,7 +127,12 @@ def single_auto_worklist(
 
 
 def full_auto_worklist(
-    all_boards: List[MPRemoteBoard], *, include: List[str], ignore: List[str], version: str, fw_folder: Path
+    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.

mpflash/list.py

@@ -14,13 +14,16 @@ def show_mcus(
     conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
+    *,
+    title_style="magenta",
+    header_style="bold magenta",    
 ):
-    console.print(mcu_table(conn_mcus, title, refresh))
+    console.print(mcu_table(conn_mcus, title, refresh, title_style=title_style, header_style=header_style))
 
 
 def abbrv_family(family: str, is_wide: bool) -> str:
     if not is_wide:
-        ABRV = {"micropython": "upy", "circuitpython": "cpy", "unknown": "?"}
+        ABRV = {"micropython": "mpy", "circuitpython": "cpy", "unknown": "?"}
         return ABRV.get(family, family[:4])
     return family
 
@@ -29,15 +32,19 @@ def mcu_table(
     conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
+    *,
+    title_style="magenta",
+    header_style="bold magenta",
 ):
     """
     builds a rich table with the connected boards information
-    The columns of the table are adjusted to the terminal width
+    The columns of the table are adjusted to the terminal width > 90 
     the columns are :
                 Narrow      Wide
     - Serial    Yes         Yes
     - Family    abbrv.      Yes
     - Port      -           yes
+    - Variant   Yes         Yes     only if any of the mcus have a variant
     - Board     Yes         Yes     BOARD_ID and Description, and the description from board_info.toml
     - CPU       -           Yes
     - Version   Yes         Yes
@@ -59,8 +66,8 @@ def mcu_table(
                 continue
     table = Table(
         title=title,
-        title_style="magenta",
-        header_style="bold magenta",
+        title_style=title_style,
+        header_style=header_style,
         collapse_padding=True,
         padding=(0, 0),
     )
@@ -68,13 +75,15 @@ def mcu_table(
     # check if the terminal is wide enough to show all columns or if we need to collapse some
     is_wide = console.width > 99
     needs_build = any(mcu.build for mcu in conn_mcus)
+    needs_variant = any(mcu.variant for mcu in conn_mcus)
 
     table.add_column("Serial" if is_wide else "Ser.", overflow="fold")
     table.add_column("Family" if is_wide else "Fam.", overflow="crop", max_width=None if is_wide else 4)
     if is_wide:
         table.add_column("Port")
     table.add_column("Board", overflow="fold")
-    # table.add_column("Variant") # TODO: add variant
+    if needs_variant:
+        table.add_column("Variant") 
     if is_wide:
         table.add_column("CPU")
     table.add_column("Version", overflow="fold", min_width=5, max_width=16)
@@ -94,6 +103,8 @@ def mcu_table(
         if is_wide:
             row.append(mcu.port)
         row.append(f"{mcu.board}\n{description}".strip())
+        if needs_variant:
+            row.append(mcu.variant)
         if is_wide:
             row.append(mcu.cpu)
         row.append(clean_version(mcu.version))

mpflash/logger.py

@@ -20,9 +20,7 @@ def _log_formatter(record: dict) -> str:
         "CRITICAL": "bold white on red",
     }
     lvl_color = color_map.get(record["level"].name, "cyan")
-    return (
-        "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
-    )
+    return "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
 
 
 def set_loglevel(loglevel: str):

mpflash/mpboard_id/__init__.py

@@ -6,93 +6,12 @@ that is included in the module.
 
 from functools import lru_cache
 from typing import List, Optional, Tuple
-
+import importlib
 from mpflash.errors import MPFlashError
-from mpflash.mpboard_id.board import Board
-from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.versions import clean_version
-
-# KNOWN ports and boards are sourced from the micropython repo,
-# this info is stored in the board_info.json file
-
-
-def get_known_ports() -> List[str]:
-    # TODO: Filter for Version
-    mp_boards = read_known_boardinfo()
-    # select the unique ports from info
-    ports = set({board.port for board in mp_boards if board.port})
-    return sorted(list(ports))
-
-
-def get_known_boards_for_port(
-    port: Optional[str] = "", versions: Optional[List[str]] = None
-) -> List[Board]:
-    """
-    Returns a list of boards for the given port and version(s)
-
-    port: The Micropython port to filter for
-    versions:  Optional, The Micropython versions to filter for (actual versions required)
-    """
-    mp_boards = read_known_boardinfo()
-    if versions:
-        preview_or_stable = "preview" in versions or "stable" in versions
-    else:
-        preview_or_stable = False
-
-    # filter for 'preview' as they are not in the board_info.json
-    # instead use stable version
-    versions = versions or []
-    if "preview" in versions:
-        versions.remove("preview")
-        versions.append("stable")
-    if versions:
-        # make sure of the v prefix
-        versions = [clean_version(v) for v in versions]
-        # filter for the version(s)
-        mp_boards = [board for board in mp_boards if board.version in versions]
-        if not mp_boards and preview_or_stable:
-            # nothing found - perhaps there is a newer version for which we do not have the board info yet
-            # use the latest known version from the board info
-            mp_boards = read_known_boardinfo()
-            last_known_version = sorted({b.version for b in mp_boards})[-1]
-            mp_boards = [board for board in mp_boards if board.version == last_known_version]
-
-    # filter for the port
-    if port:
-        mp_boards = [board for board in mp_boards if board.port == port]
-    return mp_boards
-
-
-def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List[Tuple[str, str]]:
-    """
-    Returns a list of tuples with the description and board name for the given port and version
-
-    port : str : The Micropython port to filter for
-    versions : List[str] : The Micropython versions to filter for (actual versions required)
-    """
-    mp_boards = get_known_boards_for_port(port, versions)
-
-    boards = set({(f"{board.version} {board.description}", board.board_id) for board in mp_boards})
-    return sorted(list(boards))
+from .board import Board
 
+from mpflash.versions import clean_version
+from .store import read_known_boardinfo
+from .known import get_known_ports, get_known_boards_for_port
+from .known import known_stored_boards, find_known_board
 
-@lru_cache(maxsize=20)
-def find_known_board(board_id: str) -> Board:
-    """Find the board for the given BOARD_ID or 'board description' and return the board info as a Board object"""
-    # Some functional overlap with:
-    # mpboard_id\board_id.py _find_board_id_by_description
-    info = read_known_boardinfo()
-    for board_info in info:
-        if board_id in (
-            board_info.board_id,
-            board_info.description,
-        ) or board_info.description.startswith(board_id):
-            if not board_info.cpu:
-                # failsafe for older board_info.json files
-                print(f"Board {board_id} has no CPU info, using port as CPU")
-                if " with " in board_info.description:
-                    board_info.cpu = board_info.description.split(" with ")[-1]
-                else:
-                    board_info.cpu = board_info.port
-            return board_info
-    raise MPFlashError(f"Board {board_id} not found")

mpflash/mpboard_id/add_boards.py

@@ -16,8 +16,7 @@ import mpflash.basicgit as git
 from mpflash.logger import log
 from mpflash.mpboard_id import Board
 from mpflash.mpboard_id.store import write_boardinfo_json
-from mpflash.versions import (get_preview_mp_version, get_stable_mp_version,
-                              micropython_versions)
+from mpflash.versions import get_preview_mp_version, micropython_versions
 
 # look for all mpconfigboard.h files and extract the board name
 # from the #define MICROPY_HW_BOARD_NAME "PYBD_SF6"
@@ -25,9 +24,7 @@ from mpflash.versions import (get_preview_mp_version, get_stable_mp_version,
 RE_H_MICROPY_HW_BOARD_NAME = re.compile(r"#define\s+MICROPY_HW_BOARD_NAME\s+\"(.+)\"")
 RE_H_MICROPY_HW_MCU_NAME = re.compile(r"#define\s+MICROPY_HW_MCU_NAME\s+\"(.+)\"")
 # find boards and variants in the mpconfigboard*.cmake files
-RE_CMAKE_MICROPY_HW_BOARD_NAME = re.compile(
-    r"MICROPY_HW_BOARD_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\""
-)
+RE_CMAKE_MICROPY_HW_BOARD_NAME = re.compile(r"MICROPY_HW_BOARD_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\"")
 RE_CMAKE_MICROPY_HW_MCU_NAME = re.compile(r"MICROPY_HW_MCU_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\"")
 # TODO: normal make files
 
@@ -121,9 +118,7 @@ def boards_from_headers(mpy_path: Path, version: str, family: str):
                     mcu_name = match[1]
                     found += 1
                 if found == 2:
-                    description = (
-                        f"{board_name} with {mcu_name}" if mcu_name != "-" else board_name
-                    )
+                    description = f"{board_name} with {mcu_name}" if mcu_name != "-" else board_name
                     board_list.append(
                         Board(
                             board_id=board,

mpflash/mpboard_id/board.py

@@ -21,17 +21,20 @@ class Board:
     mcu_name: str = field(default="")
     cpu: str = field(default="")
     variant: str = field(default="")
+    mcu: str = field(default="")
 
     def __post_init__(self):
         if not self.cpu:
             if " with " in self.description:
-                self.cpu = self.description.split(" with ")[-1]
+                self.cpu = self.description.rsplit(" with ")[-1]
             else:
                 self.cpu = self.port
 
     @staticmethod
     def from_dict(data: dict) -> "Board":
-        return Board(**data)
+        valid_keys = {field.name for field in Board.__dataclass_fields__.values()}
+        filtered_data = {k: v for k, v in data.items() if k in valid_keys}
+        return Board(**filtered_data)
 
     def to_dict(self) -> dict:
         return self.__dict__

mpflash/mpboard_id/board_id.py

@@ -3,11 +3,15 @@ Translate board description to board designator
 """
 
 import functools
+import re
+import sqlite3
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
+from mpflash.config import config
 from mpflash.errors import MPFlashError
 from mpflash.logger import log
+from mpflash.mpboard_id.board import Board
 from mpflash.mpboard_id.store import read_known_boardinfo
 from mpflash.versions import clean_version, get_preview_mp_version, get_stable_mp_version
 
@@ -20,21 +24,78 @@ def find_board_id_by_description(
     board_info: Optional[Path] = None,
 ) -> Optional[str]:
     """Find the MicroPython BOARD_ID based on the description in the firmware"""
-
+    version = clean_version(version) if version else ""
     try:
         boards = _find_board_id_by_description(
             descr=descr,
             short_descr=short_descr,
-            board_info=board_info,
-            version=clean_version(version) if version else None,
+            db_path=board_info,
+            version=version,
         )
-        return boards[-1].board_id
+        if not boards:
+            log.debug(f"Version {version} not found in board info, using any version")
+            boards = _find_board_id_by_description(
+                descr=descr,
+                short_descr=short_descr,
+                db_path=board_info,
+                version="%",  # any version
+            )
+        return boards[0].board_id if boards else None
     except MPFlashError:
         return "UNKNOWN_BOARD"
 
 
-@functools.lru_cache(maxsize=20)
 def _find_board_id_by_description(
+    *,
+    descr: str,
+    short_descr: str,
+    version: Optional[str] = None,
+    variant: str = "",
+    db_path: Optional[Path] = None,
+):
+    short_descr = short_descr or ""
+    boards: List[Board] = []
+    version = clean_version(version) if version else "%"
+    if "-preview" in version:
+        version = version.replace("-preview", "%")
+    descriptions = [descr, short_descr]
+    if descr.startswith("Generic"):
+        descriptions.append(descr[8:])
+        descriptions.append(short_descr[8:])
+
+    try:
+        with sqlite3.connect(db_path or config.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+
+            qry = f"""
+            SELECT 
+                *
+            FROM board_downloaded
+            WHERE 
+                board_id IN (
+                    SELECT  DISTINCT board_id
+                    FROM board_downloaded
+                    WHERE description IN {str(tuple(descriptions))}
+                )
+                AND version like '{version}'
+                AND variant like '{variant}'
+            """
+            cursor.execute(qry)
+            rows = cursor.fetchall()
+            for row in rows:
+                r = dict(row)
+
+                boards.append(Board.from_dict(dict(row)))
+    except sqlite3.OperationalError as e:
+        raise MPFlashError("Database error") from e
+    if not boards:
+        raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
+    return boards
+
+
+@functools.lru_cache(maxsize=20)
+def _find_board_id_by_description_xx(
     *,
     descr: str,
     short_descr: str,
@@ -89,4 +150,3 @@ def _find_board_id_by_description(
     if not matches:
         raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
     return sorted(matches, key=lambda x: x.version)
-