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

stubber/codemod/_partials/modules_reader.py

@@ -1,80 +1,80 @@
-"""partial used to read the modulelist.txt file"""
-from typing import TYPE_CHECKING, List, type_check_only
-
-if TYPE_CHECKING:
-    import gc
-    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:
-        ...
-
-    def file_exists(f: str) -> bool:
-        ...
-
-    @type_check_only
-    class _gc:
-        def collect(self) -> None:
-            ...
-
-    _log = logging.getLogger("stubber")
-
-    # help type checker
-    stubber: Stubber = None  # type: ignore
-    LIBS: List[str] = [".", "lib"]
-
-
-# sourcery skip: use-named-expression
-###PARTIAL###
-# Read stubs from modulelist in the current folder or in /libs
-# fall back to default modules
-def get_modulelist(stubber):
-    # new
-    gc.collect()
-    stubber.modules = []  # avoid duplicates
-    for p in LIBS:
-        fname = p + "/modulelist.txt"
-        if not file_exists(fname):
-            continue
-        with open(fname) as f:
-            # print("DEBUG: list of modules: " + p + "/modulelist.txt")
-            while True:
-                line = f.readline().strip()
-                if not line:
-                    break
-                if len(line) > 0 and line[0] != "#":
-                    stubber.modules.append(line)
-            gc.collect()
-            print("BREAK")
-            break
-
-    if not stubber.modules:
-        stubber.modules = ["micropython"]
-        # _log.warn("Could not find modulelist.txt, using default modules")
-    gc.collect()
-
-
-stubber.modules = []  # avoid duplicates
-get_modulelist(stubber)
-###PARTIALEND###
+"""partial used to read the modulelist.txt file"""
+from typing import TYPE_CHECKING, List, type_check_only
+
+if TYPE_CHECKING:
+    import gc
+    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:
+        ...
+
+    def file_exists(f: str) -> bool:
+        ...
+
+    @type_check_only
+    class _gc:
+        def collect(self) -> None:
+            ...
+
+    _log = logging.getLogger("stubber")
+
+    # help type checker
+    stubber: Stubber = None  # type: ignore
+    LIBS: List[str] = [".", "lib"]
+
+
+# sourcery skip: use-named-expression
+###PARTIAL###
+# Read stubs from modulelist in the current folder or in /libs
+# fall back to default modules
+def get_modulelist(stubber):
+    # new
+    gc.collect()
+    stubber.modules = []  # avoid duplicates
+    for p in LIBS:
+        fname = p + "/modulelist.txt"
+        if not file_exists(fname):
+            continue
+        with open(fname) as f:
+            # print("DEBUG: list of modules: " + p + "/modulelist.txt")
+            while True:
+                line = f.readline().strip()
+                if not line:
+                    break
+                if len(line) > 0 and line[0] != "#":
+                    stubber.modules.append(line)
+            gc.collect()
+            print("BREAK")
+            break
+
+    if not stubber.modules:
+        stubber.modules = ["micropython"]
+        # _log.warn("Could not find modulelist.txt, using default modules")
+    gc.collect()
+
+
+stubber.modules = []  # avoid duplicates
+get_modulelist(stubber)
+###PARTIALEND###

stubber/codemod/add_comment.py

@@ -1,53 +1,53 @@
-"""Add comment(s) to each file"""
-# sourcery skip: snake-case-functions
-
-import argparse
-from typing import List
-from libcst import Module, Comment
-from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
-from libcst.helpers.module import insert_header_comments
-
-import re
-from typing import Pattern
-
-
-class AddComment(VisitorBasedCodemodCommand):
-    DESCRIPTION: str = "Add comment(s) to each file"
-
-    @staticmethod
-    def add_args(arg_parser: argparse.ArgumentParser) -> None:
-        """Add command-line args that a user can specify for running this codemod."""
-        arg_parser.add_argument(
-            "-c",
-            "--comment",
-            dest="comments",
-            action="extend",
-            nargs="+",
-            metavar="COMMENT",
-            help="Comment statement(s) to add to each file",
-            type=str,
-            required=True,
-        )
-
-    def __init__(self, context: CodemodContext, comments: List[str]) -> None:
-        """
-        Initialize the base class with context, and save our args. Remember, the
-        "dest" for each argument we added above must match a parameter name in
-        this init.
-        """
-        super().__init__(context)
-        self.comments = [c if c[0] == "#" else f"# {c}" for c in comments]
-        # regex only checks for the first line of the comment
-        self._regex_pattern: Pattern[str] = re.compile(rf"^{self.comments[0]}\s*$")
-        self.needs_add = True
-
-    def visit_Comment(self, node: Comment) -> None:
-        """
-        connect comments from the source
-        """
-        if self._regex_pattern.search(node.value):
-            self.needs_add = False
-
-    def leave_Module(self, original_node: Module, updated_node: Module) -> Module:
-        """If the tag already exists, don't modify the file."""
-        return insert_header_comments(updated_node, self.comments) if self.needs_add else updated_node
+"""Add comment(s) to each file"""
+# sourcery skip: snake-case-functions
+
+import argparse
+from typing import List
+from libcst import Module, Comment
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+from libcst.helpers.module import insert_header_comments
+
+import re
+from typing import Pattern
+
+
+class AddComment(VisitorBasedCodemodCommand):
+    DESCRIPTION: str = "Add comment(s) to each file"
+
+    @staticmethod
+    def add_args(arg_parser: argparse.ArgumentParser) -> None:
+        """Add command-line args that a user can specify for running this codemod."""
+        arg_parser.add_argument(
+            "-c",
+            "--comment",
+            dest="comments",
+            action="extend",
+            nargs="+",
+            metavar="COMMENT",
+            help="Comment statement(s) to add to each file",
+            type=str,
+            required=True,
+        )
+
+    def __init__(self, context: CodemodContext, comments: List[str]) -> None:
+        """
+        Initialize the base class with context, and save our args. Remember, the
+        "dest" for each argument we added above must match a parameter name in
+        this init.
+        """
+        super().__init__(context)
+        self.comments = [c if c[0] == "#" else f"# {c}" for c in comments]
+        # regex only checks for the first line of the comment
+        self._regex_pattern: Pattern[str] = re.compile(rf"^{self.comments[0]}\s*$")
+        self.needs_add = True
+
+    def visit_Comment(self, node: Comment) -> None:
+        """
+        connect comments from the source
+        """
+        if self._regex_pattern.search(node.value):
+            self.needs_add = False
+
+    def leave_Module(self, original_node: Module, updated_node: Module) -> Module:
+        """If the tag already exists, don't modify the file."""
+        return insert_header_comments(updated_node, self.comments) if self.needs_add else updated_node

stubber/codemod/add_method.py

@@ -1,65 +1,65 @@
-"""Codemod to add methods to a classes.
-
-Used to add methods that are documented, but are not reported by the firmware, 
-so they are also not present in the MCU stubs.
-"""
-
-
-from typing import Optional
-import libcst as cst
-from libcst import matchers as m
-
-
-# there is no simple way to re-use the code from multiple classes / methods
-# but could be added https://stackoverflow.com/questions/17522706/how-to-pass-an-instance-variable-to-a-decorator-inside-class-definition?noredirect=1&lq=1
-# so for now, just copy the code, or use a module scoped variable - but that is not thread safe
-
-
-class CallFinder(m.MatcherDecoratableTransformer):
-    """Find the Pin.__call__ method and extract it from a (machine) module."""
-
-    class_name: str = "Pin"  # class name
-    method_name: str = "__call__"  # method name
-
-    def __init__(self):
-        super().__init__()
-        self.call_meth: Optional[cst.FunctionDef] = None
-
-    @m.call_if_inside(m.ClassDef(name=m.Name(class_name)))
-    @m.visit(m.FunctionDef(name=m.Name(method_name)))
-    def detect_call(self, node: cst.FunctionDef) -> None:
-        """find the  __call__ method and store it."""
-        self.call_meth = node
-
-
-class CallAdder(m.MatcherDecoratableTransformer):
-    """Add a __call__ method to a class if it is missing."""
-
-    class_name = "Pin"  # class name
-    has_call = 0  # number of __call__ methods found
-
-    def __init__(self, call_meth: cst.FunctionDef) -> None:
-        super().__init__()
-        self.call_meth = call_meth
-
-    @m.call_if_inside(m.ClassDef(name=m.Name(class_name)))
-    @m.visit(m.FunctionDef(name=m.Name("__call__")))
-    def detect_call(self, node: cst.FunctionDef) -> None:
-        """Detect if the class already has a __call__ method."""
-        self.has_call += 1
-
-    @m.leave(m.ClassDef(name=m.Name(class_name)))
-    def add_call(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:
-        """Add the __call__ method to the class if it is not already there."""
-        if self.has_call:
-            # no change needed
-            return updated_node
-        assert isinstance(updated_node.body, cst.IndentedBlock), "Class body is not indented"
-        # Add it to the end of the body & keep other body items
-        new_body = cst.IndentedBlock(
-            body=list(updated_node.body.body) + [self.call_meth],
-            header=updated_node.body.header,
-            footer=updated_node.body.footer,
-            indent=updated_node.body.indent,
-        )
-        return updated_node.with_changes(body=new_body)
+"""Codemod to add methods to a classes.
+
+Used to add methods that are documented, but are not reported by the firmware, 
+so they are also not present in the MCU stubs.
+"""
+
+
+from typing import Optional
+import libcst as cst
+from libcst import matchers as m
+
+
+# there is no simple way to re-use the code from multiple classes / methods
+# but could be added https://stackoverflow.com/questions/17522706/how-to-pass-an-instance-variable-to-a-decorator-inside-class-definition?noredirect=1&lq=1
+# so for now, just copy the code, or use a module scoped variable - but that is not thread safe
+
+
+class CallFinder(m.MatcherDecoratableTransformer):
+    """Find the Pin.__call__ method and extract it from a (machine) module."""
+
+    class_name: str = "Pin"  # class name
+    method_name: str = "__call__"  # method name
+
+    def __init__(self):
+        super().__init__()
+        self.call_meth: Optional[cst.FunctionDef] = None
+
+    @m.call_if_inside(m.ClassDef(name=m.Name(class_name)))
+    @m.visit(m.FunctionDef(name=m.Name(method_name)))
+    def detect_call(self, node: cst.FunctionDef) -> None:
+        """find the  __call__ method and store it."""
+        self.call_meth = node
+
+
+class CallAdder(m.MatcherDecoratableTransformer):
+    """Add a __call__ method to a class if it is missing."""
+
+    class_name = "Pin"  # class name
+    has_call = 0  # number of __call__ methods found
+
+    def __init__(self, call_meth: cst.FunctionDef) -> None:
+        super().__init__()
+        self.call_meth = call_meth
+
+    @m.call_if_inside(m.ClassDef(name=m.Name(class_name)))
+    @m.visit(m.FunctionDef(name=m.Name("__call__")))
+    def detect_call(self, node: cst.FunctionDef) -> None:
+        """Detect if the class already has a __call__ method."""
+        self.has_call += 1
+
+    @m.leave(m.ClassDef(name=m.Name(class_name)))
+    def add_call(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:
+        """Add the __call__ method to the class if it is not already there."""
+        if self.has_call:
+            # no change needed
+            return updated_node
+        assert isinstance(updated_node.body, cst.IndentedBlock), "Class body is not indented"
+        # Add it to the end of the body & keep other body items
+        new_body = cst.IndentedBlock(
+            body=list(updated_node.body.body) + [self.call_meth],
+            header=updated_node.body.header,
+            footer=updated_node.body.footer,
+            indent=updated_node.body.indent,
+        )
+        return updated_node.with_changes(body=new_body)