micropython-stubber 1.20.4__py3-none-any.whl → 1.20.6__py3-none-any.whl

stubber/codemod/_partials/__init__.py

@@ -1,50 +1,48 @@
-from collections import deque
-from enum import Enum
-from pathlib import Path
-from typing import Iterator, cast
-
-# TODO: this way of accessing the partials is not very robust
-PARTIALS_DIR = Path(__file__).parent.absolute()
-
-PARTIAL_START = "###PARTIAL###"
-PARTIAL_END = "###PARTIALEND###"
-
-
-def _read_partial(path: Path) -> Iterator[str]:
-    """
-    Read a partial from the file at `path`
-    and yield only the lines between the ###PARTIAL### and ###PARTIALEND### markers
-    """
-    lines = deque(path.read_text(encoding="utf-8").splitlines(keepends=True))
-    _start = False
-    _end = False
-    # todo: allow processing of files that do not have the markers
-    while True:
-        try:
-            if not _start and (line := lines.popleft()):
-                _start = line.strip() == PARTIAL_START
-            if not _end and (line := lines.pop()):
-                _end = line.strip() == PARTIAL_END
-            if _start and _end:
-                break
-        except IndexError:
-            # or avoid erroring out if the file does not have the markers
-            raise ValueError(f"Partial {path} does not have ###PARTIAL### and ###PARTIALEND### markers")
-
-    yield from lines
-
-
-class _PartialMember:
-    def contents(self) -> str:
-        """Return the contents of the partial."""
-        return "".join(_read_partial(cast(Enum, self).value))
-
-
-Partial = Enum(
-    "Partial",
-    [(p.stem.upper(), p.absolute()) for p in PARTIALS_DIR.glob("*.py")],
-    type=_PartialMember,
-)
-
-
-__all__ = ["Partial"]
+from collections import deque
+from enum import Enum
+from pathlib import Path
+from typing import Iterator, cast
+
+PARTIALS_DIR = Path(__file__).parent.absolute()
+
+PARTIAL_START = "###PARTIAL###"
+PARTIAL_END = "###PARTIALEND###"
+
+
+def _read_partial(path: Path) -> Iterator[str]:
+    """
+    Read a partial from the file at `path`
+    and yield only the lines between the ###PARTIAL### and ###PARTIALEND### markers
+    """
+    lines = deque(path.read_text(encoding="utf-8").splitlines(keepends=True))
+    _start = False
+    _end = False
+    while True:
+        try:
+            if not _start and (line := lines.popleft()):
+                _start = line.strip() == PARTIAL_START
+            if not _end and (line := lines.pop()):
+                _end = line.strip() == PARTIAL_END
+            if _start and _end:
+                break
+        except IndexError:
+            # or avoid erroring out if the file does not have the markers
+            raise ValueError(f"Partial {path} does not have ###PARTIAL### and ###PARTIALEND### markers")
+
+    yield from lines
+
+
+class _PartialMember:
+    def contents(self) -> str:
+        """Return the contents of the partial."""
+        return "".join(_read_partial(cast(Enum, self).value))
+
+
+Partial = Enum(
+    "Partial",
+    [(p.stem.upper(), p.absolute()) for p in PARTIALS_DIR.glob("*.py")],
+    type=_PartialMember,
+)
+
+
+__all__ = ["Partial"]

stubber/codemod/_partials/db_main.py

@@ -1,147 +1,147 @@
-# type: ignore
-"""
-This file contains the `def main()` funcion for the db variant of createstubs.py
-- type_check_only is used to avoid circular imports
-The partial is enclosed in ###PARTIAL### and ###PARTIALEND### markers
-"""
-
-# sourcery skip: require-parameter-annotation, for-append-to-extend, use-named-expression
-
-from typing import TYPE_CHECKING, List
-
-if TYPE_CHECKING:
-    import gc
-    import logging
-
-    class logging:
-        def getLogger(self, name: str) -> "logging": ...
-
-        def info(self, msg: str) -> None: ...
-
-    log = logging()
-
-    class Stubber:
-        path: str
-        _report: List[str]
-        modules = []
-        _json_name: str
-
-        def __init__(self, path: str = "", firmware_id: str = "") -> None: ...
-
-        def clean(self) -> None: ...
-
-        def create_one_stub(self, modulename: str) -> bool: ...
-
-        def report_start(self, filename: str = "modules.json"): ...
-
-        def report_end(self): ...
-
-        def create_all_stubs(self): ...
-
-    def read_path() -> str: ...
-
-    class _gc:
-        def collect(self) -> None: ...
-
-    gc: _gc
-    log = logging.getLogger("stubber")
-
-    def file_exists(filename: str) -> bool: ...
-
-    LIBS = [".", "lib"]
-
-
-###PARTIAL###
-SKIP_FILE = "modulelist.done"
-
-
-def get_modules(skip=0):
-    # new
-    for p in LIBS:
-        fname = p + "/modulelist.txt"
-        if not file_exists(fname):
-            continue
-        try:
-            with open(fname) as f:
-                i = 0
-                while True:
-                    line = f.readline().strip()
-                    if not line:
-                        break
-                    if len(line) > 0 and line[0] == "#":
-                        continue
-                    i += 1
-                    if i < skip:
-                        continue
-                    yield line
-                break
-        except OSError:
-            pass
-
-
-def write_skip(done):
-    # write count of modules already processed to file
-    with open(SKIP_FILE, "w") as f:
-        f.write(str(done) + "\n")
-
-
-def read_skip():
-    # read count of modules already processed from file
-    done = 0
-    try:
-        with open(SKIP_FILE) as f:
-            done = int(f.readline().strip())
-    except OSError:
-        pass
-    return done
-
-
-def main():
-    import machine  # type: ignore
-
-    was_running = file_exists(SKIP_FILE)
-    if was_running:
-        log.info("Continue from last run")
-    else:
-        log.info("Starting new run")
-    # try:
-    #     f = open("modulelist.done", "r+b")
-    #     was_running = True
-    #     print("Continue from last run")
-    # except OSError:
-    #     f = open("modulelist.done", "w+b")
-    #     was_running = False
-    stubber = Stubber(path=read_path())
-
-    # f_name = "{}/{}".format(stubber.path, "modules.json")
-    skip = 0
-    if not was_running:
-        # Only clean folder if this is a first run
-        stubber.clean()
-        stubber.report_start("modules.json")
-    else:
-        skip = read_skip()
-        stubber._json_name = "{}/{}".format(stubber.path, "modules.json")
-
-    for modulename in get_modules(skip):
-        # ------------------------------------
-        # do epic shit
-        # but sometimes things fail / run out of memory and reboot
-        try:
-            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"))
-        skip += 1
-        write_skip(skip)
-
-    print("All modules have been processed, Finalizing report")
-    stubber.report_end()
-
-
-###PARTIALEND###
+# type: ignore
+"""
+This file contains the `def main()` funcion for the db variant of createstubs.py
+- type_check_only is used to avoid circular imports
+The partial is enclosed in ###PARTIAL### and ###PARTIALEND### markers
+"""
+
+# sourcery skip: require-parameter-annotation, for-append-to-extend, use-named-expression
+
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    import gc
+    import logging
+
+    class logging:
+        def getLogger(self, name: str) -> "logging": ...
+
+        def info(self, msg: str) -> None: ...
+
+    log = logging()
+
+    class Stubber:
+        path: str
+        _report: List[str]
+        modules = []
+        _json_name: str
+
+        def __init__(self, path: str = "", firmware_id: str = "") -> None: ...
+
+        def clean(self) -> None: ...
+
+        def create_one_stub(self, modulename: str) -> bool: ...
+
+        def report_start(self, filename: str = "modules.json"): ...
+
+        def report_end(self): ...
+
+        def create_all_stubs(self): ...
+
+    def read_path() -> str: ...
+
+    class _gc:
+        def collect(self) -> None: ...
+
+    gc: _gc
+    log = logging.getLogger("stubber")
+
+    def file_exists(filename: str) -> bool: ...
+
+    LIBS = [".", "lib"]
+
+
+###PARTIAL###
+SKIP_FILE = "modulelist.done"
+
+
+def get_modules(skip=0):
+    # new
+    for p in LIBS:
+        fname = p + "/modulelist.txt"
+        if not file_exists(fname):
+            continue
+        try:
+            with open(fname) as f:
+                i = 0
+                while True:
+                    line = f.readline().strip()
+                    if not line:
+                        break
+                    if len(line) > 0 and line[0] == "#":
+                        continue
+                    i += 1
+                    if i < skip:
+                        continue
+                    yield line
+                break
+        except OSError:
+            pass
+
+
+def write_skip(done):
+    # write count of modules already processed to file
+    with open(SKIP_FILE, "w") as f:
+        f.write(str(done) + "\n")
+
+
+def read_skip():
+    # read count of modules already processed from file
+    done = 0
+    try:
+        with open(SKIP_FILE) as f:
+            done = int(f.readline().strip())
+    except OSError:
+        pass
+    return done
+
+
+def main():
+    import machine  # type: ignore
+
+    was_running = file_exists(SKIP_FILE)
+    if was_running:
+        log.info("Continue from last run")
+    else:
+        log.info("Starting new run")
+    # try:
+    #     f = open("modulelist.done", "r+b")
+    #     was_running = True
+    #     print("Continue from last run")
+    # except OSError:
+    #     f = open("modulelist.done", "w+b")
+    #     was_running = False
+    stubber = Stubber(path=read_path())
+
+    # f_name = "{}/{}".format(stubber.path, "modules.json")
+    skip = 0
+    if not was_running:
+        # Only clean folder if this is a first run
+        stubber.clean()
+        stubber.report_start("modules.json")
+    else:
+        skip = read_skip()
+        stubber._json_name = "{}/{}".format(stubber.path, "modules.json")
+
+    for modulename in get_modules(skip):
+        # ------------------------------------
+        # do epic shit
+        # but sometimes things fail / run out of memory and reboot
+        try:
+            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"))
+        skip += 1
+        write_skip(skip)
+
+    print("All modules have been processed, Finalizing report")
+    stubber.report_end()
+
+
+###PARTIALEND###

stubber/codemod/_partials/lvgl_main.py

@@ -1,77 +1,77 @@
-"""
-This file contains the `def main()` funcion for the lvgl variant of createstubs.py
-- type_check_only is used to avoid circular imports
-The partial is enclosed in ###PARTIAL### and ###PARTIALEND### markers
-"""
-from typing import TYPE_CHECKING, List, type_check_only
-
-if TYPE_CHECKING:
-    import sys
-    import logging
-
-    @type_check_only
-    class Stubber:
-        path: str
-        _report: List[str]
-        modules = []
-
-        def __init__(self, path: str = "", firmware_id: str = "") -> None:
-            ...
-
-        def clean(self) -> None:
-            ...
-
-        def create_one_stub(self, modulename: str) -> bool:
-            ...
-
-        def report(self, filename: str = "modules.json"):
-            ...
-
-        def create_all_stubs(self):
-            ...
-
-    @type_check_only
-    def read_path() -> str:
-        ...
-
-    @type_check_only
-    class _gc:
-        def collect(self) -> None:
-            ...
-
-    gc: _gc
-    _log = logging.getLogger("stubber")
-
-
-###PARTIAL###
-def main():
-    try:
-        import lvgl  # type: ignore
-    except Exception:
-        print("\n\nNOTE: The `lvgl` module could not be found on this firmware\n\n")
-        return
-    # Specify firmware name & version
-    fw_id = "lvgl"
-    try:
-        fw_id = "lvgl-{0}_{1}_{2}-{3}-{4}".format(
-            lvgl.version_major(),
-            lvgl.version_minor(),
-            lvgl.version_patch(),
-            lvgl.version_info(),
-            sys.platform,
-        )
-    except Exception:
-        fw_id = "lvgl-{0}_{1}_{2}_{3}-{4}".format(8, 1, 0, "dev", sys.platform)
-    finally:
-        stubber = Stubber(firmware_id=fw_id) # type: ignore
-    stubber.clean()
-    # modules to stub : only lvgl specifics
-    stubber.modules = ["io", "lodepng", "rtch", "lvgl"]  # spell-checker: enable
-
-    gc.collect() # type: ignore
-
-    stubber.create_all_stubs()
-    stubber.report()
-
-
-###PARTIALEND###
+"""
+This file contains the `def main()` funcion for the lvgl variant of createstubs.py
+- type_check_only is used to avoid circular imports
+The partial is enclosed in ###PARTIAL### and ###PARTIALEND### markers
+"""
+from typing import TYPE_CHECKING, List, type_check_only
+
+if TYPE_CHECKING:
+    import sys
+    import logging
+
+    @type_check_only
+    class Stubber:
+        path: str
+        _report: List[str]
+        modules = []
+
+        def __init__(self, path: str = "", firmware_id: str = "") -> None:
+            ...
+
+        def clean(self) -> None:
+            ...
+
+        def create_one_stub(self, modulename: str) -> bool:
+            ...
+
+        def report(self, filename: str = "modules.json"):
+            ...
+
+        def create_all_stubs(self):
+            ...
+
+    @type_check_only
+    def read_path() -> str:
+        ...
+
+    @type_check_only
+    class _gc:
+        def collect(self) -> None:
+            ...
+
+    gc: _gc
+    _log = logging.getLogger("stubber")
+
+
+###PARTIAL###
+def main():
+    try:
+        import lvgl  # type: ignore
+    except Exception:
+        print("\n\nNOTE: The `lvgl` module could not be found on this firmware\n\n")
+        return
+    # Specify firmware name & version
+    fw_id = "lvgl"
+    try:
+        fw_id = "lvgl-{0}_{1}_{2}-{3}-{4}".format(
+            lvgl.version_major(),
+            lvgl.version_minor(),
+            lvgl.version_patch(),
+            lvgl.version_info(),
+            sys.platform,
+        )
+    except Exception:
+        fw_id = "lvgl-{0}_{1}_{2}_{3}-{4}".format(8, 1, 0, "dev", sys.platform)
+    finally:
+        stubber = Stubber(firmware_id=fw_id) # type: ignore
+    stubber.clean()
+    # modules to stub : only lvgl specifics
+    stubber.modules = ["io", "lodepng", "rtch", "lvgl"]  # spell-checker: enable
+
+    gc.collect() # type: ignore
+
+    stubber.create_all_stubs()
+    stubber.report()
+
+
+###PARTIALEND###