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

mpflash/mpflash/vendor/board_database.py

@@ -1,185 +0,0 @@
-"""
-The micropython git repo contains many 'board.json' files.
-
-This is an example:
-ports/stm32/boards/PYBV11/board.json
-
-{
-    "deploy": [
-        "../PYBV10/deploy.md"
-    ],
-    "docs": "",
-    "features": [],
-    "images": [
-        "PYBv1_1.jpg",
-        "PYBv1_1-C.jpg",
-        "PYBv1_1-E.jpg"
-    ],
-    "mcu": "stm32f4",
-    "product": "Pyboard v1.1",
-    "thumbnail": "",
-    "url": "https://store.micropython.org/product/PYBv1.1",
-    "variants": {
-        "DP": "Double-precision float",
-        "DP_THREAD": "Double precision float + Threads",
-        "NETWORK": "Wiznet 5200 Driver",
-        "THREAD": "Threading"
-    },
-    "vendor": "George Robotics"
-}
-
-This module implements `class Database` which reads all 'board.json' files and
-provides a way to browse it's data.
-"""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-from glob import glob
-from pathlib import Path
-
-
-@dataclass(order=True)
-class Variant:
-    name: str
-    """
-    Example: "DP_THREAD"
-    """
-    text: str
-    """
-    Example: "Double precision float + Threads"
-    """
-    board: Board = field(repr=False)
-
-
-@dataclass(order=True)
-class Board:
-    name: str
-    """
-    Example: "PYBV11"
-    """
-    variants: list[Variant]
-    """
-    List of variants available for this board.
-    Variants are sorted. May be an empty list if no variants are available.
-    Example key: "DP_THREAD"
-    """
-    url: str
-    """
-    Primary URL to link to this board.
-    """
-    mcu: str
-    """
-    Example: "stm32f4"
-    """
-    product: str
-    """
-    Example: "Pyboard v1.1"
-    """
-    vendor: str
-    """
-    Example: "George Robotics"
-    """
-    images: list[str]
-    """
-    Images of this board, stored in the micropython-media repository.
-    Example: ["PYBv1_1.jpg", "PYBv1_1-C.jpg", "PYBv1_1-E.jpg"]
-    """
-    deploy: list[str]
-    """
-    Files that explain how to deploy for this board:
-    Example: ["../PYBV10/deploy.md"]
-    """
-    port: Port | None = field(default=None, compare=False)
-
-    @staticmethod
-    def factory(filename_json: Path) -> Board:
-        with filename_json.open() as f:
-            board_json = json.load(f)
-
-        board = Board(
-            name=filename_json.parent.name,
-            variants=[],
-            url=board_json["url"],
-            mcu=board_json["mcu"],
-            product=board_json["product"],
-            vendor=board_json["vendor"],
-            images=board_json["images"],
-            deploy=board_json["deploy"],
-        )
-        board.variants.extend(
-            sorted([Variant(*v, board) for v in board_json.get("variants", {}).items()])  # type: ignore
-        )
-        return board
-
-
-@dataclass(order=True)
-class Port:
-    name: str
-    """
-    Example: "stm32"
-    """
-    boards: dict[str, Board] = field(default_factory=dict, repr=False)
-    """
-    Example key: "PYBV11"
-    """
-
-
-@dataclass
-class Database:
-    """
-    This database contains all information retrieved from all 'board.json' files.
-    """
-
-    mpy_root_directory: Path = field(repr=False)
-    port_filter: str = field(default="", repr=False)
-
-    ports: dict[str, Port] = field(default_factory=dict)
-    boards: dict[str, Board] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        mpy_dir = self.mpy_root_directory
-        # Take care to avoid using Path.glob! Performance was 15x slower.
-        for p in glob(f"{mpy_dir}/ports/**/boards/**/board.json"):
-            filename_json = Path(p)
-            port_name = filename_json.parent.parent.parent.name
-            if self.port_filter and self.port_filter != port_name:
-                continue
-
-            # Create a port
-            port = self.ports.get(port_name, None)
-            if port is None:
-                port = Port(port_name)
-                self.ports[port_name] = port
-
-            # Load board.json and attach it to the board
-            board = Board.factory(filename_json)
-            board.port = port
-
-            port.boards[board.name] = board
-            self.boards[board.name] = board
-
-        # Add 'special' ports, that don't have boards
-        # TODO(mst) Tidy up later (variant descriptions etc)
-        for special_port_name in ["unix", "webassembly", "windows"]:
-            if self.port_filter and self.port_filter != special_port_name:
-                continue
-            path = Path(mpy_dir, "ports", special_port_name)
-            variant_names = [var.name for var in path.glob("variants/*") if var.is_dir()]
-            board = Board(
-                special_port_name,
-                [],
-                f"https://github.com/micropython/micropython/blob/master/ports/{special_port_name}/README.md",
-                "",
-                "",
-                "",
-                [],
-                [],
-            )
-            board.variants = [Variant(v, "", board) for v in variant_names]
-            port = Port(special_port_name, {special_port_name: board})
-            board.port = port
-
-            self.ports[special_port_name] = port
-            self.boards[board.name] = board

mpflash/mpflash/vendor/click_aliases.py

@@ -1,91 +0,0 @@
-# Copyright (c) 2016 Robbin Bonthond
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-# ------------------------------------------------------------------------------------
-# modified to avoid conflcts with rich_click
-
-# sourcery skip: assign-if-exp, use-named-expression
-
-import rich_click as click
-
-_click7 = click.__version__[0] >= "7"
-
-
-class ClickAliasedGroup(click.RichGroup):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._commands = {}
-        self._aliases = {}
-
-    def add_command(self, *args, **kwargs):
-        aliases = kwargs.pop("aliases", [])
-        super().add_command(*args, **kwargs)
-        if aliases:
-            cmd = args[0]
-            name = args[1] if len(args) > 1 else None
-            name = name or cmd.name
-            if name is None:
-                raise TypeError("Command has no name.")
-
-            self._commands[name] = aliases
-            for alias in aliases:
-                self._aliases[alias] = cmd.name
-
-    def command(self, *args, **kwargs):
-        aliases = kwargs.pop("aliases", [])
-        decorator = super().command(*args, **kwargs)
-        if not aliases:
-            return decorator
-
-        def _decorator(f):
-            cmd = decorator(f)
-            if aliases:
-                self._commands[cmd.name] = aliases
-                for alias in aliases:
-                    self._aliases[alias] = cmd.name
-            return cmd
-
-        return _decorator
-
-    def group(self, *args, **kwargs):
-        aliases = kwargs.pop("aliases", [])
-        decorator = super().group(*args, **kwargs)
-        if not aliases:
-            return decorator
-
-        def _decorator(f):
-            cmd = decorator(f)
-            if aliases:
-                self._commands[cmd.name] = aliases
-                for alias in aliases:
-                    self._aliases[alias] = cmd.name
-            return cmd
-
-        return _decorator
-
-    def resolve_alias(self, cmd_name):
-        if cmd_name in self._aliases:
-            return self._aliases[cmd_name]
-        return cmd_name
-
-    def get_command(self, ctx, cmd_name):
-        cmd_name = self.resolve_alias(cmd_name)
-        command = super().get_command(ctx, cmd_name)
-        if command:
-            return command
-        return None
-
-    # def format_commands(self, ctx, formatter):
-    # TODO: output alias with commands - but that is a significant re-write
-    # for now add alias to help text
-
-
-# ------------------------------------------------------------------------------------

mpflash/mpflash/vendor/dfu.py

@@ -1,165 +0,0 @@
-# sourcery skip: require-parameter-annotation
-# sourcery skip: replace-interpolation-with-fstring
-# type: ignore
-#!/usr/bin/python
-
-# Written by Antonio Galea - 2010/11/18
-# Distributed under Gnu LGPL 3.0
-# see http://www.gnu.org/licenses/lgpl-3.0.txt
-
-import os
-import struct
-import sys
-import zlib
-from optparse import OptionParser
-
-DEFAULT_DEVICE = "0x0483:0xdf11"
-
-
-def named(tuple, names):
-    return dict(zip(names.split(), tuple))
-
-
-def consume(fmt, data, names):
-    n = struct.calcsize(fmt)
-    return named(struct.unpack(fmt, data[:n]), names), data[n:]
-
-
-def cstring(string):
-    return string.split(b"\0", 1)[0]
-
-
-def compute_crc(data):
-    return 0xFFFFFFFF & -zlib.crc32(data) - 1
-
-
-def parse(file, dump_images=False):
-    print('File: "%s"' % file)
-    data = open(file, "rb").read()
-    crc = compute_crc(data[:-4])
-    prefix, data = consume("<5sBIB", data, "signature version size targets")
-    print("%(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d" % prefix)
-    for t in range(prefix["targets"]):
-        tprefix, data = consume("<6sBI255s2I", data, "signature altsetting named name size elements")
-        tprefix["num"] = t
-        if tprefix["named"]:
-            tprefix["name"] = cstring(tprefix["name"])
-        else:
-            tprefix["name"] = ""
-        print(
-            '%(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d'
-            % tprefix
-        )
-        tsize = tprefix["size"]
-        target, data = data[:tsize], data[tsize:]
-        for e in range(tprefix["elements"]):
-            eprefix, target = consume("<2I", target, "address size")
-            eprefix["num"] = e
-            print("  %(num)d, address: 0x%(address)08x, size: %(size)d" % eprefix)
-            esize = eprefix["size"]
-            image, target = target[:esize], target[esize:]
-            if dump_images:
-                out = "%s.target%d.image%d.bin" % (file, t, e)
-                open(out, "wb").write(image)
-                print('    DUMPED IMAGE TO "%s"' % out)
-        if len(target):
-            print("target %d: PARSE ERROR" % t)
-    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"
-        % suffix
-    )
-    if crc != suffix["crc"]:
-        print("CRC ERROR: computed crc32 is 0x%08x" % crc)
-    data = data[16:]
-    if data:
-        print("PARSE ERROR")
-
-
-def build(file, targets, device=DEFAULT_DEVICE):
-    data = b""
-    for _, target in enumerate(targets):
-        tdata = b""
-        for image in target:
-            # pad image to 8 bytes (needed at least for L476)
-            pad = (8 - len(image["data"]) % 8) % 8
-            image["data"] = image["data"] + bytes(bytearray(8)[0:pad])
-            #
-            tdata += struct.pack("<2I", image["address"], len(image["data"])) + image["data"]
-        tdata = struct.pack("<6sBI255s2I", b"Target", 0, 1, b"ST...", len(tdata), len(target)) + tdata
-        data += tdata
-    data = struct.pack("<5sBIB", b"DfuSe", 1, len(data) + 11, len(targets)) + data
-    v, d = map(lambda x: int(x, 0) & 0xFFFF, device.split(":", 1))
-    data += struct.pack("<4H3sB", 0, d, v, 0x011A, b"UFD", 16)
-    crc = compute_crc(data)
-    data += struct.pack("<I", crc)
-    open(file, "wb").write(data)
-
-
-if __name__ == "__main__":
-    usage = """
-%prog [-d|--dump] infile.dfu
-%prog {-b|--build} address:file.bin [-b address:file.bin ...] [{-D|--device}=vendor:device] outfile.dfu"""
-    parser = OptionParser(usage=usage)
-    parser.add_option(
-        "-b",
-        "--build",
-        action="append",
-        dest="binfiles",
-        help="build a DFU file from given BINFILES",
-        metavar="BINFILES",
-    )
-    parser.add_option(
-        "-D",
-        "--device",
-        action="store",
-        dest="device",
-        help="build for DEVICE, defaults to %s" % DEFAULT_DEVICE,
-        metavar="DEVICE",
-    )
-    parser.add_option(
-        "-d",
-        "--dump",
-        action="store_true",
-        dest="dump_images",
-        default=False,
-        help="dump contained images to current directory",
-    )
-    (options, args) = parser.parse_args()
-
-    if options.binfiles and len(args) == 1:
-        target = []
-        for arg in options.binfiles:
-            try:
-                address, binfile = arg.split(":", 1)
-            except ValueError:
-                print("Address:file couple '%s' invalid." % arg)
-                sys.exit(1)
-            try:
-                address = int(address, 0) & 0xFFFFFFFF
-            except ValueError:
-                print("Address %s invalid." % address)
-                sys.exit(1)
-            if not os.path.isfile(binfile):
-                print("Unreadable file '%s'." % binfile)
-                sys.exit(1)
-            target.append({"address": address, "data": open(binfile, "rb").read()})
-        outfile = args[0]
-        device = DEFAULT_DEVICE
-        if options.device:
-            device = options.device
-        try:
-            v, d = map(lambda x: int(x, 0) & 0xFFFF, device.split(":", 1))
-        except:
-            print("Invalid device '%s'." % device)
-            sys.exit(1)
-        build(outfile, [target], device)
-    elif len(args) == 1:
-        infile = args[0]
-        if not os.path.isfile(infile):
-            print("Unreadable file '%s'." % infile)
-            sys.exit(1)
-        parse(infile, dump_images=options.dump_images)
-    else:
-        parser.print_help()
-        sys.exit(1)