micropython-stubber 1.14.1__py3-none-any.whl → 1.15.1__py3-none-any.whl

stubber/board/createstubs_info.py

@@ -38,11 +38,11 @@ class Stubber:
         except AttributeError:
             pass
 
-        self._log = logging.getLogger("stubber")
+        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"]))
+        self.log.info("Port: {}".format(self.info["port"]))
+        self.log.info("Board: {}".format(self.info["board"]))
         gc.collect()
         if firmware_id:
             self._fwid = firmware_id.lower()
@@ -60,11 +60,11 @@ class Stubber:
             path = get_root()
 
         self.path = "{}/stubs/{}".format(path, self.flat_fwid).replace("//", "/")
-        self._log.debug(self.path)
+        self.log.debug(self.path)
         try:
             ensure_folder(path + "/")
         except OSError:
-            self._log.error("error creating stub folder {}".format(path))
+            self.log.error("error creating stub folder {}".format(path))
         self.problematic = [
             "upip",
             "upysh",
@@ -89,11 +89,11 @@ class Stubber:
         # name_, repr_(value), type as text, item_instance
         _result = []
         _errors = []
-        self._log.debug("get attributes {} {}".format(repr(item_instance), item_instance))
+        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))
+            self.log.debug("get attribute {}".format(name))
             try:
                 val = getattr(item_instance, name)
                 # name , item_repr(value) , type as text, item_instance, order
@@ -111,7 +111,11 @@ class Stubber:
                     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))
+                _errors.append(
+                    "Couldn't get attribute '{}' from object '{}', Err: {}".format(
+                        name, item_instance, e
+                    )
+                )
             except MemoryError as e:
                 print("MemoryError: {}".format(e))
                 sleep(1)
@@ -129,20 +133,20 @@ class Stubber:
 
     def create_all_stubs(self):
         "Create stubs for all configured modules"
-        self._log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
+        self.log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
         log_mem("create_all_stubs")
         gc.collect()
         for module_name in self.modules:
             self.create_one_stub(module_name)
-        self._log.info("Finally done")
+        self.log.info("Finally done")
 
     def create_one_stub(self, module_name: str):
         log_mem(f"create_one_stub:{module_name}")
         if module_name in self.problematic:
-            self._log.warning("Skip module: {:<25}        : Known problematic".format(module_name))
+            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))
+            self.log.warning("Skip module: {:<25}        : Excluded".format(module_name))
             return False
 
         file_name = "{}/{}.py".format(self.path, module_name.replace(".", "/"))
@@ -179,48 +183,56 @@ class Stubber:
             m1 = gc.mem_free()  # type: ignore
             log_mem(module_name)
 
-            self._log.info("Stub module: {:<25} to file: {:<70} mem:{:>5}".format(module_name, fname, m1))
+            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."))
+            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
-            s = '"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(module_name, self._fwid, self.info, __version__)
+            s = '"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(
+                module_name, self._fwid, self.info, __version__
+            )
             fp.write(s)
             fp.write("from typing import Any\n\n")
             self.write_object_stub(fp, new_module, module_name, "")
 
-        self._report.append('{{"module": "{}", "file": "{}"}}'.format(module_name, file_name.replace("\\", "/")))
+        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]
-                self._log.warning("could not del new_module")
+                self.log.warning("could not del new_module")
             try:
                 del sys.modules[module_name]
             except KeyError:
-                self._log.debug("could not del sys.modules[{}]".format(module_name))
+                self.log.debug("could not del sys.modules[{}]".format(module_name))
         gc.collect()
         return True
 
-    def write_object_stub(self, fp, object_expr: object, obj_name: str, indent: str, in_class: int = 0):
+    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))
+            self.log.warning("SKIPPING problematic module:{}".format(object_expr))
             return
 
-        # self._log.debug("DUMP    : {}".format(object_expr))
+        # self.log.debug("DUMP    : {}".format(object_expr))
         items, errors = self.get_obj_attributes(object_expr)
 
         if errors:
-            self._log.error(errors)
+            self.log.error(errors)
 
         for item_name, item_repr, item_type_txt, item_instance, _ in items:
             # name_, repr_(value), type as text, item_instance, order
@@ -228,11 +240,11 @@ class Stubber:
             if item_name in ["classmethod", "staticmethod", "BaseException", "Exception"]:
                 continue
             if item_name[0].isdigit():
-                self._log.warning("NameError: invalid name {}".format(item_name))
+                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:
-                self._log.debug("{0}class {1}:".format(indent, item_name))
+                self.log.debug("{0}class {1}:".format(indent, item_name))
                 superclass = ""
                 is_exception = (
                     item_name.endswith("Exception")
@@ -255,7 +267,7 @@ class Stubber:
                 # write classdef
                 fp.write(s)
                 # first write the class literals and methods
-                self._log.debug("# recursion over class {0}".format(item_name))
+                self.log.debug("# recursion over class {0}".format(item_name))
                 self.write_object_stub(
                     fp,
                     item_instance,
@@ -269,7 +281,9 @@ class Stubber:
                 s += indent + "        ...\n\n"
                 fp.write(s)
             elif "method" in item_type_txt or "function" in item_type_txt:
-                self._log.debug("# def {1} function or method, type = '{0}'".format(item_type_txt, item_name))
+                self.log.debug(
+                    "# def {1} function or method, type = '{0}'".format(item_type_txt, item_name)
+                )
                 # module Function or class method
                 # will accept any number of params
                 # return type Any
@@ -280,12 +294,16 @@ class Stubber:
                     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)
+                    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 = "{}def {}({}*args, **kwargs) -> {}:\n".format(
+                        indent, item_name, first, ret
+                    )
                 s += indent + "    ...\n\n"
                 fp.write(s)
-                self._log.debug("\n" + s)
+                self.log.debug("\n" + s)
             elif item_type_txt == "<class 'module'>":
                 # Skip imported modules
                 # fp.write("# import {}\n".format(item_name))
@@ -309,12 +327,14 @@ class Stubber:
                         # https://docs.python.org/3/tutorial/classes.html#item_instance-objects
                         t = "Any"
                     # Requires Python 3.6 syntax, which is OK for the stubs/pyi
-                    s = "{0}{1} : {2} ## {3} = {4}\n".format(indent, item_name, t, item_type_txt, item_repr)
+                    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)
+                self.log.debug("\n" + s)
             else:
                 # keep only the name
-                self._log.debug("# all other, type = '{0}'".format(item_type_txt))
+                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: Any\n")
@@ -340,7 +360,7 @@ class Stubber:
         "Remove all files from the stub folder"
         if path is None:
             path = self.path
-        self._log.info("Clean/remove files in folder: {}".format(path))
+        self.log.info("Clean/remove files in folder: {}".format(path))
         try:
             os.stat(path)  # TEMP workaround mpremote listdir bug -
             items = os.listdir(path)
@@ -360,9 +380,13 @@ class Stubber:
 
     def report(self, filename: str = "modules.json"):
         "create json with list of exported modules"
-        self._log.info("Created stubs for {} modules on board {}\nPath: {}".format(len(self._report), self._fwid, self.path))
+        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))
+        self.log.info("Report file: {}".format(f_name))
         gc.collect()
         try:
             # write json by node to reduce memory requirements
@@ -374,9 +398,9 @@ class Stubber:
                     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))
+            self.log.info("Memory used: {0} Kb".format(used // 1024))
         except OSError:
-            self._log.error("Failed to create the report.")
+            self.log.error("Failed to create the report.")
 
     def write_json_header(self, f):
         f.write("{")
@@ -411,7 +435,7 @@ def ensure_folder(path: str):
                     try:
                         os.mkdir(p)
                     except OSError as e2:
-                        _log.error("failed to create folder {}".format(p))
+                        log.error("failed to create folder {}".format(p))
                         raise e2
         # next level deep
         start = i + 1
@@ -433,7 +457,9 @@ def _info():  # type:() -> dict[str, str]
             "version": "",
             "build": "",
             "ver": "",
-            "port": "stm32" if sys.platform.startswith("pyb") else sys.platform,  # port: esp32 / win32 / linux / stm32
+            "port": "stm32"
+            if sys.platform.startswith("pyb")
+            else sys.platform,  # port: esp32 / win32 / linux / stm32
             "board": "GENERIC",
             "cpu": "",
             "mpy": "",
@@ -445,7 +471,11 @@ def _info():  # type:() -> dict[str, str]
     except AttributeError:
         pass
     try:
-        machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine
+        machine = (
+            sys.implementation._machine
+            if "_machine" in dir(sys.implementation)
+            else os.uname().machine
+        )
         info["board"] = machine.strip()
         info["cpu"] = machine.split("with")[1].strip()
         info["mpy"] = (
@@ -515,7 +545,8 @@ def _info():  # type:() -> dict[str, str]
         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.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
             and info["version"] <= "1.19.9"
         ):
             # drop the .0 for newer releases
@@ -886,7 +917,7 @@ def log_mem(id="", verbose=True):
 
 if __name__ == "__main__" or is_micropython():
     try:
-        _log = logging.getLogger("stubber")
+        log = logging.getLogger("stubber")
         logging.basicConfig(level=logging.INFO)
         # logging.basicConfig(level=logging.DEBUG)
     except NameError:

stubber/board/createstubs_lvgl.py

@@ -3,7 +3,7 @@ Create stubs for the lvgl modules on a MicroPython board.
 
 Note that the stubs can be very large, and it may be best to directly store them on an SD card if your device supports this.
 
-This variant was generated from createstubs.py by micropython-stubber v1.13.8
+This variant was generated from createstubs.py by micropython-stubber v1.15.0
 """
 # Copyright (c) 2019-2023 Jos Verlinde
 # pylint: disable= invalid-name, missing-function-docstring, import-outside-toplevel, logging-not-lazy
@@ -24,7 +24,7 @@ try:
 except ImportError:
     from ucollections import OrderedDict  # type: ignore
 
-__version__ = "v1.13.8"
+__version__ = "v1.15.0"
 ENOENT = 2
 _MAX_CLASS_LEVEL = 2  # Max class nesting
 LIBS = [".", "/lib", "/sd/lib", "/flash/lib", "lib"]
@@ -40,12 +40,12 @@ class Stubber:
                 raise NotImplementedError("MicroPython 1.13.0 cannot be stubbed")
         except AttributeError:
             pass
-
-        self._log = logging.getLogger("stubber")
+        self.log = None
+        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"]))
+        self.log.info("Port: {}".format(self.info["port"]))
+        self.log.info("Board: {}".format(self.info["board"]))
         gc.collect()
         if firmware_id:
             self._fwid = firmware_id.lower()
@@ -63,11 +63,11 @@ class Stubber:
             path = get_root()
 
         self.path = "{}/stubs/{}".format(path, self.flat_fwid).replace("//", "/")
-        self._log.debug(self.path)
+        self.log.debug(self.path)
         try:
             ensure_folder(path + "/")
         except OSError:
-            self._log.error("error creating stub folder {}".format(path))
+            self.log.error("error creating stub folder {}".format(path))
         self.problematic = [
             "upip",
             "upysh",
@@ -92,11 +92,11 @@ class Stubber:
         # name_, repr_(value), type as text, item_instance
         _result = []
         _errors = []
-        self._log.debug("get attributes {} {}".format(repr(item_instance), item_instance))
+        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))
+            self.log.debug("get attribute {}".format(name))
             try:
                 val = getattr(item_instance, name)
                 # name , item_repr(value) , type as text, item_instance, order
@@ -132,18 +132,18 @@ class Stubber:
 
     def create_all_stubs(self):
         "Create stubs for all configured modules"
-        self._log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
+        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")
+        self.log.info("Finally done")
 
     def create_one_stub(self, module_name: str):
         if module_name in self.problematic:
-            self._log.warning("Skip module: {:<25}        : Known problematic".format(module_name))
+            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))
+            self.log.warning("Skip module: {:<25}        : Excluded".format(module_name))
             return False
 
         file_name = "{}/{}.py".format(self.path, module_name.replace(".", "/"))
@@ -178,10 +178,10 @@ class Stubber:
         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))
+            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."))
+            self.log.warning("Skip module: {:<25} {:<79}".format(module_name, "Module not found."))
             return False
 
         # Start a new file
@@ -201,11 +201,11 @@ class Stubber:
             try:
                 del new_module
             except (OSError, KeyError):  # lgtm [py/unreachable-statement]
-                self._log.warning("could not del new_module")
+                self.log.warning("could not del new_module")
             try:
                 del sys.modules[module_name]
             except KeyError:
-                self._log.debug("could not del sys.modules[{}]".format(module_name))
+                self.log.debug("could not del sys.modules[{}]".format(module_name))
         gc.collect()
         return True
 
@@ -213,14 +213,14 @@ class Stubber:
         "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))
+            self.log.warning("SKIPPING problematic module:{}".format(object_expr))
             return
 
-        # self._log.debug("DUMP    : {}".format(object_expr))
+        # self.log.debug("DUMP    : {}".format(object_expr))
         items, errors = self.get_obj_attributes(object_expr)
 
         if errors:
-            self._log.error(errors)
+            self.log.error(errors)
 
         for item_name, item_repr, item_type_txt, item_instance, _ in items:
             # name_, repr_(value), type as text, item_instance, order
@@ -228,11 +228,11 @@ class Stubber:
                 # do not create stubs for these primitives
                 continue
             if item_name[0].isdigit():
-                self._log.warning("NameError: invalid name {}".format(item_name))
+                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:
-                self._log.debug("{0}class {1}:".format(indent, item_name))
+                self.log.debug("{0}class {1}:".format(indent, item_name))
                 superclass = ""
                 is_exception = (
                     item_name.endswith("Exception")
@@ -255,7 +255,7 @@ class Stubber:
                 # write classdef
                 fp.write(s)
                 # first write the class literals and methods
-                self._log.debug("# recursion over class {0}".format(item_name))
+                self.log.debug("# recursion over class {0}".format(item_name))
                 self.write_object_stub(
                     fp,
                     item_instance,
@@ -269,7 +269,7 @@ class Stubber:
                 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))
+                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
@@ -285,7 +285,7 @@ class Stubber:
                     s = "{}def {}({}*args, **kwargs) -> {}:\n".format(indent, item_name, first, ret)
                 s += indent + "    ...\n\n"
                 fp.write(s)
-                self._log.debug("\n" + s)
+                self.log.debug("\n" + s)
             elif item_type_txt == "<class 'module'>":
                 # Skip imported modules
                 # fp.write("# import {}\n".format(item_name))
@@ -311,10 +311,10 @@ class Stubber:
                     # Requires Python 3.6 syntax, which is OK for the stubs/pyi
                     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)
+                self.log.debug("\n" + s)
             else:
                 # keep only the name
-                self._log.debug("# all other, type = '{0}'".format(item_type_txt))
+                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")
@@ -340,7 +340,7 @@ class Stubber:
         "Remove all files from the stub folder"
         if path is None:
             path = self.path
-        self._log.info("Clean/remove files in folder: {}".format(path))
+        self.log.info("Clean/remove files in folder: {}".format(path))
         try:
             os.stat(path)  # TEMP workaround mpremote listdir bug -
             items = os.listdir(path)
@@ -360,9 +360,9 @@ class Stubber:
 
     def report(self, filename: str = "modules.json"):
         "create json with list of exported modules"
-        self._log.info("Created stubs for {} modules on board {}\nPath: {}".format(len(self._report), self._fwid, self.path))
+        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))
+        self.log.info("Report file: {}".format(f_name))
         gc.collect()
         try:
             # write json by node to reduce memory requirements
@@ -374,9 +374,9 @@ class Stubber:
                     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))
+            self.log.info("Memory used: {0} Kb".format(used // 1024))
         except OSError:
-            self._log.error("Failed to create the report.")
+            self.log.error("Failed to create the report.")
 
     def write_json_header(self, f):
         f.write("{")
@@ -411,7 +411,7 @@ def ensure_folder(path: str):
                     try:
                         os.mkdir(p)
                     except OSError as e2:
-                        _log.error("failed to create folder {}".format(p))
+                        log.error("failed to create folder {}".format(p))
                         raise e2
         # next level deep
         start = i + 1
@@ -662,7 +662,7 @@ def main():
 
 if __name__ == "__main__" or is_micropython():
     try:
-        _log = logging.getLogger("stubber")
+        log = logging.getLogger("stubber")
         logging.basicConfig(level=logging.INFO)
         # logging.basicConfig(level=logging.DEBUG)
     except NameError: