mpflash 1.26.4__tar.gz → 1.26.6__tar.gz

{mpflash-1.26.4 → mpflash-1.26.6}/.github/workflows/copilot-setup-steps.yml

@@ -26,7 +26,7 @@ jobs:
     # If you do not check out your code, Copilot will do this for you.
     steps:
       - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           version: "latest"
 

{mpflash-1.26.4 → mpflash-1.26.6}/.github/workflows/pytest_mpflash.yml

@@ -51,7 +51,7 @@ jobs:
             # uv is not in the default image
             #----------------------------------------------
             - name: Install the latest version of uv
-              uses: astral-sh/setup-uv@v6
+              uses: astral-sh/setup-uv@v7
               with:
                 version: "latest"
 

{mpflash-1.26.4 → mpflash-1.26.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpflash
-Version: 1.26.4
+Version: 1.26.6
 Summary: Flash and download tool for MicroPython firmwares
 Project-URL: Homepage, https://github.com/Josverl/mpflash
 Project-URL: Documentation, https://github.com/Josverl/mpflash/blob/main/README.md

{mpflash-1.26.4 → mpflash-1.26.6}/docs/logger_fixes.md

@@ -33,26 +33,8 @@ from mpflash.logger import configure_safe_logging
 configure_safe_logging()
 ```
 
-### 3. External Logger Safety
-
-The `setup_external_logger_safety()` function configures both the standard Python logging and Loguru for safe operation:
-
-```python
-from mpflash.logger import setup_external_logger_safety
-setup_external_logger_safety()
-```
-
 ## Usage
 
-### For micropython-stubber users:
-
-Before running stubber commands that might log problematic messages, initialize safe logging:
-
-```python
-from mpflash.logger import setup_external_logger_safety
-setup_external_logger_safety()
-
-# Now run stubber commands safely
 ```
 
 ### For other external packages:
@@ -65,12 +47,6 @@ from mpflash.logger import configure_safe_logging
 configure_safe_logging()
 ```
 
-**Option 2: External logger safety (recommended)**
-```python
-from mpflash.logger import setup_external_logger_safety
-setup_external_logger_safety()
-```
-
 ## Verification
 
 The fixes have been tested with all problematic message types:

{mpflash-1.26.4 → mpflash-1.26.6}/mpflash/ask_input.py

@@ -13,7 +13,7 @@ from .common import DownloadParams, FlashParams, ParamType
 from .config import config
 from .mpboard_id import get_known_boards_for_port, known_ports, known_stored_boards
 from .mpremoteboard import MPRemoteBoard
-from .versions import micropython_versions
+from .versions import clean_version, micropython_versions
 
 
 def ask_missing_params(
@@ -106,6 +106,7 @@ def ask_missing_params(
 def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
     """
     Filters the known boards based on the selected versions and returns the filtered boards.
+    If no boards are found for the requested version(s), falls back to previous stable/preview versions.
 
     Args:
         answers (dict): The user's answers.
@@ -114,8 +115,11 @@ def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
         Sequence[Tuple[str, str]]: The filtered boards.
     """
     versions = []
+    original_versions = []
+
     # if version is not asked ; then need to get the version from the inputs
     if "versions" in answers:
+        original_versions = list(answers["versions"])
         versions = list(answers["versions"])
         if "stable" in versions:
             versions.remove("stable")
@@ -124,7 +128,45 @@ def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
             versions.remove("preview")
             versions.extend((micropython_versions()[-1], micropython_versions()[-2]))  # latest preview and stable
 
-    some_boards = known_stored_boards(answers["port"], versions)  #    or known_mp_boards(answers["port"])
+    some_boards = known_stored_boards(answers["port"], versions)
+
+    # If no boards found and we have specific versions, try fallback
+    if not some_boards and versions:
+        log.debug(f"No boards found for {answers['port']} with version(s) {versions}, trying fallback")
+
+        # Get all micropython versions to find fallback candidates
+        all_versions = micropython_versions()
+        fallback_versions = []
+
+        for original_version in original_versions:
+            if original_version == "stable":
+                # For stable, try previous stable versions
+                stable_versions = [v for v in all_versions if not v.endswith("preview")]
+                # Try the last 3 stable versions
+                fallback_versions.extend(stable_versions[-3:])
+            elif original_version == "preview":
+                # For preview, try current preview and recent stable versions
+                preview_versions = [v for v in all_versions if v.endswith("preview")]
+                stable_versions = [v for v in all_versions if not v.endswith("preview")]
+                fallback_versions.extend(preview_versions[-1:] + stable_versions[-2:])
+            else:
+                # For specific version, try that version and previous versions
+                try:
+                    version_index = all_versions.index(original_version)
+                    # Try current and up to 2 previous versions
+                    start_idx = max(0, version_index - 2)
+                    fallback_versions.extend(all_versions[start_idx : version_index + 1])
+                except ValueError:
+                    # Version not found in list, try recent stable versions
+                    stable_versions = [v for v in all_versions if not v.endswith("preview")]
+                    fallback_versions.extend(stable_versions[-2:])
+
+        # Remove duplicates and clean versions
+        fallback_versions = [clean_version(v) for v in list(set(fallback_versions))]
+
+        if fallback_versions:
+            log.debug(f"Trying fallback versions: {fallback_versions}")
+            some_boards = known_stored_boards(answers["port"], fallback_versions)
 
     if some_boards:
         # Create a dictionary where the keys are the second elements of the tuples

{mpflash-1.26.4 → mpflash-1.26.6}/mpflash/basicgit.py

@@ -13,17 +13,6 @@ from loguru import logger as log
 
 from mpflash.config import config
 
-# from github import Auth, BadCredentialsException, Github
-
-# # 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_" + "11AAHPVFQ0G4NTaQ73Bw5J" + "_fAp7K9sZ1qL8VFnI9g78eUlCdmOXHB3WzSdj2jtEYb4XF3N7PDJBl32qIxq"
-# PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
-
-# # GH_CLIENT = Github(auth=Auth.Token(PAT))
-
-# GH_CLIENT = None
-
 
 def _run_local_git(
     cmd: List[str],

{mpflash-1.26.4 → mpflash-1.26.6}/mpflash/config.py

@@ -100,7 +100,8 @@ class MPFlashConfig:
 
             # 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_" + "11AAHPVFQ0G4NTaQ73Bw5J" + "_fAp7K9sZ1qL8VFnI9g78eUlCdmOXHB3WzSdj2jtEYb4XF3N7PDJBl32qIxq"
+            # mpflash_read_mp_versions - 31-10-2025
+            PAT_NO_ACCESS = "github_pat_" + "11AAHPVFQ0qUKF3mRb9iw2" + "_rwgJ0FZUDYftFFyZhilncyVcqhIZaVF4abZxbGgMOhdSTEPUEKEpAM7m2gp"
             PAT = os.environ.get("GITHUB_TOKEN") or PAT_NO_ACCESS
             self._gh_client = Github(auth=Auth.Token(PAT))
         return self._gh_client

{mpflash-1.26.4 → mpflash-1.26.6}/mpflash/list.py

@@ -23,7 +23,7 @@ def show_mcus(
 
 def abbrv_family(family: str, is_wide: bool) -> str:
     if not is_wide:
-        ABRV = {"micropython": "mpy", "circuitpython": "cpy", "unknown": "?"}
+        ABRV = {"MicroPython": "MPy", "CircuitPython": "CP", "unknown": "?"}
         return ABRV.get(family, family[:4])
     return family
 

{mpflash-1.26.4 → mpflash-1.26.6}/mpflash/logger.py

@@ -5,10 +5,6 @@ Ensures log messages are compatible with the current console encoding.
 Removes or replaces Unicode icons if the encoding is not UTF-8.
 Prevents Loguru colorization errors with angle bracket notation.
 
-Usage for external packages:
-    from mpflash.logger import setup_external_logger_safety
-    setup_external_logger_safety()
-
 This is particularly important when using packages like micropython-stubber
 that may log messages containing angle bracket notation like <board_default>.
 """
@@ -110,50 +106,6 @@ def set_loglevel(loglevel: str) -> None:
     )  # type: ignore
 
 
-# def configure_safe_logging() -> None:
-#     """
-#     Configure logging to be safe from colorization errors.
-
-#     This function helps prevent issues when external packages
-#     (like micropython-stubber) log messages with angle brackets
-#     that could be misinterpreted as color tags.
-#     """
-#     # Remove all existing handlers to start fresh
-#     try:
-#         log.remove()
-#     except ValueError:
-#         pass
-
-#     # Add a completely safe handler with no colorization
-#     log.add(
-#         sys.stderr,
-#         level="TRACE",
-#         colorize=False,  # Completely disable colorization
-#         format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name}:{function}:{line} - {message}",
-#     )
-
-
-# def setup_external_logger_safety() -> None:
-#     """
-#     Setup safe logging configuration for external packages.
-
-#     Call this function before running tools that might log messages
-#     with angle bracket notation (like micropython-stubber) to prevent
-#     Loguru colorization errors.
-#     """
-#     import logging
-
-#     # Configure the root logger to be safe
-#     logging.basicConfig(
-#         level=logging.DEBUG,
-#         format="%(asctime)s | %(levelname)s | %(name)s:%(funcName)s:%(lineno)d - %(message)s",
-#         handlers=[logging.StreamHandler(sys.stderr)],
-#     )
-
-#     # Also configure loguru for safety
-#     configure_safe_logging()
-
-
 def make_quiet() -> None:
     """
     Make the logger quiet.

mpflash-1.26.6/mpflash/mpremoteboard/mpy_fw_info.py

@@ -0,0 +1,288 @@
+# pragma: no cover
+import os
+import sys
+
+
+# our own logging module to avoid dependency on and interfering with logging module
+class logging:
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    level = INFO
+    prnt = print
+
+    @staticmethod
+    def getLogger(name):
+        return logging()
+
+    @classmethod
+    def basicConfig(cls, level):
+        cls.level = level
+
+    def debug(self, msg):
+        if self.level <= logging.DEBUG:
+            self.prnt("DEBUG :", msg)
+
+    def info(self, msg):
+        if self.level <= logging.INFO:
+            self.prnt("INFO  :", msg)
+
+    def warning(self, msg):
+        if self.level <= logging.WARNING:
+            self.prnt("WARN  :", msg)
+
+    def error(self, msg):
+        if self.level <= logging.ERROR:
+            self.prnt("ERROR :", msg)
+
+
+log = logging.getLogger("stubber")
+logging.basicConfig(level=logging.INFO)
+# logging.basicConfig(level=logging.DEBUG)
+
+
+def get_build(s):
+    # extract build from sys.version or os.uname().version if available
+    # sys.version: 'MicroPython v1.23.0-preview.6.g3d0b6276f'
+    # sys.implementation.version: 'v1.13-103-gb137d064e'
+    if not s:
+        return ""
+    s = s.split(" on ", 1)[0] if " on " in s else s
+    if s.startswith("v"):
+        if "-" not in s:
+            return ""
+        b = s.split("-")[1]
+        return b
+    if "-preview" not in s:
+        return ""
+    b = s.split("-preview")[1].split(".")[1]
+    return b
+
+
+def _version_str(version: tuple) -> str:
+    v_str = ".".join([str(n) for n in version[:3]])
+    if len(version) > 3 and version[3]:
+        v_str += "-" + version[3]
+    return v_str
+
+
+def _get_base_system_info() -> dict[str, str]:
+    """Get basic system implementation details."""
+    try:
+        fam = sys.implementation[0]  # type: ignore
+    except TypeError:
+        # testing on CPython 3.11
+        fam = sys.implementation.name
+
+    info = dict(
+        {
+            "family": fam,
+            "version": "",
+            "build": "",
+            "ver": "",
+            "port": sys.platform,  # port: esp32 / win32 / linux / stm32
+            "board": "UNKNOWN",
+            "board_id": "",
+            "variant": "",
+            "cpu": "",
+            "mpy": "",
+            "arch": "",
+        }
+    )
+    return info
+
+
+def _normalize_port_info(info: dict[str, str]) -> None:
+    """Normalize port names to be consistent with the repo."""
+    if info["port"].startswith("pyb"):
+        info["port"] = "stm32"
+    elif info["port"] == "win32":
+        info["port"] = "windows"
+    elif info["port"] == "linux":
+        info["port"] = "unix"
+
+
+def _extract_version_info(info: dict[str, str]) -> None:
+    """Extract version information from sys.implementation."""
+    try:
+        info["version"] = _version_str(sys.implementation.version)  # type: ignore
+    except AttributeError:
+        pass
+
+
+def get_boardname(info: dict) -> None:
+    "Read the board_id from the boardname.py file that may have been created upfront"
+    try:
+        from boardname import BOARD_ID  # type: ignore
+
+        log.info("Found BOARD_ID: {}".format(BOARD_ID))
+    except ImportError:
+        log.warning("BOARD_ID not found")
+        BOARD_ID = ""
+    info["board_id"] = BOARD_ID
+    info["board"] = BOARD_ID.split("-")[0] if "-" in BOARD_ID else BOARD_ID
+    info["variant"] == BOARD_ID.split("-")[1] if "-" in BOARD_ID else ""
+
+
+def _extract_hardware_info(info: dict[str, str]) -> None:
+    """Extract board, CPU, and machine details."""
+    try:
+        _machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine  # type: ignore
+        info["board"] = _machine.strip()
+        si_build = sys.implementation._build if "_build" in dir(sys.implementation) else ""
+        if si_build:
+            info["board"] = si_build.split("-")[0]
+            info["variant"] = si_build.split("-")[1] if "-" in si_build else ""
+        info["board_id"] = si_build
+        info["cpu"] = _machine.split("with")[-1].strip()
+        info["mpy"] = (
+            sys.implementation._mpy  # type: ignore
+            if "_mpy" in dir(sys.implementation)
+            else sys.implementation.mpy
+            if "mpy" in dir(sys.implementation)
+            else ""  # type: ignore
+        )
+    except (AttributeError, IndexError):
+        pass
+
+    if not info["board_id"]:
+        get_boardname(info)
+
+
+def _build(s):
+    # extract build from sys.version or os.uname().version if available
+    # sys.version: 'MicroPython v1.24.0-preview.6.g3d0b6276f'
+    # sys.implementation.version: 'v1.13-103-gb137d064e'
+    if not s:
+        return ""
+    s = s.split(" on ", 1)[0] if " on " in s else s
+    if s.startswith("v"):
+        if not "-" in s:
+            return ""
+        b = s.split("-")[1]
+        return b
+    if not "-preview" in s:
+        return ""
+    b = s.split("-preview")[1].split(".")[1]
+    return b
+
+
+def _extract_build_info(info: dict[str, str]) -> None:
+    """Extract build information from various system sources."""
+    try:
+        if "uname" in dir(os):  # old
+            # extract build from uname().version if available
+            info["build"] = _build(os.uname()[3])  # type: ignore
+            if not info["build"]:
+                # extract build from uname().release if available
+                info["build"] = _build(os.uname()[2])  # type: ignore
+        elif "version" in dir(sys):  # new
+            # extract build from sys.version if available
+            info["build"] = _build(sys.version)
+    except (AttributeError, IndexError, TypeError):
+        pass
+
+    # Fallback version detection for specific platforms
+    if info["version"] == "" and sys.platform not in ("unix", "win32"):
+        try:
+            u = os.uname()  # type: ignore
+            info["version"] = u.release
+        except (IndexError, AttributeError, TypeError):
+            pass
+
+
+def _detect_firmware_family(info: dict[str, str]) -> None:
+    """Detect special firmware families (pycopy, pycom, ev3-pybricks)."""
+    for fam_name, mod_name, mod_thing in [
+        ("pycopy", "pycopy", "const"),
+        ("pycom", "pycom", "FAT"),
+        ("ev3-pybricks", "pybricks.hubs", "EV3Brick"),
+    ]:
+        try:
+            _t = __import__(mod_name, None, None, (mod_thing))
+            info["family"] = fam_name
+            del _t
+            break
+        except (ImportError, KeyError):
+            pass
+
+    if info["family"] == "ev3-pybricks":
+        info["release"] = "2.0.0"
+
+
+def _process_micropython_version(info: dict[str, str]) -> None:
+    """Process MicroPython-specific version formatting."""
+    if info["family"] == "micropython":
+        if (
+            info["version"]
+            and info["version"].endswith(".0")
+            and info["version"] >= "1.10.0"  # versions from 1.10.0 to 1.24.0 do not have a micro .0
+            and info["version"] <= "1.19.9"
+        ):
+            # versions from 1.10.0 to 1.24.0 do not have a micro .0
+            info["version"] = info["version"][:-2]
+
+
+def _process_mpy_info(info: dict[str, str]) -> None:
+    """Process MPY architecture and version information."""
+    # spell-checker: disable
+    if "mpy" in info and info["mpy"]:  # mpy on some v1.11+ builds
+        sys_mpy = int(info["mpy"])
+        # .mpy architecture
+        try:
+            arch = [
+                None,
+                "x86",
+                "x64",
+                "armv6",
+                "armv6m",
+                "armv7m",
+                "armv7em",
+                "armv7emsp",
+                "armv7emdp",
+                "xtensa",
+                "xtensawin",
+                "rv32imc",
+            ][sys_mpy >> 10]
+            if arch:
+                info["arch"] = arch
+        except IndexError:
+            info["arch"] = "unknown"
+        # .mpy version.minor
+        info["mpy"] = "v{}.{}".format(sys_mpy & 0xFF, sys_mpy >> 8 & 3)
+
+
+def _format_version_strings(info: dict[str, str]) -> None:
+    """Handle final version string formatting."""
+    if info["build"] and not info["version"].endswith("-preview"):
+        info["version"] = info["version"] + "-preview"
+    # simple to use version[-build] string
+    info["ver"] = f"{info['version']}-{info['build']}" if info["build"] else f"{info['version']}"
+
+
+def _info():  # type:() -> dict[str, str]
+    """
+    Gather comprehensive system information for MicroPython stubbing.
+
+    Returns a dictionary containing family, version, port, board, and other
+    system details needed for stub generation.
+    """
+    # Get base system information
+    info = _get_base_system_info()
+
+    # Apply transformations and gather additional info
+    _normalize_port_info(info)
+    _extract_version_info(info)
+    _extract_hardware_info(info)
+    _extract_build_info(info)
+    _detect_firmware_family(info)
+    _process_micropython_version(info)
+    _process_mpy_info(info)
+    _format_version_strings(info)
+
+    return info
+
+
+print(_info())
+del _info, get_build, _version_str

{mpflash-1.26.4 → mpflash-1.26.6}/pyproject.toml

@@ -5,7 +5,7 @@
 
 [project]
 name = "mpflash"
-version = "1.26.4"
+version = "1.26.6"
 description = "Flash and download tool for MicroPython firmwares"
 authors = [
     {name = "Jos Verlinde", email = "jos_verlinde@hotmail.com"}

{mpflash-1.26.4 → mpflash-1.26.6}/tests/test_ask_input.py

@@ -1,12 +1,11 @@
 from pathlib import Path
-
-import pytest
 from unittest.mock import MagicMock, Mock
-from pytest_mock import MockerFixture
 
-from mpflash.ask_input import ask_missing_params
+import pytest
+from mpflash.ask_input import ask_missing_params, filter_matching_boards
 from mpflash.common import DownloadParams, FlashParams
 from mpflash.config import MPFlashConfig
+from pytest_mock import MockerFixture
 
 pytestmark = [pytest.mark.mpflash]
 
@@ -225,3 +224,121 @@ def test_ask_missing_params_with_interactivity(
                 assert sorted(getattr(result, key)) == sorted(input[key])
             else:
                 assert getattr(result, key) == input[key]
+
+
+@pytest.mark.parametrize(
+    "port, versions, expected_fallback",
+    [
+        ("rp2", ["stable"], True),  # Should fallback to previous stable versions
+        ("rp2", ["preview"], True),  # Should fallback to preview and recent stable
+        ("esp32", ["v1.26.1"], True),  # Should fallback for specific new version
+        ("stm32", ["v1.20.0"], False),  # Should find boards (assuming this version exists in DB)
+    ],
+)
+def test_filter_matching_boards_fallback(port: str, versions: list, expected_fallback: bool, mocker: MockerFixture, session_fx):
+    """Test that filter_matching_boards falls back to previous versions when no boards found."""
+
+    # Mock the dependencies
+    mock_micropython_versions = mocker.patch("mpflash.ask_input.micropython_versions")
+    mock_micropython_versions.return_value = [
+        "v1.20.0",
+        "v1.21.0",
+        "v1.22.0",
+        "v1.23.0",
+        "v1.24.0",
+        "v1.25.0",
+        "v1.26.0",
+        "v1.26.1",
+        "v1.27.0-preview",
+    ]
+
+    mock_known_stored_boards = mocker.patch("mpflash.ask_input.known_stored_boards")
+
+    if expected_fallback:
+        # First call returns empty (simulating no boards for new version)
+        # Second call returns some boards (simulating fallback success)
+        mock_known_stored_boards.side_effect = [
+            [],  # No boards found for requested version
+            [("v1.25.0 PICO_W                          Raspberry Pi Pico W", "PICO_W")],  # Fallback boards
+        ]
+    else:
+        # Single call returns boards (no fallback needed)
+        mock_known_stored_boards.return_value = [("v1.20.0 PICO                            Raspberry Pi Pico", "PICO")]
+
+    answers = {"port": port, "versions": versions}
+
+    result = filter_matching_boards(answers)
+
+    # Should always return some boards (either original or fallback)
+    assert len(result) > 0
+    assert all(isinstance(item, tuple) and len(item) == 2 for item in result)
+
+    if expected_fallback:
+        # Should have called known_stored_boards twice (original + fallback)
+        assert mock_known_stored_boards.call_count == 2
+        # First call with original versions
+        first_call_versions = mock_known_stored_boards.call_args_list[0][0][1]
+        # Second call should have different (fallback) versions
+        second_call_versions = mock_known_stored_boards.call_args_list[1][0][1]
+        assert first_call_versions != second_call_versions
+    else:
+        # Should have called known_stored_boards only once
+        assert mock_known_stored_boards.call_count == 1
+
+
+def test_filter_matching_boards_stable_version_mapping(mocker: MockerFixture):
+    """Test that 'stable' is correctly mapped to the latest stable version."""
+
+    mock_micropython_versions = mocker.patch("mpflash.ask_input.micropython_versions")
+    mock_micropython_versions.return_value = ["v1.24.0", "v1.25.0", "v1.26.0", "v1.26.1", "v1.27.0-preview"]
+
+    mock_known_stored_boards = mocker.patch("mpflash.ask_input.known_stored_boards")
+    mock_known_stored_boards.return_value = [("v1.26.0 PICO                            Raspberry Pi Pico", "PICO")]
+
+    answers = {"port": "rp2", "versions": ["stable"]}
+
+    result = filter_matching_boards(answers)
+
+    # Should call with the latest stable version (v1.26.1 - second to last in the list)
+    mock_known_stored_boards.assert_called()
+    called_versions = mock_known_stored_boards.call_args[0][1]
+    assert "v1.26.1" in called_versions
+
+
+def test_filter_matching_boards_preview_version_mapping(mocker: MockerFixture):
+    """Test that 'preview' is correctly mapped to preview and stable versions."""
+
+    mock_micropython_versions = mocker.patch("mpflash.ask_input.micropython_versions")
+    mock_micropython_versions.return_value = ["v1.24.0", "v1.25.0", "v1.26.0", "v1.26.1", "v1.27.0-preview"]
+
+    mock_known_stored_boards = mocker.patch("mpflash.ask_input.known_stored_boards")
+    mock_known_stored_boards.return_value = [("v1.27.0-preview PICO                    Raspberry Pi Pico", "PICO")]
+
+    answers = {"port": "rp2", "versions": ["preview"]}
+
+    result = filter_matching_boards(answers)
+
+    # Should call with both preview and latest stable
+    mock_known_stored_boards.assert_called()
+    called_versions = mock_known_stored_boards.call_args[0][1]
+    assert "v1.27.0-preview" in called_versions  # latest preview
+    assert "v1.26.1" in called_versions  # latest stable
+
+
+def test_filter_matching_boards_no_fallback_success(mocker: MockerFixture):
+    """Test behavior when both original and fallback fail to find boards."""
+
+    mock_micropython_versions = mocker.patch("mpflash.ask_input.micropython_versions")
+    mock_micropython_versions.return_value = ["v1.26.0", "v1.26.1", "v1.27.0-preview"]
+
+    mock_known_stored_boards = mocker.patch("mpflash.ask_input.known_stored_boards")
+    mock_known_stored_boards.return_value = []  # Always return empty
+
+    answers = {"port": "unknown_port", "versions": ["v1.26.1"]}
+
+    result = filter_matching_boards(answers)
+
+    # Should return a "No boards found" message
+    assert len(result) == 1
+    assert "No unknown_port boards found" in result[0][0]
+    assert result[0][1] == ""