mpflash 1.25.0.post1__py3-none-any.whl → 1.25.0rc1__py3-none-any.whl

mpflash/mpboard_id/board_id.py

@@ -2,18 +2,14 @@
 Translate board description to board designator
 """
 
-import functools
-import re
-import sqlite3
-from pathlib import Path
+
 from typing import List, Optional
 
-from mpflash.config import config
+from mpflash.db.core import Session
+from mpflash.db.models import Board
 from mpflash.errors import MPFlashError
 from mpflash.logger import log
-from mpflash.mpboard_id.board import Board
-from mpflash.mpboard_id.store import read_known_boardinfo
-from mpflash.versions import clean_version, get_preview_mp_version, get_stable_mp_version
+from mpflash.versions import clean_version
 
 
 def find_board_id_by_description(
@@ -21,7 +17,6 @@ def find_board_id_by_description(
     short_descr: str,
     *,
     version: str,
-    board_info: Optional[Path] = None,
 ) -> Optional[str]:
     """Find the MicroPython BOARD_ID based on the description in the firmware"""
     version = clean_version(version) if version else ""
@@ -29,7 +24,6 @@ def find_board_id_by_description(
         boards = _find_board_id_by_description(
             descr=descr,
             short_descr=short_descr,
-            db_path=board_info,
             version=version,
         )
         if not boards:
@@ -37,7 +31,6 @@ def find_board_id_by_description(
             boards = _find_board_id_by_description(
                 descr=descr,
                 short_descr=short_descr,
-                db_path=board_info,
                 version="%",  # any version
             )
         return boards[0].board_id if boards else None
@@ -51,7 +44,6 @@ def _find_board_id_by_description(
     short_descr: str,
     version: Optional[str] = None,
     variant: str = "",
-    db_path: Optional[Path] = None,
 ):
     short_descr = short_descr or ""
     boards: List[Board] = []
@@ -63,90 +55,15 @@ def _find_board_id_by_description(
         descriptions.append(descr[8:])
         descriptions.append(short_descr[8:])
 
-    try:
-        with sqlite3.connect(db_path or config.db_path) as conn:
-            conn.row_factory = sqlite3.Row
-            cursor = conn.cursor()
-
-            qry = f"""
-            SELECT 
-                *
-            FROM board_downloaded
-            WHERE 
-                board_id IN (
-                    SELECT  DISTINCT board_id
-                    FROM board_downloaded
-                    WHERE description IN {str(tuple(descriptions))}
-                )
-                AND version like '{version}'
-                AND variant like '{variant}'
-            """
-            cursor.execute(qry)
-            rows = cursor.fetchall()
-            for row in rows:
-                r = dict(row)
+    with Session() as session:
+        qry = session.query(Board).filter(
+            Board.description.in_(descriptions),
+            Board.version.like(version),
+            Board.variant.like(variant),
+        )
+        boards = qry.all()
 
-                boards.append(Board.from_dict(dict(row)))
-    except sqlite3.OperationalError as e:
-        raise MPFlashError("Database error") from e
     if not boards:
         raise MPFlashError(f"No board info found for description '{descr}' or '{short_descr}'")
     return boards
 
-
-@functools.lru_cache(maxsize=20)
-def _find_board_id_by_description_xx(
-    *,
-    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
-
-    Parameters:
-    descr: str
-        Description of the board
-    short_descr: str
-        Short description of the board (optional)
-    version: str
-        Version of the MicroPython firmware
-    board_info: Path
-        Path to the board_info.json file (optional)
-
-    """
-    # Some functional overlap with
-    # src\mpflash\mpflash\mpboard_id\__init__.py find_known_board
-
-    candidate_boards = read_known_boardinfo(board_info)
-    if not short_descr and " with " in descr:
-        short_descr = descr.split(" with ")[0]
-    if version:
-        # filter for matching version
-        if version in ("stable"):
-            version = get_stable_mp_version()
-        if version in ("preview", "master"):
-            version = get_preview_mp_version()
-        known_versions = sorted({b.version for b in candidate_boards})
-        if version not in known_versions:
-            log.trace(known_versions)
-            log.debug(f"Version {version} not found in board info, using latest stable version {get_stable_mp_version()}")
-            version = ".".join(get_stable_mp_version().split(".")[:2])  # take only major.minor
-        if version_matches := [b for b in candidate_boards if b.version.startswith(version)]:
-            candidate_boards = version_matches
-        else:
-            raise MPFlashError(f"No board info found for version {version}")
-    # First try full match on description, then partial match
-    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]
-    if not matches:
-        # partial match (for added VARIANT)
-        matches = [b for b in candidate_boards if b.description.startswith(descr)]
-        if not matches and short_descr:
-            matches = [b for b in candidate_boards if b.description.startswith(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)

mpflash/mpboard_id/known.py

@@ -7,62 +7,50 @@ This module provides access to the board info and the known ports and boards."""
 from functools import lru_cache
 from typing import List, Optional, Tuple
 
-from mpflash.db.boards import find_board_id, find_board_info
+from sqlalchemy import text
+
+from mpflash.db.core import Session
+from mpflash.db.models import Board
 from mpflash.errors import MPFlashError
-from mpflash.versions import clean_version
 from mpflash.logger import log
+from mpflash.versions import clean_version
 
-from .board import Board
-from .store import read_known_boardinfo
 
+def known_ports(version: str = "") -> list[str]:
+    """Return a list of known ports for a given version."""
+    version = clean_version(version) if version else "%%"
+    with Session() as session:
+        qry = text("SELECT distinct port FROM boards WHERE version like :version ORDER BY port;")
+        ports = session.execute(qry, {"version": version}).columns("port").fetchall()
+    return [row.port for row in ports]
 
-def get_known_ports() -> List[str]:
-    # TODO: Filter for Version
-    log.warning("get_known_ports() is deprecated")
-    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 known_versions(port: str = "") -> list[str]:
+    """Return a list of known versions for a given port."""
+    port = port.strip() if port else "%%"
+    with Session() as session:
+        qry = text("SELECT distinct version FROM boards WHERE port like :port ORDER BY version;")
+        versions = session.execute(qry, {"port": port}).columns("version").fetchall()
+    return [row.version for row in versions]
 
-def get_known_boards_for_port(port: Optional[str] = "", versions: Optional[List[str]] = None) -> List[Board]:
+
+def get_known_boards_for_port(port: str = "", versions: List[str] = []):
     """
     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")
-    # filter for the port
-    if port:
-        mp_boards = [board for board in mp_boards if board.port == port]
-    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]
-
-    return mp_boards
-
-
-def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List[Tuple[str, str]]:
+    versions = [clean_version(v) for v in versions] if versions else []
+    with Session() as session:
+        qry = session.query(Board).filter(Board.port.like(port))
+        if versions:
+            qry = qry.filter(Board.version.in_(versions))
+        boards = qry.all()
+        return boards
+
+
+def known_stored_boards(port: str, versions: List[str] = []) -> List[Tuple[str, str]]:
     """
     Returns a list of tuples with the description and board name for the given port and version
 
@@ -75,18 +63,18 @@ def known_stored_boards(port: str, versions: Optional[List[str]] = None) -> List
     return sorted(list(boards))
 
 
-@lru_cache(maxsize=20)
-def find_known_board(board_id: str, version ="") -> Board:
+def find_known_board(board_id: str, version="") -> 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
-    # TODO: Refactor to search the SQLite DB instead of the JSON file
-    board_ids = find_board_id(board_id = board_id, version = version or "%")
-    boards = []
-    for board_id in board_ids:
-        # if we have a board_id, use it to find the board info
-        boards += [Board.from_dict(dict(r)) for r in find_board_info(board_id = board_id)]
-
-    if boards:
-        return boards[0]
+    with Session() as session:
+        qry = session.query(Board).filter(Board.board_id == board_id)
+        if version:
+            qry = qry.filter(Board.version == version)
+        board = qry.first()
+        if not board:
+            # if no board found, try to find it by description
+            qry = session.query(Board).filter(Board.description == board_id)
+            if version:
+                qry = qry.filter(Board.version == version)
+        if board:
+            return board
     raise MPFlashError(f"Board {board_id} not found")

mpflash/mpboard_id/resolve.py

@@ -0,0 +1,19 @@
+from logging import log
+from mpflash.common import Params
+from mpflash.mpboard_id import find_known_board
+
+
+def resolve_board_ids(params: Params):
+    """Resolve board descriptions to board_id, and remove empty strings from list of boards"""
+    for board_id in params.boards:
+        if board_id == "":
+            params.boards.remove(board_id)
+            continue
+        if " " in board_id:
+            try:
+                if info := find_known_board(board_id):
+                    log.info(f"Resolved board description: {info.board_id}")
+                    params.boards.remove(board_id)
+                    params.boards.append(info.board_id)
+            except Exception as e:
+                log.warning(f"Unable to resolve board description: {e}")

mpflash/mpremoteboard/__init__.py

@@ -170,7 +170,7 @@ class MPRemoteBoard:
             self.cpu = info["cpu"]
             self.arch = info["arch"]
             self.mpy = info["mpy"]
-            self.description = descr = info["board"]
+            self.description = descr = info["description"] if 'description' in info else info["board"]
             pos = descr.rfind(" with")
             short_descr = descr[:pos].strip() if pos != -1 else ""
             if info.get("board_id", None):

mpflash/mpremoteboard/mpy_fw_info.py

@@ -51,6 +51,7 @@ def _info():  # type:() -> dict[str, str]
     try:
         _machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine  # type: ignore
         info["board"] = _machine.strip()
+        info["description"] = _machine.strip()
         si_build = sys.implementation._build if "_build" in dir(sys.implementation) else ""
         if si_build:
             info["board"] = si_build.split("-")[0]

mpflash/mpremoteboard/runner.py

@@ -91,11 +91,12 @@ def run(
         )
     except FileNotFoundError as e:
         raise FileNotFoundError(f"Failed to start {cmd[0]}") from e
-
+    _timed_out = False
     def timed_out():
-        proc.kill()
+        _timed_out = True
         if log_warnings:
             log.warning(f"Command {cmd} timed out after {timeout} seconds")
+        proc.kill()
 
     timer = Timer(timeout, timed_out)
     try:
@@ -135,6 +136,8 @@ def run(
         log.error(f"Failed to decode output: {e}")
     finally:
         timer.cancel()
+        if _timed_out:
+            raise TimeoutError(f"Command {cmd} timed out after {timeout} seconds")
 
     proc.wait(timeout=1)
     return proc.returncode or 0, output

mpflash/vendor/pydfu.py

@@ -338,7 +338,7 @@ def read_dfu_file(filename):
     #   I   uint32_t    size        Size of the DFU file (without suffix)
     #   B   uint8_t     targets     Number of targets
     dfu_prefix, data = consume("<5sBIB", data, "signature version size targets")
-    print("    %(signature)s v%(version)d, image size: %(size)d, " "targets: %(targets)d" % dfu_prefix)
+    print("    %(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d" % dfu_prefix)
     for target_idx in range(dfu_prefix["targets"]):
         # Decode the Image Prefix
         #
@@ -350,15 +350,14 @@ def read_dfu_file(filename):
         #   255s    char[255]   name        Name of the target
         #   I       uint32_t    size        Size of image (without prefix)
         #   I       uint32_t    elements    Number of elements in the image
-        img_prefix, data = consume("<6sBI255s2I", data, "signature altsetting named name " "size elements")
+        img_prefix, data = consume("<6sBI255s2I", data, "signature altsetting named name size elements")
         img_prefix["num"] = target_idx
         if img_prefix["named"]:
             img_prefix["name"] = cstring(img_prefix["name"])
         else:
             img_prefix["name"] = ""
         print(
-            "    %(signature)s %(num)d, alt setting: %(altsetting)s, "
-            'name: "%(name)s", size: %(size)d, elements: %(elements)d' % img_prefix
+            '    %(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d' % img_prefix
         )
 
         target_size = img_prefix["size"]
@@ -395,7 +394,7 @@ def read_dfu_file(filename):
     #   B   uint8_t     len         16
     #   I   uint32_t    crc32       Checksum
     dfu_suffix = named(struct.unpack("<4H3sBI", data[:16]), "device product vendor dfu ufd len crc")
-    print("    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, " "dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x" % dfu_suffix)
+    print("    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x" % dfu_suffix)
     if crc != dfu_suffix["crc"]:
         print("CRC ERROR: computed crc32 is 0x%08x" % crc)
         return

mpflash/versions.py

@@ -78,6 +78,7 @@ def is_version(version: str):
     """Check if the version is a valid version string"""
     # Just in time import
     from packaging.version import Version
+
     return Version._regex.search(version) is not None
 
 
@@ -86,6 +87,7 @@ def micropython_versions(minver: str = "v1.20", reverse: bool = False, cache_it=
     """Get the list of micropython versions from github tags"""
     # Just in time import
     from packaging.version import parse
+
     try:
         gh_client = config.gh_client
         repo = gh_client.get_repo("micropython/micropython")
@@ -126,6 +128,7 @@ def checkedout_version(path: Path, flat: bool = False) -> str:
     """Get the checked-out version of the repo"""
     # Just in time import
     import mpflash.basicgit as git
+
     version = git.get_local_tag(path.as_posix())
     if not version:
         raise ValueError("No valid Tag found")

{mpflash-1.25.0.post1.dist-info → mpflash-1.25.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mpflash
-Version: 1.25.0.post1
+Version: 1.25.0rc1
 Summary: Flash and download tool for MicroPython firmwares
 License: MIT
 Keywords: MicroPython,firmware,flash,download,UF2,esptool
@@ -29,13 +29,13 @@ Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: mpremote (>=1.22.0,<2.0.0)
 Requires-Dist: packaging (>=24.2,<25.0)
 Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
-Requires-Dist: poetry (>=2.0.1,<3.0.0)
 Requires-Dist: psutil (>=5.9.8,<8.0.0)
 Requires-Dist: pygithub (>=2.1.1,<3.0.0)
 Requires-Dist: pyusb (>=1.2.1,<2.0.0)
 Requires-Dist: pywin32 (>=310,<311) ; sys_platform == "win32"
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich-click (>=1.8.1,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.41,<3.0.0)
 Requires-Dist: tenacity (==9.0.0)
 Project-URL: Homepage, https://github.com/Josverl/mpflash/blob/main/README.md
 Project-URL: Repository, https://github.com/Josverl/mpflash

mpflash-1.25.0rc1.dist-info/RECORD

@@ -0,0 +1,69 @@
+mpflash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpflash/add_firmware.py,sha256=P1yaNUdExfzC_qnhE-P5ALZg1Uh7XT6Xf7NYccJP7Rc,4317
+mpflash/ask_input.py,sha256=eoaFZf2F85RszyqcLBmuJvKtDe4PdT_T-nwOBFaWehg,8903
+mpflash/basicgit.py,sha256=Aiz6rF6PVhQir-FU-T1NhbjsW803y39Js6xnWs8-yu4,9676
+mpflash/bootloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpflash/bootloader/activate.py,sha256=orQOw4XTkXVZI-rMInRb0T5Wp3qA_BlzbJUA2gyBToU,2361
+mpflash/bootloader/detect.py,sha256=OagP2QVWeLLWkZt2paqEF6r4_x3QDcBGNCPOWfMy9NQ,2686
+mpflash/bootloader/manual.py,sha256=WYC4x-dxrSwVUfgnKTlu34pCzckrWJKZnWsARDocycI,3169
+mpflash/bootloader/micropython.py,sha256=v_kZkvg0uWZDbMrT78gmiYHbD83QLdnrctvEClI8iRg,529
+mpflash/bootloader/touch1200.py,sha256=VND7_YniS9Vx6WEaAxjI72RZZ6WBOwmBTsKJkbuaAHk,1105
+mpflash/cli_download.py,sha256=sMMIVTE4P9O2GpWB9jcbOiKQX-XJ0nu2bBylRbWu0X8,3872
+mpflash/cli_flash.py,sha256=K2TEyQndibtKdwSkeeu_esDUsu8H0_4DB_37SF7DR9E,7657
+mpflash/cli_group.py,sha256=Uf_1ZmeeSIsaGLuuKn3KPPPVi8fJVbIacJYFZx_oPHc,2684
+mpflash/cli_list.py,sha256=XwX0j9JzFzm2o-_oEWLR07QaMMAUrS1a553_-IpCdj0,2352
+mpflash/cli_main.py,sha256=NMhEtMtSe7ApE-210Q4p-g7ZgewgO-4z1Q-vNKLQ47Y,1277
+mpflash/common.py,sha256=fEFxSy2KVAhBUlJv0GsWnUHdJtRckp2XGlYVPAhS8WE,5924
+mpflash/config.py,sha256=bmwNSJzk27iHcI-r3C6hm6-TeOat2ymzbbv-Q-xuO2o,3048
+mpflash/connected.py,sha256=oxZdk1o-AfNPhJsSxr3KrMH_gdYfrjqc_IpT6J8Ng9k,3496
+mpflash/db/__init__.py,sha256=wnIlO4nOXsPGXMbn2OCqHRsR-hUmtJsko8VdqjH3ZUE,45
+mpflash/db/core.py,sha256=2t6pE385d8WgVrG7Kp2jmGdVZ5n0FiK6mHWAWOqZXW4,1949
+mpflash/db/gather_boards.py,sha256=8QS7NIt3n9ROqtgVAnoqU8YMeObLGaN2pvJL7d_kULA,3905
+mpflash/db/loader.py,sha256=RUbcnJ51r6bDq61vdglAlvYZzIaoLLGtTtm3FrSFrTQ,4758
+mpflash/db/meta.py,sha256=I7JycEx37MVVYowA0VFfUYFX9IURiTTsWQ1RhFgGqes,2251
+mpflash/db/micropython_boards.zip,sha256=cc4m7VSskj__rhabw3j5OZCiz1yEi6yCx7JGFn1QB0k,16647
+mpflash/db/models.py,sha256=Q4yjZPcNRIGWevoACeGDS1i31QX6jq1q5TsyPjmdmz4,3448
+mpflash/db/tools.py,sha256=6SEGfshNob4yRQ4h-Cj_xcWMRY28sbA8CWauNXV_uMI,814
+mpflash/download/__init__.py,sha256=zidXvsSFCfR-BZCZ6TiB7uEucEuUqXnZhKSfTs60lzU,7930
+mpflash/download/from_web.py,sha256=PVJDaFfYLJGXlPva5fExh4Yg2H7j3idyJEcfOiVVJBs,7608
+mpflash/download/fwinfo.py,sha256=gpa92PkysT1B7mxPAFJ-b_6y03QCNgHKm-J6T_RFNMI,1852
+mpflash/download/jid.py,sha256=ToRImbHdtvJ7AtZDH3aQURxBDci-0RvRtj5uCt8tHlI,2213
+mpflash/downloaded.py,sha256=RLz52l7uSvNW5HGMicTAj8aWLxnXYTsQbfcwCbjb_oo,4042
+mpflash/errors.py,sha256=IAidY3qkZsXy6Pm1rdmVFmGyg81ywHhse3itaPctA2w,247
+mpflash/flash/__init__.py,sha256=jif7-ifsXMabidjNdqUQyl1CwD5_USjCAZFhU5W-Aw8,2992
+mpflash/flash/esp.py,sha256=4977E1hDqJ4-EIkLzwrUtgZuc0ZTD7NvP1PQZgZ2DoU,3227
+mpflash/flash/stm32.py,sha256=dqp9BZ4Vr-6GlQcF12TSmRf-5TXkov9qvCpMgeUJc7Y,574
+mpflash/flash/stm32_dfu.py,sha256=W-3JsRQyf3DduoIRXDmGZ35RogqtjQgcJnk-GOtQoLE,3090
+mpflash/flash/uf2/__init__.py,sha256=haL84hP2p1ZjKF6dXJJHAB_NTf7jT91MuZvmvg9SpIA,3617
+mpflash/flash/uf2/boardid.py,sha256=U5wGM8VA3wEpUxQCMtuXpMZZomdVH8J_Zd5_GekUMuU,423
+mpflash/flash/uf2/linux.py,sha256=uTgqyS7C7xfQ25RrTcSUkt-m2u2Ks_o7bPLzIecPoC8,4355
+mpflash/flash/uf2/macos.py,sha256=JTaIpqnR_0k4oSEvzs9amhmK-PMxUJyZLnZ_wZwxa-0,1228
+mpflash/flash/uf2/uf2disk.py,sha256=4_P2l-kedM7VSliA2u706LQLxvu3xWSod1-lj-xjZis,298
+mpflash/flash/uf2/windows.py,sha256=S---sVjVrC00ZcnpOewtJIBfSCj2cr7FGQwEm_ZEDnY,1334
+mpflash/flash/worklist.py,sha256=ZqbgYChXFGEVLVlGKeS9eJJDToxBYqjrfWE2NIa7Cck,5622
+mpflash/list.py,sha256=NNhKpRh3ARZMdq56GLJgJ67GeuUf9SxjTzFhQjDsi9A,4008
+mpflash/logger.py,sha256=nHeH_Z9M5c1b0ECunNmxz_mCfl9b7v5suaSDDqAdS2E,1078
+mpflash/mpboard_id/__init__.py,sha256=Z6gDDWTCSKPp2fsuaUz80zgrklBR9XDlSLF9y_evR9A,391
+mpflash/mpboard_id/alternate.py,sha256=ZhqfdA9sLJmyOfJ6WwK9wrzzUn6JQdkAreiL0q5XEQg,1913
+mpflash/mpboard_id/board_id.py,sha256=dGbYnqaGHm6Z68P6aCq5bv95pyhi9KKhQleQXmlyO8Y,2046
+mpflash/mpboard_id/board_info.json,sha256=A3ZIt38KvAy2NMB5srHorSBd3Q3wOZIXufWiIs3XLrs,1019745
+mpflash/mpboard_id/board_info.zip,sha256=-2bnQGRsIQuJUfz-7_-GQ8pMWJ1evhCez6yfjhXocNw,23213
+mpflash/mpboard_id/known.py,sha256=IZ3LDYZpQo7TmWa67FzmbUJIqWuxoD_QiZ4JT1A6344,3304
+mpflash/mpboard_id/resolve.py,sha256=5KCZ0Tcg3FYZ3HK_zux5EguwoSC2E03kCpW2fh4rN2A,779
+mpflash/mpremoteboard/__init__.py,sha256=kZ-MziZPwx6UOs_ybLYEYeUDndC1XyylMcpGTiEHpTk,12043
+mpflash/mpremoteboard/mpy_fw_info.py,sha256=ZDEPJN9XJnoG_oeWcLNiLJAD5bkVX2yI_j4K7msUxWM,5196
+mpflash/mpremoteboard/runner.py,sha256=auJuK7uBq_qdZOX9DgzRARyAsTyhT8c9ycP02VqhMf4,4943
+mpflash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpflash/vendor/board_database.py,sha256=Cb8fEhJaZ2siMkLPW5rPwV9yzBsTtKGOqWUd9TxNgFM,8763
+mpflash/vendor/click_aliases.py,sha256=adLhqLxNpJEPjSCIRSTkR-QzSgavGFKT0cwRbjxpzRU,5395
+mpflash/vendor/dfu.py,sha256=6rqGCBS8mTxxaLtkdzJ8O6nc74kFk8jrkmKvxw-x-u8,5693
+mpflash/vendor/pico-universal-flash-nuke/LICENSE.txt,sha256=Zkc2iTNbib2NCMwtLjMEz0vFCPglgvaw6Mj7QiWldpQ,1484
+mpflash/vendor/pico-universal-flash-nuke/universal_flash_nuke.uf2,sha256=QuPMppqHMVOt3vDVU0bikHRLsTiDRQYNUcGQ_OLRFGI,28160
+mpflash/vendor/pydfu.py,sha256=1I8dwbacUH_-u2y6gYZYRKO_Iof8Eb3rZsVyQ1ETluI,20364
+mpflash/vendor/readme.md,sha256=BQ7Uxf8joeYMjTUuSLLBG49ob6a9MgFPIEwuc72-Mfw,415
+mpflash/versions.py,sha256=HuujLNdMKY_mQXyEqwXVHcU8nbuXeBiWP2TMA5JQhr4,4884
+mpflash-1.25.0rc1.dist-info/entry_points.txt,sha256=Jk_visOhYOsZIcSP2Ms9hKqfKy1iorR-6dYltSoWCpY,52
+mpflash-1.25.0rc1.dist-info/LICENSE,sha256=mWpNhsIxWzetYNnTpr4eb3HtgsxGIC8KcYWxXEcxQvE,1077
+mpflash-1.25.0rc1.dist-info/METADATA,sha256=L7CGVRIBkloWrj0gm30DxyXLAtFUPE425HzvyjenePU,23938
+mpflash-1.25.0rc1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+mpflash-1.25.0rc1.dist-info/RECORD,,

mpflash/db/boards.py

@@ -1,63 +0,0 @@
-
-from __future__ import annotations
-
-import sqlite3
-from pathlib import Path
-from typing import List
-
-from mpflash.common import FWInfo
-from mpflash.config import config
-from mpflash.logger import log
-
-
-def find_board_id(
-    db_path: Path | None = None, board_id: str = "", description: str = "", version: str = "%"
-) -> List[str]:
-    """Get a list of board IDs from the database based on the board ID or description"""
-    db_path = db_path or config.db_path
-    conn = sqlite3.connect(db_path)
-    conn.row_factory = sqlite3.Row
-    rows = []
-    with conn:
-        cursor = conn.cursor()
-        
-        query = """
-        SELECT DISTINCT board_id FROM board_downloaded
-        where board_id like ? and version like ?
-        ORDER BY `version` ASC
-        """
-        cursor.execute(query, (board_id,version))
-        rows = cursor.fetchall()
-        if len(rows) == 0:
-            cursor.execute(
-                """
-                SELECT DISTINCT description FROM board_downloaded
-                where description like ? and version like ?
-                ORDER BY `description` ASC
-                """,
-                (description,version),
-            )
-            rows = cursor.fetchall()
-        
-    return [row['board_id'] for row in rows]
-
-
-def find_board_info(
-    db_path: Path | None = None, board_id: str = "", version: str = "%"
-) -> List[sqlite3.Row]:
-    """get a list of board rows  from the database based on the board ID and version"""
-    db_path = db_path or config.db_path
-    conn = sqlite3.connect(db_path)
-    conn.row_factory = sqlite3.Row
-    rows = []
-    with conn:
-        cursor = conn.cursor()
-        query = """
-        SELECT * FROM board_downloaded
-        where board_id like ? and version like ?
-        ORDER BY board_id, version ASC
-        """
-        cursor.execute(query, (board_id,version,))
-        rows = cursor.fetchall()
-
-    return rows

mpflash/db/downloads.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-from pathlib import Path
-from typing import List
-
-from mpflash.common import FWInfo
-from mpflash.config import config
-from mpflash.logger import log
-
-
-def upsert_download(conn: sqlite3.Connection, board: FWInfo):
-    """
-    Adds a row to the downloaded firmware table in the database.
-      - downloads.board_id <-- FWInfo.variant
-      - downloads.source   <-- FWInfo.firmware
-
-    Args:
-        conn : The database connection to use.
-        board : The firmware information to add to the database.
-
-    """
-    with conn:
-        conn.execute(
-            """
-            INSERT INTO downloads 
-                (port, board, filename, source, board_id, version, build, ext, family, custom, description) 
-            VALUES 
-                (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(filename) DO UPDATE SET
-                port=excluded.port,
-                board=excluded.board,
-                source=excluded.source,
-                board_id=excluded.board_id,
-                version=excluded.version,
-                build=excluded.build,
-                ext=excluded.ext,
-                family=excluded.family,
-                custom=excluded.custom,
-                description=excluded.description
-            """,
-            (
-                board.port,
-                board.board,
-                board.filename,
-                board.firmware,
-                board.variant,
-                board.version,
-                board.build,
-                board.ext,
-                board.family,
-                board.custom,
-                board.description,
-            ),
-        )
-        conn.commit()
-
-def downloaded(db_path: Path | None = None) -> List[FWInfo]:
-    """Load a list of locally downloaded firmwares from the database"""
-    db_path = db_path or config.db_path
-    with sqlite3.connect(db_path) as conn:
-        firmwares: List[FWInfo] = []
-        try:
-            conn.row_factory = sqlite3.Row
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM downloads")
-            rows = cursor.fetchall()
-            for row in rows:
-                fw_info = FWInfo.from_dict(
-                    {
-                        "filename": row["filename"],
-                        "version": row["version"],
-                        "board": row["board"],
-                        "variant": row["board_id"],
-                        "port": row["port"],
-                        "firmware": row["source"],
-                        "build": row["build"],
-                        "preview": 1 if int(row["build"]) > 0 else 0,
-                    }
-                )
-                firmwares.append(fw_info)
-        except sqlite3.Error as e:
-            log.error(f"Database error: {e}")
-
-    # sort by filename
-    firmwares.sort(key=lambda x: x.filename)
-    return firmwares