mpflash 0.7.7__py3-none-any.whl → 0.8.1__py3-none-any.whl

mpflash/mpboard_id/board_id.py

@@ -3,17 +3,14 @@ Translate board description to board designator
 """
 
 import functools
-import json
 from pathlib import Path
 from typing import Optional
 
 from mpflash.errors import MPFlashError
+from mpflash.logger import log
+from mpflash.mpboard_id.store import read_known_boardinfo
 from mpflash.vendor.versions import clean_version, get_stable_mp_version
 
-###############################################################################################
-HERE = Path(__file__).parent
-###############################################################################################
-
 
 def find_board_id_by_description(
     descr: str,
@@ -31,45 +28,43 @@ def find_board_id_by_description(
             board_info=board_info,
             version=clean_version(version) if version else None,
         )
-        return boards[-1]["board"]
+        return boards[-1].board_id
     except MPFlashError:
         return "UNKNOWN_BOARD"
 
 
 @functools.lru_cache(maxsize=20)
 def _find_board_id_by_description(
-    *, descr: str, short_descr: str, version: Optional[str] = None, board_info: Optional[Path] = None
+    *,
+    descr: str,
+    short_descr: str,
+    version: Optional[str] = None,
+    board_info: Optional[Path] = None,
 ):
     """
     Find the MicroPython BOARD_ID based on the description in the firmware
     using the pre-built board_info.json file
     """
-    if not board_info:
-        board_info = HERE / "board_info.json"
-    if not board_info.exists():
-        raise FileNotFoundError(f"Board info file not found: {board_info}")
 
-    candidate_boards = _read_board_info(board_info)
+    candidate_boards = read_known_boardinfo(board_info)
 
     if version:
         # filter for matching version
         if version in ("preview", "stable"):
             # match last stable
             version = get_stable_mp_version()
-        version_matches = [b for b in candidate_boards if b["version"].startswith(version)]
+        known_versions = sorted({b.version for b in candidate_boards})
+        if version not in known_versions:
+            # FIXME if latest stable is newer than the last version in the boardlist this will fail
+            log.trace(f"Version {version} not found in board info, using latest known version {known_versions[-1]}")
+            version = known_versions[-1]
+        version_matches = [b for b in candidate_boards if b.version.startswith(version)]
         if not version_matches:
             raise MPFlashError(f"No board info found for version {version}")
         candidate_boards = version_matches
-    matches = [b for b in candidate_boards if b["description"] == descr]
+    matches = [b for b in candidate_boards if b.description == descr]
     if not matches and short_descr:
-        matches = [b for b in candidate_boards if b["description"] == short_descr]
+        matches = [b for b in candidate_boards if b.description == short_descr]
     if not matches:
         raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
-    return sorted(matches, key=lambda x: x["version"])
-
-
-@functools.lru_cache(maxsize=20)
-def _read_board_info(board_info):
-    with open(board_info, "r") as file:
-        info = json.load(file)
-    return info
+    return sorted(matches, key=lambda x: x.version)

mpflash/mpboard_id/store.py

@@ -0,0 +1,42 @@
+import functools
+import zipfile
+from pathlib import Path
+from typing import List, Optional
+
+import jsons
+
+from mpflash.mpboard_id.board import Board
+
+###############################################################################################
+HERE = Path(__file__).parent
+###############################################################################################
+
+
+def write_boardinfo_json(board_list: List[Board], *, folder: Path):
+    """Writes the board information to JSON and CSV files.
+
+    Args:
+        board_list (List[Board]): The list of Board objects.
+    """
+    import zipfile
+
+    # create a zip file with the json file
+    with zipfile.ZipFile(folder / "board_info.zip", "w", compression=zipfile.ZIP_DEFLATED) as zipf:
+        # write the list to json file inside the zip
+        with zipf.open("board_info.json", "w") as fp:
+            fp.write(jsons.dumps(board_list, jdkwargs={"indent": 4}).encode())
+
+
+@functools.lru_cache(maxsize=20)
+def read_known_boardinfo(board_info: Optional[Path] = None) -> List[Board]:
+
+    if not board_info:
+        board_info = HERE / "board_info.zip"
+    if not board_info.exists():
+        raise FileNotFoundError(f"Board info file not found: {board_info}")
+
+    with zipfile.ZipFile(board_info, "r") as zf:
+        with zf.open("board_info.json", "r") as file:
+            info = jsons.loads(file.read().decode(encoding="utf-8"), List[Board])
+
+    return info

mpflash/vendor/basicgit.py

@@ -0,0 +1,288 @@
+"""
+Simple Git module, where needed via powershell
+
+Some of the functions are based on the PyGithub module
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Union
+
+import cachetools.func
+from github import Auth, Github
+from loguru import logger as log
+from packaging.version import parse
+
+# from stubber.utils.versions import SET_PREVIEW
+
+# 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))
+
+
+def _run_local_git(
+    cmd: List[str],
+    repo: Optional[Union[Path, str]] = None,
+    expect_stderr=False,
+    capture_output=True,
+    echo_output=True,
+):
+    "run a external (git) command in the repo's folder and deal with some of the errors"
+    try:
+        if repo:
+            if isinstance(repo, str):
+                repo = Path(repo)
+            result = subprocess.run(
+                cmd, capture_output=capture_output, check=True, cwd=repo.absolute().as_posix(), encoding="utf-8"
+            )
+        else:
+            result = subprocess.run(cmd, capture_output=capture_output, check=True, encoding="utf-8")
+    except (NotADirectoryError, FileNotFoundError) as e:  # pragma: no cover
+        return None
+    except subprocess.CalledProcessError as e:  # pragma: no cover
+        # add some logging for github actions
+        log.error(f"{str(e)} : { e.stderr}")
+        return None
+    if result.stderr and result.stderr != b"":
+        stderr = result.stderr
+        if "cloning into" in stderr.lower():
+            # log.info(stderr)
+            expect_stderr = True
+        if "warning" in stderr.lower():
+            log.warning(stderr)
+            expect_stderr = True
+        elif capture_output and echo_output:  # pragma: no cover
+            log.info(stderr)
+        if not expect_stderr:
+            raise ChildProcessError(stderr)
+
+    if result.returncode and result.returncode < 0:
+        raise ChildProcessError(result.stderr)
+    return result
+
+
+def clone(remote_repo: str, path: Path, shallow: bool = False, tag: Optional[str] = None) -> bool:
+    """git clone [--depth 1] [--branch <tag_name>] <remote> <directory>"""
+    cmd = ["git", "clone"]
+    if shallow:
+        cmd += ["--depth", "1"]
+    if tag in {"preview", "latest", "master"}:
+        tag = None
+    cmd += [remote_repo, "--branch", tag, str(path)] if tag else [remote_repo, str(path)]
+    if result := _run_local_git(cmd, expect_stderr=True, capture_output=False):
+        return result.returncode == 0
+    else:
+        return False
+
+
+def get_local_tag(repo: Optional[Union[str, Path]] = None, abbreviate: bool = True) -> Union[str, None]:
+    """
+    get the most recent git version tag of a local repo
+    repo Path should be in the form of : repo = "./repo/micropython"
+
+    returns the tag or None
+    """
+    if not repo:
+        repo = Path(".")
+    elif isinstance(repo, str):
+        repo = Path(repo)
+
+    result = _run_local_git(
+        # ["git", "describe", "--tags"],
+        ["git", "describe", "--tags", "--dirty", "--always", "--match", "v[1-9].*"],
+        repo=repo.as_posix(),
+        expect_stderr=True,
+    )
+    if not result:
+        return None
+    tag: str = result.stdout
+    tag = tag.replace("\r", "").replace("\n", "")
+    if not abbreviate or "-" not in tag:
+        return tag
+    if "-preview" in tag:
+        tag = tag.split("-preview")[0] + "-preview"
+    return tag
+
+
+def get_local_tags(repo: Optional[Path] = None, minver: Optional[str] = None) -> List[str]:
+    """
+    get list of all tags of a local repo
+    """
+    if not repo:
+        repo = Path(".")
+
+    result = _run_local_git(["git", "tag", "-l"], repo=repo.as_posix(), expect_stderr=True)
+    if not result or result.returncode != 0:
+        return []
+    tags = result.stdout.replace("\r", "").split("\n")
+    tags = [tag for tag in tags if tag.startswith("v")]
+    if minver:
+        tags = [tag for tag in tags if parse(tag) >= parse(minver)]
+    return sorted(tags)
+
+
+@cachetools.func.ttl_cache(maxsize=16, ttl=60)  # 60 seconds
+def get_tags(repo: str, minver: Optional[str] = None) -> List[str]:
+    """
+    Get list of tag of a repote github repo
+    """
+    if not repo or not isinstance(repo, str) or "/" not in repo:  # type: ignore
+        return []
+    try:
+        gh_repo = GH_CLIENT.get_repo(repo)
+    except ConnectionError as e:
+        # TODO: unable to capture the exeption
+        log.warning(f"Unable to get tags - {e}")
+        return []
+    tags = [tag.name for tag in gh_repo.get_tags()]
+    if minver:
+        tags = [tag for tag in tags if parse(tag) >= parse(minver)]
+    return sorted(tags)
+
+
+def checkout_tag(tag: str, repo: Optional[Union[str, Path]] = None) -> bool:
+    """
+    checkout a specific git tag
+    """
+    cmd = ["git", "checkout", tag, "--quiet", "--force"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True, capture_output=True)
+    if not result:
+        return False
+    # actually a good result
+    msg = {result.stdout}
+    if msg != {""}:
+        log.warning(f"git message: {msg}")
+    return True
+
+
+def sync_submodules(repo: Optional[Union[Path, str]] = None) -> bool:
+    """
+    make sure any submodules are in sync
+    """
+    cmds = [
+        ["git", "submodule", "sync", "--quiet"],
+        # ["git", "submodule", "update", "--quiet"],
+        ["git", "submodule", "update", "--init", "lib/micropython-lib"],
+    ]
+    for cmd in cmds:
+        if result := _run_local_git(cmd, repo=repo, expect_stderr=True):
+            # actually a good result
+            log.debug(result.stderr)
+        else:
+            return False
+    return True
+
+
+def checkout_commit(commit_hash: str, repo: Optional[Union[Path, str]] = None) -> bool:
+    """
+    Checkout a specific commit
+    """
+    cmd = ["git", "checkout", commit_hash, "--quiet", "--force"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True)
+    if not result:
+        return False
+    # actually a good result
+    log.debug(result.stderr)
+    return True
+
+
+def switch_tag(tag: Union[str, Path], repo: Optional[Union[Path, str]] = None) -> bool:
+    """
+    switch to the specified version tag of a local repo
+    repo should be in the form of : path/.git
+    repo = '../micropython/.git'
+    returns None
+    """
+
+    cmd = ["git", "switch", "--detach", tag, "--quiet", "--force"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True)
+    if not result:
+        return False
+    # actually a good result
+    log.debug(result.stderr)
+    return True
+
+
+def switch_branch(branch: str, repo: Optional[Union[Path, str]] = None) -> bool:
+    """
+    switch to the specified branch in a local repo"
+    repo should be in the form of : path/.git
+    repo = '../micropython/.git'
+    returns None
+    """
+    cmd = ["git", "switch", branch, "--quiet", "--force"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True)
+    if not result:
+        return False
+    # actually a good result
+    log.debug(result.stderr)
+    return True
+
+
+def fetch(repo: Union[Path, str]) -> bool:
+    """
+    fetches a repo
+    repo should be in the form of : path/.git
+    repo = '../micropython/.git'
+    returns True on success
+    """
+    if not repo:
+        raise NotADirectoryError
+
+    cmd = ["git", "fetch", "--all", "--tags", "--quiet"]
+    result = _run_local_git(cmd, repo=repo, echo_output=False)
+    return result.returncode == 0 if result else False
+
+
+def pull(repo: Union[Path, str], branch: str = "main") -> bool:
+    """
+    pull a repo origin into main
+    repo should be in the form of : path/.git
+    repo = '../micropython/.git'
+    returns True on success
+    """
+    if not repo:
+        raise NotADirectoryError
+    repo = Path(repo)
+    # first checkout HEAD
+    cmd = ["git", "checkout", branch, "--quiet", "--force"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True)
+    if not result:
+        log.error("error during git checkout main", result)
+        return False
+
+    cmd = ["git", "pull", "origin", branch, "--quiet", "--autostash"]
+    result = _run_local_git(cmd, repo=repo, expect_stderr=True)
+    if not result:
+        log.error("error durign pull", result)
+        return False
+    return result.returncode == 0
+
+
+def get_git_describe(folder: Optional[str] = None):
+    """
+    Based on MicroPython makeversionhdr.py
+    returns : current git tag, commits ,commit hash : "v1.19.1-841-g3446"
+    """
+    # Note: git describe doesn't work if no tag is available
+    try:
+        git_describe = subprocess.check_output(
+            ["git", "describe", "--tags", "--dirty", "--always", "--match", "v[1-9].*"],
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            cwd=folder,
+        ).strip()
+    except subprocess.CalledProcessError as er:
+        if er.returncode == 128:
+            # git exit code of 128 means no repository found
+            return None
+        git_describe = ""
+    except OSError:
+        return None
+    # format
+    return git_describe

mpflash/vendor/dfu.py

@@ -1,5 +1,6 @@
 # sourcery skip: require-parameter-annotation
 # sourcery skip: replace-interpolation-with-fstring
+# type: ignore
 #!/usr/bin/python
 
 # Written by Antonio Galea - 2010/11/18

mpflash/vendor/versions.py

@@ -9,6 +9,8 @@ from functools import lru_cache
 from loguru import logger as log
 from packaging.version import parse
 
+from mpflash.common import GH_CLIENT
+
 V_PREVIEW = "preview"
 "Latest preview version"
 
@@ -67,12 +69,12 @@ def clean_version(
 
 
 @lru_cache(maxsize=10)
-def micropython_versions(minver: str = "v1.20"):
+def micropython_versions(minver: str = "v1.20", reverse: bool = False):
     """Get the list of micropython versions from github tags"""
     try:
         gh_client = GH_CLIENT
         repo = gh_client.get_repo("micropython/micropython")
-        versions = [tag.name for tag in repo.get_tags() if parse(tag.name) >= parse(minver)]
+        versions = [tag.name for tag in repo.get_tags()]
     except Exception:
         versions = [
             "v9.99.9-preview",
@@ -94,7 +96,9 @@ def micropython_versions(minver: str = "v1.20"):
             "v1.11",
             "v1.10",
         ]
-        versions = [v for v in versions if parse(v) >= parse(minver)]
+    versions = [v for v in versions if parse(v) >= parse(minver)]
+    # remove all but the most recent (preview) version
+    versions = versions[:1] + [v for v in versions if "preview" not in v]
     return sorted(versions)
 
 

mpflash/worklist.py

@@ -3,10 +3,9 @@ from typing import Dict, List, Optional, Tuple
 
 from loguru import logger as log
 
-from mpflash.common import FWInfo
+from mpflash.common import FWInfo, filtered_comports
 from mpflash.errors import MPFlashError
 
-from .config import config
 from .downloaded import find_downloaded_firmware
 from .list import show_mcus
 from .mpboard_id import find_known_board
@@ -60,14 +59,53 @@ def auto_update(
 
         # 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}.")
+        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,
     *,
-    serial_port: str,
     version: str,
     fw_folder: Path,
 ) -> WorkList:
@@ -81,13 +119,16 @@ def single_auto_worklist(
     Returns:
         WorkList: List of boards and firmware information to update
     """
-    conn_boards = [MPRemoteBoard(serial_port)]
+    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(*, version: str, fw_folder: Path) -> WorkList:
+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.
@@ -99,49 +140,31 @@ def full_auto_worklist(*, version: str, fw_folder: Path) -> WorkList:
     Returns:
         WorkList: List of boards and firmware information to update
     """
-    try:
-        conn_boards = [
-            MPRemoteBoard(sp, update=True) for sp in MPRemoteBoard.connected_boards() if sp not in config.ignore_ports
-        ]
-    except ConnectionError as e:
-        log.error(f"Error connecting to boards: {e}")
+    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 []
-    return auto_update(conn_boards, version, fw_folder)  # type: ignore
-
-
-def manual_worklist(
-    version: str,
-    fw_folder: Path,
-    serial_port: str,
-    board: str,
-    # port: str,
-) -> WorkList:
-    """Create a worklist for a single board specified manually.
 
-    Args:
-        version (str): Firmware version
-        fw_folder (Path): Path to the firmware folder
-        serial_port (str): Serial port of the board
-        board (str): Board name
 
-    Returns:
-        WorkList: List of boards and firmware information to update
-    """
-    mcu = MPRemoteBoard(serial_port)
-    # TODO : Find a way to avoid needing to specify the port
-    # Lookup the matching port and cpu in board_info based in the board name
+def filter_boards(
+    all_boards: List[MPRemoteBoard],
+    *,
+    include: List[str],
+    ignore: List[str],
+):
     try:
-        info = find_known_board(board)
-        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} not found in board_info.json")
-        return []
-    mcu.board = board
-    firmwares = find_downloaded_firmware(fw_folder=fw_folder, board_id=board, version=version, port=mcu.port)
-    if not firmwares:
-        log.error(f"No firmware found for {mcu.port} {board} version {version}")
+        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 []
-        # use the most recent matching firmware
-    return [(mcu, firmwares[-1])]  # type: ignore
+    return selected_boards  # type: ignore

{mpflash-0.7.7.dist-info → mpflash-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpflash
-Version: 0.7.7
+Version: 0.8.1
 Summary: Flash and download tool for MicroPython firmwares
 Home-page: https://github.com/Josverl/micropython-stubber/blob/main/src/mpflash/README.md
 License: MIT
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: bincopy (>=20.0.0,<21.0.0)
 Requires-Dist: blkinfo (>=0.2.0,<0.3.0)
+Requires-Dist: cachetools (>=5.3.0,<6.0.0)
 Requires-Dist: esptool (>=4.7.0,<5.0.0)
 Requires-Dist: inquirer (>=3.2.4,<4.0.0)
 Requires-Dist: jsonlines (>=4.0.0,<5.0.0)
@@ -32,20 +33,32 @@ Requires-Dist: psutil (>=5.9.8,<6.0.0)
 Requires-Dist: pygithub (>=2.1.1,<3.0.0)
 Requires-Dist: pyusb (>=1.2.1,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
-Requires-Dist: rich-click (>=1.7.3,<2.0.0)
+Requires-Dist: rich-click (>=1.8.1,<2.0.0)
 Requires-Dist: tenacity (==8.2.3)
 Project-URL: Repository, https://github.com/Josverl/micropython-stubber
 Description-Content-Type: text/markdown
 
 # MPFLASH
+  [![pypi version](https://badgen.net/pypi/v/mpflash)](https://pypi.org/project/mpflash/)
+  [![python versions](https://badgen.net/pypi/python/mpflash)](https://badgen.net/pypi/python/mpflash)
+[![Downloads](https://static.pepy.tech/badge/mpflash)](https://pepy.tech/project/mpflash)
+
 
 `mpflash` is a command-line tool for working with MicroPython firmware. It provides features to help you flash and update Micropython on one or more .
 
-This tool was initially created to be used in a CI/CD pipeline to automate the process of downloading and flashing MicroPython firmware to multiple boards, but it has been extend with a TUI to me be used for manual downloadig, flashing and development.
+This tool was initially created to be used in a CI/CD pipeline to automate the process of downloading and flashing MicroPython firmware to multiple boards, but it has been extend with a TUI to be used for manual downloadig, flashing and development.
 
-`mpflash` has been tested on Windows x64, Linux X64, but not (yet) macOS.
-Tested ports: `rp2`, `samd`, `esp32`, `esp32s3`, `esp32c3`, `esp8266` and `stm32`
+`mpflash` has been tested on:  
+ - OS: Windows x64, Linux X64, but not (yet) macOS.
+ - Micropython (hardware) ports: 
+    - `rp2`, using `.uf2`, using filecopy (macos not tested yet)
+    - `samd`, using ` .uf2`, using filecopy (macos not tested yet)
+    - `esp32`, using `.bin`, using esptool,
+    - `esp8266`, using `.bin`, using esptool
+    - `stm32`, using ` .dfu`, using pydfu
 
+Not yet implemented: `nrf`, `cc3200`, `mimxrt`
+ 
 ## Features
  1. List the connected boards including their firmware details, in a tabular or json format
  2. Download MicroPython firmware for versions, and matching a specified board or matches your current attached board.
@@ -73,8 +86,7 @@ On Windows this will not be an issue, but on Linux you can use  udev rules to gi
 ## Detailed usage
 You can list the connected boards using the following command:
 ```bash
-$ mpflash list
-D:\MyPython\micropython-stubber> mpflash list
+$> mpflash list
                                                Connected boards
 ┏━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━┓
 ┃ Serial  ┃Family       ┃Port  ┃Board                                      ┃CPU     ┃Version          ┃build ┃