micropython-stubber 1.16.3__py3-none-any.whl → 1.17.0__py3-none-any.whl

stubber/board/createstubs_db_min.py

@@ -1,847 +1,325 @@
-"""
-Create stubs for (all) modules on a MicroPython board.
-
-    This variant of the createstubs.py script is optimized for use on very-low-memory devices.
-    Note: this version has undergone limited testing.
-    
-    1) reads the list of modules from a text file `modulelist.txt` that should be uploaded to the device.
-    2) stored the already processed modules in a text file `modulelist.done` 
-    3) process the modules in the database:
-        - stub the module
-        - update the modulelist.done file
-        - reboots the device if it runs out of memory
-    4) creates the modules.json
-
-    If that cannot be found then only a single module (micropython) is stubbed.
-    In order to run this on low-memory devices two additional steps are recommended: 
-    - minification, using python-minifierto reduce overall size, and remove logging overhead.
-    - cross compilation, using mpy-cross, to avoid the compilation step on the micropython device 
-
-
-This variant was generated from createstubs.py by micropython-stubber v1.16.3
-"""
-# Copyright (c) 2019-2023 Jos Verlinde
-
-import gc
-# import logging
-import os
-import sys
+A2='No report file'
+A1='Failed to create the report.'
+A0='method'
+z='function'
+y='bool'
+x='str'
+w='float'
+v='int'
+u='micropython'
+t='stubber'
+s=TypeError
+r=Exception
+q=KeyError
+p=sorted
+o=MemoryError
+n=NotImplementedError
+j=',\n'
+i='modules.json'
+h='{}/{}'
+g='w'
+f='dict'
+e='list'
+d='tuple'
+c=str
+b=repr
+W='-preview'
+V='-'
+U='board'
+T=IndexError
+S=print
+R=True
+Q='family'
+P=len
+O=ImportError
+N=dir
+M=open
+K='port'
+J='.'
+I=AttributeError
+H=False
+G='/'
+E=None
+D=OSError
+C='version'
+B=''
+import gc as F,os,sys
 from time import sleep
-
-try:
-    from ujson import dumps
-except:
-    from json import dumps
-
-try:
-    from machine import reset  # type: ignore
-except ImportError:
-    pass
-
-try:
-    from collections import OrderedDict
-except ImportError:
-    from ucollections import OrderedDict  # type: ignore
-
-try:
-    from nope_machine import WDT
-
-    wdt = WDT()
-
-except ImportError:
-
-    class _WDT:
-        def feed(self):
-            pass
-
-    wdt = _WDT()
-
-
-wdt.feed()
-
-__version__ = "v1.16.3"
-ENOENT = 2
-_MAX_CLASS_LEVEL = 2  # Max class nesting
-LIBS = [".", "/lib", "/sd/lib", "/flash/lib", "lib"]
-
-
+try:from ujson import dumps
+except:from json import dumps
+try:from machine import reset
+except O:pass
+try:from collections import OrderedDict as k
+except O:from ucollections import OrderedDict as k
+__version__='v1.17.0'
+A3=2
+A4=2
+A5=['lib','/lib','/sd/lib','/flash/lib',J]
+class L:
+	INFO=20;WARNING=30;ERROR=40;level=INFO;prnt=S
+	@staticmethod
+	def getLogger(name):return L()
+	@classmethod
+	def basicConfig(A,level):A.level=level
+	def info(A,msg):
+		if A.level<=L.INFO:A.prnt('INFO  :',msg)
+	def warning(A,msg):
+		if A.level<=L.WARNING:A.prnt('WARN  :',msg)
+	def error(A,msg):
+		if A.level<=L.ERROR:A.prnt('ERROR :',msg)
+A=L.getLogger(t)
+L.basicConfig(level=L.INFO)
 class Stubber:
-    "Generate stubs for modules in firmware"
-
-    def __init__(self, path: str = None, firmware_id: str = None):  # type: ignore
-        try:
-            if os.uname().release == "1.13.0" and os.uname().version < "v1.13-103":  # type: ignore
-                raise NotImplementedError("MicroPython 1.13.0 cannot be stubbed")
-        except AttributeError:
-            pass
-        # self.log = logging.getLogger("stubber")
-        self._report = []  # type: list[str]
-        self.info = _info()
-        # self.log.info("Port: {}".format(self.info["port"]))
-        # self.log.info("Board: {}".format(self.info["board"]))
-        gc.collect()
-        wdt.feed()
-        if firmware_id:
-            self._fwid = firmware_id.lower()
-        else:
-            if self.info["family"] == "micropython":
-                self._fwid = "{family}-v{version}-{port}-{board}".format(**self.info).rstrip("-")
-            else:
-                self._fwid = "{family}-v{version}-{port}".format(**self.info)
-        self._start_free = gc.mem_free()  # type: ignore
-
-        if path:
-            if path.endswith("/"):
-                path = path[:-1]
-        else:
-            path = get_root()
-
-        self.path = "{}/stubs/{}".format(path, self.flat_fwid).replace("//", "/")
-        # self.log.debug(self.path)
-        try:
-            ensure_folder(path + "/")
-        except OSError:
-            print("error creating stub folder {}".format(path))
-        self.problematic = [
-            "upip",
-            "upysh",
-            "webrepl_setup",
-            "http_client",
-            "http_client_ssl",
-            "http_server",
-            "http_server_ssl",
-        ]
-        self.excluded = [
-            "webrepl",
-            "_webrepl",
-            "port_diag",
-            "example_sub_led.py",
-            "example_pub_button.py",
-        ]
-        # there is no option to discover modules from micropython, list is read from an external file.
-        self.modules = []  # type: list[str]
-
-    def get_obj_attributes(self, item_instance: object):
-        "extract information of the objects members and attributes"
-        # name_, repr_(value), type as text, item_instance
-        _result = []
-        _errors = []
-        # self.log.debug("get attributes {} {}".format(repr(item_instance), item_instance))
-        for name in dir(item_instance):
-            if name.startswith("_") and not name in self.modules:
-                continue
-            # self.log.debug("get attribute {}".format(name))
-            try:
-                val = getattr(item_instance, name)
-                # name , item_repr(value) , type as text, item_instance, order
-                # self.log.debug("attribute {}:{}".format(name, val))
-                try:
-                    type_text = repr(type(val)).split("'")[1]
-                except IndexError:
-                    type_text = ""
-                if type_text in {"int", "float", "str", "bool", "tuple", "list", "dict"}:
-                    order = 1
-                elif type_text in {"function", "method"}:
-                    order = 2
-                elif type_text in ("class"):
-                    order = 3
-                else:
-                    order = 4
-                _result.append((name, repr(val), repr(type(val)), val, order))
-            except AttributeError as e:
-                _errors.append("Couldn't get attribute '{}' from object '{}', Err: {}".format(name, item_instance, e))
-            except MemoryError as e:
-                # print("MemoryError: {}".format(e))
-                sleep(1)
-                reset()
-
-        # remove internal __
-        # _result = sorted([i for i in _result if not (i[0].startswith("_"))], key=lambda x: x[4])
-        _result = sorted([i for i in _result if not (i[0].startswith("__"))], key=lambda x: x[4])
-        gc.collect()
-        return _result, _errors
-
-    def add_modules(self, modules):
-        "Add additional modules to be exported"
-        self.modules = sorted(set(self.modules) | set(modules))
-
-    def create_all_stubs(self):
-        "Create stubs for all configured modules"
-        # self.log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
-        gc.collect()
-        for module_name in self.modules:
-            self.create_one_stub(module_name)
-        # self.log.info("Finally done")
-
-    def create_one_stub(self, module_name: str):
-        wdt.feed()
-        if module_name in self.problematic:
-            # self.log.warning("Skip module: {:<25}        : Known problematic".format(module_name))
-            return False
-        if module_name in self.excluded:
-            # self.log.warning("Skip module: {:<25}        : Excluded".format(module_name))
-            return False
-
-        file_name = "{}/{}.py".format(self.path, module_name.replace(".", "/"))
-        gc.collect()
-        result = False
-        try:
-            result = self.create_module_stub(module_name, file_name)
-        except OSError:
-            return False
-        gc.collect()
-        return result
-
-    def create_module_stub(self, module_name: str, file_name: str = None) -> bool:  # type: ignore
-        """Create a Stub of a single python module
-
-        Args:
-        - module_name (str): name of the module to document. This module will be imported.
-        - file_name (Optional[str]): the 'path/filename.py' to write to. If omitted will be created based on the module name.
-        """
-        if file_name is None:
-            fname = module_name.replace(".", "_") + ".py"
-            file_name = self.path + "/" + fname
-        else:
-            fname = file_name.split("/")[-1]
-
-        if "/" in module_name:
-            # for nested modules
-            module_name = module_name.replace("/", ".")
-
-        # import the module (as new_module) to examine it
-        new_module = None
-        try:
-            new_module = __import__(module_name, None, None, ("*"))
-            m1 = gc.mem_free()  # type: ignore
-            # self.log.info("Stub module: {:<25} to file: {:<70} mem:{:>5}".format(module_name, fname, m1))
-
-        except ImportError:
-            # self.log.warning("Skip module: {:<25} {:<79}".format(module_name, "Module not found."))
-            return False
-
-        # Start a new file
-        ensure_folder(file_name)
-        with open(file_name, "w") as fp:
-            # todo: improve header
-            info_ = str(self.info).replace("OrderedDict(", "").replace("})", "}")
-            s = '"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(module_name, self._fwid, info_, __version__)
-            fp.write(s)
-            fp.write("from __future__ import annotations\nfrom typing import Any\nfrom _typeshed import Incomplete\n\n")
-            self.write_object_stub(fp, new_module, module_name, "")
-
-        self._report.append('{{"module": "{}", "file": "{}"}}'.format(module_name, file_name.replace("\\", "/")))
-
-        if module_name not in {"os", "sys", "logging", "gc"}:
-            # try to unload the module unless we use it
-            try:
-                del new_module
-            except (OSError, KeyError):  # lgtm [py/unreachable-statement]
-                pass
-            # lets not try - most times it does not work anyway
-            # try:
-            #     del sys.modules[module_name]
-            # except KeyError:
-            pass
-        gc.collect()
-        return True
-
-    def write_object_stub(self, fp, object_expr: object, obj_name: str, indent: str, in_class: int = 0):
-        "Write a module/object stub to an open file. Can be called recursive."
-        gc.collect()
-        if object_expr in self.problematic:
-            # self.log.warning("SKIPPING problematic module:{}".format(object_expr))
-            return
-
-        # # self.log.debug("DUMP    : {}".format(object_expr))
-        items, errors = self.get_obj_attributes(object_expr)
-
-        if errors:
-            print(errors)
-
-        for item_name, item_repr, item_type_txt, item_instance, _ in items:
-            # name_, repr_(value), type as text, item_instance, order
-            if item_name in ["classmethod", "staticmethod", "BaseException", "Exception"]:
-                # do not create stubs for these primitives
-                continue
-            if item_name[0].isdigit():
-                # self.log.warning("NameError: invalid name {}".format(item_name))
-                continue
-            # Class expansion only on first 3 levels (bit of a hack)
-            if (
-                item_type_txt == "<class 'type'>"
-                and len(indent) <= _MAX_CLASS_LEVEL * 4
-                # and not obj_name.endswith(".Pin")
-                # avoid expansion of Pin.cpu / Pin.board to avoid crashes on most platforms
-            ):
-                # self.log.info("{0}class {1}:".format(indent, item_name))
-                superclass = ""
-                is_exception = (
-                    item_name.endswith("Exception")
-                    or item_name.endswith("Error")
-                    or item_name
-                    in [
-                        "KeyboardInterrupt",
-                        "StopIteration",
-                        "SystemExit",
-                    ]
-                )
-                if is_exception:
-                    superclass = "Exception"
-                s = "\n{}class {}({}):\n".format(indent, item_name, superclass)
-                # s += indent + "    ''\n"
-                if is_exception:
-                    s += indent + "    ...\n"
-                    fp.write(s)
-                    continue
-                # write classdef
-                fp.write(s)
-                # first write the class literals and methods
-                # self.log.debug("# recursion over class {0}".format(item_name))
-                self.write_object_stub(
-                    fp,
-                    item_instance,
-                    "{0}.{1}".format(obj_name, item_name),
-                    indent + "    ",
-                    in_class + 1,
-                )
-                # end with the __init__ method to make sure that the literals are defined
-                # Add __init__
-                s = indent + "    def __init__(self, *argv, **kwargs) -> None:\n"
-                s += indent + "        ...\n\n"
-                fp.write(s)
-            elif any(word in item_type_txt for word in ["method", "function", "closure"]):
-                # self.log.debug("# def {1} function/method/closure, type = '{0}'".format(item_type_txt, item_name))
-                # module Function or class method
-                # will accept any number of params
-                # return type Any/Incomplete
-                ret = "Incomplete"
-                first = ""
-                # Self parameter only on class methods/functions
-                if in_class > 0:
-                    first = "self, "
-                # class method - add function decoration
-                if "bound_method" in item_type_txt or "bound_method" in item_repr:
-                    s = "{}@classmethod\n".format(indent) + "{}def {}(cls, *args, **kwargs) -> {}:\n".format(indent, item_name, ret)
-                else:
-                    s = "{}def {}({}*args, **kwargs) -> {}:\n".format(indent, item_name, first, ret)
-                s += indent + "    ...\n\n"
-                fp.write(s)
-                # self.log.debug("\n" + s)
-            elif item_type_txt == "<class 'module'>":
-                # Skip imported modules
-                # fp.write("# import {}\n".format(item_name))
-                pass
-
-            elif item_type_txt.startswith("<class '"):
-                t = item_type_txt[8:-2]
-                s = ""
-
-                if t in ["str", "int", "float", "bool", "bytearray", "bytes"]:
-                    # known type: use actual value
-                    s = "{0}{1} = {2} # type: {3}\n".format(indent, item_name, item_repr, t)
-                elif t in ["dict", "list", "tuple"]:
-                    # dict, list , tuple: use empty value
-                    ev = {"dict": "{}", "list": "[]", "tuple": "()"}
-                    s = "{0}{1} = {2} # type: {3}\n".format(indent, item_name, ev[t], t)
-                else:
-                    # something else
-                    if t in ["object", "set", "frozenset", "Pin", "FileIO"]:
-                        # https://docs.python.org/3/tutorial/classes.html#item_instance-objects
-                        #  use these types for the attribute
-                        s = "{0}{1} : {2} ## = {4}\n".format(indent, item_name, t, item_type_txt, item_repr)
-                    else:
-                        # Requires Python 3.6 syntax, which is OK for the stubs/pyi
-                        t = "Incomplete"
-                        s = "{0}{1} : {2} ## {3} = {4}\n".format(indent, item_name, t, item_type_txt, item_repr)
-                fp.write(s)
-                # self.log.debug("\n" + s)
-            else:
-                # keep only the name
-                # self.log.debug("# all other, type = '{0}'".format(item_type_txt))
-                fp.write("# all other, type = '{0}'\n".format(item_type_txt))
-
-                fp.write(indent + item_name + " # type: Incomplete\n")
-
-        # del items
-        # del errors
-        # try:
-        #     del item_name, item_repr, item_type_txt, item_instance  # type: ignore
-        # except (OSError, KeyError, NameError):
-        #     pass
-
-    @property
-    def flat_fwid(self):
-        "Turn _fwid from 'v1.2.3' into '1_2_3' to be used in filename"
-        s = self._fwid
-        # path name restrictions
-        chars = " .()/\\:$"
-        for c in chars:
-            s = s.replace(c, "_")
-        return s
-
-    def clean(self, path: str = None):  # type: ignore
-        "Remove all files from the stub folder"
-        wdt.feed()
-        if path is None:
-            path = self.path
-        # self.log.info("Clean/remove files in folder: {}".format(path))
-        try:
-            os.stat(path)  # TEMP workaround mpremote listdir bug -
-            items = os.listdir(path)
-        except (OSError, AttributeError):
-            # os.listdir fails on unix
-            return
-        for fn in items:
-            item = "{}/{}".format(path, fn)
-            try:
-                os.remove(item)
-            except OSError:
-                try:  # folder
-                    self.clean(item)
-                    os.rmdir(item)
-                except OSError:
-                    pass
-
-    def report(self, filename: str = "modules.json"):
-        "create json with list of exported modules"
-        wdt.feed()
-        # self.log.info("Created stubs for {} modules on board {}\nPath: {}".format(len(self._report), self._fwid, self.path))
-        f_name = "{}/{}".format(self.path, filename)
-        # self.log.info("Report file: {}".format(f_name))
-        gc.collect()
-        try:
-            # write json by node to reduce memory requirements
-            with open(f_name, "w") as f:
-                self.write_json_header(f)
-                first = True
-                for n in self._report:
-                    self.write_json_node(f, n, first)
-                    first = False
-                self.write_json_end(f)
-            used = self._start_free - gc.mem_free()  # type: ignore
-            # self.log.info("Memory used: {0} Kb".format(used // 1024))
-        except OSError:
-            print("Failed to create the report.")
-
-    def write_json_header(self, f):
-        f.write("{")
-        f.write(dumps({"firmware": self.info})[1:-1])
-        f.write(",\n")
-        f.write(dumps({"stubber": {"version": __version__}, "stubtype": "firmware"})[1:-1])
-        f.write(",\n")
-        f.write('"modules" :[\n')
-
-    def write_json_node(self, f, n, first):
-        if not first:
-            f.write(",\n")
-        f.write(n)
-
-    def write_json_end(self, f):
-        f.write("\n]}")
-
-
-def ensure_folder(path: str):
-    "Create nested folders if needed"
-    i = start = 0
-    while i != -1:
-        i = path.find("/", start)
-        if i != -1:
-            p = path[0] if i == 0 else path[:i]
-            # p = partial folder
-            try:
-                _ = os.stat(p)
-            except OSError as e:
-                # folder does not exist
-                if e.args[0] == ENOENT:
-                    try:
-                        os.mkdir(p)
-                    except OSError as e2:
-                        print("failed to create folder {}".format(p))
-                        raise e2
-        # next level deep
-        start = i + 1
-
-
-def _build(s):
-    # extract build from sys.version or os.uname().version if available
-    # sys.version: 'MicroPython v1.23.0-preview.6.g3d0b6276f'
-    # sys.implementation.version: 'v1.13-103-gb137d064e'
-    if not s:
-        return ""
-    s = s.split(" on ", 1)[0] if " on " in s else s
-    if s.startswith("v"):
-        if not "-" in s:
-            return ""
-        b = s.split("-")[1]
-        return b
-    if not "-preview" in s:
-        return ""
-    b = s.split("-preview")[1].split(".")[1]
-    return b
-
-
-def _info():  # type:() -> dict[str, str]
-    info = OrderedDict(
-        {
-            "family": sys.implementation.name,
-            "version": "",
-            "build": "",
-            "ver": "",
-            "port": sys.platform,  # port: esp32 / win32 / linux / stm32
-            "board": "UNKNOWN",
-            "cpu": "",
-            "mpy": "",
-            "arch": "",
-        }
-    )
-    # change port names to be consistent with the repo
-    if info["port"].startswith("pyb"):
-        info["port"] = "stm32"
-    elif info["port"] == "win32":
-        info["port"] = "windows"
-    elif info["port"] == "linux":
-        info["port"] = "unix"
-    try:
-        info["version"] = version_str(sys.implementation.version)  # type: ignore
-    except AttributeError:
-        pass
-    try:
-        _machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine  # type: ignore
-        # info["board"] = "with".join(_machine.split("with")[:-1]).strip()
-        info["board"] = _machine
-        info["cpu"] = _machine.split("with")[-1].strip()
-        info["mpy"] = (
-            sys.implementation._mpy
-            if "_mpy" in dir(sys.implementation)
-            else sys.implementation.mpy
-            if "mpy" in dir(sys.implementation)
-            else ""
-        )
-    except (AttributeError, IndexError):
-        pass
-    gc.collect()
-    read_boardname(info)
-    gc.collect()
-
-    try:
-        if "uname" in dir(os):  # old
-            # extract build from uname().version if available
-            info["build"] = _build(os.uname()[3])  # type: ignore
-            if not info["build"]:
-                # extract build from uname().release if available
-                info["build"] = _build(os.uname()[2])  # type: ignore
-        elif "version" in dir(sys):  # new
-            # extract build from sys.version if available
-            info["build"] = _build(sys.version)
-    except (AttributeError, IndexError, TypeError):
-        pass
-    # avoid  build hashes
-    # if info["build"] and len(info["build"]) > 5:
-    #     info["build"] = ""
-
-    if info["version"] == "" and sys.platform not in ("unix", "win32"):
-        try:
-            u = os.uname()  # type: ignore
-            info["version"] = u.release
-        except (IndexError, AttributeError, TypeError):
-            pass
-    # detect families
-    for fam_name, mod_name, mod_thing in [
-        ("pycopy", "pycopy", "const"),
-        ("pycom", "pycom", "FAT"),
-        ("ev3-pybricks", "pybricks.hubs", "EV3Brick"),
-    ]:
-        try:
-            _t = __import__(mod_name, None, None, (mod_thing))
-            info["family"] = fam_name
-            del _t
-            break
-        except (ImportError, KeyError):
-            pass
-
-    if info["family"] == "ev3-pybricks":
-        info["release"] = "2.0.0"
-
-    if info["family"] == "micropython":
-        info["version"]
-        if (
-            info["version"]
-            and info["version"].endswith(".0")
-            and info["version"] >= "1.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
-            and info["version"] <= "1.19.9"
-        ):
-            # versions from 1.10.0 to 1.20.0 do not have a micro .0
-            info["version"] = info["version"][:-2]
-
-    # spell-checker: disable
-    if "mpy" in info and info["mpy"]:  # mpy on some v1.11+ builds
-        sys_mpy = int(info["mpy"])
-        # .mpy architecture
-        arch = [
-            None,
-            "x86",
-            "x64",
-            "armv6",
-            "armv6m",
-            "armv7m",
-            "armv7em",
-            "armv7emsp",
-            "armv7emdp",
-            "xtensa",
-            "xtensawin",
-        ][sys_mpy >> 10]
-        if arch:
-            info["arch"] = arch
-        # .mpy version.minor
-        info["mpy"] = "v{}.{}".format(sys_mpy & 0xFF, sys_mpy >> 8 & 3)
-    if info["build"] and not info["version"].endswith("-preview"):
-        info["version"] = info["version"] + "-preview"
-    # simple to use version[-build] string
-    info["ver"] = f"{info['version']}-{info['build']}" if info["build"] else f"{info['version']}"
-
-    return info
-
-
-def version_str(version: tuple):  #  -> str:
-    v_str = ".".join([str(n) for n in version[:3]])
-    if len(version) > 3 and version[3]:
-        v_str += "-" + version[3]
-    return v_str
-
-
-def read_boardname(info, desc: str = ""):
-    info["board"] = info["board"].replace(" ", "_")
-    found = False
-    for filename in [d + "/board_name.txt" for d in LIBS]:
-        wdt.feed()
-        # # print("look up the board name in the file", filename)
-        if file_exists(filename):
-            with open(filename, "r") as file:
-                data = file.read()
-            if data:
-                info["board"] = data.strip()
-                found = True
-                break
-    if not found:
-        # print("Board not found, guessing board name")
-        descr = ""
-        # descr = desc or info["board"].strip()
-        # if "with " + info["cpu"].upper() in descr:
-        #     # remove the with cpu part
-        #     descr = descr.split("with " + info["cpu"].upper())[0].strip()
-        info["board"] = descr
-
-
-# def read_boardname(info, desc: str = ""):
-#         wdt.feed()
-#         # # print("look up the board name in the file", filename)
-#         if file_exists(filename):
-#             descr = desc or info["board"].strip()
-#             pos = descr.rfind(" with")
-#             if pos != -1:
-#                 short_descr = descr[:pos].strip()
-#             else:
-#                 short_descr = ""
-#             # print("searching info file: {} for: '{}' or '{}'".format(filename, descr, short_descr))
-#             if find_board(info, descr, filename, short_descr):
-#                 found = True
-#                 break
-#     if not found:
-#         # print("Board not found, guessing board name")
-#         descr = desc or info["board"].strip()
-#         if "with " + info["cpu"].upper() in descr:
-#             # remove the with cpu part
-#             descr = descr.split("with " + info["cpu"].upper())[0].strip()
-#         info["board"] = descr
-#     info["board"] = info["board"].replace(" ", "_")
-#     gc.collect()
-
-
-# def find_board(info: dict, descr: str, filename: str, short_descr: str):
-#     "Find the board in the provided board_info.csv file"
-#     short_hit = ""
-#     with open(filename, "r") as file:
-#         # ugly code to make testable in python and micropython
-#         # TODO: This is VERY slow on micropython whith MPREMOTE mount on esp32 (2-3 minutes to read file)
-#         while 1:
-#             line = file.readline()
-#             if not line:
-#                 break
-#             descr_, board_ = line.split(",")[0].strip(), line.split(",")[1].strip()
-#             if descr_ == descr:
-#                 info["board"] = board_
-#                 return True
-#             elif short_descr and descr_ == short_descr:
-#                 if "with" in short_descr:
-#                     # Good enough - no need to trawl the entire file
-#                     info["board"] = board_
-#                     return True
-#                 # good enough if not found in the rest of the file (but slow)
-#                 short_hit = board_
-#     if short_hit:
-#         info["board"] = short_hit
-#         return True
-#     return False
-
-
-def get_root() -> str:  # sourcery skip: use-assigned-variable
-    "Determine the root folder of the device"
-    try:
-        c = os.getcwd()
-    except (OSError, AttributeError):
-        # unix port
-        c = "."
-    r = c
-    for r in [c, "/sd", "/flash", "/", "."]:
-        try:
-            _ = os.stat(r)
-            break
-        except OSError:
-            continue
-    return r
-
-
-def file_exists(filename: str):
-    try:
-        if os.stat(filename)[0] >> 14:
-            return True
-        return False
-    except OSError:
-        return False
-
-
-def show_help():
-    # print("-p, --path   path to store the stubs in, defaults to '.'")
-    sys.exit(1)
-
-
-def read_path() -> str:
-    "get --path from cmdline. [unix/win]"
-    path = ""
-    if len(sys.argv) == 3:
-        cmd = (sys.argv[1]).lower()
-        if cmd in ("--path", "-p"):
-            path = sys.argv[2]
-        else:
-            show_help()
-    elif len(sys.argv) == 2:
-        show_help()
-    return path
-
-
-def is_micropython() -> bool:
-    "runtime test to determine full or micropython"
-    # pylint: disable=unused-variable,eval-used
-    try:
-        # either test should fail on micropython
-        # a) https://docs.micropython.org/en/latest/genrst/syntax.html#spaces
-        # Micropython : SyntaxError
-        # a = eval("1and 0")  # lgtm [py/unused-local-variable]
-        # Eval blocks some minification aspects
-
-        # b) https://docs.micropython.org/en/latest/genrst/builtin_types.html#bytes-with-keywords-not-implemented
-        # Micropython: NotImplementedError
-        b = bytes("abc", encoding="utf8")  # type: ignore # lgtm [py/unused-local-variable]
-
-        # c) https://docs.micropython.org/en/latest/genrst/core_language.html#function-objects-do-not-have-the-module-attribute
-        # Micropython: AttributeError
-        c = is_micropython.__module__  # type: ignore # lgtm [py/unused-local-variable]
-        return False
-    except (NotImplementedError, AttributeError):
-        return True
-
-
+	def __init__(B,path=E,firmware_id=E):
+		C=firmware_id
+		try:
+			if os.uname().release=='1.13.0'and os.uname().version<'v1.13-103':raise n('MicroPython 1.13.0 cannot be stubbed')
+		except I:pass
+		B.info=_info();A.info('Port: {}'.format(B.info[K]));A.info('Board: {}'.format(B.info[U]));F.collect()
+		if C:B._fwid=C.lower()
+		elif B.info[Q]==u:B._fwid='{family}-v{version}-{port}-{board}'.format(**B.info).rstrip(V)
+		else:B._fwid='{family}-v{version}-{port}'.format(**B.info)
+		B._start_free=F.mem_free()
+		if path:
+			if path.endswith(G):path=path[:-1]
+		else:path=get_root()
+		B.path='{}/stubs/{}'.format(path,B.flat_fwid).replace('//',G)
+		try:X(path+G)
+		except D:A.error('error creating stub folder {}'.format(path))
+		B.problematic=['upip','upysh','webrepl_setup','http_client','http_client_ssl','http_server','http_server_ssl'];B.excluded=['webrepl','_webrepl','port_diag','example_sub_led.py','example_pub_button.py'];B.modules=[];B._json_name=E;B._json_first=H
+	def get_obj_attributes(L,item_instance):
+		H=item_instance;C=[];K=[]
+		for A in N(H):
+			if A.startswith('__')and not A in L.modules:continue
+			try:
+				D=getattr(H,A)
+				try:E=b(type(D)).split("'")[1]
+				except T:E=B
+				if E in{v,w,x,y,d,e,f}:G=1
+				elif E in{z,A0}:G=2
+				elif E in'class':G=3
+				else:G=4
+				C.append((A,b(D),b(type(D)),D,G))
+			except I as J:K.append("Couldn't get attribute '{}' from object '{}', Err: {}".format(A,H,J))
+			except o as J:S('MemoryError: {}'.format(J));sleep(1);reset()
+		C=p([A for A in C if not A[0].startswith('__')],key=lambda x:x[4]);F.collect();return C,K
+	def add_modules(A,modules):A.modules=p(set(A.modules)|set(modules))
+	def create_all_stubs(B):
+		A.info('Start micropython-stubber {} on {}'.format(__version__,B._fwid));B.report_start();F.collect()
+		for C in B.modules:B.create_one_stub(C)
+		B.report_end();A.info('Finally done')
+	def create_one_stub(C,module_name):
+		B=module_name
+		if B in C.problematic:A.warning('Skip module: {:<25}        : Known problematic'.format(B));return H
+		if B in C.excluded:A.warning('Skip module: {:<25}        : Excluded'.format(B));return H
+		I='{}/{}.pyi'.format(C.path,B.replace(J,G));F.collect();E=H
+		try:E=C.create_module_stub(B,I)
+		except D:return H
+		F.collect();return E
+	def create_module_stub(K,module_name,file_name=E):
+		I=file_name;C=module_name
+		if I is E:L=C.replace(J,'_')+'.pyi';I=K.path+G+L
+		else:L=I.split(G)[-1]
+		if G in C:C=C.replace(G,J)
+		N=E
+		try:N=__import__(C,E,E,'*');Q=F.mem_free();A.info('Stub module: {:<25} to file: {:<70} mem:{:>5}'.format(C,L,Q))
+		except O:return H
+		X(I)
+		with M(I,g)as P:S=c(K.info).replace('OrderedDict(',B).replace('})','}');T='"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(C,K._fwid,S,__version__);P.write(T);P.write('from __future__ import annotations\nfrom typing import Any, Generator\nfrom _typeshed import Incomplete\n\n');K.write_object_stub(P,N,C,B)
+		K.report_add(C,I)
+		if C not in{'os','sys','logging','gc'}:
+			try:del N
+			except(D,q):A.warning('could not del new_module')
+		F.collect();return R
+	def write_object_stub(K,fp,object_expr,obj_name,indent,in_class=0):
+		X='generator';W='{0}{1}: {3} = {2}\n';V='bound_method';U='Incomplete';N=in_class;M='Exception';L=object_expr;I=fp;D=indent;F.collect()
+		if L in K.problematic:A.warning('SKIPPING problematic module:{}'.format(L));return
+		Y,O=K.get_obj_attributes(L)
+		if O:A.error(O)
+		for(E,J,H,Z,b)in Y:
+			if E in['classmethod','staticmethod','BaseException',M]:continue
+			if E[0].isdigit():A.warning('NameError: invalid name {}'.format(E));continue
+			if H=="<class 'type'>"and P(D)<=A4*4:
+				Q=B;R=E.endswith(M)or E.endswith('Error')or E in['KeyboardInterrupt','StopIteration','SystemExit']
+				if R:Q=M
+				C='\n{}class {}({}):\n'.format(D,E,Q)
+				if R:C+=D+'    ...\n';I.write(C);continue
+				I.write(C);K.write_object_stub(I,Z,'{0}.{1}'.format(obj_name,E),D+'    ',N+1);C=D+'    def __init__(self, *argv, **kwargs) -> None:\n';C+=D+'        ...\n\n';I.write(C)
+			elif any(A in H for A in[A0,z,'closure']):
+				S=U;T=B
+				if N>0:T='self, '
+				if V in H or V in J:C='{}@classmethod\n'.format(D)+'{}def {}(cls, *args, **kwargs) -> {}:\n'.format(D,E,S)
+				else:C='{}def {}({}*args, **kwargs) -> {}:\n'.format(D,E,T,S)
+				C+=D+'    ...\n\n';I.write(C)
+			elif H=="<class 'module'>":0
+			elif H.startswith("<class '"):
+				G=H[8:-2];C=B
+				if G in(x,v,w,y,'bytearray','bytes'):C=W.format(D,E,J,G)
+				elif G in(f,e,d):a={f:'{}',e:'[]',d:'()'};C=W.format(D,E,a[G],G)
+				elif G in('object','set','frozenset','Pin',X):
+					if G==X:G='Generator'
+					C='{0}{1}: {2} ## = {4}\n'.format(D,E,G,H,J)
+				else:G=U;C='{0}{1}: {2} ## {3} = {4}\n'.format(D,E,G,H,J)
+				I.write(C)
+			else:I.write("# all other, type = '{0}'\n".format(H));I.write(D+E+' # type: Incomplete\n')
+	@property
+	def flat_fwid(self):
+		A=self._fwid;B=' .()/\\:$'
+		for C in B:A=A.replace(C,'_')
+		return A
+	def clean(C,path=E):
+		if path is E:path=C.path
+		A.info('Clean/remove files in folder: {}'.format(path))
+		try:os.stat(path);F=os.listdir(path)
+		except(D,I):return
+		for G in F:
+			B=h.format(path,G)
+			try:os.remove(B)
+			except D:
+				try:C.clean(B);os.rmdir(B)
+				except D:pass
+	def report_start(B,filename=i):
+		H='firmware';B._json_name=h.format(B.path,filename);B._json_first=R;X(B._json_name);A.info('Report file: {}'.format(B._json_name));F.collect()
+		try:
+			with M(B._json_name,g)as G:G.write('{');G.write(dumps({H:B.info})[1:-1]);G.write(j);G.write(dumps({t:{C:__version__},'stubtype':H})[1:-1]);G.write(j);G.write('"modules" :[\n')
+		except D as I:A.error(A1);B._json_name=E;raise I
+	def report_add(B,module_name,stub_file):
+		if not B._json_name:raise r(A2)
+		try:
+			with M(B._json_name,'a')as C:
+				if not B._json_first:C.write(j)
+				else:B._json_first=H
+				E='{{"module": "{}", "file": "{}"}}'.format(module_name,stub_file.replace('\\',G));C.write(E)
+		except D:A.error(A1)
+	def report_end(B):
+		if not B._json_name:raise r(A2)
+		with M(B._json_name,'a')as C:C.write('\n]}')
+		A.info('Path: {}'.format(B.path))
+def X(path):
+	B=E=0
+	while B!=-1:
+		B=path.find(G,E)
+		if B!=-1:
+			C=path[0]if B==0 else path[:B]
+			try:I=os.stat(C)
+			except D as F:
+				if F.args[0]==A3:
+					try:os.mkdir(C)
+					except D as H:A.error('failed to create folder {}'.format(C));raise H
+		E=B+1
+def Y(s):
+	C=' on '
+	if not s:return B
+	s=s.split(C,1)[0]if C in s else s
+	if s.startswith('v'):
+		if not V in s:return B
+		A=s.split(V)[1];return A
+	if not W in s:return B
+	A=s.split(W)[1].split(J)[1];return A
+def _info():
+	Z='ev3-pybricks';X='pycom';V='pycopy';S='unix';R='win32';P='arch';M='cpu';L='ver';F='mpy';D='build';A=k({Q:sys.implementation.name,C:B,D:B,L:B,K:sys.platform,U:'UNKNOWN',M:B,F:B,P:B})
+	if A[K].startswith('pyb'):A[K]='stm32'
+	elif A[K]==R:A[K]='windows'
+	elif A[K]=='linux':A[K]=S
+	try:A[C]=A6(sys.implementation.version)
+	except I:pass
+	try:H=sys.implementation._machine if'_machine'in N(sys.implementation)else os.uname().machine;A[U]=H;A[M]=H.split('with')[-1].strip();A[F]=sys.implementation._mpy if'_mpy'in N(sys.implementation)else sys.implementation.mpy if F in N(sys.implementation)else B
+	except(I,T):pass
+	A[U]=A7()
+	try:
+		if'uname'in N(os):
+			A[D]=Y(os.uname()[3])
+			if not A[D]:A[D]=Y(os.uname()[2])
+		elif C in N(sys):A[D]=Y(sys.version)
+	except(I,T,s):pass
+	if A[C]==B and sys.platform not in(S,R):
+		try:a=os.uname();A[C]=a.release
+		except(T,I,s):pass
+	for(b,c,d)in[(V,V,'const'),(X,X,'FAT'),(Z,'pybricks.hubs','EV3Brick')]:
+		try:e=__import__(c,E,E,d);A[Q]=b;del e;break
+		except(O,q):pass
+	if A[Q]==Z:A['release']='2.0.0'
+	if A[Q]==u:
+		A[C]
+		if A[C]and A[C].endswith('.0')and A[C]>='1.10.0'and A[C]<='1.19.9':A[C]=A[C][:-2]
+	if F in A and A[F]:
+		G=int(A[F]);J=[E,'x86','x64','armv6','armv6m','armv7m','armv7em','armv7emsp','armv7emdp','xtensa','xtensawin'][G>>10]
+		if J:A[P]=J
+		A[F]='v{}.{}'.format(G&255,G>>8&3)
+	if A[D]and not A[C].endswith(W):A[C]=A[C]+W
+	A[L]=f"{A[C]}-{A[D]}"if A[D]else f"{A[C]}";return A
+def A6(version):
+	A=version;B=J.join([c(A)for A in A[:3]])
+	if P(A)>3 and A[3]:B+=V+A[3]
+	return B
+def A7():
+	try:from boardname import BOARDNAME as C;A.info('Found BOARDNAME: {}'.format(C))
+	except O:A.warning('BOARDNAME not found');C=B
+	return C
+def get_root():
+	try:A=os.getcwd()
+	except(D,I):A=J
+	B=A
+	for B in[A,'/sd','/flash',G,J]:
+		try:C=os.stat(B);break
+		except D:continue
+	return B
+def Z(filename):
+	try:
+		if os.stat(filename)[0]>>14:return R
+		return H
+	except D:return H
+def l():S("-p, --path   path to store the stubs in, defaults to '.'");sys.exit(1)
+def read_path():
+	path=B
+	if P(sys.argv)==3:
+		A=sys.argv[1].lower()
+		if A in('--path','-p'):path=sys.argv[2]
+		else:l()
+	elif P(sys.argv)==2:l()
+	return path
+def m():
+	try:A=bytes('abc',encoding='utf8');B=m.__module__;return H
+	except(n,I):return R
+a='modulelist.done'
+def A8(skip=0):
+	for E in A5:
+		B=E+'/modulelist.txt'
+		if not Z(B):continue
+		try:
+			with M(B)as F:
+				C=0
+				while R:
+					A=F.readline().strip()
+					if not A:break
+					if P(A)>0 and A[0]=='#':continue
+					C+=1
+					if C<skip:continue
+					yield A
+				break
+		except D:pass
+def A9(done):
+	with M(a,g)as A:A.write(c(done)+'\n')
+def AA():
+	A=0
+	try:
+		with M(a)as B:A=int(B.readline().strip())
+	except D:pass
+	return A
 def main():
-    import machine  # type: ignore
-
-    try:
-        f = open("modulelist.done", "r+b")
-        was_running = True
-        # print("Opened existing db")
-    except OSError:
-        f = open("modulelist.done", "w+b")
-        # print("created new db")
-        was_running = False
-    stubber = Stubber(path=read_path())
-
-    # f_name = "{}/{}".format(stubber.path, "modules.json")
-    if not was_running:
-        # Only clean folder if this is a first run
-        stubber.clean()
-    # get list of modules to process
-    get_modulelist(stubber)
-    # remove the ones that are already done
-    modules_done = {}  # type: dict[str, str]
-    try:
-        with open("modulelist.done") as f:
-            # not optimal , but works on mpremote and esp8266
-            for line in f.read().split("\n"):
-                line = line.strip()
-                gc.collect()
-                if len(line) > 0:
-                    key, value = line.split("=", 1)
-                    modules_done[key] = value
-    except (OSError, SyntaxError):
-        pass
-    gc.collect()
-    # see if we can continue from where we left off
-    modules = [m for m in stubber.modules if m not in modules_done.keys()]
-    gc.collect()
-    for modulename in modules:
-        # ------------------------------------
-        # do epic shit
-        # but sometimes things fail / run out of memory and reboot
-        ok = False
-        try:
-            ok = stubber.create_one_stub(modulename)
-        except MemoryError:
-            # RESET AND HOPE THAT IN THE NEXT CYCLE WE PROGRESS FURTHER
-            machine.reset()
-        # -------------------------------------
-        gc.collect()
-        modules_done[modulename] = str(stubber._report[-1] if ok else "failed")
-        with open("modulelist.done", "a") as f:
-            f.write("{}={}\n".format(modulename, "ok" if ok else "failed"))
-
-    # Finished processing - load all the results , and remove the failed ones
-    if modules_done:
-        # stubber.write_json_end(mod_fp)
-        stubber._report = [v for _, v in modules_done.items() if v != "failed"]
-        stubber.report()
-
-
-def get_modulelist(stubber):
-    stubber.modules = []  # avoid duplicates
-    for p in LIBS:
-        try:
-            with open(p + "/modulelist.txt") as f:
-                print ("DEBUG: list of modules: " + p + "/modulelist.txt")
-                for line in f.read().split("\n"):
-                    line = line.strip()
-                    if len(line) > 0 and line[0] != "#":
-                        stubber.modules.append(line)
-                gc.collect()
-                break
-        except OSError:
-            pass
-    if not stubber.modules:
-        stubber.modules = ["micropython"]
-        _log.warn("Could not find modulelist.txt, using default modules")
-    gc.collect()
-
-
-if __name__ == "__main__" or is_micropython():
-    try:
-        log = logging.getLogger("stubber")
-        logging.basicConfig(level=logging.INFO)
-        # logging.basicConfig(level=logging.DEBUG)
-    except NameError:
-        pass
-    if not file_exists("no_auto_stubber.txt"):
-        try:
-            gc.threshold(4 * 1024)  # type: ignore
-            gc.enable()
-        except BaseException:
-            pass
-        main()
+	import machine as D;C=Z(a)
+	if C:A.info('Continue from last run')
+	else:A.info('Starting new run')
+	stubber=Stubber(path=read_path());B=0
+	if not C:stubber.clean();stubber.report_start(i)
+	else:B=AA();stubber._json_name=h.format(stubber.path,i)
+	for E in A8(B):
+		try:stubber.create_one_stub(E)
+		except o:D.reset()
+		F.collect();B+=1;A9(B)
+	S('All modules have been processed, Finalizing report');stubber.report_end()
+if __name__=='__main__'or m():
+	if not Z('no_auto_stubber.txt'):
+		try:F.threshold(4*1024);F.enable()
+		except BaseException:pass
+		main()