micropython-stubber 1.17.5__py3-none-any.whl → 1.19.0__py3-none-any.whl

stubber/commands/clone_cmd.py

@@ -31,16 +31,16 @@ def cli_clone(path: Union[str, Path], stubs: bool = False):
     dest_path = Path(path)
     if not dest_path.exists():
         os.mkdir(dest_path)
-    # repos are relative to provided path
-    if dest_path != CONFIG.repo_path:
+    if dest_path == CONFIG.repo_path:
+        # same as default
+        mpy_path = CONFIG.mpy_path
+        mpy_lib_path = CONFIG.mpy_lib_path
+        mpy_stubs_path = CONFIG.mpy_stubs_path
+    else:
+        # repos are relative to provided path
         mpy_path = dest_path / "micropython"
         mpy_lib_path = dest_path / "micropython-lib"
         mpy_stubs_path = dest_path / "micropython-stubs"
-    else:
-        mpy_path = CONFIG.mpy_path
-        mpy_lib_path = CONFIG.mpy_lib_path
-
-        mpy_stubs_path = CONFIG.stub_path.parent
 
     repos: List[Tuple[Path, str, str]] = [
         (mpy_path, "https://github.com/micropython/micropython.git", "master"),

stubber/commands/config_cmd.py

@@ -1,7 +1,9 @@
 """Show the current configuration"""
+
 # pragma: no cover
 
 from loguru import logger as log
+
 from stubber.utils.config import CONFIG
 
 from .cli import stubber_cli
@@ -20,6 +22,7 @@ def cli_config():
     log.info(f"CONFIG.repo_path           {CONFIG.repo_path}")
     log.info(f"CONFIG.mpy_path            {CONFIG.mpy_path}")
     log.info(f"CONFIG.mpy_lib_path        {CONFIG.mpy_lib_path}")
+    log.info(f"CONFIG.mpy_stubs_path      {CONFIG.mpy_stubs_path}")
 
     log.info(f"CONFIG.stub_path           {CONFIG.stub_path}")
     log.info(f"CONFIG.publish_path        {CONFIG.publish_path}")

stubber/freeze/get_frozen.py

@@ -25,9 +25,7 @@ from typing import List, Optional
 from loguru import logger as log
 from packaging.version import Version
 
-import stubber.basicgit as git
 from stubber import utils
-from stubber.codemod.add_comment import AddComment
 from stubber.freeze.freeze_folder import freeze_folders  # Micropython < v1.12
 from stubber.freeze.freeze_manifest_2 import freeze_one_manifest_2
 from stubber.utils.config import CONFIG

stubber/publish/candidates.py

@@ -236,7 +236,7 @@ def board_candidates(
         else:
             r = git.checkout_tag(repo=mpy_path, tag=version)
         if not r:
-            log.warning(f"Incorrect version or did you run `stubber clone` to get the micropython repo?")
+            log.warning(f"Incorrect version: {version} or did you forget to run `stubber clone` to get the micropython repo?")
             return []
         ports = list_micropython_ports(family=family, mpy_path=mpy_path)
         for port in ports:

stubber/publish/package.py

@@ -4,7 +4,7 @@ prepare a set of stub files for publishing to PyPi
 """
 import sys
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
+from typing import Dict, Union
 
 from loguru import logger as log
 from packaging.version import parse

stubber/publish/pathnames.py

@@ -4,7 +4,7 @@ Helper functions to deal with path names and filenames for the folders in the st
 """
 
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
 from loguru import logger as log
 

stubber/publish/stubpackage.py

@@ -790,6 +790,7 @@ class StubPackage(PoetryBuilder):
                 "name": self.package_name,
                 "version": self.pkg_version,
                 "error": None,
+                "path": self.package_path.as_posix(),
             }
         )
         super().__init__(

stubber/rst/lookup.py

@@ -3,7 +3,7 @@ Lookup tables for the rst documentation stubber
 """
 
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple
+from typing import List, Optional, Tuple
 
 # These are shown to import
 __all__ = [

stubber/tools/manifestfile.py

@@ -26,10 +26,10 @@
 # THE SOFTWARE.
 
 from __future__ import print_function
+
 import contextlib
 import os
 import sys
-import glob
 import tempfile
 from collections import namedtuple
 
@@ -270,7 +270,9 @@ class ManifestFile:
                 raise ManifestFileError("Expected .py file")
             kind = KIND_COMPILE_AS_MPY
 
-        self._manifest_files.append(ManifestOutput(FILE_TYPE_LOCAL, full_path, target_path, timestamp, kind, self._metadata[-1], opt))
+        self._manifest_files.append(
+            ManifestOutput(FILE_TYPE_LOCAL, full_path, target_path, timestamp, kind, self._metadata[-1], opt)
+        )
 
     def _search(self, base_path, package_path, files, exts, kind, opt=None, strict=False):
         base_path = self._resolve_path(base_path)
@@ -411,7 +413,7 @@ class ManifestFile:
 
             for lib_dir in lib_dirs:
                 # Search for {lib_dir}/**/{name}/manifest.py.
-                for root, dirnames, filenames in os.walk(os.path.join(self._path_vars["MPY_LIB_DIR"], lib_dir)):
+                for root, _, filenames in os.walk(os.path.join(self._path_vars["MPY_LIB_DIR"], lib_dir)):
                     if os.path.basename(root) == name and "manifest.py" in filenames:
                         self.include(root, is_require=True, **kwargs)
                         return

stubber/utils/config.py

@@ -15,43 +15,25 @@ from .typed_config_toml import TomlConfigSource
 @section("micropython-stubber")
 class StubberConfig(Config):
     "stubber configuration class"
-    stub_path = key(key_name="stub-path", cast=Path, required=False, default=Path("./stubs"))
-    "a Path to the stubs directory"
     # relative to stubs folder
-    fallback_path = key(key_name="fallback-path", cast=Path, required=False, default=Path("typings/fallback"))
+    fallback_path: Path = key(key_name="fallback-path", cast=Path, required=False, default=Path("typings/fallback"))
     "a Path to the fallback stubs directory"
 
     # ------------------------------------------------------------------------------------------
     # micropython and micropython-lib are relative to ./repo folder
-    repo_path = key(key_name="repo-path", cast=Path, required=False, default=Path("./repos"))
+    repo_path: Path = key(key_name="repo-path", cast=Path, required=False, default=Path("./repos"))
     "a Path to the repo directory"
 
-    mpy_path = key(key_name="mpy-path", cast=Path, required=False, default=Path("micropython"))
+    mpy_path: Path = key(key_name="mpy-path", cast=Path, required=False, default=Path("micropython"))
     "a Path to the micropython folder in the repos directory"
 
-    mpy_lib_path = key(key_name="mpy-lib-path", cast=Path, required=False, default=Path("micropython-lib"))
+    mpy_lib_path: Path = key(key_name="mpy-lib-path", cast=Path, required=False, default=Path("micropython-lib"))
     "a Path to the micropython-lib folder in the repos directory"
 
-    # mpy_stubs_repo_path = key(key_name="mpy-stubs-repo-path", cast=Path, required=False, default=Path("./micropython-stubs"))
-    # "a Path to the micropython-stubs folder in the repos directory"
+    mpy_stubs_path: Path = key(key_name="mpy-stubs-path", cast=Path, required=False, default=Path("micropython-stubs"))
+    "a Path to the micropython-stubs folder in the repos directory (or current directory)"
 
-    publish_path = key(
-        key_name="publish-path",
-        cast=Path,
-        required=False,
-        default=Path("./repos/micropython-stubs/publish"),
-    )
-    "A Path to the folder where all stub publication artifacts are stored"
-
-    template_path = key(
-        key_name="template-path",
-        cast=Path,
-        required=False,
-        default=Path("./repos/micropython-stubs/publish/template"),
-    )
-    "a Path to the publication folder that has the template files"
-
-    stable_version = key(key_name="stable-version", cast=str, required=False, default="1.20.0")
+    stable_version: str = key(key_name="stable-version", cast=str, required=False, default="1.20.0")
 
     "last published stable"
 
@@ -66,25 +48,33 @@ class StubberConfig(Config):
     BLOCKED_PORTS = ["minimal", "bare-arm"]
     "ports that should be ignored as a source of stubs"
 
-    # def __init__(self):
-    #     super().__init__()
-    #     self.update_versions()
+    @property
+    def stub_path(self) -> Path:
+        "return the stubs path in the microypthon-stubs repo"
+        return self.mpy_stubs_path / "stubs"
+
+    @property
+    def publish_path(self) -> Path:
+        "return the stubs path in the microypthon-stubs repo"
+        return self.mpy_stubs_path / "publish"
 
-    # def update_versions(self):
-    #     try:
-    #         self.ALL_VERSIONS = git.get_tags(self.mpy_path, minver="v1.17")
-    #     except Exception:
-    #         self.ALL_VERSIONS = ["1.17", "1.18", "1.19", "1.19.1"]
-    #     self.STABLE_VERSION = self.ALL_VERSIONS[-1]
+    @property
+    def template_path(self) -> Path:
+        "return the stubs path in the microypthon-stubs repo"
+        return self.mpy_stubs_path / "publish" / "template"
 
     def post_read_hook(self) -> dict:
         config_updates = {}
         # relative to stubs
-        config_updates.update(fallback_path=self.stub_path / self.fallback_path)
+        # config_updates.update(fallback_path=self.stub_path / self.fallback_path)
 
         # relative to repo path
         config_updates.update(mpy_path=self.repo_path / self.mpy_path)
         config_updates.update(mpy_lib_path=self.repo_path / self.mpy_lib_path)
+        if self.mpy_stubs_path.is_absolute() or self.mpy_stubs_path == Path("."):
+            config_updates.update(mpy_stubs_path=self.mpy_stubs_path)
+        else:
+            config_updates.update(mpy_stubs_path=self.repo_path / self.mpy_stubs_path)
         # read the versions from the git tags
         all_versions = []
         try:
@@ -107,7 +97,7 @@ def readconfig(filename: str = "pyproject.toml", prefix: str = "tool.", must_exi
     while not (path / filename).exists():
         path = path.parent
         if path == path.parent:
-            log.info(f"Could not find config file: {filename}")
+            log.trace(f"Could not find config file: {filename}")
             use_toml = False
             break
 

stubber/utils/repos.py

@@ -107,9 +107,9 @@ def fetch_repos(tag: str, mpy_path: Path, mpy_lib_path: Path):
     git.fetch(mpy_path)
     git.fetch(mpy_lib_path)
     try:
-        git.fetch(CONFIG.stub_path.parent)
+        git.fetch(CONFIG.mpy_stubs_path)
     except Exception:
-        log.trace("no stubs repo found : {CONFIG.stub_path.parent}")
+        log.trace("no stubs repo found : {CONFIG.mpy_stubs_path}")
 
     if not tag:
         tag = V_PREVIEW

stubber/utils/versions.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 
 from github import Github
+from loguru import logger as log
 from packaging.version import parse
 
 import stubber.basicgit as git

mpflash/mpflash/flasher.py

@@ -1,287 +0,0 @@
-from pathlib import Path
-from typing import List, Optional, Tuple
-
-import jsonlines
-import rich_click as click
-from loguru import logger as log
-
-# TODO: - refactor so that we do not need the entire stubber package
-from stubber.bulk.mpremoteboard import MPRemoteBoard
-
-from .cli_group import cli
-from .common import DEFAULT_FW_PATH, FWInfo, clean_version
-from .config import config
-from .flash_esp import flash_esp
-from .flash_stm32 import flash_stm32
-from .flash_uf2 import flash_uf2
-from .list import show_boards
-
-# #########################################################################################################
-
-
-def load_firmwares(fw_folder: Path) -> List[FWInfo]:
-    """Load a list of available  firmwares from the jsonl file"""
-    firmwares: List[FWInfo] = []
-    try:
-        with jsonlines.open(fw_folder / "firmware.jsonl") as reader:
-            firmwares.extend(iter(reader))
-    except FileNotFoundError:
-        log.error(f"No firmware.jsonl found in {fw_folder}")
-    # sort by filename
-    firmwares.sort(key=lambda x: x["filename"])
-    return firmwares
-
-
-def find_firmware(
-    *,
-    board: str,
-    version: str = "",
-    port: str = "",
-    preview: bool = False,
-    variants: bool = False,
-    fw_folder: Optional[Path] = None,
-    trie: int = 1,
-):
-    # TODO : better path handling
-    fw_folder = fw_folder or DEFAULT_FW_PATH
-    # Use the information in firmwares.jsonl to find the firmware file
-    fw_list = load_firmwares(fw_folder)
-
-    if not fw_list:
-        log.error(f"No firmware files found. Please download the firmware first.")
-        return []
-    # filter by version
-    version = clean_version(version, drop_v=True)
-    if preview or "preview" in version:
-        # never get a preview for an older version
-        fw_list = [fw for fw in fw_list if fw["preview"]]
-    else:
-        fw_list = [fw for fw in fw_list if fw["version"] == version]
-
-    # filter by port
-    if port:
-        fw_list = [fw for fw in fw_list if fw["port"] == port]
-
-    if board:
-        if variants:
-            fw_list = [fw for fw in fw_list if fw["board"] == board]
-        else:
-            # the variant should match exactly the board name
-            fw_list = [fw for fw in fw_list if fw["variant"] == board]
-
-    if not fw_list and trie < 2:
-        board_id = board.replace("_", "-")
-        # ESP board naming conventions have changed by adding a PORT refix
-        if port.startswith("esp") and not board_id.startswith(port.upper()):
-            board_id = f"{port.upper()}_{board_id}"
-        # RP2 board naming conventions have changed by adding a _RPIprefix
-        if port == "rp2" and not board_id.startswith("RPI_"):
-            board_id = f"RPI_{board_id}"
-
-        log.warning(f"Trying to find a firmware for the board {board_id}")
-        fw_list = find_firmware(
-            fw_folder=fw_folder,
-            board=board_id,
-            version=version,
-            port=port,
-            preview=preview,
-            trie=trie + 1,
-        )
-        # hope we have a match now for the board
-    # sort by filename
-    fw_list.sort(key=lambda x: x["filename"])
-    return fw_list
-
-
-# #########################################################################################################
-#
-# #########################################################################################################
-WorkList = List[Tuple[MPRemoteBoard, FWInfo]]
-
-
-def auto_update(conn_boards: List[MPRemoteBoard], target_version: str, fw_folder: Path):
-    """Builds a list of boards to update based on the connected boards and the firmware available"""
-    wl: WorkList = []
-    for mcu in conn_boards:
-        if mcu.family != "micropython":
-            log.warning(
-                f"Skipping {mcu.board} on {mcu.serialport} as it is not a micropython board"
-            )
-            continue
-        board_firmwares = find_firmware(
-            fw_folder=fw_folder,
-            board=mcu.board,
-            version=target_version,
-            port=mcu.port,
-            preview="preview" in target_version,
-        )
-
-        if not board_firmwares:
-            log.error(
-                f"No {target_version} firmware found for {mcu.board} on {mcu.serialport}."
-            )
-            continue
-        if len(board_firmwares) > 1:
-            log.debug(
-                f"Multiple {target_version} firmwares found for {mcu.board} on {mcu.serialport}."
-            )
-        # 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}."
-        )
-        wl.append((mcu, fw_info))
-    return wl
-
-
-# #########################################################################################################
-# CLI
-# #########################################################################################################
-
-
-@cli.command(
-    "flash",
-    short_help="Flash one or all connected MicroPython boards with a specific firmware and version.",
-)
-@click.option(
-    "--firmware",
-    "-f",
-    "fw_folder",
-    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
-    default="./firmware",
-    show_default=True,
-    help="The folder to retrieve the firmware from.",
-)
-@click.option(
-    "--version",
-    "-v",
-    "target_version",
-    default="stable",
-    show_default=True,
-    help="The version of MicroPython to flash.",
-    metavar="SEMVER, stable or preview",
-)
-@click.option(
-    "--serial",
-    "--serial-port",
-    "-s",
-    "serial_port",
-    default="auto",
-    show_default=True,
-    help="Which serial port(s) to flash",
-    metavar="SERIAL_PORT",
-)
-@click.option(
-    "--port",
-    "-p",
-    "port",
-    help="The MicroPython port to flash",
-    metavar="PORT",
-    default="",
-)
-@click.option(
-    "--board",
-    "-b",
-    "board",
-    help="The MicroPython board ID to flash. if not specified will try to read the BOARD_ID from the connected MCU.",
-    metavar="BOARD_ID",
-    default="",
-)
-@click.option(
-    "--erase/--no-erase",
-    default=True,
-    show_default=True,
-    help="""Erase flash before writing new firmware.""",
-)
-@click.option(
-    "--preview/--no-preview",
-    default=False,
-    show_default=True,
-    help="""Include preview versions in the download list.""",
-)
-def flash_board(
-    target_version: str,
-    fw_folder: Path,
-    serial_port: Optional[str] = None,
-    board: Optional[str] = None,
-    port: Optional[str] = None,
-    variant: Optional[str] = None,
-    erase: bool = False,
-    preview: bool = False,
-):
-    todo: WorkList = []
-    target_version = clean_version(target_version)
-    # Update all micropython boards to the latest version
-    if target_version and port and board and serial_port:
-        mcu = MPRemoteBoard(serial_port)
-        mcu.port = port
-        mcu.cpu = port if port.startswith("esp") else ""
-        mcu.board = board
-        firmwares = find_firmware(
-            fw_folder=fw_folder,
-            board=board,
-            version=target_version,
-            port=port,
-            preview=preview or "preview" in target_version,
-        )
-        if not firmwares:
-            log.error(f"No firmware found for {port} {board} version {target_version}")
-            return
-        # use the most recent matching firmware
-        todo = [(mcu, firmwares[-1])]
-    elif serial_port:
-        if serial_port == "auto":
-            # update all connected boards
-            conn_boards = [
-                MPRemoteBoard(sp)
-                for sp in MPRemoteBoard.connected_boards()
-                if sp not in config.ignore_ports
-            ]
-        else:
-            # just this serial port
-            conn_boards = [MPRemoteBoard(serial_port)]
-        show_boards(conn_boards)
-        todo = auto_update(conn_boards, target_version, fw_folder)
-
-    flashed = []
-    for mcu, fw_info in todo:
-        fw_file = fw_folder / fw_info["filename"]  # type: ignore
-        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']}")
-
-        updated = None
-        # try:
-        if mcu.port in ["samd", "rp2"]:
-            updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
-        elif mcu.port in ["esp32", "esp8266"]:
-            updated = flash_esp(mcu, fw_file=fw_file, erase=erase)
-        elif mcu.port in ["stm32"]:
-            updated = flash_stm32(mcu, fw_file=fw_file, erase=erase)
-
-        if updated:
-            flashed.append(updated)
-        else:
-            log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
-
-    if flashed:
-        log.info(f"Flashed {len(flashed)} boards")
-        conn_boards = [
-            MPRemoteBoard(sp)
-            for sp in MPRemoteBoard.connected_boards()
-            if sp not in config.ignore_ports
-        ]
-        show_boards(conn_boards, title="Connected boards after flashing")
-
-
-# TODO:
-# flash from some sort of queue to allow different images to be flashed to the same board
-#  - flash variant 1
-#  - stub variant 1
-#  - flash variant 2
-#  - stub variant 2
-#
-# JIT download / download any missing firmwares based on the detected boards

stubber/bulk/board_id.py

@@ -1,40 +0,0 @@
-"""
-Translate board description to board designator
-"""
-
-from pathlib import Path
-from typing import Optional
-
-###############################################################################################
-# TODO : make this a bit nicer
-HERE = Path(__file__).parent
-###############################################################################################
-
-
-def find_board_designator(descr: str, short_descr: str, board_info: Optional[Path] = None) -> Optional[str]:
-    """
-    Find the miropython BOARD designator based on the description in the firmware
-    using the pre-built board_info.csv file
-    """
-    if not board_info:
-        board_info = HERE / "../data/board_info.csv"
-    if not board_info.exists():
-        raise FileNotFoundError(f"Board info file not found: {board_info}")
-
-    short_hit = ""
-    with open(board_info, "r") as file:
-        while 1:
-            line = file.readline()
-            if not line:
-                break
-            descr_, board_ = line.split(",")[0].strip(), line.split(",")[1].strip()
-            if descr_ == descr:
-                return board_
-            if short_descr and descr_ == short_descr:
-                if "with" in short_descr:
-                    # Good enough - no need to trawl the entire file
-                    # info["board"] = board_
-                    return board_
-                # good enough if not found in the rest of the file (but slow)
-                short_hit = board_
-    return short_hit or None