micropython-stubber 1.23.1.post1__py3-none-any.whl → 1.23.2__py3-none-any.whl

mpflash/mpflash/flash/worklist.py

@@ -1,170 +1,170 @@
-"""Worklist for updating boards"""
-
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-from loguru import logger as log
-
-from mpflash.common import FWInfo, filtered_comports
-from mpflash.downloaded import find_downloaded_firmware
-from mpflash.errors import MPFlashError
-from mpflash.list import show_mcus
-from mpflash.mpboard_id import find_known_board
-from mpflash.mpremoteboard import MPRemoteBoard
-
-# #########################################################################################################
-WorkList = List[Tuple[MPRemoteBoard, FWInfo]]
-# #########################################################################################################
-
-
-def auto_update(
-    conn_boards: List[MPRemoteBoard],
-    target_version: str,
-    fw_folder: Path,
-    *,
-    selector: Optional[Dict[str, str]] = None,
-) -> WorkList:
-    """Builds a list of boards to update based on the connected boards and the firmwares available locally in the firmware folder.
-
-    Args:
-        conn_boards (List[MPRemoteBoard]): List of connected boards
-        target_version (str): Target firmware version
-        fw_folder (Path): Path to the firmware folder
-        selector (Optional[Dict[str, str]], optional): Selector for filtering firmware. Defaults to None.
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    if selector is None:
-        selector = {}
-    wl: WorkList = []
-    for mcu in conn_boards:
-        if mcu.family not in ("micropython", "unknown"):
-            log.warning(f"Skipping flashing {mcu.family} {mcu.port} {mcu.board} on {mcu.serialport} as it is not a MicroPython firmware")
-            continue
-        board_firmwares = find_downloaded_firmware(
-            fw_folder=fw_folder,
-            board_id=mcu.board,
-            version=target_version,
-            port=mcu.port,
-            selector=selector,
-        )
-
-        if not board_firmwares:
-            log.error(f"No {target_version} firmware found for {mcu.board} on {mcu.serialport}.")
-            continue
-
-        if len(board_firmwares) > 1:
-            log.warning(f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}.")
-
-        # just use the last firmware
-        fw_info = board_firmwares[-1]
-        log.info(f"Found {target_version} firmware {fw_info.filename} for {mcu.board} on {mcu.serialport}.")
-        wl.append((mcu, fw_info))
-    return wl
-
-
-def manual_worklist(
-    serial: str,
-    *,
-    board_id: str,
-    version: str,
-    fw_folder: Path,
-) -> WorkList:
-    """Create a worklist for a single board specified manually.
-
-    Args:
-        serial (str): Serial port of the board
-        board (str): Board_ID
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Manual updating {serial} to {board_id} {version}")
-    mcu = MPRemoteBoard(serial)
-    # Lookup the matching port and cpu in board_info based in the board name
-    try:
-        info = find_known_board(board_id)
-        mcu.port = info.port
-        # need the CPU type for the esptool
-        mcu.cpu = info.cpu
-    except (LookupError, MPFlashError) as e:
-        log.error(f"Board {board_id} not found in board_info.zip")
-        log.exception(e)
-        return []
-    mcu.board = board_id
-    firmwares = find_downloaded_firmware(fw_folder=fw_folder, board_id=board_id, version=version, port=mcu.port)
-    if not firmwares:
-        log.error(f"No firmware found for {mcu.port} {board_id} version {version}")
-        return []
-    # use the most recent matching firmware
-    return [(mcu, firmwares[-1])]  # type: ignore
-
-
-def single_auto_worklist(
-    serial: str,
-    *,
-    version: str,
-    fw_folder: Path,
-) -> WorkList:
-    """Create a worklist for a single serial-port.
-
-    Args:
-        serial_port (str): Serial port of the board
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Auto updating {serial} to {version}")
-    conn_boards = [MPRemoteBoard(serial)]
-    todo = auto_update(conn_boards, version, fw_folder)  # type: ignore # List / list
-    show_mcus(conn_boards)  # type: ignore
-    return todo
-
-
-def full_auto_worklist(
-    all_boards: List[MPRemoteBoard], *, include: List[str], ignore: List[str], version: str, fw_folder: Path
-) -> WorkList:
-    """
-    Create a worklist for all connected micropython boards based on the information retrieved from the board.
-    This allows the firmware version of one or moae boards to be changed without needing to specify the port or board_id manually.
-
-    Args:
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    log.trace(f"Auto updating all boards to {version}")
-    if selected_boards := filter_boards(all_boards, include=include, ignore=ignore):
-        return auto_update(selected_boards, version, fw_folder)
-    else:
-        return []
-
-
-def filter_boards(
-    all_boards: List[MPRemoteBoard],
-    *,
-    include: List[str],
-    ignore: List[str],
-):
-    try:
-        comports = [
-            p.device
-            for p in filtered_comports(
-                ignore=ignore,
-                include=include,
-                bluetooth=False,
-            )
-        ]
-        selected_boards = [b for b in all_boards if b.serialport in comports]
-        # [MPRemoteBoard(port.device, update=True) for port in comports]
-    except ConnectionError as e:
-        log.error(f"Error connecting to boards: {e}")
-        return []
-    return selected_boards  # type: ignore
+"""Worklist for updating boards"""
+
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from loguru import logger as log
+
+from mpflash.common import FWInfo, filtered_comports
+from mpflash.downloaded import find_downloaded_firmware
+from mpflash.errors import MPFlashError
+from mpflash.list import show_mcus
+from mpflash.mpboard_id import find_known_board
+from mpflash.mpremoteboard import MPRemoteBoard
+
+# #########################################################################################################
+WorkList = List[Tuple[MPRemoteBoard, FWInfo]]
+# #########################################################################################################
+
+
+def auto_update(
+    conn_boards: List[MPRemoteBoard],
+    target_version: str,
+    fw_folder: Path,
+    *,
+    selector: Optional[Dict[str, str]] = None,
+) -> WorkList:
+    """Builds a list of boards to update based on the connected boards and the firmwares available locally in the firmware folder.
+
+    Args:
+        conn_boards (List[MPRemoteBoard]): List of connected boards
+        target_version (str): Target firmware version
+        fw_folder (Path): Path to the firmware folder
+        selector (Optional[Dict[str, str]], optional): Selector for filtering firmware. Defaults to None.
+
+    Returns:
+        WorkList: List of boards and firmware information to update
+    """
+    if selector is None:
+        selector = {}
+    wl: WorkList = []
+    for mcu in conn_boards:
+        if mcu.family not in ("micropython", "unknown"):
+            log.warning(f"Skipping flashing {mcu.family} {mcu.port} {mcu.board} on {mcu.serialport} as it is not a MicroPython firmware")
+            continue
+        board_firmwares = find_downloaded_firmware(
+            fw_folder=fw_folder,
+            board_id=mcu.board,
+            version=target_version,
+            port=mcu.port,
+            selector=selector,
+        )
+
+        if not board_firmwares:
+            log.error(f"No {target_version} firmware found for {mcu.board} on {mcu.serialport}.")
+            continue
+
+        if len(board_firmwares) > 1:
+            log.warning(f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}.")
+
+        # just use the last firmware
+        fw_info = board_firmwares[-1]
+        log.info(f"Found {target_version} firmware {fw_info.filename} for {mcu.board} on {mcu.serialport}.")
+        wl.append((mcu, fw_info))
+    return wl
+
+
+def manual_worklist(
+    serial: str,
+    *,
+    board_id: str,
+    version: str,
+    fw_folder: Path,
+) -> WorkList:
+    """Create a worklist for a single board specified manually.
+
+    Args:
+        serial (str): Serial port of the board
+        board (str): Board_ID
+        version (str): Firmware version
+        fw_folder (Path): Path to the firmware folder
+
+    Returns:
+        WorkList: List of boards and firmware information to update
+    """
+    log.trace(f"Manual updating {serial} to {board_id} {version}")
+    mcu = MPRemoteBoard(serial)
+    # Lookup the matching port and cpu in board_info based in the board name
+    try:
+        info = find_known_board(board_id)
+        mcu.port = info.port
+        # need the CPU type for the esptool
+        mcu.cpu = info.cpu
+    except (LookupError, MPFlashError) as e:
+        log.error(f"Board {board_id} not found in board_info.zip")
+        log.exception(e)
+        return []
+    mcu.board = board_id
+    firmwares = find_downloaded_firmware(fw_folder=fw_folder, board_id=board_id, version=version, port=mcu.port)
+    if not firmwares:
+        log.error(f"No firmware found for {mcu.port} {board_id} version {version}")
+        return []
+    # use the most recent matching firmware
+    return [(mcu, firmwares[-1])]  # type: ignore
+
+
+def single_auto_worklist(
+    serial: str,
+    *,
+    version: str,
+    fw_folder: Path,
+) -> WorkList:
+    """Create a worklist for a single serial-port.
+
+    Args:
+        serial_port (str): Serial port of the board
+        version (str): Firmware version
+        fw_folder (Path): Path to the firmware folder
+
+    Returns:
+        WorkList: List of boards and firmware information to update
+    """
+    log.trace(f"Auto updating {serial} to {version}")
+    conn_boards = [MPRemoteBoard(serial)]
+    todo = auto_update(conn_boards, version, fw_folder)  # type: ignore # List / list
+    show_mcus(conn_boards)  # type: ignore
+    return todo
+
+
+def full_auto_worklist(
+    all_boards: List[MPRemoteBoard], *, include: List[str], ignore: List[str], version: str, fw_folder: Path
+) -> WorkList:
+    """
+    Create a worklist for all connected micropython boards based on the information retrieved from the board.
+    This allows the firmware version of one or moae boards to be changed without needing to specify the port or board_id manually.
+
+    Args:
+        version (str): Firmware version
+        fw_folder (Path): Path to the firmware folder
+
+    Returns:
+        WorkList: List of boards and firmware information to update
+    """
+    log.trace(f"Auto updating all boards to {version}")
+    if selected_boards := filter_boards(all_boards, include=include, ignore=ignore):
+        return auto_update(selected_boards, version, fw_folder)
+    else:
+        return []
+
+
+def filter_boards(
+    all_boards: List[MPRemoteBoard],
+    *,
+    include: List[str],
+    ignore: List[str],
+):
+    try:
+        comports = [
+            p.device
+            for p in filtered_comports(
+                ignore=ignore,
+                include=include,
+                bluetooth=False,
+            )
+        ]
+        selected_boards = [b for b in all_boards if b.serialport in comports]
+        # [MPRemoteBoard(port.device, update=True) for port in comports]
+    except ConnectionError as e:
+        log.error(f"Error connecting to boards: {e}")
+        return []
+    return selected_boards  # type: ignore

mpflash/mpflash/list.py

@@ -1,106 +1,106 @@
-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=40)
-    # 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.replace("/dev/", ""),
-            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
+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 +1,41 @@
-"""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")
+"""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")