micropython-stubber 1.17.6__py3-none-any.whl → 1.20.0__py3-none-any.whl

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