mpflash 1.24.6__py3-none-any.whl → 1.24.8__py3-none-any.whl

mpflash/download.py

@@ -13,12 +13,11 @@ from urllib.parse import urljoin
 # #########################################################################################################
 # make sure that jsonlines does not mistake the MicroPython ujson for the CPython ujson
 import jsonlines
-import requests
-from bs4 import BeautifulSoup
 from loguru import logger as log
 from rich.progress import track
 
 from mpflash.common import PORT_FWTYPES, FWInfo
+from mpflash.downloaded import clean_downloaded_firmwares
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import get_known_ports
 from mpflash.versions import clean_version
@@ -51,6 +50,8 @@ RE_VERSION_PREVIEW = r"v([\d\.]+)-?(?:preview\.)?(\d+)?\."
 @functools.lru_cache(maxsize=500)
 def get_page(page_url: str) -> str:
     """Get the HTML of a page and return it as a string."""
+    # Just in time import
+    import requests
     response = requests.get(page_url)
     return response.content.decode()
 
@@ -68,14 +69,17 @@ def get_board_urls(page_url: str) -> List[Dict[str, str]]:
         List[Dict[str, str]]: A list of dictionaries containing the board name and url.
 
     """
+    # Just in time import
+    from bs4 import BeautifulSoup
+
     downloads_html = get_page(page_url)
     soup = BeautifulSoup(downloads_html, "html.parser")
-    tags = soup.findAll("a", recursive=True, attrs={"class": "board-card"})
+    tags = soup.find_all("a", recursive=True, attrs={"class": "board-card"})
     # assumes that all links are relative to the page url
-    boards = [tag.get("href") for tag in tags]
+    boards = [tag.get("href") for tag in tags]  # type: ignore
     if "?" in page_url:
         page_url = page_url.split("?")[0]
-    return [{"board": board, "url": page_url + board} for board in boards]
+    return [{"board": board, "url": page_url + board} for board in boards]  # type: ignore
 
 
 def board_firmware_urls(board_url: str, base_url: str, ext: str) -> List[str]:
@@ -89,19 +93,22 @@ def board_firmware_urls(board_url: str, base_url: str, ext: str) -> List[str]:
     the urls are relative urls to the site root
 
     """
+    # Just in time import
+    from bs4 import BeautifulSoup
+
     html = get_page(board_url)
     soup = BeautifulSoup(html, "html.parser")
     # get all the a tags:
     #  1. that have a url that starts with `/resources/firmware/`
     #  2. end with a matching extension for this port.
-    tags = soup.findAll(
+    tags = soup.find_all(
         "a",
         recursive=True,
         attrs={"href": re.compile(r"^/resources/firmware/.*\." + ext.lstrip(".") + "$")},
     )
     if "?" in base_url:
         base_url = base_url.split("?")[0]
-    links: List = [urljoin(base_url, tag.get("href")) for tag in tags]
+    links: List = [urljoin(base_url, tag.get("href")) for tag in tags]  # type: ignore
     return links
 
 
@@ -211,19 +218,21 @@ def download_firmwares(
         force : A flag indicating whether to force the download even if the firmware file already exists.
         clean : A flag indicating to clean the date from the firmware filename.
     """
+
+
     skipped = downloaded = 0
     versions = [] if versions is None else [clean_version(v) for v in versions]
     # handle renamed boards
     boards = add_renamed_boards(boards)
 
-    unique_boards = get_firmware_list(ports, boards, versions, clean)
+    available_firmwares = get_firmware_list(ports, boards, versions, clean)
 
-    for b in unique_boards:
+    for b in available_firmwares:
         log.debug(b.filename)
     # relevant
 
-    log.info(f"Found {len(unique_boards)} relevant unique firmwares")
-    if not unique_boards:
+    log.info(f"Found {len(available_firmwares)} relevant unique firmwares")
+    if not available_firmwares:
         log.error("No relevant firmwares could be found on https://micropython.org/download")
         log.info(f"{versions=} {ports=} {boards=}")
         log.info("Please check the website for the latest firmware files or try the preview version.")
@@ -231,8 +240,27 @@ def download_firmwares(
 
     firmware_folder.mkdir(exist_ok=True)
 
+    downloaded, skipped = download_firmware_files(available_firmwares, firmware_folder, force  )
+    log.success(
+        f"Downloaded {downloaded} firmware images{f', skipped {str(skipped)} existing' if skipped else ''}."
+    )
+    return downloaded + skipped
+
+def download_firmware_files(available_firmwares :List[FWInfo],firmware_folder:Path, force:bool ):
+    """
+    Downloads the firmware files to the specified folder.
+    Args:
+        firmware_folder : The folder to save the downloaded firmware files.
+        force : A flag indicating whether to force the download even if the firmware file already exists.
+        requests : The requests module to use for downloading the firmware files.
+        unique_boards : The list of unique firmware information to download.
+    """
+    # Just in time import
+    import requests
+
     with jsonlines.open(firmware_folder / "firmware.jsonl", "a") as writer:
-        for board in unique_boards:
+        downloaded = skipped = 0
+        for board in available_firmwares:
             filename = firmware_folder / board.port / board.filename
             filename.parent.mkdir(exist_ok=True)
             if filename.exists() and not force:
@@ -249,23 +277,23 @@ def download_firmwares(
             except requests.RequestException as e:
                 log.exception(e)
                 continue
-            writer.write(board.to_dict())
+            writer.write(board.to_dict())  #  type: ignore
             downloaded += 1
-    # if downloaded > 0:
-    #     clean_downloaded_firmwares(firmware_folder)
-    log.success(f"Downloaded {downloaded} firmwares, skipped {skipped} existing files.")
-    return downloaded + skipped
+    if downloaded > 0:
+        clean_downloaded_firmwares(firmware_folder)
+    return downloaded,skipped
 
 
-def get_firmware_list(ports: List[str], boards: List[str], versions: List[str], clean: bool):
+def get_firmware_list(ports: List[str], boards: List[str], versions: List[str], clean: bool = True):
     """
-    Retrieves a list of unique firmware information based on the specified ports, boards, versions, and clean flag.
+    Retrieves a list of unique firmware files available om micropython.org > downloads
+    based on the specified ports, boards, versions, and clean flag.
 
     Args:
-        ports : The list of ports to check for firmware.
-        boards : The list of boards to filter the firmware by.
-        versions : The list of versions to filter the firmware by.
-        clean : A flag indicating whether to perform a clean check.
+        ports : One or more ports to check for firmware.
+        boards : One or more boards to filter the firmware by.
+        versions : One or more versions to filter the firmware by.
+        clean : Remove date-stamp and Git Hash from the firmware name.
 
     Returns:
         List[FWInfo]: A list of unique firmware information.
@@ -273,7 +301,9 @@ def get_firmware_list(ports: List[str], boards: List[str], versions: List[str],
     """
 
     log.trace("Checking MicroPython download pages")
+    versions = [clean_version(v, drop_v=False) for v in versions]
     preview = "preview" in versions
+
     board_urls = sorted(get_boards(ports, boards, clean), key=key_fw_ver_pre_ext_bld)
 
     log.debug(f"Total {len(board_urls)} firmwares")
@@ -321,6 +351,9 @@ def download(
         MPFlashError : If no boards are found or specified.
 
     """
+    # Just in time import
+    import requests
+
     if not boards:
         log.critical("No boards found, please connect a board or specify boards to download firmware for.")
         raise MPFlashError("No boards found")

mpflash/downloaded.py

@@ -113,11 +113,7 @@ def filter_downloaded_fwlist(
     log.trace(f"Filtering firmware for {version} : {len(fw_list)} found.")
     # filter by port
     if port:
-        fw_list = [
-            fw
-            for fw in fw_list
-            if fw.port == port and Path(fw.firmware).suffix in PORT_FWTYPES[port]
-        ]
+        fw_list = [fw for fw in fw_list if fw.port == port and Path(fw.firmware).suffix in PORT_FWTYPES[port]]
         log.trace(f"Filtering firmware for {port} : {len(fw_list)} found.")
 
     if board_id:

mpflash/flash/__init__.py

@@ -2,8 +2,9 @@ from pathlib import Path
 
 from loguru import logger as log
 
-from mpflash.bootloader import enter_bootloader
-from mpflash.common import PORT_FWTYPES, BootloaderMethod
+from mpflash.bootloader.activate import enter_bootloader
+from mpflash.common import PORT_FWTYPES, BootloaderMethod, UF2_PORTS
+from mpflash.errors import MPFlashError
 
 from .esp import flash_esp
 from .stm32 import flash_stm32
@@ -12,44 +13,58 @@ from .worklist import WorkList
 
 # #########################################################################################################
 
-
-
 def flash_list(
     todo: WorkList,
     fw_folder: Path,
     erase: bool,
     bootloader: BootloaderMethod,
-):
+    **kwargs
+):  # sourcery skip: use-named-expression
     """Flash a list of boards with the specified firmware."""
-    UF2_PORTS = [port for port, exts in PORT_FWTYPES.items() if ".uf2" in exts]
     flashed = []
     for mcu, fw_info in todo:
         fw_file = fw_folder / fw_info.filename
         if not fw_file.exists():
             log.error(f"File {fw_file} does not exist, skipping {mcu.board} on {mcu.serialport}")
             continue
+
         log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info.version}")
+        try:
+            updated = flash_mcu(mcu, fw_file=fw_file, erase=erase, bootloader=bootloader, **kwargs)
+        except MPFlashError as e:
+            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}: {e}")
+            continue
+        if updated:
+            flashed.append(updated)
+        else:
+            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
+    return flashed
+
+
+def flash_mcu(
+        mcu, 
+        *, 
+        fw_file: Path,
+        erase: bool = False,
+        bootloader: BootloaderMethod = BootloaderMethod.AUTO,
+        **kwargs        
+    ):
+        """Flash a single MCU with the specified firmware."""
         updated = None
         try:
             if mcu.port in UF2_PORTS and fw_file.suffix == ".uf2":
                 if not enter_bootloader(mcu, bootloader):
-                    continue
+                    raise MPFlashError(f"Failed to enter bootloader for {mcu.board} on {mcu.serialport}")
                 updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
             elif mcu.port in ["stm32"]:
                 if not enter_bootloader(mcu, bootloader):
-                    continue
+                    raise MPFlashError(f"Failed to enter bootloader for {mcu.board} on {mcu.serialport}")
                 updated = flash_stm32(mcu, fw_file, erase=erase)
             elif mcu.port in ["esp32", "esp8266"]:
                 #  bootloader is handled by esptool for esp32/esp8266
-                updated = flash_esp(mcu, fw_file=fw_file, erase=erase)
+                updated = flash_esp(mcu, fw_file=fw_file, erase=erase, **kwargs)
             else:
-                log.error(f"Don't (yet) know how to flash {mcu.port}-{mcu.board} on {mcu.serialport}")
+                raise MPFlashError(f"Don't (yet) know how to flash {mcu.port}-{mcu.board} on {mcu.serialport}")
         except Exception as e:
-            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
-            log.exception(e)
-
-        if updated:
-            flashed.append(updated)
-        else:
-            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
-    return flashed
+            raise MPFlashError(f"Failed to flash {mcu.board} on {mcu.serialport}") from e
+        return updated

mpflash/flash/esp.py

@@ -5,7 +5,7 @@
 """
 
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 import esptool
 from loguru import logger as log
@@ -13,9 +13,17 @@ from loguru import logger as log
 from mpflash.mpboard_id import find_known_board
 from mpflash.mpremoteboard import MPRemoteBoard
 
+FlashMode = Literal["keep", "qio", "qout", "dio", "dout"]
 
-def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optional[MPRemoteBoard]:
-    if mcu.port not in ["esp32", "esp8266"] or mcu.board in ["ARDUINO_NANO_ESP32"]:
+def flash_esp(
+    mcu: MPRemoteBoard,
+    fw_file: Path,
+    *,
+    erase: bool = True,
+    flash_mode: FlashMode = "keep",  # keep, qio, qout, dio, dout
+    flash_size: str = "detect",
+) -> Optional[MPRemoteBoard]:
+    if mcu.port not in ["esp32", "esp8266"] or mcu.board.startswith("ARDUINO_"):
         log.error(f"esptool not supported for {mcu.port} {mcu.board} on {mcu.serialport}")
         return None
 
@@ -25,26 +33,49 @@ def flash_esp(mcu: MPRemoteBoard, fw_file: Path, *, erase: bool = True) -> Optio
         mcu.cpu = find_known_board(mcu.board).cpu
 
     cmds: List[List[str]] = []
-    if erase:
-        cmds.append(f"esptool --chip {mcu.cpu} --port {mcu.serialport} erase_flash".split())
 
+    chip = "auto"
+    start_addr = "0x0"
     if mcu.cpu.upper().startswith("ESP32"):
+        start_addr = "0x0"
+
         baud_rate = str(921_600)
-        if mcu.cpu.upper() in ("ESP32", "ESP32S2"):
+        if mcu.cpu.upper() == "ESP32":
+            start_addr = "0x1000"
+            chip = "esp32"
+        elif "C2" in mcu.cpu.upper():
+            start_addr = "0x1000"
+            chip = "esp32c2"
+        elif "S2" in mcu.cpu.upper():
             start_addr = "0x1000"
-        elif mcu.cpu.upper() in ("ESP32S3", "ESP32C3"):
+            chip = "esp32s2"
+            baud_rate = str(460_800)
+        elif "S3" in mcu.cpu.upper():
             start_addr = "0x0"
+            chip = "esp32s3"
+        elif "C3" in mcu.cpu.upper():
+            start_addr = "0x0"
+            chip = "esp32c3"
+        elif "C6" in mcu.cpu.upper():
+            start_addr = "0x0"
+            chip = "esp32c6"
+            baud_rate = str(460_800)
+
         cmds.append(
-            f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --compress {start_addr}".split()
+            f"esptool --chip {chip} --port {mcu.serialport} -b {baud_rate} write_flash --flash_mode {flash_mode} --flash_size {flash_size} --compress {start_addr}".split()
             + [str(fw_file)]
         )
     elif mcu.cpu.upper() == "ESP8266":
         baud_rate = str(460_800)
         start_addr = "0x0"
+        chip = "esp8266"
         cmds.append(
-            f"esptool --chip {mcu.cpu} --port {mcu.serialport} -b {baud_rate} write_flash --flash_size=detect {start_addr}".split()
+            f"esptool --chip {chip} --port {mcu.serialport} -b {baud_rate} write_flash --flash_mode {flash_mode} --flash_size=detect {start_addr}".split()
             + [str(fw_file)]
         )
+    # now that we have the chip, we can do the erare properly
+    if erase:
+        cmds.insert(0, f"esptool --chip {chip} --port {mcu.serialport} erase_flash".split())
     try:
         for cmd in cmds:
             log.info(f"Running {' '.join(cmd)} ")

mpflash/flash/uf2/__init__.py

@@ -5,6 +5,7 @@ Flash SAMD and RP2 via UF2
 import shutil
 import sys
 from pathlib import Path
+import time
 from typing import Optional
 
 import tenacity
@@ -38,7 +39,21 @@ def flash_uf2(mcu: MPRemoteBoard, fw_file: Path, erase: bool) -> Optional[MPRemo
         log.error(f"UF2 not supported on {mcu.board} on {mcu.serialport}")
         return None
     if erase:
-        log.warning("Erase not (yet) supported on .UF2, skipping erase.")
+        if mcu.port == "rp2":
+            rp2_erase =Path(__file__).parent.joinpath("../../vendor/pico-universal-flash-nuke/universal_flash_nuke.uf2").resolve()
+            log.info(f"Erasing {mcu.port} with {rp2_erase.name}")
+            # optimistic 
+            destination = waitfor_uf2(board_id=mcu.port.upper())
+            if not destination :
+                log.error("Board is not in bootloader mode")
+                return None
+            copy_firmware_to_uf2(rp2_erase, destination)
+            if sys.platform in ["linux"]:
+                dismount_uf2_linux()
+            # allow for MCU restart after erase
+            time.sleep(0.5)
+        else:
+            log.warning(f"Erase not (yet) supported on .UF2, for port {mcu.port}, skipping erase.")
 
     destination = waitfor_uf2(board_id=mcu.port.upper())
 
@@ -84,5 +99,6 @@ def copy_firmware_to_uf2(fw_file: Path, destination: Path):
     Copy the firmware file to the destination,
     Retry 3 times with 1s delay
     """
-    log.info(f"Copying {fw_file} to {destination}.")
+    log.trace(f"Firmware: {fw_file}")
+    log.info(f"Copying {fw_file.name} to {destination}.")
     return shutil.copy(fw_file, destination)

mpflash/flash/uf2/linux.py

@@ -1,4 +1,4 @@
-""" Flashing UF2 based MCU on Linux"""
+"""Flashing UF2 based MCU on Linux"""
 
 # sourcery skip: snake-case-functions
 from __future__ import annotations
@@ -42,10 +42,7 @@ def get_uf2_drives():
             uf2.mountpoint = uf2_part["mountpoint"]
             yield uf2
         elif disk["type"] == "disk" and disk.get("children") and len(disk.get("children")) > 0:
-            if (
-                disk.get("children")[0]["type"] == "part"
-                and disk.get("children")[0]["fstype"] == "vfat"
-            ):
+            if disk.get("children")[0]["type"] == "part" and disk.get("children")[0]["fstype"] == "vfat":
                 uf2_part = disk.get("children")[0]
                 # print( json.dumps(uf2_part, indent=4))
                 uf2 = UF2Disk()
@@ -69,9 +66,7 @@ def pmount(disk: UF2Disk):
             # drive is always vfat - so specify to have quicker results
             subprocess.run(["pmount", "-t", "vfat", disk.device_path, disk.mountpoint])
         except FileNotFoundError:
-            log.error(
-                "pmount not found, please install it using 'sudo apt install pmount', and add this user to the plugdev group."
-            )
+            log.error("pmount not found, please install it using 'sudo apt install pmount', and add this user to the plugdev group.")
             return
         log.debug(f"Mounted {disk.label} at {disk.mountpoint}")
         glb_dismount_me.append(disk)
@@ -89,7 +84,7 @@ def pumount(disk: UF2Disk):
     if disk.mountpoint:
         subprocess.run(["pumount", disk.mountpoint])  # ), f"/media/{disk.label}"])
         log.info(f"Unmounted {disk.label} from {disk.mountpoint}")
-        disk.mountpoint = f""
+        disk.mountpoint = ""
     else:
         log.warning(f"{disk.label} already dismounted")
 

mpflash/flash/uf2/macos.py

@@ -1,4 +1,4 @@
-""" Flashing UF2 based MCU on macos"""
+"""Flashing UF2 based MCU on macos"""
 
 # sourcery skip: snake-case-functions
 from __future__ import annotations

mpflash/flash/uf2/windows.py

@@ -12,7 +12,7 @@ import psutil
 from rich.progress import track
 
 
-def wait_for_UF2_windows(board_id: str, s_max: int = 10)-> Optional[Path]:
+def wait_for_UF2_windows(board_id: str, s_max: int = 10) -> Optional[Path]:
     """Wait for the MCU to mount as a drive"""
     if s_max < 1:
         s_max = 10

mpflash/flash/worklist.py

@@ -44,7 +44,7 @@ def auto_update(
             continue
         board_firmwares = find_downloaded_firmware(
             fw_folder=fw_folder,
-            board_id=mcu.board,
+            board_id=mcu.board if not mcu.variant else f"{mcu.board}-{mcu.variant}",
             version=target_version,
             port=mcu.port,
             selector=selector,
@@ -127,7 +127,12 @@ def single_auto_worklist(
 
 
 def full_auto_worklist(
-    all_boards: List[MPRemoteBoard], *, include: List[str], ignore: List[str], version: str, fw_folder: Path
+    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.

mpflash/list.py

@@ -14,13 +14,16 @@ def show_mcus(
     conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
+    *,
+    title_style="magenta",
+    header_style="bold magenta",    
 ):
-    console.print(mcu_table(conn_mcus, title, refresh))
+    console.print(mcu_table(conn_mcus, title, refresh, title_style=title_style, header_style=header_style))
 
 
 def abbrv_family(family: str, is_wide: bool) -> str:
     if not is_wide:
-        ABRV = {"micropython": "upy", "circuitpython": "cpy", "unknown": "?"}
+        ABRV = {"micropython": "mpy", "circuitpython": "cpy", "unknown": "?"}
         return ABRV.get(family, family[:4])
     return family
 
@@ -29,15 +32,19 @@ def mcu_table(
     conn_mcus: List[MPRemoteBoard],
     title: str = "Connected boards",
     refresh: bool = True,
+    *,
+    title_style="magenta",
+    header_style="bold magenta",
 ):
     """
     builds a rich table with the connected boards information
-    The columns of the table are adjusted to the terminal width
+    The columns of the table are adjusted to the terminal width > 90 
     the columns are :
                 Narrow      Wide
     - Serial    Yes         Yes
     - Family    abbrv.      Yes
     - Port      -           yes
+    - Variant   Yes         Yes     only if any of the mcus have a variant
     - Board     Yes         Yes     BOARD_ID and Description, and the description from board_info.toml
     - CPU       -           Yes
     - Version   Yes         Yes
@@ -59,8 +66,8 @@ def mcu_table(
                 continue
     table = Table(
         title=title,
-        title_style="magenta",
-        header_style="bold magenta",
+        title_style=title_style,
+        header_style=header_style,
         collapse_padding=True,
         padding=(0, 0),
     )
@@ -68,13 +75,15 @@ def mcu_table(
     # check if the terminal is wide enough to show all columns or if we need to collapse some
     is_wide = console.width > 99
     needs_build = any(mcu.build for mcu in conn_mcus)
+    needs_variant = any(mcu.variant for mcu in conn_mcus)
 
     table.add_column("Serial" if is_wide else "Ser.", overflow="fold")
     table.add_column("Family" if is_wide else "Fam.", overflow="crop", max_width=None if is_wide else 4)
     if is_wide:
         table.add_column("Port")
     table.add_column("Board", overflow="fold")
-    # table.add_column("Variant") # TODO: add variant
+    if needs_variant:
+        table.add_column("Variant") 
     if is_wide:
         table.add_column("CPU")
     table.add_column("Version", overflow="fold", min_width=5, max_width=16)
@@ -94,6 +103,8 @@ def mcu_table(
         if is_wide:
             row.append(mcu.port)
         row.append(f"{mcu.board}\n{description}".strip())
+        if needs_variant:
+            row.append(mcu.variant)
         if is_wide:
             row.append(mcu.cpu)
         row.append(clean_version(mcu.version))

mpflash/logger.py

@@ -20,9 +20,7 @@ def _log_formatter(record: dict) -> str:
         "CRITICAL": "bold white on red",
     }
     lvl_color = color_map.get(record["level"].name, "cyan")
-    return (
-        "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
-    )
+    return "[not bold green]{time:HH:mm:ss}[/not bold green] | {level.icon} " + f"[{lvl_color}]{{message}}[/{lvl_color}]"
 
 
 def set_loglevel(loglevel: str):

mpflash/mpboard_id/__init__.py

@@ -6,93 +6,12 @@ that is included in the module.
 
 from functools import lru_cache
 from typing import List, Optional, Tuple
-
+import importlib
 from mpflash.errors import MPFlashError
-from mpflash.mpboard_id.board import Board
-from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.versions import clean_version
-
-# KNOWN ports and boards are sourced from the micropython repo,
-# this info is stored in the board_info.json file
-
-
-def get_known_ports() -> List[str]:
-    # TODO: Filter for Version
-    mp_boards = read_known_boardinfo()
-    # select the unique ports from info
-    ports = set({board.port for board in mp_boards if board.port})
-    return sorted(list(ports))
-
-
-def get_known_boards_for_port(
-    port: Optional[str] = "", versions: Optional[List[str]] = None
-) -> List[Board]:
-    """
-    Returns a list of boards for the given port and version(s)
-
-    port: The Micropython port to filter for
-    versions:  Optional, The Micropython versions to filter for (actual versions required)
-    """
-    mp_boards = read_known_boardinfo()
-    if versions:
-        preview_or_stable = "preview" in versions or "stable" in versions
-    else:
-        preview_or_stable = False
-
-    # filter for 'preview' as they are not in the board_info.json
-    # instead use stable version
-    versions = versions or []
-    if "preview" in versions:
-        versions.remove("preview")
-        versions.append("stable")
-    if versions:
-        # make sure of the v prefix
-        versions = [clean_version(v) for v in versions]
-        # filter for the version(s)
-        mp_boards = [board for board in mp_boards if board.version in versions]
-        if not mp_boards and preview_or_stable:
-            # nothing found - perhaps there is a newer version for which we do not have the board info yet
-            # use the latest known version from the board info
-            mp_boards = read_known_boardinfo()
-            last_known_version = sorted({b.version for b in mp_boards})[-1]
-            mp_boards = [board for board in mp_boards if board.version == last_known_version]
-
-    # filter for the port
-    if port:
-        mp_boards = [board for board in mp_boards if board.port == port]
-    return mp_boards
-
-
-def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List[Tuple[str, str]]:
-    """
-    Returns a list of tuples with the description and board name for the given port and version
-
-    port : str : The Micropython port to filter for
-    versions : List[str] : The Micropython versions to filter for (actual versions required)
-    """
-    mp_boards = get_known_boards_for_port(port, versions)
-
-    boards = set({(f"{board.version} {board.description}", board.board_id) for board in mp_boards})
-    return sorted(list(boards))
+from .board import Board
 
+from mpflash.versions import clean_version
+from .store import read_known_boardinfo
+from .known import get_known_ports, get_known_boards_for_port
+from .known import known_stored_boards, find_known_board
 
-@lru_cache(maxsize=20)
-def find_known_board(board_id: str) -> Board:
-    """Find the board for the given BOARD_ID or 'board description' and return the board info as a Board object"""
-    # Some functional overlap with:
-    # mpboard_id\board_id.py _find_board_id_by_description
-    info = read_known_boardinfo()
-    for board_info in info:
-        if board_id in (
-            board_info.board_id,
-            board_info.description,
-        ) or board_info.description.startswith(board_id):
-            if not board_info.cpu:
-                # failsafe for older board_info.json files
-                print(f"Board {board_id} has no CPU info, using port as CPU")
-                if " with " in board_info.description:
-                    board_info.cpu = board_info.description.split(" with ")[-1]
-                else:
-                    board_info.cpu = board_info.port
-            return board_info
-    raise MPFlashError(f"Board {board_id} not found")