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

mpflash/mpflash/cli_group.py

@@ -1,111 +0,0 @@
-"""
-Main entry point for the CLI group.
-Additional comands are added in the submodules.
-"""
-
-import rich_click as click
-
-from mpflash.vendor.click_aliases import ClickAliasedGroup
-
-from .config import __version__, config
-from .logger import log, make_quiet, set_loglevel
-
-
-def cb_verbose(ctx, param, value):
-    """Callback to set the log level to DEBUG if verbose is set"""
-    if value and not config.quiet:
-        # log.debug(f"Setting verbose mode to {value}")
-        config.verbose = True
-        if value > 1:
-            set_loglevel("TRACE")
-        else:
-            set_loglevel("DEBUG")
-        log.debug(f"version: {__version__}")
-    else:
-        set_loglevel("INFO")
-        config.verbose = False
-    return value
-
-
-def cb_interactive(ctx, param, value: bool):
-    log.trace(f"Setting interactive mode to {value}")
-    config.interactive = value
-    return value
-
-
-def cb_test(ctx, param, value):
-    if value:
-        log.trace(f"Setting tests to {value}")
-        config.tests = value
-    return value
-
-def cb_usb(ctx, param, value: bool):
-    config.usb = bool(value)
-    return value
-
-
-def cb_quiet(ctx, param, value):
-    log.trace(f"Setting quiet mode to {value}")
-    if value:
-        make_quiet()
-    return value
-
-
-@click.group(cls=ClickAliasedGroup)
-# @click.group()
-@click.version_option(package_name="mpflash")
-@click.option(
-    "--quiet",
-    "-q",
-    is_eager=True,
-    is_flag=True,
-    help="Suppresses all output.",
-    callback=cb_quiet,
-    envvar="MPFLASH_QUIET",
-    show_default=True,
-)
-@click.option(
-    "--interactive/--no-interactive",
-    "-i/-x",
-    is_eager=True,
-    help="Suppresses all request for Input.",
-    callback=cb_interactive,
-    # envvar="MPFLASH_QUIET",
-    default=True,
-    show_default=True,
-)
-@click.option(
-    "-V",
-    "--verbose",
-    is_eager=True,
-    count=True,
-    help="Enables verbose mode.",
-    callback=cb_verbose,
-)
-@click.option(
-    "--usb",
-    "-u",
-    is_eager=True,
-    is_flag=True,
-    default=False,
-    help="Shows USB location of the connected boards.",
-    callback=cb_usb,
-    show_default=True,
-)
-@click.option(
-    "--test",
-    is_eager=True,
-    help="Test a specific feature.",
-    callback=cb_test,
-    multiple=True,
-    default=[],
-    envvar="MPFLASH_TEST",
-    metavar="FLAG",
-)
-def cli(**kwargs):
-    """mpflash - MicroPython flashing tool.
-
-    A CLI to download and flash MicroPython firmware to different ports and boards.
-    """
-    # all functionality is added in the submodules
-    pass

mpflash/mpflash/cli_list.py

@@ -1,87 +0,0 @@
-import json
-from typing import List
-
-import rich_click as click
-from rich import print
-
-from .cli_group import cli
-from .connected import list_mcus
-from .list import show_mcus
-from .logger import make_quiet
-
-
-@cli.command(
-    "list",
-    help="List the connected MCU boards. alias: devs",
-    aliases=["devs"],
-)
-@click.option(
-    "--json",
-    "-j",
-    "as_json",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="""Output in json format""",
-)
-@click.option(
-    "--serial",
-    "--serial-port",
-    "-s",
-    "serial",
-    default=["*"],
-    multiple=True,
-    show_default=True,
-    help="Serial port(s) (or globs) to list. ",
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--ignore",
-    "-i",
-    is_eager=True,
-    help="Serial port(s) (or globs) to ignore. Defaults to MPFLASH_IGNORE.",
-    multiple=True,
-    default=[],
-    envvar="MPFLASH_IGNORE",
-    show_default=True,
-    metavar="SERIALPORT",
-)
-@click.option(
-    "--bluetooth/--no-bluetooth",
-    "-b/-nb",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="""Include bluetooth ports in the list""",
-)
-@click.option(
-    "--progress/--no-progress",
-    # "-p/-np", -p is already used for --port
-    "progress",
-    is_flag=True,
-    default=True,
-    show_default=True,
-    help="""Show progress""",
-)
-def cli_list_mcus(serial: List[str], ignore: List[str], bluetooth: bool, as_json: bool, progress: bool = True) -> int:
-    """List the connected MCU boards, and output in a nice table or json."""
-    serial = list(serial)
-    ignore = list(ignore)
-    if as_json:
-        # avoid noise in json output
-        make_quiet()
-    # TODO? Ask user to select a serialport if [?] is given ?
-
-    conn_mcus = list_mcus(ignore=ignore, include=serial, bluetooth=bluetooth)
-    # ignore boards that have the [micropython-stubber] ignore flag set
-    conn_mcus = [item for item in conn_mcus if not (item.toml.get("mpflash", {}).get("ignore", False))]    
-    if as_json:
-        # remove the path and firmware attibutes from the json output as they are always empty
-        for mcu in conn_mcus:
-            del mcu.path
-            del mcu.firmware
-        print(json.dumps([mcu.__dict__ for mcu in conn_mcus], indent=4))
-        progress = False
-    if progress:
-        show_mcus(conn_mcus, refresh=False)
-    return 0 if conn_mcus else 1

mpflash/mpflash/cli_main.py

@@ -1,39 +0,0 @@
-"""mpflash is a CLI to download and flash MicroPython firmware to various boards."""
-
-import os
-
-import click.exceptions as click_exceptions
-from loguru import logger as log
-
-from .cli_download import cli_download
-from .cli_flash import cli_flash_board
-from .cli_group import cli
-from .cli_list import cli_list_mcus
-
-
-def mpflash():
-    cli.add_command(cli_list_mcus)
-    cli.add_command(cli_download)
-    cli.add_command(cli_flash_board)
-
-    # cli(auto_envvar_prefix="MPFLASH")
-    if False and os.environ.get("COMPUTERNAME").startswith("JOSVERL"):
-        # intentional less error suppression on dev machine
-        result = cli(standalone_mode=False)
-    else:
-        try:
-            result = cli(standalone_mode=True)
-            exit(result)
-        except AttributeError as e:
-            log.error(f"Error: {e}")
-            exit(-1)
-        except click_exceptions.ClickException as e:
-            log.error(f"Error: {e}")
-            exit(-2)
-        except click_exceptions.Abort as e:
-            # Aborted - Ctrl-C
-            exit(-3)
-
-
-if __name__ == "__main__":
-    mpflash()

mpflash/mpflash/common.py

@@ -1,217 +0,0 @@
-import fnmatch
-import glob
-import os
-import platform
-from dataclasses import dataclass, field
-from enum import Enum
-from pathlib import Path
-from typing import List, Optional, Union
-
-from serial.tools import list_ports
-from serial.tools.list_ports_common import ListPortInfo
-
-from mpflash.basicgit import GH_CLIENT as GH_CLIENT
-
-from .logger import log
-
-# from mpflash.mpremoteboard import MPRemoteBoard
-
-PORT_FWTYPES = {
-    "stm32": [".dfu"],  # need .dfu for pydfu.py - .hex for cube cli/GUI
-    "esp32": [".bin"],
-    "esp8266": [".bin"],
-    "rp2": [".uf2"],
-    "samd": [".uf2"],
-    # below this not yet implemented / tested
-    "mimxrt": [".hex"],
-    "nrf": [".uf2"],
-    "renesas-ra": [".hex"],
-}
-
-
-@dataclass
-class FWInfo:
-    """
-    Downloaded Firmware information
-    is somewhat related to the BOARD class in the mpboard_id module
-    """
-
-    port: str  # MicroPython port
-    board: str  # MicroPython board
-    filename: str = field(default="")  # relative filename of the firmware image
-    firmware: str = field(default="")  # url or path to original firmware image
-    variant: str = field(default="")  # MicroPython variant
-    preview: bool = field(default=False)  # True if the firmware is a preview version
-    version: str = field(default="")  # MicroPython version (NO v prefix)
-    url: str = field(default="")  # url to the firmware image download folder
-    build: str = field(default="0")  # The build = number of commits since the last release
-    ext: str = field(default="")  # the file extension of the firmware
-    family: str = field(default="micropython")  # The family of the firmware
-    custom: bool = field(default=False)  # True if the firmware is a custom build
-    description: str = field(default="")  # Description used by this firmware (custom only)
-
-    def to_dict(self) -> dict:
-        """Convert the object to a dictionary"""
-        return self.__dict__
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "FWInfo":
-        """Create a FWInfo object from a dictionary"""
-        # add missing keys
-        if "ext" not in data:
-            data["ext"] = Path(data["firmware"]).suffix
-        if "family" not in data:
-            data["family"] = "micropython"
-        return cls(**data)
-
-
-@dataclass
-class Params:
-    """Common parameters for downloading and flashing firmware"""
-
-    ports: List[str] = field(default_factory=list)
-    boards: List[str] = field(default_factory=list)
-    versions: List[str] = field(default_factory=list)
-    fw_folder: Path = Path()
-    serial: List[str] = field(default_factory=list)
-    ignore: List[str] = field(default_factory=list)
-    bluetooth: bool = False
-
-
-@dataclass
-class DownloadParams(Params):
-    """Parameters for downloading firmware"""
-
-    clean: bool = False
-    force: bool = False
-
-
-class BootloaderMethod(Enum):
-    AUTO = "auto"
-    MANUAL = "manual"
-    MPY = "mpy"
-    TOUCH_1200 = "touch1200"
-    NONE = "none"
-
-
-@dataclass
-class FlashParams(Params):
-    """Parameters for flashing a board"""
-
-    erase: bool = True
-    bootloader: BootloaderMethod = BootloaderMethod.NONE
-    cpu: str = ""
-
-    def __post_init__(self):
-        if isinstance(self.bootloader, str):
-            self.bootloader = BootloaderMethod(self.bootloader)
-
-
-ParamType = Union[DownloadParams, FlashParams]
-
-
-def filtered_comports(
-    ignore: Optional[List[str]] = None,
-    include: Optional[List[str]] = None,
-    bluetooth: bool = False,
-) -> List[ListPortInfo]:  # sourcery skip: assign-if-exp
-    """
-    Get a list of filtered comports using the include and ignore lists.
-    both can be globs (e.g. COM*) or exact port names (e.g. COM1)
-    """
-    if not ignore:
-        ignore = []
-    elif not isinstance(ignore, list):  # type: ignore
-        ignore = list(ignore)
-    if not include:
-        include = ["*"]
-    elif not isinstance(include, list):  # type: ignore
-        include = list(include)
-
-    if ignore == [] and platform.system() == "Darwin":
-        # By default ignore some of the irrelevant ports on macOS
-        ignore = [
-            "/dev/*.debug-console",
-        ]
-
-    # remove ports that are to be ignored
-    log.trace(f"{include=}, {ignore=}, {bluetooth=}")
-
-    comports = [
-        p for p in list_ports.comports() if not any(fnmatch.fnmatch(p.device, i) for i in ignore)
-    ]
-
-    if False:
-        import jsons
-
-        print(jsons.dumps(comports).replace('{"description":', '\n{"description":'))
-
-    if platform.system() == "Linux":
-        # use p.location to filter out the bogus ports on newer Linux kernels
-        # filter out the bogus ports on newer Linux kernels
-        comports = [p for p in comports if p.location]
-
-    log.trace(f"comports: {[p.device for p in comports]}")
-    # remove bluetooth ports
-
-    if include != ["*"]:
-        # if there are explicit ports to include, add them to the list
-        explicit = [
-            p for p in list_ports.comports() if any(fnmatch.fnmatch(p.device, i) for i in include)
-        ]
-        log.trace(f"explicit: {[p.device for p in explicit]}")
-        if ignore == []:
-            # if nothing to ignore, just use the explicit list as a sinple sane default
-            comports = explicit
-        else:
-            # if there are ports to ignore, add the explicit list to the filtered list
-            comports = list(set(explicit) | set(comports))
-    if platform.system() == "Darwin":
-        # Failsafe: filter out debug-console ports
-        comports = [p for p in comports if not p.description.endswith(".debug-console")]
-
-    if not bluetooth:
-        # filter out bluetooth ports
-        comports = [p for p in comports if "bluetooth" not in p.description.lower()]
-        comports = [p for p in comports if "BTHENUM" not in p.hwid]
-        if platform.system() == "Darwin":
-            comports = [p for p in comports if ".Bluetooth" not in p.device]
-            # filter out ports with no hwid
-            comports = [p for p in comports if p.hwid != "n/a"]
-    log.debug(f"filtered_comports: {[p.device for p in comports]}")
-    # sort
-    if platform.system() == "Windows":
-        # Windows sort of comports by number - but fallback to device name
-        return sorted(
-            comports,
-            key=lambda x: int(x.device.split()[0][3:]) if x.device.split()[0][3:].isdigit() else x,
-        )
-    # sort by device name
-    return sorted(comports, key=lambda x: x.device)
-
-
-def find_serial_by_path(target_port: str):
-    """Find the symbolic link path of a serial port by its device path."""
-    # sourcery skip: use-next
-
-    if platform.system() == "Windows":
-        return None
-    # List all available serial ports
-    available_ports = list_ports.comports()
-    # Filter to get the device path of the target port
-    target_device_path = None
-    for port in available_ports:
-        if port.device == target_port:
-            target_device_path = port.device
-            break
-
-    if not target_device_path:
-        return None  # Target port not found among available ports
-
-    # Search for all symbolic links in /dev/serial/by-path/
-    for symlink in glob.glob("/dev/serial/by-path/*"):
-        # Resolve the symbolic link to its target
-        if os.path.realpath(symlink) == target_device_path:
-            return symlink  # Return the matching symlink path
-
-    return None  # Return None if no match is found

mpflash/mpflash/config.py

@@ -1,44 +0,0 @@
-"""centralized configuration for mpflash"""
-
-import os
-from importlib.metadata import version
-from pathlib import Path
-from typing import List
-
-import platformdirs
-
-from mpflash.logger import log
-
-
-def get_version():
-    name = __package__ or "mpflash"
-    return version(name)
-
-
-class MPtoolConfig:
-    """Centralized configuration for mpflash"""
-
-    quiet: bool = False
-    verbose: bool = False
-    usb: bool = False
-    ignore_ports: List[str] = []
-    firmware_folder: Path = platformdirs.user_downloads_path() / "firmware"
-    # test options specified on the commandline
-    tests: List[str] = []
-    _interactive: bool = True
-
-    @property
-    def interactive(self):
-        # No interactions in CI
-        if os.getenv("GITHUB_ACTIONS") == "true":
-            log.warning("Disabling interactive mode in CI")
-            return False
-        return self._interactive
-
-    @interactive.setter
-    def interactive(self, value: bool):
-        self._interactive = value
-
-
-config = MPtoolConfig()
-__version__ = get_version()

mpflash/mpflash/connected.py

@@ -1,96 +0,0 @@
-from typing import List, Tuple
-
-from rich import print
-from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
-from rich.table import Column
-
-from mpflash.common import filtered_comports
-from mpflash.mpremoteboard import MPRemoteBoard
-
-from mpflash.common import find_serial_by_path
-
-
-def connected_ports_boards(
-    *, include: List[str], ignore: List[str], bluetooth: bool = False
-) -> Tuple[List[str], List[str], List[MPRemoteBoard]]:
-    """
-    Returns a tuple containing lists of unique ports and boards from the connected MCUs.
-    Boards that are physically connected, but give no tangible response are ignored.
-
-    Returns:
-        A tuple containing three lists:
-            - A list of unique ports where MCUs are connected.
-            - A list of unique board names of the connected MCUs.
-            - A list of MPRemoteBoard instances of the connected MCUs.
-    """
-    conn_mcus = [
-        b for b in list_mcus(include=include, ignore=ignore, bluetooth=bluetooth) if b.connected
-    ]
-    # ignore boards that have the [micropython-stubber] ignore flag set
-    conn_mcus = [
-        item for item in conn_mcus if not (item.toml.get("mpflash", {}).get("ignore", False))
-    ]
-
-    ports = list({b.port for b in conn_mcus})
-    boards = list({b.board for b in conn_mcus})
-    return (ports, boards, conn_mcus)
-
-
-# #########################################################################################################
-rp_spinner = SpinnerColumn(finished_text="✅")
-rp_text = TextColumn("{task.description} {task.fields[device]}", table_column=Column())
-rp_bar = BarColumn(bar_width=None, table_column=Column())
-
-
-def list_mcus(
-    *, ignore: List[str], include: List[str], bluetooth: bool = False
-) -> List[MPRemoteBoard]:
-    """
-    Retrieves information about connected microcontroller boards.
-
-    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]
-
-    comports = filtered_comports(
-        ignore=ignore,
-        include=include,
-        bluetooth=bluetooth,
-    )
-    connected_mcus = [
-        MPRemoteBoard(
-            c.device,
-            location=find_serial_by_path(c.device) or c.location or c.hwid or  "?",
-        )
-        for c in comports
-    ]
-
-    # a lot of boilerplate to show a progress bar with the comport currently scanned
-    # low update rate to facilitate screen readers/narration
-    with Progress(
-        rp_spinner,
-        rp_text,
-        rp_bar,
-        TimeElapsedColumn(),
-        refresh_per_second=1,
-    ) as progress:
-        tsk_scan = progress.add_task("[green]Scanning", visible=False, total=None)
-        progress.tasks[tsk_scan].fields["device"] = "..."
-        progress.tasks[tsk_scan].visible = True
-        progress.start_task(tsk_scan)
-        try:
-            for mcu in connected_mcus:
-                progress.update(tsk_scan, device=mcu.serialport.replace("/dev/tty", "tty"))
-                try:
-                    mcu.get_mcu_info()
-                except ConnectionError as e:
-                    print(f"Error: {e}")
-                    continue
-        finally:
-            # transient
-            progress.stop_task(tsk_scan)
-            progress.tasks[tsk_scan].visible = False
-    return connected_mcus