firestarter 3.2.7b1__tar.gz → 3.2.7b3__tar.gz

{firestarter-3.2.7b1/firestarter.egg-info → firestarter-3.2.7b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firestarter
-Version: 3.2.7b1
+Version: 3.2.7b3
 Summary: EPROM programmer software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Project-URL: Homepage, https://github.com/henols/firestarter_app

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.7b1'
-__version_tuple__ = version_tuple = (3, 2, 7, 'b1')
+__version__ = version = '3.2.7b3'
+__version_tuple__ = version_tuple = (3, 2, 7, 'b3')
 
-__commit_id__ = commit_id = 'g0159d48'
+__commit_id__ = commit_id = 'g85b7152'

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/channel.py

@@ -59,23 +59,16 @@ def is_prerelease_build() -> bool:
     """True when this build came off `beta` (its own version is a pre-release).
 
     Fails **closed**: an unparseable version is treated as stable, so a gated
-    feature stays hidden rather than leaking. This matches
-    `_maybe_auto_route_to_pre`, which also treats `InvalidVersion` as
-    not-a-prerelease. In practice `__version__` is a literal in the package and
-    is always valid PEP 440; dev versions (`2.0.7_dev`) parse as pre-releases and
-    therefore keep gated features enabled while working from a checkout.
+    feature stays hidden rather than leaking. `_maybe_auto_route_to_pre` uses
+    this function, so it treats an unparseable version the same way. In
+    practice `__version__` is a literal in the package and is always valid
+    PEP 440; dev versions (`2.0.7_dev`) parse as pre-releases and therefore
+    keep gated features enabled while working from a checkout.
     """
-    try:
-        from packaging.version import InvalidVersion, Version
+    import firestarter as _pkg
+    from firestarter.fw_release_gate import is_prerelease_version
 
-        import firestarter as _pkg
-
-        try:
-            return bool(Version(_pkg.__version__).is_prerelease)
-        except InvalidVersion:
-            return False
-    except ImportError:  # pragma: no cover — packaging is a hard dependency
-        return False
+    return is_prerelease_version(_pkg.__version__) is True
 
 
 def is_board_available(board: str | None) -> bool:

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/cli_handlers.py

@@ -37,6 +37,7 @@ from firestarter.channel import (
     available_boards,
     dev_command_gate_message,
     is_dev_tools_enabled,
+    is_prerelease_build,
 )
 from firestarter.chip_resolver import (
     describe_ambiguity,
@@ -186,6 +187,27 @@ def _complete_eprom(
 _ALL_BOARDS: tuple[str, ...] = ("uno", "uno328pb", "leonardo", "py32f071")
 _BOARD_CHOICES: list[str] = available_boards(_ALL_BOARDS)
 _PY32_ENABLED: bool = "py32f071" in _BOARD_CHOICES
+# A stable build never offers pre-release firmware: `fw --pre` is refused and
+# `fw --list` shows stable releases only. fw_release_gate refuses the install.
+_PRE_CHANNEL_ENABLED: bool = is_prerelease_build()
+
+
+def _reject_gated_option(name: str, given: bool, enabled: bool) -> None:
+    """The one refusal for a CLI option that this build's channel does not offer.
+
+    It reads like Click's own unknown-option error, because on this build the
+    option does not exist.
+    """
+    if given and not enabled:
+        raise click.UsageError(f"no such option: {name}")
+
+
+def _reject_pre_only_option(name: str, given: bool) -> None:
+    """Refuse a pre-release-only CLI option on a stable build.
+
+    Reads `_PRE_CHANNEL_ENABLED` at CALL time, like `_reject_py32_only_option`.
+    """
+    _reject_gated_option(name, given, _PRE_CHANNEL_ENABLED)
 
 
 def _reject_py32_only_option(name: str, given: bool) -> None:
@@ -204,8 +226,7 @@ def _reject_py32_only_option(name: str, given: bool) -> None:
     default -- which is what makes it monkeypatchable while the Click surface
     stays frozen at import time.
     """
-    if given and not _PY32_ENABLED:
-        raise click.UsageError(f"no such option: {name}")
+    _reject_gated_option(name, given, _PY32_ENABLED)
 
 
 def map_typed_errors(f: Callable[..., Any]) -> Callable[..., Any]:
@@ -322,29 +343,15 @@ def _maybe_auto_route_to_pre(args: object) -> None:
         or getattr(args, "stable", False)
     ):
         return
-    try:
-        from packaging.version import InvalidVersion, Version
-
-        import firestarter as _pkg
-
-        try:
-            if Version(_pkg.__version__).is_prerelease:
-                args.pre = True  # type: ignore[attr-defined]
-                helper_logger.info(
-                    "Beta app detected — defaulting to --pre. "
-                    "Use --firmware-version X.Y.Z to pin a stable version."
-                )
-        except InvalidVersion:
-            # Deliberate fail-OPEN, and deliberately the opposite polarity to
-            # fw_release_gate, which fails CLOSED on the same unreadable input.
-            # The asymmetry is intended: the worst case here is that the wrong
-            # channel is picked, which the gate then judges on its merits; the
-            # worst case there is a board flashed with firmware this host cannot
-            # drive, recoverable only through the bootloader. Do not "align"
-            # these two without re-reading both worst cases.
-            pass
-    except ImportError:
-        pass
+    # An unreadable version is not a pre-release here: the worst case is the
+    # wrong channel, which fw_release_gate then judges and refuses (it fails
+    # CLOSED on the same input). Do not "align" the two polarities.
+    if is_prerelease_build():
+        args.pre = True  # type: ignore[attr-defined]
+        helper_logger.info(
+            "Beta app detected — defaulting to --pre. "
+            "Use --firmware-version X.Y.Z to pin a stable version."
+        )
 
 
 def _build_op_flags(
@@ -1764,6 +1771,7 @@ def _maybe_auto_route_to_pre_click(
 @click.option(
     "--pre",
     is_flag=True,
+    hidden=not _PRE_CHANNEL_ENABLED,
     help="Fetch latest pre-release firmware (mirrors pip install --pre).",
 )
 @click.option(
@@ -1772,7 +1780,11 @@ def _maybe_auto_route_to_pre_click(
     type=_FirmwareVersionType(),
     default=None,
     metavar="VERSION",
-    help="Pin exact firmware version (e.g. 3.1.0, 3.1.0b2, 3.1.0rc1).",
+    help=(
+        "Pin exact firmware version (e.g. 3.1.0, 3.1.0b2, 3.1.0rc1)."
+        if _PRE_CHANNEL_ENABLED
+        else "Pin exact firmware version (e.g. 3.1.0)."
+    ),
 )
 @click.option(
     "--stable",
@@ -1861,11 +1873,15 @@ def fw(
 ) -> None:
     """Firmware version.
 
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one
+    is refused before anything is installed.
     """
     app: AppContext = ctx.obj
 
+    # Before the mutex check, so a stable build never names --pre in an error
+    # other than this one.
+    _reject_pre_only_option("--pre", pre)
+
     # 3-way --pre / --firmware-version / --stable mutex enforced once,
     # post-parse, with a deterministic error message that doesn't depend on
     # the user's option ordering. Raises click.UsageError → exit-2, matching
@@ -1914,7 +1930,7 @@ def fw(
         channel_filter: Literal["all", "pre", "stable"]
         if pre:
             channel_filter = "pre"
-        elif stable:
+        elif stable or not _PRE_CHANNEL_ENABLED:
             channel_filter = "stable"
         else:
             channel_filter = "all"

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/eprom_operations.py

@@ -16,7 +16,7 @@ import statistics
 import time
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Callable, Dict, Tuple  # noqa: UP035
+from typing import BinaryIO, Callable, Dict, Tuple  # noqa: UP035
 
 import tqdm
 from tqdm.contrib.logging import logging_redirect_tqdm
@@ -362,6 +362,25 @@ def _blank_expected_bytes(_offset: int, length: int) -> bytes:
     return b"\xff" * length
 
 
+def _open_default_read_file(eprom_name: str) -> tuple[str, BinaryIO]:
+    """Create the output file `read` uses when the user gives none:
+    `<NAME>.bin`, or `<NAME>-<n>.bin` with the lowest free `n` when that
+    file exists, so a second read never overwrites the first.
+
+    Mode 'xb' claims the name and creates the file in one step, so two reads
+    that start together never get the same name.
+    """
+    base = eprom_name.upper()
+    path = f"{base}.bin"
+    n = 1
+    while True:
+        try:
+            return path, open(path, "xb")
+        except FileExistsError:
+            path = f"{base}-{n}.bin"
+            n += 1
+
+
 def _write_blank_guard_refusal_message(
     eprom_name: str, region_start: int, result: CompareResult
 ) -> str:
@@ -1298,14 +1317,20 @@ class EpromOperator:
             if not cmd_data:
                 return False
 
-            actual_output_file = output_file or f"{eprom_name.upper()}.bin"
-            logger.info(
-                f"Reading EPROM {eprom_name.upper()}, saving to {actual_output_file}"
-            )
-            start_time = time.time()
-
+            actual_output_file = output_file or ""
+            is_ok = False
             try:
-                with open(actual_output_file, "wb") as file_handle:
+                if output_file:
+                    file_handle = open(output_file, "wb")
+                else:
+                    actual_output_file, file_handle = _open_default_read_file(
+                        eprom_name
+                    )
+                logger.info(
+                    f"Reading EPROM {eprom_name.upper()}, saving to {actual_output_file}"
+                )
+                start_time = time.time()
+                with file_handle:
 
                     def _write_to_file(address, data_chunk):
                         file_handle.seek(address)
@@ -1326,6 +1351,14 @@ class EpromOperator:
             except IOError as e:  # noqa: UP024
                 logger.error(f"File I/O error with {actual_output_file}: {e}")
                 return False
+            finally:
+                # A failed read with a generated name leaves no file behind,
+                # so the next read takes that name again.
+                if not output_file and actual_output_file and not is_ok:
+                    try:
+                        os.remove(actual_output_file)
+                    except OSError:
+                        pass
 
     def consistency_check_eprom(
         self,

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/exceptions.py

@@ -181,6 +181,9 @@ class FirmwareReleaseRefusedError(FirmwareOperationError):
     waives it; `--force` does not, because `--force` means "reinstall the same
     version" and is also a wire flag (FLAG_FORCE).
 
+    Also raised when this CLI is a stable release and the firmware release is a
+    pre-release. Nothing waives that refusal.
+
     A FirmwareOperationError, so cli_handlers.map_typed_errors renders it
     verbatim through the existing FirmwareOperationError arm. No new arm.
     """

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/firmware.py

@@ -39,7 +39,12 @@ from firestarter.exceptions import (
     ProgrammerNotFoundError,
     SerialError,
 )
-from firestarter.fw_release_gate import require_installable_release
+from firestarter.fw_release_gate import (
+    feature_version,
+    is_prerelease_version,
+    matches_stable_cli,
+    require_installable_release,
+)
 from firestarter.serial_comm import SerialCommunicator
 from firestarter.timestamps import iso_text_to_cet
 
@@ -331,15 +336,21 @@ class FirmwareManager:
         channel: Literal["stable", "pre", "pinned"] = "stable",
         version: str | None = None,
         board: str = "uno",
+        app_version: str | None = None,
     ) -> Tuple[str | None, str | None]:  # noqa: UP006
         """Router: returns (resolved_version, download_url) or (None, None) on failure.
 
-        channel='stable'  → delegates to fetch_latest_release_info (back-compat shim).
+        channel='stable'  → for a stable app_version, the highest stable release on
+                            its feature version (a stable CLI 3.2.x runs 3.2.y only);
+                            otherwise delegates to fetch_latest_release_info.
         channel='pre'     → paginates /releases, takes the highest non-draft release by
                             PEP 440, stable or pre-release; falls back to stable if none.
         channel='pinned'  → fetches /releases/tags/{version} directly.
         """  # noqa: E501
         if channel == "stable":
+            app_feature = feature_version(app_version)
+            if is_prerelease_version(app_version) is False and app_feature:
+                return self._fetch_matching_stable_release_info(app_feature, board)
             return self.fetch_latest_release_info(board=board)
 
         elif channel == "pinned":
@@ -413,6 +424,44 @@ class FirmwareManager:
             )
             return None, None
 
+    def _fetch_matching_stable_release_info(
+        self, app_feature: tuple[int, int], board: str
+    ) -> Tuple[str | None, str | None]:  # noqa: UP006
+        """The highest non-draft stable release whose feature version is app_feature."""
+        line = f"{app_feature[0]}.{app_feature[1]}.x"
+        try:
+            all_releases = self._fetch_all_releases()
+        except requests.RequestException as e:
+            logger.error(f"Failed to fetch firmware releases: {e}")
+            return None, None
+
+        candidates = []
+        for r in all_releases:
+            if r.get("draft"):
+                continue
+            try:
+                tag_version = Version(r.get("tag_name", ""))
+            except InvalidVersion:
+                continue
+            if tag_version.is_prerelease:
+                continue
+            if (tag_version.major, tag_version.minor) == app_feature:
+                candidates.append((tag_version, r))
+
+        if not candidates:
+            logger.error(f"No stable firmware release {line} was found.")
+            return None, None
+
+        _, picked = max(candidates, key=lambda t: t[0])
+        download_url = _pick_asset(picked.get("assets", []), board)
+        if not download_url:
+            logger.error(
+                f"Release {picked.get('tag_name')!r} has no asset "
+                f"{_asset_label(board)} for board {board!r}."
+            )
+            return None, None
+        return picked.get("tag_name"), download_url
+
     def list_releases(
         self,
         channel_filter: Literal["all", "pre", "stable"] = "all",
@@ -847,8 +896,17 @@ class FirmwareManager:
             self._hint_dfu_board()
             return False
 
+        if app_version is None:
+            # Dereferenced at call time, not bound at import, so a test can
+            # monkeypatch firestarter.__version__ without reloading this module.
+            import firestarter as _pkg
+
+            app_version = _pkg.__version__
         latest_version, download_url = self.fetch_release_info(
-            channel=channel, version=pinned_version, board=board_to_use
+            channel=channel,
+            version=pinned_version,
+            board=board_to_use,
+            app_version=app_version,
         )
 
         # Guard the release tag where it is BORN, not on each branch that
@@ -866,12 +924,9 @@ class FirmwareManager:
         # onto the pre channel, which is the channel most likely to be ahead of
         # it. That raises how often this refusal fires. Do not "fix" the auto
         # route to avoid the refusal -- the refusal is the point.
-        if app_version is None:
-            # Dereferenced at call time, not bound at import, so a test can
-            # monkeypatch firestarter.__version__ without reloading this module.
-            import firestarter as _pkg
-
-            app_version = _pkg.__version__
+        #
+        # The same call refuses a pre-release on a stable CLI. That covers a
+        # library caller that asks a stable CLI for channel="pre".
         require_installable_release(
             app_version,
             latest_version,
@@ -917,8 +972,22 @@ class FirmwareManager:
                     "only guard."
                 )
 
+        # A stable CLI runs a stable release on its own feature version only. A
+        # board on anything else is never up to date, even when its version is
+        # higher: a stable 3.2.6 CLI moves a 3.2.3b1 board to 3.2.2.
+        mismatched = bool(
+            current_version
+            and is_prerelease_version(app_version) is False
+            and not matches_stable_cli(app_version, current_version)
+        )
         is_up_to_date = False
-        if current_version and latest_version:
+        if mismatched:
+            logger.warning(
+                f"Firmware {current_version} does not match CLI {app_version}. "
+                "A stable CLI uses a stable firmware release with the same "
+                "major.minor version."
+            )
+        elif current_version and latest_version:
             is_up_to_date = self._compare_versions(current_version, latest_version)
 
         if is_up_to_date and not force_install:
@@ -946,10 +1015,12 @@ class FirmwareManager:
         elif (
             not is_up_to_date and current_version and latest_version
         ):  # No flags, but update available
-            if Confirm.ask(
-                f"New firmware {latest_version} available for {board_to_use} (current: {current_version}). Update now?",  # noqa: E501
-                default=False,
-            ):
+            prompt = (
+                f"Install firmware {latest_version} for {board_to_use} (current: {current_version})?"  # noqa: E501
+                if mismatched
+                else f"New firmware {latest_version} available for {board_to_use} (current: {current_version}). Update now?"  # noqa: E501
+            )
+            if Confirm.ask(prompt, default=False):
                 should_install_now = True
             else:
                 logger.info("Firmware update cancelled by user.")

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter/fw_release_gate.py

@@ -16,6 +16,16 @@ The rule is the FEATURE version, (major, minor). The patch number is ignored,
 and so is the pre-release suffix: 3.1.0b2 and 3.1.0b5 are one feature version.
 A release is refused when its feature version is ABOVE this CLI's.
 
+A stable CLI also refuses every pre-release firmware. A stable CLI is a final
+PEP 440 release; a pre-release firmware is a b/rc/dev tag. This rule ignores the
+feature version, and nothing waives it: a stable user gets stable firmware only.
+A pre-release CLI (a b/rc tag, or a dev checkout) installs either.
+
+A stable CLI also refuses a release BELOW its feature version. A stable CLI
+3.2.x runs stable firmware 3.2.y only (`matches_stable_cli`). Nothing waives
+this refusal either. `firmware.fetch_release_info` picks the highest matching
+stable release for a stable CLI, so `fw --install` installs a matching release.
+
 The reverse pairing -- a CLI newer than the firmware -- is NOT gated here.
 `_maybe_auto_route_to_pre` in cli_handlers.py steers channel selection away from
 it. The two checks cover opposite directions and neither replaces the other.
@@ -23,7 +33,7 @@ it. The two checks cover opposite directions and neither replaces the other.
 Polarity: fail closed. A false pass flashes a board this host cannot drive, and
 the board must then be recovered through the bootloader. A false refusal only
 makes the install unavailable, and `firestarter fw --list` still enumerates
-every release. A version that cannot be read on either side is refused exactly
+the releases. A version that cannot be read on either side is refused exactly
 like a version that is too new.
 
 One deliberate exception: a release version of None is NOT a refusal. With no
@@ -31,7 +41,8 @@ release there is nothing to flash, and `manage_firmware_update` already reports
 the failed fetch. Turning a GitHub outage into a version-mismatch refusal would
 be a lie. This is the one place the gate looks fail-open and is not.
 
-Escape: `--allow-newer-firmware`. Never an environment variable.
+Escape for the feature-version refusal: `--allow-newer-firmware`. Never an
+environment variable. The pre-release and older-line refusals have no escape.
 
 Unlike the pre-serial gates, the authoritative call runs AFTER the release
 metadata fetch, because the release tag is only known then. It still runs before
@@ -75,6 +86,23 @@ _UNREADABLE_FORMAT = (
     "--allow-newer-firmware. This pairing is not tested."
 )
 
+_PRERELEASE_ON_STABLE_FORMAT = (
+    "Firmware {release} is a pre-release. This CLI is {app}, a stable release. "
+    "A stable CLI installs stable firmware only. "
+    "Refusing to install firmware {release}.\n"
+    "Run 'firestarter fw --install' to install the latest stable firmware.\n"
+    "To use pre-release firmware, install a pre-release CLI. "
+    "Run 'pip install --upgrade --pre firestarter'."
+)
+
+_OLDER_LINE_ON_STABLE_FORMAT = (
+    "Firmware {release} is feature version {release_feature}. This CLI is {app}, "
+    "a stable release. A stable CLI installs stable firmware {app_feature}.x only. "
+    "Refusing to install firmware {release}.\n"
+    "Run 'firestarter fw --install' to install the latest stable firmware "
+    "{app_feature}.x."
+)
+
 _UNREADABLE_TEXT = "an unreadable version"
 
 
@@ -94,6 +122,31 @@ def feature_version(raw: str | None) -> tuple[int, int] | None:
     return (parsed.major, parsed.minor)
 
 
+def is_prerelease_version(raw: str | None) -> bool | None:
+    """True for a PEP 440 pre-release (b, rc or dev), False for a final release.
+
+    None when the version cannot be read. The caller decides what that means;
+    the feature-version check already refuses an unreadable version.
+    """
+    if not raw:
+        return None
+    try:
+        return Version(raw).is_prerelease
+    except InvalidVersion:
+        return None
+
+
+def matches_stable_cli(app_version: str | None, fw_version: str | None) -> bool:
+    """True when fw_version is a stable release on app_version's feature version.
+
+    The firmware a stable CLI runs. False when either version cannot be read.
+    """
+    if is_prerelease_version(fw_version) is not False:
+        return False
+    app = feature_version(app_version)
+    return app is not None and feature_version(fw_version) == app
+
+
 def is_refused(app_version: str | None, release_version: str | None) -> bool:
     """True when this CLI must not flash this release.
 
@@ -117,9 +170,32 @@ def require_installable_release(
 ) -> None:
     """Raise FirmwareReleaseRefusedError when this CLI must not flash this release.
 
-    Returns None on pass. `allow_newer` waives the refusal; it defaults to False
-    so a library caller that does not ask for the waiver does not get it.
+    Returns None on pass. `allow_newer` waives the feature-version refusal; it
+    defaults to False so a library caller that does not ask for the waiver does
+    not get it. Nothing waives the pre-release or older-line refusal on a
+    stable CLI.
+
+    An unreadable version on either side is not judged by the stable-CLI rules.
+    The feature-version check refuses it.
     """
+    if is_prerelease_version(app_version) is False:
+        if is_prerelease_version(release_version) is True:
+            raise FirmwareReleaseRefusedError(
+                _PRERELEASE_ON_STABLE_FORMAT.format(
+                    app=app_version, release=release_version
+                )
+            )
+        app = feature_version(app_version)
+        release = feature_version(release_version)
+        if app and release and release < app:
+            raise FirmwareReleaseRefusedError(
+                _OLDER_LINE_ON_STABLE_FORMAT.format(
+                    app=app_version,
+                    release=release_version,
+                    app_feature=f"{app[0]}.{app[1]}",
+                    release_feature=f"{release[0]}.{release[1]}",
+                )
+            )
     if allow_newer or not is_refused(app_version, release_version):
         return
     app = feature_version(app_version)

{firestarter-3.2.7b1 → firestarter-3.2.7b3/firestarter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firestarter
-Version: 3.2.7b1
+Version: 3.2.7b3
 Summary: EPROM programmer software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Project-URL: Homepage, https://github.com/henols/firestarter_app

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/firestarter.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "3.2.7b1",
+  "tag": "3.2.7b3",
   "distance": 0,
-  "node": "g0159d48",
+  "node": "g85b7152",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-28"

{firestarter-3.2.7b1 → firestarter-3.2.7b3}/tests/__snapshots__/test_characterization.ambr

@@ -217,8 +217,8 @@
   
     Firmware version.
   
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one is
+    refused before anything is installed.
   
   Options:
     -i, --install                   Try to install the latest firmware.
@@ -257,15 +257,12 @@
   
     Firmware version.
   
-    ``--pre``, ``--firmware-version`` and ``--stable`` are mutually exclusive;
-    passing more than one is refused before anything is installed.
+    The release channel options are mutually exclusive; passing more than one is
+    refused before anything is installed.
   
   Options:
     -i, --install                   Try to install the latest firmware.
-    --pre                           Fetch latest pre-release firmware (mirrors
-                                    pip install --pre).
-    --firmware-version VERSION      Pin exact firmware version (e.g. 3.1.0,
-                                    3.1.0b2, 3.1.0rc1).
+    --firmware-version VERSION      Pin exact firmware version (e.g. 3.1.0).
     --stable                        Explicitly select stable channel. With
                                     --list, filters to stable releases only.
     --list                          List available firmware releases for the