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

mpflash/mpflash/common.py

@@ -1,165 +1,210 @@
-import fnmatch
-import os
-import sys
-from dataclasses import dataclass, field
-from enum import Enum
-from pathlib import Path
-from typing import List, Optional, Union
-
-from github import Auth, Github
-from serial.tools import list_ports
-from serial.tools.list_ports_common import ListPortInfo
-
-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"],
-}
-
-# Token with no permissions to avoid throttling
-# https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#getting-a-higher-rate-limit
-PAT_NO_ACCESS = (
-    "github_pat" + "_11AAHPVFQ0qAkDnSUaMKSp" + "_ZkDl5NRRwBsUN6EYg9ahp1Dvj4FDDONnXVgimxC2EtpY7Q7BUKBoQ0Jq72X"
-)
-PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
-GH_CLIENT = Github(auth=Auth.Token(PAT))
-
-
-@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)
-
-
-@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.
-    """
-    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)
-
-    # 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)]
-    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 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 sys.platform == "darwin":
-            comports = [p for p in comports if ".Bluetooth" not in p.device]
-        log.trace(f"no Bluetooth: {[p.device for p in comports]}")
-    log.debug(f"filtered_comports: {[p.device for p in comports]}")
-    # sort
-    if sys.platform == "win32":
-        # 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)
+import fnmatch
+import glob
+import os
+import platform
+import sys
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional, Union
+
+from github import Auth, Github
+from serial.tools import list_ports
+from serial.tools.list_ports_common import ListPortInfo
+
+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"],
+}
+
+# Token with no permissions to avoid throttling
+# https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#getting-a-higher-rate-limit
+PAT_NO_ACCESS = (
+    "github_pat"
+    + "_11AAHPVFQ0qAkDnSUaMKSp"
+    + "_ZkDl5NRRwBsUN6EYg9ahp1Dvj4FDDONnXVgimxC2EtpY7Q7BUKBoQ0Jq72X"
+)
+PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
+GH_CLIENT = Github(auth=Auth.Token(PAT))
+
+
+@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)
+
+    # 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 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 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 sys.platform == "darwin":
+            comports = [p for p in comports if ".Bluetooth" not in p.device]
+        log.trace(f"no Bluetooth: {[p.device for p in comports]}")
+    log.debug(f"filtered_comports: {[p.device for p in comports]}")
+    # sort
+    if sys.platform == "win32":
+        # 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 os.name == "nt":
+        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 +1,44 @@
-"""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()
+"""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,78 +1,96 @@
-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.mpremoteboard import MPRemoteBoard
-
-from .common import filtered_comports
-
-
-def connected_ports_boards(*, include: List[str], ignore: List[str]) -> 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.
-    """
-    mpr_boards = [b for b in list_mcus(include=include, ignore=ignore) if b.connected]
-    ports = list({b.port for b in mpr_boards})
-    boards = list({b.board for b in mpr_boards})
-    return (ports, boards, mpr_boards)
-
-
-# #########################################################################################################
-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):
-    """
-    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,
-    )
-    conn_mcus = [MPRemoteBoard(c.device, location=c.location 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 conn_mcus:
-                progress.update(tsk_scan, device=mcu.serialport.replace("/dev/", ""))
-                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 conn_mcus
+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