micropython-stubber 1.23.2__py3-none-any.whl → 1.24.0__py3-none-any.whl

mpflash/mpflash/mpboard_id/add_boards.py

@@ -23,9 +23,10 @@ from mpflash.versions import micropython_versions
 # and the #define MICROPY_HW_MCU_NAME "STM32F767xx"
 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 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]*)\"")
+# 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_MCU_NAME = re.compile(r"MICROPY_HW_MCU_NAME\s?=\s?\"(?P<variant>[\w\s\S]*)\"")
 # TODO: normal make files
 
@@ -42,10 +43,8 @@ def boards_from_repo(mpy_path: Path, version: str, family: Optional[str] = None)
     """
     if not mpy_path.exists() or not mpy_path.is_dir():
         raise FileNotFoundError(f"MicroPython path {mpy_path} does not exist.")
-    if not family:
-        family = "micropython"
-    if not version:
-        version = git.get_local_tag()  # type: ignore
+    family = family or "micropython"
+    version = version or git.get_local_tag()  # type: ignore
     if not version:
         raise ValueError("No version provided and no local tag found.")
 
@@ -53,9 +52,10 @@ def boards_from_repo(mpy_path: Path, version: str, family: Optional[str] = None)
     # look in mpconfigboard.h files
     board_list = boards_from_cmake(mpy_path, version, family)
 
-    # look for variants in the .cmake files
+    # look for boards in the .cmake files
     board_list.extend(boards_from_headers(mpy_path, version, family))
-    # TODO:? look for variants in the Makefile files
+
+    # TODO:? look for variants in the board.json files
 
     return board_list
 
@@ -63,7 +63,7 @@ def boards_from_repo(mpy_path: Path, version: str, family: Optional[str] = None)
 def boards_from_cmake(mpy_path: Path, version: str, family: str):
     """Get boards from the mpconfigboard.cmake files to the board_list."""
     board_list = []
-    for path in mpy_path.glob("ports/**/mpconfigboard.cmake"):
+    for path in mpy_path.glob("ports/**/mpconfigboard*.cmake"):
         board = path.parent.name
         port = path.parent.parent.parent.name
         with open(path, "r") as f:
@@ -118,7 +118,9 @@ 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,
@@ -160,6 +162,8 @@ def boards_for_versions(versions: List[str], mpy_path: Path):
         List[Board]: The list of Board objects.
     """
     board_list: List[Board] = []
+    # first fetch all tags from the repository
+    git.fetch(mpy_path)
     for version in track(versions, description="Searching MicroPython versions"):
         if git.checkout_tag(tag=version, repo=mpy_path):
             new_ones = boards_from_repo(mpy_path, version, family="micropython")
@@ -197,9 +201,10 @@ def make_table(board_list: List[Board]) -> rich.table.Table:
     is_wide = True
 
     table = rich.table.Table(title="MicroPython Board Information")
+    table.add_column("Port", justify="left", style="magenta")
     table.add_column("BOARD_ID", justify="left", style="green")
+    table.add_column("Variant(s)", justify="left", style="blue")
     table.add_column("Description", justify="left", style="cyan")
-    table.add_column("Port", justify="left", style="magenta")
     table.add_column("Board Name", justify="left", style="blue")
     if is_wide:
         table.add_column("MCU Name", justify="left", style="blue")
@@ -209,7 +214,7 @@ def make_table(board_list: List[Board]) -> rich.table.Table:
         table.add_column("Family", justify="left", style="blue")
 
     for board in board_list:
-        row = [board.board_id, board.description, *(board.port, board.board_name)]
+        row = [board.port, board.board_id, board.variant, board.description, board.board_name]
         if is_wide:
             row.append(board.mcu_name)
         row.extend((str(Path(board.path).suffix), board.version))
@@ -222,7 +227,13 @@ def make_table(board_list: List[Board]) -> rich.table.Table:
 
 def ask_mpy_path():
     """Ask the user for the path to the MicroPython repository."""
-    questions = [inquirer.Text("mpy_path", message="Enter the path to the MicroPython repository", default=".\\repos\\micropython")]
+    questions = [
+        inquirer.Text(
+            "mpy_path",
+            message="Enter the path to the MicroPython repository",
+            default=".\\repos\\micropython",
+        )
+    ]
     if answers := inquirer.prompt(questions):
         return Path(answers["mpy_path"])
     else:

mpflash/mpflash/mpboard_id/board.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import  Union
+from typing import Union
 
 
 # - source : get_boardnames.py
@@ -20,7 +20,7 @@ class Board:
     family: str = field(default="micropython")
     mcu_name: str = field(default="")
     cpu: str = field(default="")
-    # TODO: add variant
+    variant: str = field(default="")
 
     def __post_init__(self):
         if not self.cpu:

mpflash/mpflash/mpboard_id/board_id.py

@@ -56,14 +56,12 @@ def _find_board_id_by_description(
         Path to the board_info.json file (optional)
 
     """
-    # FIXME: functional overlap with
+    # 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]
-
-    candidate_boards = read_known_boardinfo(board_info)
-
     if version:
         # filter for matching version
         if version in ("preview", "stable"):
@@ -71,16 +69,22 @@ def _find_board_id_by_description(
             version = get_stable_mp_version()
         known_versions = sorted({b.version for b in candidate_boards})
         if version not in known_versions:
-            # FIXME if latest stable is newer than the last version in the boardlist this will fail
             log.trace(f"Version {version} not found in board info, using latest known version {known_versions[-1]}")
-            version = known_versions[-1]
+            version = '.'.join(known_versions[-1].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/mpflash/mpboard_id/store.py

@@ -1,18 +1,18 @@
 import functools
 import zipfile
 from pathlib import Path
-from typing import List, Optional
+from typing import Final, List, Optional
 
 import jsons
 
 from mpflash.mpboard_id.board import Board
 
 ###############################################################################################
-HERE = Path(__file__).parent
+HERE: Final = Path(__file__).parent
 ###############################################################################################
 
 
-def write_boardinfo_json(board_list: List[Board], *, folder: Path):
+def write_boardinfo_json(board_list: List[Board], *, folder: Optional[Path] = None):
     """Writes the board information to a JSON file.
 
     Args:
@@ -21,6 +21,8 @@ def write_boardinfo_json(board_list: List[Board], *, folder: Path):
     """
     import zipfile
 
+    if not folder:
+        folder = HERE
     # create a zip file with the json file
     with zipfile.ZipFile(folder / "board_info.zip", "w", compression=zipfile.ZIP_DEFLATED) as zipf:
         # write the list to json file inside the zip
@@ -30,6 +32,9 @@ def write_boardinfo_json(board_list: List[Board], *, folder: Path):
 
 @functools.lru_cache(maxsize=20)
 def read_known_boardinfo(board_info: Optional[Path] = None) -> List[Board]:
+    """Reads the board information from a JSON file in a zip file."""
+
+    import zipfile
 
     if not board_info:
         board_info = HERE / "board_info.zip"

mpflash/mpflash/mpremoteboard/__init__.py

@@ -55,7 +55,7 @@ class MPRemoteBoard:
         self.arch = ""
         self.mpy = ""
         self.build = ""
-        self.location = location # USB location
+        self.location = location  # USB location
         self.toml = {}
         if update:
             self.get_mcu_info()
@@ -97,7 +97,9 @@ class MPRemoteBoard:
 
         if sys.platform == "win32":
             # Windows sort of comports by number - but fallback to device name
-            return sorted(output, key=lambda x: int(x.split()[0][3:]) if x.split()[0][3:].isdigit() else x)
+            return sorted(
+                output, key=lambda x: int(x.split()[0][3:]) if x.split()[0][3:].isdigit() else x
+            )
         # sort by device name
         return sorted(output)
 
@@ -116,9 +118,10 @@ class MPRemoteBoard:
             ["run", str(HERE / "mpy_fw_info.py")],
             no_info=True,
             timeout=timeout,
-            resume=True,  # Avoid restarts
+            resume=False,  # Avoid restarts
         )
-        if rc != OK:
+        if rc:
+            log.debug(f"rc: {rc}, result: {result}")
             raise ConnectionError(f"Failed to get mcu_info for {self.serialport}")
         # Ok we have the info, now parse it
         raw_info = result[0].strip()
@@ -134,7 +137,9 @@ class MPRemoteBoard:
             self.description = descr = info["board"]
             pos = descr.rfind(" with")
             short_descr = descr[:pos].strip() if pos != -1 else ""
-            if board_name := find_board_id_by_description(descr, short_descr, version=self.version):
+            if board_name := find_board_id_by_description(
+                descr, short_descr, version=self.version
+            ):
                 self.board = board_name
             else:
                 self.board = "UNKNOWN_BOARD"
@@ -174,7 +179,7 @@ class MPRemoteBoard:
             except Exception as e:
                 log.error(f"Failed to parse board_info.toml: {e}")
         else:
-            log.trace(f"Failed to read board_info.toml: {result}")
+            log.trace(f"Did not find a board_info.toml: {result}")
 
     def disconnect(self) -> bool:
         """
@@ -202,7 +207,7 @@ class MPRemoteBoard:
         log_errors: bool = True,
         no_info: bool = False,
         timeout: int = 60,
-        resume: bool = False,
+        resume: Optional[bool] = None,
         **kwargs,
     ):
         """
@@ -223,7 +228,7 @@ class MPRemoteBoard:
         if self.serialport:
             prefix += ["connect", self.serialport]
         # if connected add resume to keep state between commands
-        if self.connected or resume:
+        if (resume != False) and self.connected or resume:
             prefix += ["resume"]
         cmd = prefix + cmd
         log.debug(" ".join(cmd))

mpflash/mpflash/mpremoteboard/mpy_fw_info.py

@@ -36,7 +36,9 @@ def _info():  # type:() -> dict[str, str]
             "version": "",
             "build": "",
             "ver": "",
-            "port": "stm32" if sys.platform.startswith("pyb") else sys.platform,  # port: esp32 / win32 / linux / stm32
+            "port": (
+                "stm32" if sys.platform.startswith("pyb") else sys.platform
+            ),  # port: esp32 / win32 / linux / stm32
             "board": "GENERIC",
             "cpu": "",
             "mpy": "",
@@ -48,7 +50,11 @@ def _info():  # type:() -> dict[str, str]
     except AttributeError:
         pass
     try:
-        machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine
+        machine = (
+            sys.implementation._machine
+            if "_machine" in dir(sys.implementation)
+            else os.uname().machine
+        )
         info["board"] = machine.strip()
         info["cpu"] = machine.split("with")[-1].strip() if "with" in machine else ""
         info["mpy"] = (
@@ -100,7 +106,8 @@ def _info():  # type:() -> dict[str, str]
         if (
             info["version"]
             and info["version"].endswith(".0")
-            and info["version"] >= "1.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
+            and info["version"]
+            >= "1.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
             and info["version"] <= "1.19.9"
         ):
             # drop the .0 for newer releases
@@ -110,19 +117,23 @@ def _info():  # type:() -> dict[str, str]
     if "mpy" in info and info["mpy"]:  # mpy on some v1.11+ builds
         sys_mpy = int(info["mpy"])
         # .mpy architecture
-        arch = [
-            None,
-            "x86",
-            "x64",
-            "armv6",
-            "armv6m",
-            "armv7m",
-            "armv7em",
-            "armv7emsp",
-            "armv7emdp",
-            "xtensa",
-            "xtensawin",
-        ][sys_mpy >> 10]
+        try:
+            arch = [
+                None,
+                "x86",
+                "x64",
+                "armv6",
+                "armv6m",
+                "armv7m",
+                "armv7em",
+                "armv7emsp",
+                "armv7emdp",
+                "xtensa",
+                "xtensawin",
+                "hazard3riscv",  # assumed
+            ][sys_mpy >> 10]
+        except IndexError:
+            arch = "unknown"
         if arch:
             info["arch"] = arch
         # .mpy version.minor

mpflash/mpflash/vendor/board_database.py

@@ -0,0 +1,185 @@
+"""
+The micropython git repo contains many 'board.json' files.
+
+This is an example:
+ports/stm32/boards/PYBV11/board.json
+
+{
+    "deploy": [
+        "../PYBV10/deploy.md"
+    ],
+    "docs": "",
+    "features": [],
+    "images": [
+        "PYBv1_1.jpg",
+        "PYBv1_1-C.jpg",
+        "PYBv1_1-E.jpg"
+    ],
+    "mcu": "stm32f4",
+    "product": "Pyboard v1.1",
+    "thumbnail": "",
+    "url": "https://store.micropython.org/product/PYBv1.1",
+    "variants": {
+        "DP": "Double-precision float",
+        "DP_THREAD": "Double precision float + Threads",
+        "NETWORK": "Wiznet 5200 Driver",
+        "THREAD": "Threading"
+    },
+    "vendor": "George Robotics"
+}
+
+This module implements `class Database` which reads all 'board.json' files and
+provides a way to browse it's data.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from glob import glob
+from pathlib import Path
+
+
+@dataclass(order=True)
+class Variant:
+    name: str
+    """
+    Example: "DP_THREAD"
+    """
+    text: str
+    """
+    Example: "Double precision float + Threads"
+    """
+    board: Board = field(repr=False)
+
+
+@dataclass(order=True)
+class Board:
+    name: str
+    """
+    Example: "PYBV11"
+    """
+    variants: list[Variant]
+    """
+    List of variants available for this board.
+    Variants are sorted. May be an empty list if no variants are available.
+    Example key: "DP_THREAD"
+    """
+    url: str
+    """
+    Primary URL to link to this board.
+    """
+    mcu: str
+    """
+    Example: "stm32f4"
+    """
+    product: str
+    """
+    Example: "Pyboard v1.1"
+    """
+    vendor: str
+    """
+    Example: "George Robotics"
+    """
+    images: list[str]
+    """
+    Images of this board, stored in the micropython-media repository.
+    Example: ["PYBv1_1.jpg", "PYBv1_1-C.jpg", "PYBv1_1-E.jpg"]
+    """
+    deploy: list[str]
+    """
+    Files that explain how to deploy for this board:
+    Example: ["../PYBV10/deploy.md"]
+    """
+    port: Port | None = field(default=None, compare=False)
+
+    @staticmethod
+    def factory(filename_json: Path) -> Board:
+        with filename_json.open() as f:
+            board_json = json.load(f)
+
+        board = Board(
+            name=filename_json.parent.name,
+            variants=[],
+            url=board_json["url"],
+            mcu=board_json["mcu"],
+            product=board_json["product"],
+            vendor=board_json["vendor"],
+            images=board_json["images"],
+            deploy=board_json["deploy"],
+        )
+        board.variants.extend(
+            sorted([Variant(*v, board) for v in board_json.get("variants", {}).items()])  # type: ignore
+        )
+        return board
+
+
+@dataclass(order=True)
+class Port:
+    name: str
+    """
+    Example: "stm32"
+    """
+    boards: dict[str, Board] = field(default_factory=dict, repr=False)
+    """
+    Example key: "PYBV11"
+    """
+
+
+@dataclass
+class Database:
+    """
+    This database contains all information retrieved from all 'board.json' files.
+    """
+
+    mpy_root_directory: Path = field(repr=False)
+    port_filter: str = field(default="", repr=False)
+
+    ports: dict[str, Port] = field(default_factory=dict)
+    boards: dict[str, Board] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        mpy_dir = self.mpy_root_directory
+        # Take care to avoid using Path.glob! Performance was 15x slower.
+        for p in glob(f"{mpy_dir}/ports/**/boards/**/board.json"):
+            filename_json = Path(p)
+            port_name = filename_json.parent.parent.parent.name
+            if self.port_filter and self.port_filter != port_name:
+                continue
+
+            # Create a port
+            port = self.ports.get(port_name, None)
+            if port is None:
+                port = Port(port_name)
+                self.ports[port_name] = port
+
+            # Load board.json and attach it to the board
+            board = Board.factory(filename_json)
+            board.port = port
+
+            port.boards[board.name] = board
+            self.boards[board.name] = board
+
+        # Add 'special' ports, that don't have boards
+        # TODO(mst) Tidy up later (variant descriptions etc)
+        for special_port_name in ["unix", "webassembly", "windows"]:
+            if self.port_filter and self.port_filter != special_port_name:
+                continue
+            path = Path(mpy_dir, "ports", special_port_name)
+            variant_names = [var.name for var in path.glob("variants/*") if var.is_dir()]
+            board = Board(
+                special_port_name,
+                [],
+                f"https://github.com/micropython/micropython/blob/master/ports/{special_port_name}/README.md",
+                "",
+                "",
+                "",
+                [],
+                [],
+            )
+            board.variants = [Variant(v, "", board) for v in variant_names]
+            port = Port(special_port_name, {special_port_name: board})
+            board.port = port
+
+            self.ports[special_port_name] = port
+            self.boards[board.name] = board

mpflash/mpflash/vendor/readme.md

@@ -1,3 +1,12 @@
 These modules are vendored from the following repositories:
 
-micropython/micropython
+- https://github.com/micropython/micropython (MIT)
+  - dfu.py
+  - pydfy.py
+
+- https://github.com/mattytrentini/mpbuild (MIT)
+  - board_database.py
+
+- https://github.com/click-contrib/click-aliases  (Public Domain)
+  - click_aliases.py (Robbin Bonthond)
+

mpflash/mpflash/versions.py

@@ -1,14 +1,12 @@
 """
-#############################################################
-# Version handling copied from stubber/utils/versions.py
-#############################################################
+Version handling for mpflash and micropython-stubber
 """
 
 from pathlib import Path
 
 from cache_to_disk import NoCacheCondition, cache_to_disk
 from loguru import logger as log
-from packaging.version import parse
+from packaging.version import Version, parse
 
 import mpflash.basicgit as git
 from mpflash.common import GH_CLIENT
@@ -71,58 +69,48 @@ def clean_version(
     return version
 
 
+def is_version(version: str):
+    """Check if the version is a valid version string"""
+    return Version._regex.search(version) is not None
+
+
 @cache_to_disk(n_days_to_cache=1)
-def micropython_versions(minver: str = "v1.20", reverse: bool = False):
+def micropython_versions(minver: str = "v1.20", reverse: bool = False, cache_it=True):
     """Get the list of micropython versions from github tags"""
-    cache_it = True
+
     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)]
+        tags = [tag.name for tag in repo.get_tags() if parse(tag.name) >= parse(minver)]
+        versions = [v for v in tags if not v.endswith(V_PREVIEW)]
         # Only keep the last preview
-        versions = [v for v in versions if not v.endswith(V_PREVIEW) or v == versions[-1]]
-    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",
-        ]
-        cache_it = False
-    versions = [v for v in versions if parse(v) >= parse(minver)]
-    # remove all but the most recent (preview) version
-    versions = versions[:1] + [v for v in versions if "preview" not in v]
-    versions = sorted(versions, reverse=reverse)
+        preview = sorted([v for v in tags if v.endswith(V_PREVIEW)], reverse=True)[0]
+        versions.append(preview)
+    except Exception as e:
+        log.error(e)
+        versions = []
+        # returns - but does not cache
+        raise NoCacheCondition(function_value=versions)
+    # remove any duplicates and sort
+    versions = sorted(list(set(versions)), reverse=reverse, key=lambda s: (not is_version(s), s))
     if cache_it:
         return versions
     # returns - but does not cache
     raise NoCacheCondition(function_value=versions)
 
 
-def get_stable_mp_version() -> str:
+def get_stable_mp_version(cache_it=True) -> str:
     # read the versions from the git tags
-    all_versions = micropython_versions(minver=OLDEST_VERSION)
-    return [v for v in all_versions if not v.endswith(V_PREVIEW)][-1]
+    all_versions = micropython_versions(minver=OLDEST_VERSION, cache_it=cache_it)
+    versions = [v for v in all_versions if not v.endswith(V_PREVIEW)]
+    return versions[-1] if versions else ""
 
 
-def get_preview_mp_version() -> str:
+def get_preview_mp_version(cache_it=True) -> str:
     # read the versions from the git tags
-    all_versions = micropython_versions(minver=OLDEST_VERSION)
-    return [v for v in all_versions if v.endswith(V_PREVIEW)][-1]
+    all_versions = micropython_versions(minver=OLDEST_VERSION, cache_it=cache_it)
+    versions = [v for v in all_versions if v.endswith(V_PREVIEW)]
+    return versions[0] if versions else ""
 
 
 # Do not cache , same path will have different versions checked out