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

stubber/board/createstubs_min.py

@@ -1,1011 +1,288 @@
-"""
-Create stubs for (all) modules on a MicroPython board
-"""
-# Copyright (c) 2019-2023 Jos Verlinde
-
-import gc
-# import logging
-import os
-import sys
+z='No report file'
+y='Failed to create the report.'
+x='{}/{}'
+w='logging'
+v='sys'
+u='method'
+t='function'
+s='bool'
+r='str'
+q='float'
+p='int'
+o='stubber'
+n=TypeError
+m=Exception
+l=KeyError
+k=sorted
+j=NotImplementedError
+f='pycom'
+e=',\n'
+d='dict'
+c='list'
+b='tuple'
+a='micropython'
+Z=repr
+Y=print
+V='-preview'
+U=True
+T='-'
+S='board'
+R=len
+Q=open
+P=IndexError
+O='family'
+N=ImportError
+M=dir
+K='port'
+J='.'
+I=AttributeError
+H=False
+G='/'
+E=OSError
+D=None
+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 N:pass
+try:from collections import OrderedDict as g
+except N:from ucollections import OrderedDict as g
+__version__='v1.17.0'
+A0=2
+A1=2
+A5=['lib','/lib','/sd/lib','/flash/lib',J]
+class L:
+	INFO=20;WARNING=30;ERROR=40;level=INFO;prnt=Y
+	@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(o)
+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 main():
-    stubber = Stubber(path=read_path())
-    # stubber = Stubber(path="/sd")
-    # Option: Specify a firmware name & version
-    # stubber = Stubber(firmware_id='HoverBot v1.2.1')
-    stubber.clean()
-    # there is no option to discover modules from micropython, need to hardcode
-    # below contains combined modules from  Micropython ESP8622, ESP32, Loboris, Pycom and ulab , lvgl
-    # spell-checker: disable
-    # modules to stub : 131
-    stubber.modules = [
-        "WM8960",
-        "_OTA",
-        "_asyncio",
-        "_boot_fat",
-        "_coap",
-        "_espnow",
-        "_flash_control_OTA",
-        "_main_pybytes",
-        "_mqtt",
-        "_mqtt_core",
-        "_msg_handl",
-        "_onewire",
-        "_periodical_pin",
-        "_pybytes",
-        "_pybytes_ca",
-        "_pybytes_config",
-        "_pybytes_config_reader",
-        "_pybytes_connection",
-        "_pybytes_constants",
-        "_pybytes_debug",
-        "_pybytes_library",
-        "_pybytes_machine_learning",
-        "_pybytes_main",
-        "_pybytes_protocol",
-        "_pybytes_pyconfig",
-        "_pybytes_pymesh_config",
-        "_rp2",
-        "_terminal",
-        "_thread",
-        "_uasyncio",
-        "_urequest",
-        "adcfft",
-        "aioble/__init__",
-        "aioble/central",
-        "aioble/client",
-        "aioble/core",
-        "aioble/device",
-        "aioble/l2cap",
-        "aioble/peripheral",
-        "aioble/security",
-        "aioble/server",
-        "aioespnow",
-        "ak8963",
-        "apa102",
-        "apa106",
-        "argparse",
-        "array",
-        "asyncio/__init__",
-        "asyncio/core",
-        "asyncio/event",
-        "asyncio/funcs",
-        "asyncio/lock",
-        "asyncio/stream",
-        "binascii",
-        "bluetooth",
-        "breakout_as7262",
-        "breakout_bh1745",
-        "breakout_bme280",
-        "breakout_bme68x",
-        "breakout_bmp280",
-        "breakout_dotmatrix",
-        "breakout_encoder",
-        "breakout_icp10125",
-        "breakout_ioexpander",
-        "breakout_ltr559",
-        "breakout_matrix11x7",
-        "breakout_mics6814",
-        "breakout_msa301",
-        "breakout_paa5100",
-        "breakout_pmw3901",
-        "breakout_potentiometer",
-        "breakout_rgbmatrix5x5",
-        "breakout_rtc",
-        "breakout_scd41",
-        "breakout_sgp30",
-        "breakout_trackball",
-        "breakout_vl53l5cx",
-        "btree",
-        "cmath",
-        "collections",
-        "crypto",
-        "cryptolib",
-        "curl",
-        "deflate",
-        "dht",
-        "display",
-        "display_driver_utils",
-        "ds18x20",
-        "encoder",
-        "errno",
-        "esp",
-        "esp32",
-        "espidf",
-        "espnow",
-        "ffi",
-        "flashbdev",
-        "framebuf",
-        "freesans20",
-        "fs_driver",
-        "functools",
-        "galactic",
-        "gc",
-        "gfx_pack",
-        "gsm",
-        "hashlib",
-        "heapq",
-        "hub75",
-        "ili9341",
-        "ili9XXX",
-        "imagetools",
-        "inisetup",
-        "interstate75",
-        "io",
-        "jpegdec",
-        "json",
-        "lcd160cr",
-        "lodepng",
-        "logging",
-        "lsm6dsox",
-        "lv_colors",
-        "lv_utils",
-        "lvgl",
-        "lwip",
-        "machine",
-        "math",
-        "microWebSocket",
-        "microWebSrv",
-        "microWebTemplate",
-        "micropython",
-        "mip",
-        "mip/__init__",
-        "mip/__main__",
-        "motor",
-        "mpu6500",
-        "mpu9250",
-        "neopixel",
-        "network",
-        "ntptime",
-        "onewire",
-        "os",
-        "pcf85063a",
-        "picoexplorer",
-        "picographics",
-        "picokeypad",
-        "picoscroll",
-        "picounicorn",
-        "picowireless",
-        "pimoroni",
-        "pimoroni_bus",
-        "pimoroni_i2c",
-        "plasma",
-        "platform",
-        "pyb",
-        "pycom",
-        "pye",
-        "qrcode",
-        "queue",
-        "random",
-        "requests",
-        "requests/__init__",
-        "rp2",
-        "rtch",
-        "samd",
-        "select",
-        "servo",
-        "socket",
-        "ssd1306",
-        "ssh",
-        "ssl",
-        "stm",
-        "struct",
-        "sys",
-        "termios",
-        "time",
-        "tpcalib",
-        "uarray",
-        "uasyncio/__init__",
-        "uasyncio/core",
-        "uasyncio/event",
-        "uasyncio/funcs",
-        "uasyncio/lock",
-        "uasyncio/stream",
-        "uasyncio/tasks",
-        "ubinascii",
-        "ubluetooth",
-        "ucollections",
-        "ucrypto",
-        "ucryptolib",
-        "uctypes",
-        "uerrno",
-        "uftpd",
-        "uhashlib",
-        "uheapq",
-        "uio",
-        "ujson",
-        "ulab",
-        "ulab/approx",
-        "ulab/compare",
-        "ulab/fft",
-        "ulab/filter",
-        "ulab/linalg",
-        "ulab/numerical",
-        "ulab/poly",
-        "ulab/user",
-        "ulab/vector",
-        "umachine",
-        "umqtt/__init__",
-        "umqtt/robust",
-        "umqtt/simple",
-        "uos",
-        "uplatform",
-        "uqueue",
-        "urandom",
-        "ure",
-        "urequests",
-        "urllib/urequest",
-        "uselect",
-        "usocket",
-        "ussl",
-        "ustruct",
-        "usys",
-        "utelnetserver",
-        "utime",
-        "utimeq",
-        "uwebsocket",
-        "uzlib",
-        "version",
-        "websocket",
-        "websocket_helper",
-        "wipy",
-        "writer",
-        "xpt2046",
-        "ymodem",
-        "zephyr",
-        "zlib",
-    ]  # spell-checker: enable
-
-    gc.collect()
-
-    stubber.create_all_stubs()
-    stubber.report()
-
-
-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()
+	def __init__(B,path=D,firmware_id=D):
+		C=firmware_id
+		try:
+			if os.uname().release=='1.13.0'and os.uname().version<'v1.13-103':raise j('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[S]));F.collect()
+		if C:B._fwid=C.lower()
+		elif B.info[O]==a:B._fwid='{family}-v{version}-{port}-{board}'.format(**B.info).rstrip(T)
+		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:W(path+G)
+		except E: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=D;B._json_first=H
+	def get_obj_attributes(L,item_instance):
+		H=item_instance;C=[];K=[]
+		for A in M(H):
+			if A.startswith('__')and not A in L.modules:continue
+			try:
+				D=getattr(H,A)
+				try:E=Z(type(D)).split("'")[1]
+				except P:E=B
+				if E in{p,q,r,s,b,c,d}:G=1
+				elif E in{t,u}:G=2
+				elif E in'class':G=3
+				else:G=4
+				C.append((A,Z(D),Z(type(D)),D,G))
+			except I as J:K.append("Couldn't get attribute '{}' from object '{}', Err: {}".format(A,H,J))
+			except MemoryError as J:Y('MemoryError: {}'.format(J));sleep(1);reset()
+		C=k([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=k(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();D=H
+		try:D=C.create_module_stub(B,I)
+		except E:return H
+		F.collect();return D
+	def create_module_stub(K,module_name,file_name=D):
+		I=file_name;C=module_name
+		if I is D: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)
+		M=D
+		try:M=__import__(C,D,D,'*');P=F.mem_free();A.info('Stub module: {:<25} to file: {:<70} mem:{:>5}'.format(C,L,P))
+		except N:return H
+		W(I)
+		with Q(I,'w')as O:R=str(K.info).replace('OrderedDict(',B).replace('})','}');S='"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(C,K._fwid,R,__version__);O.write(S);O.write('from __future__ import annotations\nfrom typing import Any, Generator\nfrom _typeshed import Incomplete\n\n');K.write_object_stub(O,M,C,B)
+		K.report_add(C,I)
+		if C not in{'os',v,w,'gc'}:
+			try:del M
+			except(E,l):A.warning('could not del new_module')
+		F.collect();return U
+	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,e)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 R(D)<=A1*4:
+				P=B;Q=E.endswith(M)or E.endswith('Error')or E in['KeyboardInterrupt','StopIteration','SystemExit']
+				if Q:P=M
+				C='\n{}class {}({}):\n'.format(D,E,P)
+				if Q: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[u,t,'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(r,p,q,s,'bytearray','bytes'):C=W.format(D,E,J,G)
+				elif G in(d,c,b):a={d:'{}',c:'[]',b:'()'};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=D):
+		if path is D:path=C.path
+		A.info('Clean/remove files in folder: {}'.format(path))
+		try:os.stat(path);F=os.listdir(path)
+		except(E,I):return
+		for G in F:
+			B=x.format(path,G)
+			try:os.remove(B)
+			except E:
+				try:C.clean(B);os.rmdir(B)
+				except E:pass
+	def report_start(B,filename='modules.json'):
+		H='firmware';B._json_name=x.format(B.path,filename);B._json_first=U;W(B._json_name);A.info('Report file: {}'.format(B._json_name));F.collect()
+		try:
+			with Q(B._json_name,'w')as G:G.write('{');G.write(dumps({H:B.info})[1:-1]);G.write(e);G.write(dumps({o:{C:__version__},'stubtype':H})[1:-1]);G.write(e);G.write('"modules" :[\n')
+		except E as I:A.error(y);B._json_name=D;raise I
+	def report_add(B,module_name,stub_file):
+		if not B._json_name:raise m(z)
+		try:
+			with Q(B._json_name,'a')as C:
+				if not B._json_first:C.write(e)
+				else:B._json_first=H
+				D='{{"module": "{}", "file": "{}"}}'.format(module_name,stub_file.replace('\\',G));C.write(D)
+		except E:A.error(y)
+	def report_end(B):
+		if not B._json_name:raise m(z)
+		with Q(B._json_name,'a')as C:C.write('\n]}')
+		A.info('Path: {}'.format(B.path))
+def W(path):
+	B=D=0
+	while B!=-1:
+		B=path.find(G,D)
+		if B!=-1:
+			C=path[0]if B==0 else path[:B]
+			try:I=os.stat(C)
+			except E as F:
+				if F.args[0]==A0:
+					try:os.mkdir(C)
+					except E as H:A.error('failed to create folder {}'.format(C));raise H
+		D=B+1
+def X(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 T in s:return B
+		A=s.split(T)[1];return A
+	if not V in s:return B
+	A=s.split(V)[1].split(J)[1];return A
+def _info():
+	Y='ev3-pybricks';W='pycopy';U='unix';T='win32';R='arch';Q='cpu';L='ver';F='mpy';E='build';A=g({O:sys.implementation.name,C:B,E:B,L:B,K:sys.platform,S:'UNKNOWN',Q:B,F:B,R:B})
+	if A[K].startswith('pyb'):A[K]='stm32'
+	elif A[K]==T:A[K]='windows'
+	elif A[K]=='linux':A[K]=U
+	try:A[C]=A2(sys.implementation.version)
+	except I:pass
+	try:H=sys.implementation._machine if'_machine'in M(sys.implementation)else os.uname().machine;A[S]=H;A[Q]=H.split('with')[-1].strip();A[F]=sys.implementation._mpy if'_mpy'in M(sys.implementation)else sys.implementation.mpy if F in M(sys.implementation)else B
+	except(I,P):pass
+	A[S]=A3()
+	try:
+		if'uname'in M(os):
+			A[E]=X(os.uname()[3])
+			if not A[E]:A[E]=X(os.uname()[2])
+		elif C in M(sys):A[E]=X(sys.version)
+	except(I,P,n):pass
+	if A[C]==B and sys.platform not in(U,T):
+		try:Z=os.uname();A[C]=Z.release
+		except(P,I,n):pass
+	for(b,c,d)in[(W,W,'const'),(f,f,'FAT'),(Y,'pybricks.hubs','EV3Brick')]:
+		try:e=__import__(c,D,D,d);A[O]=b;del e;break
+		except(N,l):pass
+	if A[O]==Y:A['release']='2.0.0'
+	if A[O]==a:
+		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=[D,'x86','x64','armv6','armv6m','armv7m','armv7em','armv7emsp','armv7emdp','xtensa','xtensawin'][G>>10]
+		if J:A[R]=J
+		A[F]='v{}.{}'.format(G&255,G>>8&3)
+	if A[E]and not A[C].endswith(V):A[C]=A[C]+V
+	A[L]=f"{A[C]}-{A[E]}"if A[E]else f"{A[C]}";return A
+def A2(version):
+	A=version;B=J.join([str(A)for A in A[:3]])
+	if R(A)>3 and A[3]:B+=T+A[3]
+	return B
+def A3():
+	try:from boardname import BOARDNAME as C;A.info('Found BOARDNAME: {}'.format(C))
+	except N:A.warning('BOARDNAME not found');C=B
+	return C
+def get_root():
+	try:A=os.getcwd()
+	except(E,I):A=J
+	B=A
+	for B in[A,'/sd','/flash',G,J]:
+		try:C=os.stat(B);break
+		except E:continue
+	return B
+def A4(filename):
+	try:
+		if os.stat(filename)[0]>>14:return U
+		return H
+	except E:return H
+def h():Y("-p, --path   path to store the stubs in, defaults to '.'");sys.exit(1)
+def read_path():
+	path=B
+	if R(sys.argv)==3:
+		A=sys.argv[1].lower()
+		if A in('--path','-p'):path=sys.argv[2]
+		else:h()
+	elif R(sys.argv)==2:h()
+	return path
+def i():
+	try:A=bytes('abc',encoding='utf8');B=i.__module__;return H
+	except(j,I):return U
+def main():stubber=Stubber(path=read_path());stubber.clean();stubber.modules=['WM8960','_OTA','_asyncio','_boot_fat','_coap','_espnow','_flash_control_OTA','_main_pybytes','_mqtt','_mqtt_core','_msg_handl','_onewire','_periodical_pin','_pybytes','_pybytes_ca','_pybytes_config','_pybytes_config_reader','_pybytes_connection','_pybytes_constants','_pybytes_debug','_pybytes_library','_pybytes_machine_learning','_pybytes_main','_pybytes_protocol','_pybytes_pyconfig','_pybytes_pymesh_config','_rp2','_terminal','_thread','_uasyncio','_urequest','adcfft','aioble/__init__','aioble/central','aioble/client','aioble/core','aioble/device','aioble/l2cap','aioble/peripheral','aioble/security','aioble/server','aioespnow','ak8963','apa102','apa106','argparse','array','asyncio/__init__','asyncio/core','asyncio/event','asyncio/funcs','asyncio/lock','asyncio/stream','binascii','bluetooth','breakout_as7262','breakout_bh1745','breakout_bme280','breakout_bme68x','breakout_bmp280','breakout_dotmatrix','breakout_encoder','breakout_icp10125','breakout_ioexpander','breakout_ltr559','breakout_matrix11x7','breakout_mics6814','breakout_msa301','breakout_paa5100','breakout_pmw3901','breakout_potentiometer','breakout_rgbmatrix5x5','breakout_rtc','breakout_scd41','breakout_sgp30','breakout_trackball','breakout_vl53l5cx','btree','cmath','collections','crypto','cryptolib','curl','deflate','dht','display','display_driver_utils','ds18x20','encoder','errno','esp','esp32','espidf','espnow','ffi','flashbdev','framebuf','freesans20','fs_driver','functools','galactic','gc','gfx_pack','gsm','hashlib','heapq','hub75','ili9341','ili9XXX','imagetools','inisetup','interstate75','io','jpegdec','json','lcd160cr','lodepng',w,'lsm6dsox','lv_colors','lv_utils','lvgl','lwip','machine','math','microWebSocket','microWebSrv','microWebTemplate',a,'mip','mip/__init__','mip/__main__','motor','mpu6500','mpu9250','neopixel','network','ntptime','onewire','os','pcf85063a','picoexplorer','picographics','picokeypad','picoscroll','picounicorn','picowireless','pimoroni','pimoroni_bus','pimoroni_i2c','plasma','platform','pyb',f,'pye','qrcode','queue','random','requests','requests/__init__','rp2','rtch','samd','select','servo','socket','ssd1306','ssh','ssl','stm','struct',v,'termios','time','tpcalib','uarray','uasyncio/__init__','uasyncio/core','uasyncio/event','uasyncio/funcs','uasyncio/lock','uasyncio/stream','uasyncio/tasks','ubinascii','ubluetooth','ucollections','ucrypto','ucryptolib','uctypes','uerrno','uftpd','uhashlib','uheapq','uio','ujson','ulab','ulab/approx','ulab/compare','ulab/fft','ulab/filter','ulab/linalg','ulab/numerical','ulab/poly','ulab/user','ulab/vector','umachine','umqtt/__init__','umqtt/robust','umqtt/simple','uos','uplatform','uqueue','urandom','ure','urequests','urllib/urequest','uselect','usocket','ussl','ustruct','usys','utelnetserver','utime','utimeq','uwebsocket','uzlib',C,'websocket','websocket_helper','wipy','writer','xpt2046','ymodem','zephyr','zlib'];F.collect();stubber.create_all_stubs()
+if __name__=='__main__'or i():
+	if not A4('no_auto_stubber.txt'):
+		try:F.threshold(4*1024);F.enable()
+		except BaseException:pass
+		main()