micropython-stubber 1.24.1__py3-none-any.whl → 1.24.4__py3-none-any.whl

mpflash/mpflash/add_firmware.py

@@ -1,98 +0,0 @@
-import shutil
-from pathlib import Path
-from typing import Union
-
-import jsonlines
-import requests
-from loguru import logger as log
-
-# re-use logic from mpremote
-from mpremote.mip import _rewrite_url as rewrite_url  # type: ignore
-
-from mpflash.common import FWInfo
-from mpflash.config import config
-from mpflash.versions import get_preview_mp_version, get_stable_mp_version
-
-
-def add_firmware(
-    source: Union[Path, str],
-    new_fw: FWInfo,
-    *,
-    force: bool = False,
-    custom: bool = False,
-    description: str = "",
-) -> bool:
-    """Add a firmware to the firmware folder.
-
-    stored in the port folder, with the same filename as the source.
-
-    """
-    # Check minimal info needed
-    if not new_fw.port or not new_fw.board:
-        log.error("Port and board are required")
-        return False
-    if not isinstance(source, Path) and not source.startswith("http"):
-        log.error(f"Invalid source {source}")
-        return False
-
-    # use sensible defaults
-    source_2 = Path(source)
-    new_fw.ext = new_fw.ext or source_2.suffix
-    new_fw.variant = new_fw.variant or new_fw.board
-    new_fw.custom = new_fw.custom or custom
-    new_fw.description = new_fw.description or description
-    if not new_fw.version:
-        # TODO: Get version from filename
-        # or use the last preview version
-        new_fw.version = get_preview_mp_version() if new_fw.preview else get_stable_mp_version()
-
-    config.firmware_folder.mkdir(exist_ok=True)
-
-    fw_filename = config.firmware_folder / new_fw.port / source_2.name
-
-    new_fw.filename = str(fw_filename.relative_to(config.firmware_folder))
-    new_fw.firmware = source.as_uri() if isinstance(source, Path) else source
-
-    if not copy_firmware(source, fw_filename, force):
-        log.error(f"Failed to copy {source} to {fw_filename}")
-        return False
-    # add to inventory
-    with jsonlines.open(config.firmware_folder / "firmware.jsonl", "a") as writer:
-        log.info(f"Adding {new_fw.port} {new_fw.board}")
-        log.info(f"    to {fw_filename}")
-
-        writer.write(new_fw.to_dict())
-    return True
-
-
-def copy_firmware(source: Union[Path, str], fw_filename: Path, force: bool = False):
-    """Add a firmware to the firmware folder.
-    stored in the port folder, with the same filename as the source.
-    """
-    if fw_filename.exists() and not force:
-        log.error(f" {fw_filename} already exists. Use --force to overwrite")
-        return False
-    fw_filename.parent.mkdir(exist_ok=True)
-    if isinstance(source, Path):
-        if not source.exists():
-            log.error(f"File {source} does not exist")
-            return False
-        # file copy
-        log.debug(f"Copy {source} to {fw_filename}")
-        shutil.copy(source, fw_filename)
-        return True
-    # handle github urls
-    url = rewrite_url(source)
-    if str(source).startswith("http://") or str(source).startswith("https://"):
-        log.debug(f"Download {url} to {fw_filename}")
-        response = requests.get(url)
-
-        if response.status_code == 200:
-            with open(fw_filename, "wb") as file:
-                file.write(response.content)
-                log.info("File downloaded and saved successfully.")
-                return True
-        else:
-            print("Failed to download the file.")
-            return False
-    return False

mpflash/mpflash/ask_input.py

@@ -1,236 +0,0 @@
-"""
-Interactive input for mpflash.
-
-Note: The prompts can use "{version}" and "{action}" to insert the version and action in the prompt without needing an f-string.
-The values are provided from the answers dictionary.
-"""
-
-from typing import List, Sequence, Tuple, Union
-
-from loguru import logger as log
-
-from .common import DownloadParams, FlashParams, ParamType
-from .config import config
-from .mpboard_id import (get_known_boards_for_port, get_known_ports,
-                         known_stored_boards)
-from .mpremoteboard import MPRemoteBoard
-from .versions import micropython_versions
-
-
-def ask_missing_params(
-    params: ParamType,
-) -> ParamType:
-    """
-    Asks the user for parameters that have not been supplied on the commandline and returns the updated params.
-
-    Args:
-        params (ParamType): The parameters to be updated.
-
-    Returns:
-        ParamType: The updated parameters.
-    """
-    if not config.interactive:
-        # no interactivity allowed
-        log.info("Interactive mode disabled. Skipping ask for user input.")
-        return params
-
-    import inquirer
-
-    log.trace(f"ask_missing_params: {params}")
-
-    # if action flash,  single input
-    # if action download, multiple input
-    multi_select = isinstance(params, DownloadParams)
-    action = "download" if isinstance(params, DownloadParams) else "flash"
-
-    questions = []
-    answers: dict[str, Union[str, List]] = {"action": action}
-    if not multi_select:
-        if not params.serial or "?" in params.serial:
-            questions.append(ask_serialport(multi_select=False, bluetooth=False))
-        else:
-            answers["serial"] = params.serial
-
-    if params.versions == [] or "?" in params.versions:
-        questions.append(ask_mp_version(multi_select=multi_select, action=action))
-    else:
-        # versions is used to show only the boards for the selected versions
-        answers["versions"] = params.versions  # type: ignore
-
-    if not params.boards or "?" in params.boards:
-        questions.extend(ask_port_board(multi_select=multi_select, action=action))
-    if questions:
-        answers = inquirer.prompt(questions, answers=answers)  # type: ignore
-    if not answers:
-        # input cancelled by user
-        return []  # type: ignore
-    log.trace(f"answers: {answers}")
-    if isinstance(params, FlashParams) and "serial" in answers:
-        if isinstance(answers["serial"], str):
-            answers["serial"] = [answers["serial"]]
-        params.serial = [s.split()[0] for s in answers["serial"]]  # split to remove the description
-    if "port" in answers:
-        #  params.ports = [p for p in params.ports if p != "?"]  # remove the "?" if present
-        if isinstance(answers["port"], str):
-            params.ports.append(answers["port"])
-        elif isinstance(answers["port"], list): # type: ignore
-            params.ports.extend(answers["port"])
-        else:
-            raise ValueError(f"Unexpected type for answers['port']: {type(answers['port'])}")
-        
-    if "boards" in answers:
-        params.boards = [b for b in params.boards if b != "?"]  # remove the "?" if present
-        params.boards.extend(answers["boards"] if isinstance(answers["boards"], list) else [answers["boards"]])
-    if "versions" in answers:
-        params.versions = [v for v in params.versions if v != "?"]  # remove the "?" if present
-        # make sure it is a list
-        if isinstance(answers["versions"], (list, tuple)):
-            params.versions.extend(answers["versions"])
-        else:
-            params.versions.append(answers["versions"])
-    # remove duplicates
-    params.ports = list(set(params.ports))
-    params.boards = list(set(params.boards))
-    params.versions = list(set(params.versions))
-    log.trace(f"ask_missing_params returns: {params}")
-
-    return params
-
-
-def filter_matching_boards(answers: dict) -> Sequence[Tuple[str, str]]:
-    """
-    Filters the known boards based on the selected versions and returns the filtered boards.
-
-    Args:
-        answers (dict): The user's answers.
-
-    Returns:
-        Sequence[Tuple[str, str]]: The filtered boards.
-    """
-    versions = None
-    # if version is not asked ; then need to get the version from the inputs
-    if "versions" in answers:
-        versions = list(answers["versions"])
-        if "stable" in versions:
-            versions.remove("stable")
-            versions.append(micropython_versions()[-2])  # latest stable
-        elif "preview" in versions:
-            versions.remove("preview")
-            versions.extend((micropython_versions()[-1], micropython_versions()[-2]))  # latest preview and stable
-
-    some_boards = known_stored_boards(answers["port"], versions)  #    or known_mp_boards(answers["port"])
-
-    if some_boards:
-        # Create a dictionary where the keys are the second elements of the tuples
-        # This will automatically remove duplicates because dictionaries cannot have duplicate keys
-        unique_dict = {item[1]: item for item in some_boards}
-        # Get the values of the dictionary, which are the unique items from the original list
-        some_boards = list(unique_dict.values())
-    else:
-        some_boards = [(f"No {answers['port']} boards found for version(s) {versions}", "")]
-    return some_boards
-
-
-def ask_port_board(*, multi_select: bool, action: str):
-    """
-    Asks the user for the port and board selection.
-
-    Args:
-        questions (list): The list of questions to be asked.
-        action (str): The action to be performed.
-
-    Returns:
-        None
-    """
-    # import only when needed to reduce load time
-    import inquirer
-
-    # if action flash,  single input
-    # if action download, multiple input
-    inquirer_ux = inquirer.Checkbox if multi_select else inquirer.List
-    return [
-        inquirer.List(
-            "port",
-            message="Which port do you want to {action} " + "to {serial} ?" if action == "flash" else "?",
-            choices=get_known_ports(),
-            # autocomplete=True,
-        ),
-        inquirer_ux(
-            "boards",
-            message=(
-                "Which {port} board firmware do you want to {action} " + "to {serial} ?" if action == "flash" else "?"
-            ),
-            choices=filter_matching_boards,
-            validate=at_least_one_validation,  # type: ignore
-            # validate=lambda _, x: True if x else "Please select at least one board",  # type: ignore
-        ),
-    ]
-
-def at_least_one_validation(answers, current) -> bool:
-    import inquirer.errors
-    if not current:
-        raise inquirer.errors.ValidationError("", reason="Please select at least one item.")
-    if isinstance(current, list) and not any(current):
-        raise inquirer.errors.ValidationError("", reason="Please select at least one item.")
-    return True
-
-def ask_mp_version(multi_select: bool, action: str):
-    """
-    Asks the user for the version selection.
-
-    Args:
-        questions (list): The list of questions to be asked.
-        action (str): The action to be performed.
-
-    Returns:
-
-    """
-    # import only when needed to reduce load time
-    import inquirer
-    import inquirer.errors
-
-    input_ux = inquirer.Checkbox if multi_select else inquirer.List
-
-    mp_versions: List[str] = micropython_versions()
-    mp_versions.reverse()  # newest first
-
-    # remove the versions for which there are no known boards in the board_info.json
-    # todo: this may be a little slow
-    mp_versions = [v for v in mp_versions if "preview" in v or get_known_boards_for_port("stm32", [v])]
-
-    message = "Which version(s) do you want to {action} " + ("to {serial} ?" if action == "flash" else "?")
-    q = input_ux(
-        # inquirer.List(
-        "versions",
-        message=message,
-        # Hints would be nice , but needs a hint for each and every option
-        # hints=["Use space to select multiple options"],
-        choices=mp_versions,
-        autocomplete=True,
-        validate=at_least_one_validation,  # type: ignore
-    )
-    return q
-
-
-def ask_serialport(*, multi_select: bool = False, bluetooth: bool = False):
-    """
-    Asks the user for the serial port selection.
-
-    Args:
-        questions (list): The list of questions to be asked.
-        action (str): The action to be performed.
-
-    Returns:
-        None
-    """
-    # import only when needed to reduce load time
-    import inquirer
-
-    comports = MPRemoteBoard.connected_boards(bluetooth=bluetooth, description=True)
-    return inquirer.List(
-        "serial",
-        message="Which serial port do you want to {action} ?",
-        choices=comports,
-        other=True,
-        validate=lambda _, x: True if x else "Please select or enter a serial port",  # type: ignore
-    )

mpflash/mpflash/basicgit.py

@@ -1,324 +0,0 @@
-"""
-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, BadCredentialsException, Github
-from loguru import logger as log
-from packaging.version import parse
-
-# from mpflash.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_"
-    + "11AAHPVFQ0G4NTaQ73Bw5J"
-    + "_fAp7K9sZ1qL8VFnI9g78eUlCdmOXHB3WzSdj2jtEYb4XF3N7PDJBl32qIxq"
-)
-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)
-
-
-from github.GithubException import BadCredentialsException
-
-
-@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.
-    only the last -preview tag is kept
-    """
-    if not repo or not isinstance(repo, str) or "/" not in repo:  # type: ignore
-        return []
-    try:
-        gh_repo = GH_CLIENT.get_repo(repo)
-    except BadCredentialsException as e:
-        log.error(f"Github authentication error - {e}")
-        return []
-    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)]
-    # remove all but the last preview
-    tags = [t for t in sorted(tags[:-1]) if "-preview" not in t] + sorted(tags)[-1:]
-    return 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: Union[Path, str]) -> 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
-    checkout_arduino_lib(Path(repo))
-    return True
-
-
-def checkout_arduino_lib(mpy_path: Path):
-    """
-    Checkout the arduino-lib submodule repo if it exists
-
-    This is needed as some of the arduino boards freeze modules originationg from the arduino-lib
-    """
-    # arduino_lib_path = mpy_path / "lib/arduino-lib"
-    if (mpy_path / "lib/arduino-lib").exists():
-        cmd = ["git", "submodule", "update", "--init", "lib/arduino-lib"]
-        try:
-            result = subprocess.run(cmd, cwd=mpy_path, check=True)
-            log.info(f"checkout arduino-lib: {result.returncode}")
-        except subprocess.CalledProcessError as e:
-            log.warning("Could not check out arduino-lib, error: ", e)
-
-
-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 and all tags
-    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/mpflash/bootloader/__init__.py

@@ -1,2 +0,0 @@
-from .activate import enter_bootloader  # type: ignore
-from .detect import in_bootloader  # type: ignore