mpflash 1.25.0.post1__py3-none-any.whl → 1.25.0.post3__py3-none-any.whl

mpflash/list.py

@@ -16,7 +16,7 @@ def show_mcus(
     refresh: bool = True,
     *,
     title_style="magenta",
-    header_style="bold magenta",    
+    header_style="bold magenta",
 ):
     console.print(mcu_table(conn_mcus, title, refresh, title_style=title_style, header_style=header_style))
 
@@ -38,7 +38,7 @@ def mcu_table(
 ):
     """
     builds a rich table with the connected boards information
-    The columns of the table are adjusted to the terminal width > 90 
+    The columns of the table are adjusted to the terminal width > 90
     the columns are :
                 Narrow      Wide
     - Serial    Yes         Yes
@@ -83,7 +83,7 @@ def mcu_table(
         table.add_column("Port")
     table.add_column("Board", overflow="fold")
     if needs_variant:
-        table.add_column("Variant") 
+        table.add_column("Variant")
     if is_wide:
         table.add_column("CPU")
     table.add_column("Version", overflow="fold", min_width=5, max_width=16)

mpflash/logger.py

@@ -1,4 +1,12 @@
-"""Logging."""
+"""
+Logger setup for CLI tools with Unicode-safe output.
+
+Ensures log messages are compatible with the current console encoding.
+Removes or replaces Unicode icons if the encoding is not UTF-8.
+"""
+
+import functools
+import sys
 
 from loguru import logger as log
 from rich.console import Console
@@ -7,12 +15,26 @@ from .config import config
 
 console = Console()
 
+# Detect if the output encoding supports Unicode (UTF-8)
+@functools.lru_cache(maxsize=1)
+def _is_utf8_encoding() -> bool:
+    try:
+        encoding = getattr(sys.stdout, "encoding", None)
+        if encoding is None:
+            return False
+        return encoding.lower().replace("-", "") == "utf8"
+    except BaseException:
+        return False
 
 def _log_formatter(record: dict) -> str:
-    """Log message formatter to combine loguru and rich formatting."""
+    """
+    Log message formatter for loguru and rich.
+
+    Removes Unicode icons if console encoding is not UTF-8.
+    """
     color_map = {
-        "TRACE": "dim blue",
-        "DEBUG": "cyan",
+        "TRACE": "cyan",
+        "DEBUG": "orange",
         "INFO": "bold",
         "SUCCESS": "bold green",
         "WARNING": "yellow",
@@ -20,11 +42,21 @@ 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}]"
+    # Remove icon if not UTF-8
+    if _is_utf8_encoding():
+        icon = record["level"].icon
+    else:
+        icon = record["level"].name  # fallback to text
+    # Insert color directly using f-string
+    return f"[not bold green]{{time:HH:mm:ss}}[/not bold green] | {icon} [{lvl_color}]{record['message']}[/{lvl_color}]"
+
 
+def set_loglevel(loglevel: str) -> None:
+    """
+    Set the log level for the logger.
 
-def set_loglevel(loglevel: str):
-    """Set the log level for the logger"""
+    Ensures Unicode safety for log output.
+    """
     try:
         log.remove()
     except ValueError:
@@ -32,8 +64,10 @@ def set_loglevel(loglevel: str):
     log.add(console.print, level=loglevel.upper(), colorize=False, format=_log_formatter)  # type: ignore
 
 
-def make_quiet():
-    """Make the logger quiet"""
+def make_quiet() -> None:
+    """
+    Make the logger quiet.
+    """
     config.quiet = True
     console.quiet = True
     set_loglevel("CRITICAL")

mpflash/mpboard_id/__init__.py

@@ -3,15 +3,9 @@ Access to the micropython port and board information that is stored in the board
 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 .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
 
+from .known import (find_known_board, get_known_boards_for_port, known_ports,
+                    known_stored_boards)
+from .resolve import resolve_board_ids

mpflash/mpboard_id/alternate.py

@@ -0,0 +1,56 @@
+from typing import Dict, List, Optional
+
+from loguru import logger as log
+
+
+def alternate_board_names(board_id, port="") -> List[str]:
+    more = [board_id]
+
+    log.debug("try for renamed board_id")
+
+    if board_id.startswith("PICO"):
+        more.append(board_id.replace("PICO", "RPI_PICO"))
+    elif board_id.startswith("RPI_"):
+        more.append(board_id.replace("RPI_", ""))
+    elif board_id.startswith("GENERIC"):
+        if port:
+            more.append(board_id.replace("GENERIC", f"{port.upper()}_GENERIC"))
+        else:
+            # just add both of them
+            more.append(board_id.replace("GENERIC", f"ESP32_GENERIC"))
+            more.append(board_id.replace("GENERIC", f"ESP8266_GENERIC"))
+    elif board_id.startswith("ESP32_"):
+        more.append(board_id.replace("ESP32_", ""))
+    elif board_id.startswith("ESP8266_"):
+        more.append(board_id.replace("ESP8266_", ""))
+
+    # VARIANT
+    variant_suffixes = ["SPIRAM", "THREAD"]
+    for board in more:
+        if any(suffix in board for suffix in variant_suffixes):
+            for suffix in variant_suffixes:
+                if board.endswith(f"_{suffix}"):
+                    more.append(board.replace(f"_{suffix}", ""))
+                    # more.append(board.replace(f"_{suffix}", f"-{suffix}"))
+                    break  # first one found
+
+    return more
+
+
+def add_renamed_boards(boards: List[str]) -> List[str]:
+    """
+    Adds the renamed boards to the list of boards.
+
+    Args:
+        boards : The list of boards to add the renamed boards to.
+
+    Returns:
+        List[str]: The list of boards with the renamed boards added.
+    """
+
+    _boards = boards.copy()
+    for board in boards:
+        _boards.extend(alternate_board_names(board))
+        if board != board.upper():
+            _boards.extend(alternate_board_names(board.upper()))
+    return _boards

mpflash/mpboard_id/board_id.py

@@ -2,18 +2,14 @@
 Translate board description to board designator
 """
 
-import functools
-import re
-import sqlite3
-from pathlib import Path
+
 from typing import List, Optional
 
-from mpflash.config import config
+from mpflash.db.core import Session
+from mpflash.db.models import Board
 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
+from mpflash.versions import clean_version
 
 
 def find_board_id_by_description(
@@ -21,7 +17,6 @@ def find_board_id_by_description(
     short_descr: str,
     *,
     version: str,
-    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 ""
@@ -29,7 +24,6 @@ def find_board_id_by_description(
         boards = _find_board_id_by_description(
             descr=descr,
             short_descr=short_descr,
-            db_path=board_info,
             version=version,
         )
         if not boards:
@@ -37,7 +31,6 @@ def find_board_id_by_description(
             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
@@ -51,7 +44,6 @@ def _find_board_id_by_description(
     short_descr: str,
     version: Optional[str] = None,
     variant: str = "",
-    db_path: Optional[Path] = None,
 ):
     short_descr = short_descr or ""
     boards: List[Board] = []
@@ -63,90 +55,15 @@ def _find_board_id_by_description(
         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)
+    with Session() as session:
+        qry = session.query(Board).filter(
+            Board.description.in_(descriptions),
+            Board.version.like(version),
+            Board.variant.like(variant),
+        )
+        boards = qry.all()
 
-                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,
-    version: Optional[str] = None,
-    board_info: Optional[Path] = None,
-):
-    """
-    Find the MicroPython BOARD_ID based on the description in the firmware
-    using the pre-built board_info.json file
-
-    Parameters:
-    descr: str
-        Description of the board
-    short_descr: str
-        Short description of the board (optional)
-    version: str
-        Version of the MicroPython firmware
-    board_info: Path
-        Path to the board_info.json file (optional)
-
-    """
-    # Some functional overlap with
-    # src\mpflash\mpflash\mpboard_id\__init__.py find_known_board
-
-    candidate_boards = read_known_boardinfo(board_info)
-    if not short_descr and " with " in descr:
-        short_descr = descr.split(" with ")[0]
-    if version:
-        # filter for matching version
-        if version in ("stable"):
-            version = get_stable_mp_version()
-        if version in ("preview", "master"):
-            version = get_preview_mp_version()
-        known_versions = sorted({b.version for b in candidate_boards})
-        if version not in known_versions:
-            log.trace(known_versions)
-            log.debug(f"Version {version} not found in board info, using latest stable version {get_stable_mp_version()}")
-            version = ".".join(get_stable_mp_version().split(".")[:2])  # take only major.minor
-        if version_matches := [b for b in candidate_boards if b.version.startswith(version)]:
-            candidate_boards = version_matches
-        else:
-            raise MPFlashError(f"No board info found for version {version}")
-    # First try full match on description, then partial match
-    matches = [b for b in candidate_boards if b.description == descr]
-    if not matches and short_descr:
-        matches = [b for b in candidate_boards if b.description == short_descr]
-    if not matches:
-        # partial match (for added VARIANT)
-        matches = [b for b in candidate_boards if b.description.startswith(descr)]
-        if not matches and short_descr:
-            matches = [b for b in candidate_boards if b.description.startswith(short_descr)]
-    if not matches:
-        raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
-    return sorted(matches, key=lambda x: x.version)

mpflash/mpboard_id/known.py

@@ -7,62 +7,50 @@ This module provides access to the board info and the known ports and boards."""
 from functools import lru_cache
 from typing import List, Optional, Tuple
 
-from mpflash.db.boards import find_board_id, find_board_info
+from sqlalchemy import text
+
+from mpflash.db.core import Session
+from mpflash.db.models import Board
 from mpflash.errors import MPFlashError
-from mpflash.versions import clean_version
 from mpflash.logger import log
+from mpflash.versions import clean_version
 
-from .board import Board
-from .store import read_known_boardinfo
 
+def known_ports(version: str = "") -> list[str]:
+    """Return a list of known ports for a given version."""
+    version = clean_version(version) if version else "%%"
+    with Session() as session:
+        qry = text("SELECT distinct port FROM boards WHERE version like :version ORDER BY port;")
+        ports = session.execute(qry, {"version": version}).columns("port").fetchall()
+    return [row.port for row in ports]
 
-def get_known_ports() -> List[str]:
-    # TODO: Filter for Version
-    log.warning("get_known_ports() is deprecated")
-    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 known_versions(port: str = "") -> list[str]:
+    """Return a list of known versions for a given port."""
+    port = port.strip() if port else "%%"
+    with Session() as session:
+        qry = text("SELECT distinct version FROM boards WHERE port like :port ORDER BY version;")
+        versions = session.execute(qry, {"port": port}).columns("version").fetchall()
+    return [row.version for row in versions]
 
-def get_known_boards_for_port(port: Optional[str] = "", versions: Optional[List[str]] = None) -> List[Board]:
+
+def get_known_boards_for_port(port: str = "", versions: List[str] = []):
     """
     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")
-    # filter for the port
-    if port:
-        mp_boards = [board for board in mp_boards if board.port == port]
-    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]
-
-    return mp_boards
-
-
-def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List[Tuple[str, str]]:
+    versions = [clean_version(v) for v in versions] if versions else []
+    with Session() as session:
+        qry = session.query(Board).filter(Board.port.like(port))
+        if versions:
+            qry = qry.filter(Board.version.in_(versions))
+        boards = qry.all()
+        return boards
+
+
+def known_stored_boards(port: str, versions: List[str] = []) -> List[Tuple[str, str]]:
     """
     Returns a list of tuples with the description and board name for the given port and version
 
@@ -71,22 +59,22 @@ def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List
     """
     mp_boards = get_known_boards_for_port(port, versions)
 
-    boards = set({(f"{board.version} {board.description}", board.board_id) for board in mp_boards})
+    boards = set({(f"{board.version} {board.board_id:<30} {board.description}", board.board_id) for board in mp_boards})
     return sorted(list(boards))
 
 
-@lru_cache(maxsize=20)
-def find_known_board(board_id: str, version ="") -> Board:
+def find_known_board(board_id: str, version="") -> 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
-    # TODO: Refactor to search the SQLite DB instead of the JSON file
-    board_ids = find_board_id(board_id = board_id, version = version or "%")
-    boards = []
-    for board_id in board_ids:
-        # if we have a board_id, use it to find the board info
-        boards += [Board.from_dict(dict(r)) for r in find_board_info(board_id = board_id)]
-
-    if boards:
-        return boards[0]
+    with Session() as session:
+        qry = session.query(Board).filter(Board.board_id == board_id)
+        if version:
+            qry = qry.filter(Board.version == version)
+        board = qry.first()
+        if not board:
+            # if no board found, try to find it by description
+            qry = session.query(Board).filter(Board.description == board_id)
+            if version:
+                qry = qry.filter(Board.version == version)
+        if board:
+            return board
     raise MPFlashError(f"Board {board_id} not found")

mpflash/mpboard_id/resolve.py

@@ -0,0 +1,19 @@
+from logging import log
+from mpflash.common import Params
+from mpflash.mpboard_id import find_known_board
+
+
+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}")

mpflash/mpremoteboard/__init__.py

@@ -170,7 +170,7 @@ class MPRemoteBoard:
             self.cpu = info["cpu"]
             self.arch = info["arch"]
             self.mpy = info["mpy"]
-            self.description = descr = info["board"]
+            self.description = descr = info["description"] if 'description' in info else info["board"]
             pos = descr.rfind(" with")
             short_descr = descr[:pos].strip() if pos != -1 else ""
             if info.get("board_id", None):
@@ -216,9 +216,10 @@ class MPRemoteBoard:
         self.toml = {}
         if rc in [OK]:  # sometimes we get an -9 ???
             try:
+                log.trace(result)
                 # Ok we have the info, now parse it
                 self.toml = tomllib.loads("".join(result))
-                log.debug(f"board_info.toml: {self.toml}")
+                log.debug("board_info.toml:" + self.toml["description"])
             except Exception as e:
                 log.error(f"Failed to parse board_info.toml: {e}")
         else:

mpflash/mpremoteboard/mpy_fw_info.py

@@ -51,6 +51,7 @@ def _info():  # type:() -> dict[str, str]
     try:
         _machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine  # type: ignore
         info["board"] = _machine.strip()
+        info["description"] = _machine.strip()
         si_build = sys.implementation._build if "_build" in dir(sys.implementation) else ""
         if si_build:
             info["board"] = si_build.split("-")[0]

mpflash/mpremoteboard/runner.py

@@ -91,11 +91,12 @@ def run(
         )
     except FileNotFoundError as e:
         raise FileNotFoundError(f"Failed to start {cmd[0]}") from e
-
+    _timed_out = False
     def timed_out():
-        proc.kill()
+        _timed_out = True
         if log_warnings:
             log.warning(f"Command {cmd} timed out after {timeout} seconds")
+        proc.kill()
 
     timer = Timer(timeout, timed_out)
     try:
@@ -135,6 +136,8 @@ def run(
         log.error(f"Failed to decode output: {e}")
     finally:
         timer.cancel()
+        if _timed_out:
+            raise TimeoutError(f"Command {cmd} timed out after {timeout} seconds")
 
     proc.wait(timeout=1)
     return proc.returncode or 0, output

mpflash/vendor/pydfu.py

@@ -338,7 +338,7 @@ def read_dfu_file(filename):
     #   I   uint32_t    size        Size of the DFU file (without suffix)
     #   B   uint8_t     targets     Number of targets
     dfu_prefix, data = consume("<5sBIB", data, "signature version size targets")
-    print("    %(signature)s v%(version)d, image size: %(size)d, " "targets: %(targets)d" % dfu_prefix)
+    print("    %(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d" % dfu_prefix)
     for target_idx in range(dfu_prefix["targets"]):
         # Decode the Image Prefix
         #
@@ -350,15 +350,14 @@ def read_dfu_file(filename):
         #   255s    char[255]   name        Name of the target
         #   I       uint32_t    size        Size of image (without prefix)
         #   I       uint32_t    elements    Number of elements in the image
-        img_prefix, data = consume("<6sBI255s2I", data, "signature altsetting named name " "size elements")
+        img_prefix, data = consume("<6sBI255s2I", data, "signature altsetting named name size elements")
         img_prefix["num"] = target_idx
         if img_prefix["named"]:
             img_prefix["name"] = cstring(img_prefix["name"])
         else:
             img_prefix["name"] = ""
         print(
-            "    %(signature)s %(num)d, alt setting: %(altsetting)s, "
-            'name: "%(name)s", size: %(size)d, elements: %(elements)d' % img_prefix
+            '    %(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d' % img_prefix
         )
 
         target_size = img_prefix["size"]
@@ -395,7 +394,7 @@ def read_dfu_file(filename):
     #   B   uint8_t     len         16
     #   I   uint32_t    crc32       Checksum
     dfu_suffix = named(struct.unpack("<4H3sBI", data[:16]), "device product vendor dfu ufd len crc")
-    print("    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, " "dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x" % dfu_suffix)
+    print("    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x" % dfu_suffix)
     if crc != dfu_suffix["crc"]:
         print("CRC ERROR: computed crc32 is 0x%08x" % crc)
         return
@@ -407,6 +406,20 @@ def read_dfu_file(filename):
     return elements
 
 
+def read_bin_file(filename, address):
+    """Reads binary file(.bin) and stores it as single
+    element in element array just like read_dfu_file() would.
+    """
+    element = {}
+    print("File: {}".format(filename))
+    with open(filename, "rb") as fin:
+        element["data"] = fin.read()
+    element["size"] = len(element["data"])
+    element["num"] = 0
+    element["addr"] = address
+    return [element]
+
+
 class FilterDFU(object):
     """Class for filtering USB devices to identify devices which are in DFU
     mode.
@@ -542,6 +555,13 @@ def main():
     parser.add_argument("--pid", help="USB Product ID", type=lambda x: int(x, 0), default=None)
     parser.add_argument("-m", "--mass-erase", help="mass erase device", action="store_true", default=False)
     parser.add_argument("-u", "--upload", help="read file from DFU device", dest="path", default=False)
+    parser.add_argument(
+        "-a",
+        "--address",
+        help="specify target memory address(hex or dec) when uploading .bin files",
+        type=lambda x: int(x, 0),
+        default=None,
+    )
     parser.add_argument("-x", "--exit", help="Exit DFU", action="store_true", default=False)
     parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true", default=False)
     args = parser.parse_args()
@@ -568,7 +588,14 @@ def main():
         command_run = True
 
     if args.path:
-        elements = read_dfu_file(args.path)
+        if str(args.path).endswith(".bin"):
+            if args.address is None:
+                raise ValueError("Address must be specified using -a when uploading binary")
+
+            elements = read_bin_file(args.path, args.addr)
+        else:
+            elements = read_dfu_file(args.path)
+
         if not elements:
             print("No data in dfu file")
             return

mpflash/versions.py

@@ -78,6 +78,7 @@ def is_version(version: str):
     """Check if the version is a valid version string"""
     # Just in time import
     from packaging.version import Version
+
     return Version._regex.search(version) is not None
 
 
@@ -86,6 +87,7 @@ def micropython_versions(minver: str = "v1.20", reverse: bool = False, cache_it=
     """Get the list of micropython versions from github tags"""
     # Just in time import
     from packaging.version import parse
+
     try:
         gh_client = config.gh_client
         repo = gh_client.get_repo("micropython/micropython")
@@ -126,6 +128,7 @@ def checkedout_version(path: Path, flat: bool = False) -> str:
     """Get the checked-out version of the repo"""
     # Just in time import
     import mpflash.basicgit as git
+
     version = git.get_local_tag(path.as_posix())
     if not version:
         raise ValueError("No valid Tag found")