micropython-stubber 1.24.1__py3-none-any.whl → 1.24.4__py3-none-any.whl

mpflash/mpflash/list.py

@@ -1,106 +0,0 @@
-from typing import List
-
-from rich.progress import track
-from rich.table import Table
-
-from mpflash.config import config
-from mpflash.mpremoteboard import MPRemoteBoard
-from mpflash.versions import clean_version
-
-from .logger import console
-
-
-def show_mcus(
-    conn_mcus: List[MPRemoteBoard],
-    title: str = "Connected boards",
-    refresh: bool = True,
-):
-    console.print(mcu_table(conn_mcus, title, refresh))
-
-
-def abbrv_family(family: str, is_wide: bool) -> str:
-    if not is_wide:
-        ABRV = {"micropython": "upy", "circuitpython": "cpy", "unknown": "?"}
-        return ABRV.get(family, family[:4])
-    return family
-
-
-def mcu_table(
-    conn_mcus: List[MPRemoteBoard],
-    title: str = "Connected boards",
-    refresh: bool = True,
-):
-    """
-    builds a rich table with the connected boards information
-    The columns of the table are adjusted to the terminal width
-    the columns are :
-                Narrow      Wide
-    - Serial    Yes         Yes
-    - Family    abbrv.      Yes
-    - Port      -           yes
-    - Board     Yes         Yes     BOARD_ID and Description, and the description from board_info.toml
-    - CPU       -           Yes
-    - Version   Yes         Yes
-    - Build     *           *       only if any of the mcus have a build
-    - Location  -           -       only if --usb is given
-    """
-    # refresh if requested
-    if refresh:
-        for mcu in track(
-            conn_mcus,
-            description="Updating board info",
-            transient=True,
-            show_speed=False,
-            refresh_per_second=1,
-        ):
-            try:
-                mcu.get_mcu_info()
-            except ConnectionError:
-                continue
-    table = Table(
-        title=title,
-        title_style="magenta",
-        header_style="bold magenta",
-        collapse_padding=True,
-        padding=(0, 0),
-    )
-    # Build the 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)
-
-    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 is_wide:
-        table.add_column("CPU")
-    table.add_column("Version", overflow="fold", min_width=5, max_width=16)
-    if needs_build:
-        table.add_column("Build" if is_wide else "Bld", justify="right")
-    if config.usb:
-        table.add_column("Location", overflow="fold", max_width=60)
-    # fill the table with the data
-    for mcu in conn_mcus:
-        description = f"[italic bright_cyan]{mcu.description}" if mcu.description else ""
-        if "description" in mcu.toml:
-            description += f"\n[italic bright_green]{mcu.toml['description']}"
-        row = [
-            mcu.serialport if is_wide else mcu.serialport.replace("/dev/tty", "tty"),
-            abbrv_family(mcu.family, is_wide),
-        ]
-        if is_wide:
-            row.append(mcu.port)
-        row.append(f"{mcu.board}\n{description}".strip())
-        if is_wide:
-            row.append(mcu.cpu)
-        row.append(clean_version(mcu.version))
-        if needs_build:
-            row.append(mcu.build)
-        if config.usb:
-            row.append(mcu.location)
-
-        table.add_row(*row)
-    return table

mpflash/mpflash/logger.py

@@ -1,41 +0,0 @@
-"""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 to combine loguru and rich formatting."""
-    color_map = {
-        "TRACE": "dim blue",
-        "DEBUG": "cyan",
-        "INFO": "bold",
-        "SUCCESS": "bold green",
-        "WARNING": "yellow",
-        "ERROR": "bold red",
-        "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}]"
-    )
-
-
-def set_loglevel(loglevel: str):
-    """Set the log level for the logger"""
-    try:
-        log.remove()
-    except ValueError:
-        pass
-    log.add(console.print, level=loglevel.upper(), colorize=False, format=_log_formatter)  # type: ignore
-
-
-def make_quiet():
-    """Make the logger quiet"""
-    config.quiet = True
-    console.quiet = True
-    set_loglevel("CRITICAL")

mpflash/mpflash/mpboard_id/__init__.py

@@ -1,98 +0,0 @@
-"""
-Access to the micropython port and board information that is stored in the board_info.json file 
-that is included in the module.
-
-"""
-
-from functools import lru_cache
-from typing import List, Optional, Tuple
-
-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))
-
-
-@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/mpflash/mpboard_id/add_boards.py

@@ -1,262 +0,0 @@
-"""
-Collects board name and description information from MicroPython and writes it to JSON and CSV files.
-"""
-
-import re
-from pathlib import Path
-from typing import List, Optional
-
-import inquirer
-import rich
-import rich.table
-from rich.console import Console
-from rich.progress import track
-
-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 micropython_versions
-
-# look for all mpconfigboard.h files and extract the board name
-# from the #define MICROPY_HW_BOARD_NAME "PYBD_SF6"
-# 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 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
-
-
-def boards_from_repo(mpy_path: Path, version: str, family: Optional[str] = None) -> List[Board]:
-    """Collects board name and decriptions from mpconfigboard.h files.
-
-    Args:
-        mpy_path (Path): The path to the MicroPython repository.
-        version (str): The version of MicroPython.
-
-    Returns:
-        List[Board]: A list of Board objects containing the board information.
-    """
-    if not mpy_path.exists() or not mpy_path.is_dir():
-        raise FileNotFoundError(f"MicroPython path {mpy_path} does not exist.")
-    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.")
-
-    board_list: List[Board] = []
-    # look in mpconfigboard.h files
-    board_list = boards_from_cmake(mpy_path, version, family)
-
-    # look for boards in the .cmake files
-    board_list.extend(boards_from_headers(mpy_path, version, family))
-
-    # TODO:? look for variants in the board.json files
-
-    return board_list
-
-
-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"):
-        board = path.parent.name
-        port = path.parent.parent.parent.name
-        with open(path, "r") as f:
-            board_name = mcu_name = "-"
-            for line in f:
-                line = line.strip()
-                if match := RE_CMAKE_MICROPY_HW_BOARD_NAME.match(line):
-                    description = match["variant"]
-                    board_list.append(
-                        Board(
-                            board_id=board,
-                            port=port,
-                            board_name=board_name,
-                            mcu_name=mcu_name,
-                            description=description,
-                            path=path.relative_to(mpy_path),
-                            version=version,
-                            family=family,
-                        )
-                    )
-                elif match := RE_CMAKE_MICROPY_HW_MCU_NAME.match(line):
-                    description = match["variant"]
-                    board_list.append(
-                        Board(
-                            board_id=board,
-                            port=port,
-                            board_name=board_name,
-                            mcu_name=mcu_name,
-                            description=description,
-                            path=path.relative_to(mpy_path),
-                            version=version,
-                            family=family,
-                        )
-                    )
-    return board_list
-
-
-def boards_from_headers(mpy_path: Path, version: str, family: str):
-    """Get boards from the mpconfigboard.h files to the board_list."""
-    board_list = []
-    for path in mpy_path.glob("ports/**/mpconfigboard.h"):
-        board = path.parent.name
-        port = path.parent.parent.parent.name
-        with open(path, "r") as f:
-            board_name = mcu_name = "-"
-            found = 0
-            for line in f:
-                if match := RE_H_MICROPY_HW_BOARD_NAME.match(line):
-                    board_name = match[1]
-                    found += 1
-                elif match := RE_H_MICROPY_HW_MCU_NAME.match(line):
-                    mcu_name = match[1]
-                    found += 1
-                if found == 2:
-                    description = (
-                        f"{board_name} with {mcu_name}" if mcu_name != "-" else board_name
-                    )
-                    board_list.append(
-                        Board(
-                            board_id=board,
-                            port=port,
-                            board_name=board_name,
-                            mcu_name=mcu_name,
-                            description=description,
-                            path=path.relative_to(mpy_path),
-                            version=version,
-                            family=family,
-                        )
-                    )
-                    found = 0
-            if found == 1:
-                description = board_name
-                board_list.append(
-                    Board(
-                        board_id=board,
-                        port=port,
-                        board_name=board_name,
-                        mcu_name=mcu_name,
-                        description=description,
-                        path=path.relative_to(mpy_path),
-                        version=version,
-                        family=family,
-                    )
-                )
-    return board_list
-
-
-def boards_for_versions(versions: List[str], mpy_path: Path):
-    """Gets the list of boards for multiple versions of MicroPython.
-
-    Args:
-        versions (List[str]): The list of MicroPython versions.
-        mpy_path (Path): The path to the MicroPython repository.
-
-    Returns:
-        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")
-            print(f"Found {len(new_ones)} board definitions for {version}.")
-            board_list += new_ones
-        else:
-            print(f"Could not checkout version {version}.")
-
-    # sort the board_list by description and board
-    print("Total number of boards found:", len(board_list))
-
-    board_list = unique_boards(board_list)
-    print("Unique board descriptions found:", len(board_list))
-    return board_list
-
-
-def unique_boards(board_list: List[Board], *, key_version: bool = True):
-    """Remove duplicate boards by 'BOARD_ID description' from the list."""
-    seen = set()
-    result = []
-    for x in board_list:
-        if key_version:
-            key = f"{x.board_id}|{x.version}|{x.description}"
-        else:
-            key = f"{x.board_id}|{x.description}"
-        if key not in seen:
-            result.append(x)
-            seen.add(key)
-    result.sort(key=lambda x: x.description.lower())
-    return result
-
-
-def make_table(board_list: List[Board]) -> rich.table.Table:
-    """Creates a rich table with board information."""
-    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("Board Name", justify="left", style="blue")
-    if is_wide:
-        table.add_column("MCU Name", justify="left", style="blue")
-    table.add_column("Detection", justify="left", style="yellow")
-    table.add_column("Version", justify="left", style="blue")
-    if is_wide:
-        table.add_column("Family", justify="left", style="blue")
-
-    for board in board_list:
-        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))
-        if is_wide:
-            row.append(board.family)
-        table.add_row(*row)
-
-    return 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",
-        )
-    ]
-    if answers := inquirer.prompt(questions):
-        return Path(answers["mpy_path"])
-    else:
-        raise ValueError("No path provided.")
-
-
-def main():
-    """Main function to collect and write board information."""
-
-    console = Console()
-
-    mpy_path = ask_mpy_path()
-    versions = micropython_versions(minver="v1.10") + ["master"]
-    board_list = boards_for_versions(versions, mpy_path)
-
-    here = Path(__file__).parent
-    log.info(write_boardinfo_json(board_list, folder=here))
-    # write_files(board_list, folder=CONFIG.board_path)
-
-    # table of when the board was added
-    table = make_table(unique_boards(board_list, key_version=False))
-    console.print(table)
-
-
-if __name__ == "__main__":
-    main()

mpflash/mpflash/mpboard_id/board.py

@@ -1,37 +0,0 @@
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Union
-
-
-# - source : get_boardnames.py
-@dataclass
-class Board:
-    """
-    MicroPython Board definitions, parsed from the make and header files
-    """
-
-    port: str  # micropython port
-    board_id: str  # BOARD_ID (Foldername) as used in the make files
-    board_name: str  # Short board description
-    description: str  # Long board description
-    path: Union[Path, str]
-    version: str = field(default="")  # version of MicroPython""
-    # versions: List[str] = field(default=[])  # version of MicroPython""
-    family: str = field(default="micropython")
-    mcu_name: str = field(default="")
-    cpu: str = field(default="")
-    variant: str = field(default="")
-
-    def __post_init__(self):
-        if not self.cpu:
-            if " with " in self.description:
-                self.cpu = self.description.split(" with ")[-1]
-            else:
-                self.cpu = self.port
-
-    @staticmethod
-    def from_dict(data: dict) -> "Board":
-        return Board(**data)
-
-    def to_dict(self) -> dict:
-        return self.__dict__

mpflash/mpflash/mpboard_id/board_id.py

@@ -1,90 +0,0 @@
-"""
-Translate board description to board designator
-"""
-
-import functools
-from pathlib import Path
-from typing import Optional
-
-from mpflash.errors import MPFlashError
-from mpflash.logger import log
-from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.versions import clean_version, get_stable_mp_version
-
-
-def find_board_id_by_description(
-    descr: str,
-    short_descr: str,
-    *,
-    version: str,
-    board_info: Optional[Path] = None,
-) -> Optional[str]:
-    """Find the MicroPython BOARD_ID based on the description in the firmware"""
-
-    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,
-        )
-        return boards[-1].board_id
-    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,
-    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 ("preview", "stable"):
-            # match last stable
-            version = get_stable_mp_version()
-        known_versions = sorted({b.version for b in candidate_boards})
-        if version not in known_versions:
-            log.trace(f"Version {version} not found in board info, using latest known 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,48 +0,0 @@
-import functools
-import zipfile
-from pathlib import Path
-from typing import Final, List, Optional
-
-import jsons
-
-from mpflash.mpboard_id.board import Board
-
-###############################################################################################
-HERE: Final = Path(__file__).parent
-###############################################################################################
-
-
-def write_boardinfo_json(board_list: List[Board], *, folder: Optional[Path] = None):
-    """Writes the board information to a JSON file.
-
-    Args:
-        board_list (List[Board]): The list of Board objects.
-        folder (Path): The folder where the compressed JSON file will be saved.
-    """
-    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
-        with zipf.open("board_info.json", "w") as fp:
-            fp.write(jsons.dumps(board_list, jdkwargs={"indent": 4}).encode())
-
-
-@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"
-    if not board_info.exists():
-        raise FileNotFoundError(f"Board info file not found: {board_info}")
-
-    with zipfile.ZipFile(board_info, "r") as zf:
-        with zf.open("board_info.json", "r") as file:
-            info = jsons.loads(file.read().decode(encoding="utf-8"), List[Board])
-
-    return info