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

mpflash/mpflash/list.py

@@ -1,75 +1,72 @@
-import json
 from typing import List
 
-import rich_click as click
 from rich import print
 from rich.progress import track
 from rich.table import Table
 
-# TODO: - refactor so that we do not need the entire stubber package
-from stubber.bulk.mpremoteboard import MPRemoteBoard
+from mpflash.mpremoteboard import MPRemoteBoard
 
-from .cli_group import cli
 from .config import config
+from .logger import console
 
 
-@cli.command("list", help="List the connected boards.")
-@click.option(
-    "--json",
-    "-j",
-    "as_json",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="""Output in json format""",
-)
-def list_boards(as_json: bool):
-    conn_boards = [
-        MPRemoteBoard(sp)
-        for sp in MPRemoteBoard.connected_boards()
-        if sp not in config.ignore_ports
-    ]
+def list_mcus(bluetooth: bool = False):
+    """
+    Retrieves information about connected microcontroller boards.
 
-    for mcu in track(conn_boards, description="Getting board info"):
+    Returns:
+        List[MPRemoteBoard]: A list of MPRemoteBoard instances with board information.
+    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]
+
+    for mcu in track(conn_mcus, description="Getting board info", transient=True, update_period=0.1):
         try:
             mcu.get_mcu_info()
         except ConnectionError as e:
             print(f"Error: {e}")
             continue
-    if as_json:
-        print(json.dumps([mcu.__dict__ for mcu in conn_boards], indent=4))
-    else:
-        show_boards(conn_boards, refresh=False)
+    return conn_mcus
 
 
-def show_boards(
-    conn_boards: List[MPRemoteBoard],
+def show_mcus(
+    conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
-):
+):  # sourcery skip: extract-duplicate-method
     """Show the list of connected boards in a nice table"""
-    table = Table(title=title)
-    table.add_column("Serial")
+    table = Table(
+        title=title,
+        title_style="bold",
+        header_style="bold blue",
+        collapse_padding=True,
+        width=110,
+        row_styles=["blue", "yellow"],
+    )
+    table.add_column("Serial", overflow="fold")
     table.add_column("Family")
     table.add_column("Port")
-    table.add_column("Board")
+    table.add_column("Board", overflow="fold")
+    # table.add_column("Variant") # TODO: add variant
     table.add_column("CPU")
     table.add_column("Version")
-    table.add_column("build")
+    table.add_column("build", justify="right")
 
-    for mcu in track(conn_boards, transient=True, description="Updating board info"):
+    for mcu in track(conn_mcus, description="Updating board info", transient=True, update_period=0.1):
         if refresh:
             try:
                 mcu.get_mcu_info()
             except ConnectionError:
                 continue
         table.add_row(
-            mcu.serialport,
+            mcu.serialport.replace("/dev/", ""),
             mcu.family,
             mcu.port,
-            mcu.board,
+            f"{mcu.board}\n{mcu.description}".strip(),
+            # mcu.variant,
             mcu.cpu,
             mcu.version,
             mcu.build,
         )
-    print(table)
+    console.print(table)

mpflash/mpflash/logger.py

@@ -1,13 +1,15 @@
-import sys
+"""Logging."""
 
 from loguru import logger as log
 from rich.console import Console
 
+from .config import config
+
 console = Console()
 
 
 def _log_formatter(record: dict) -> str:
-    """Log message formatter"""
+    """Log message formatter to combine loguru and rich formatting."""
     color_map = {
         "TRACE": "dim blue",
         "DEBUG": "cyan",
@@ -19,8 +21,7 @@ def _log_formatter(record: dict) -> str:
     }
     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}]"
+        "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
     )
 
 
@@ -30,13 +31,11 @@ def set_loglevel(loglevel: str):
         log.remove()
     except ValueError:
         pass
-    log.add(
-        console.print, level=loglevel.upper(), colorize=False, format=_log_formatter
-    )
+    log.add(console.print, level=loglevel.upper(), colorize=False, format=_log_formatter)  # type: ignore
+
 
-    # log.add(
-    #     console.print,
-    #     level=loglevel.upper(),
-    #     format=_log_formatter,
-    #     colorize=True,
-    # )
+def make_quiet():
+    """Make the logger quiet"""
+    config.quiet = True
+    console.quiet = True
+    set_loglevel("CRITICAL")

mpflash/mpflash/mpboard_id/__init__.py

@@ -0,0 +1,96 @@
+"""
+Access to the micropython port and board information that is stored in the board_info.json file 
+that is included in the module.
+
+"""
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import List, Optional, Tuple, TypedDict, Union
+
+from mpflash.errors import MPFlashError
+from mpflash.common import PORT_FWTYPES
+from mpflash.vendor.versions import clean_version
+
+
+# Board  based on the dataclass Board but changed to TypedDict
+# - source : get_boardnames.py
+class Board(TypedDict):
+    """MicroPython Board definition"""
+
+    description: str
+    port: str
+    board: str
+    board_name: str
+    mcu_name: str
+    path: Union[Path, str]
+    version: str
+    cpu: str
+
+
+@lru_cache(maxsize=None)
+def read_stored_boardinfo() -> List[Board]:
+    """Reads the board_info.json file and returns the data as a list of Board objects"""
+    with open(Path(__file__).parent / "board_info.json", "r") as file:
+        return json.load(file)
+
+
+def local_mp_ports() -> List[str]:
+    # TODO: Filter for Version
+    mp_boards = read_stored_boardinfo()
+    # select the unique ports from info
+    ports = set({board["port"] for board in mp_boards if board["port"] in PORT_FWTYPES.keys()})
+    return sorted(list(ports))
+
+
+def get_stored_boards_for_port(port: str, versions: Optional[List[str]] = None):
+    """
+    Returns a list of boards for the given port and version(s)
+
+    port : str : The Micropython port to filter for
+    versions : List[str] : The Micropython versions to filter for (actual versions required)"""
+    mp_boards = read_stored_boardinfo()
+
+    # 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]
+    # filter for the 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_stored_boards_for_port(port, versions)
+
+    boards = set({(f'{board["version"]} {board["description"]}', board["board"]) for board in mp_boards})
+    return sorted(list(boards))
+
+
+@lru_cache(maxsize=20)
+def find_stored_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"""
+    info = read_stored_boardinfo()
+    for board_info in info:
+        if board_id in (board_info["board"], board_info["description"]):
+            if "cpu" not in board_info or not board_info["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/mpflash/mpboard_id/board_id.py

@@ -0,0 +1,63 @@
+"""
+Translate board description to board designator
+"""
+
+import functools
+import json
+from pathlib import Path
+from typing import Optional
+
+from mpflash.errors import MPFlashError
+from mpflash.vendor.versions import clean_version
+
+###############################################################################################
+HERE = Path(__file__).parent
+###############################################################################################
+
+
+def find_board_id(
+    descr: str, short_descr: str, board_info: Optional[Path] = None, version: str = "stable"
+) -> Optional[str]:
+    # TODO: use the json file instead of the csv and get the cpu
+    boards = find_board_by_description(
+        descr=descr,
+        short_descr=short_descr,
+        board_info=board_info,
+        version=clean_version(version),
+    )
+    return boards[-1]["board"]
+
+
+@functools.lru_cache(maxsize=20)
+def find_board_by_description(*, descr: str, short_descr: str, version="v1.21.0", board_info: Optional[Path] = None):
+    """
+    Find the MicroPython BOARD designator based on the description in the firmware
+    using the pre-built board_info.json file
+    """
+    if not board_info:
+        board_info = HERE / "board_info.json"
+    if not board_info.exists():
+        raise FileNotFoundError(f"Board info file not found: {board_info}")
+
+    info = _read_board_info(board_info)
+
+    # filter for matching version
+    if version == "preview":
+        # TODO: match last stable
+        version = "v1.22.2"
+    version_matches = [b for b in info if b["version"].startswith(version)]
+    if not version_matches:
+        raise MPFlashError(f"No board info found for version {version}")
+    matches = [b for b in version_matches if b["description"] == descr]
+    if not matches and short_descr:
+        matches = [b for b in version_matches if b["description"] == short_descr]
+    if not matches:
+        raise MPFlashError(f"No board info found for description {descr}")
+    return sorted(matches, key=lambda x: x["version"])
+
+
+@functools.lru_cache(maxsize=20)
+def _read_board_info(board_info):
+    with open(board_info, "r") as file:
+        info = json.load(file)
+    return info