micropython-stubber 1.23.1__py3-none-any.whl → 1.23.2__py3-none-any.whl

stubber/codemod/modify_list.py

@@ -1,54 +1,54 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Sequence, Optional
-
-import libcst as cst
-from libcst import matchers as m
-from stubber.codemod.utils import ScopeableMatcherTransformer
-
-
-@dataclass
-class ListChangeSet:
-    """Describes a set of changes to be made to a list.
-    - add: a list of elements to add to the list
-    - remove: a list of elements to remove from the list
-    - replace: if True, the list will be replaced with the elements in add
-    """
-
-    add: Sequence[cst.BaseExpression] = field(default_factory=list)
-    remove: Sequence[m.BaseMatcherNode] = field(default_factory=list)
-    replace: bool = False
-
-    @classmethod
-    def from_strings(
-        cls, *, add: Optional[Sequence[str]] = None, remove: Optional[Sequence[str]] = None, replace: bool = False
-    ) -> ListChangeSet:
-        add_nodes = [cst.SimpleString(f'"{s}"') for s in add] if add else []
-        remove_nodes = (
-            [m.SimpleString(f'"{s}"') for s in remove or []] if remove else []
-        )
-        return ListChangeSet(add=add_nodes, remove=remove_nodes, replace=replace)
-
-
-class ModifyListElements(ScopeableMatcherTransformer):
-    """
-    Modifies the elements of a list (i.e, of modules to stub or exclude),
-    adding and removing elements as specified in the change_set.
-    """
-
-    change_set: ListChangeSet
-
-    def __init__(self, *, change_set: ListChangeSet):
-        self.change_set = change_set
-        super().__init__()
-
-    @m.leave(m.List())
-    def modify_list_elements(self, original_node: cst.List, updated_node: cst.List) -> cst.List:
-        current_elements = [e.value for e in original_node.elements if not any(self.matches(e.value, r) for r in self.change_set.remove)]
-        new_elements = [] if self.change_set.replace else current_elements
-        new_elements.extend(self.change_set.add)
-
-        new_list = cst.List(elements=[cst.Element(value=cst.ensure_type(e, cst.BaseExpression)) for e in new_elements])
-
-        return updated_node.with_changes(elements=new_list.elements)
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Sequence, Optional
+
+import libcst as cst
+from libcst import matchers as m
+from stubber.codemod.utils import ScopeableMatcherTransformer
+
+
+@dataclass
+class ListChangeSet:
+    """Describes a set of changes to be made to a list.
+    - add: a list of elements to add to the list
+    - remove: a list of elements to remove from the list
+    - replace: if True, the list will be replaced with the elements in add
+    """
+
+    add: Sequence[cst.BaseExpression] = field(default_factory=list)
+    remove: Sequence[m.BaseMatcherNode] = field(default_factory=list)
+    replace: bool = False
+
+    @classmethod
+    def from_strings(
+        cls, *, add: Optional[Sequence[str]] = None, remove: Optional[Sequence[str]] = None, replace: bool = False
+    ) -> ListChangeSet:
+        add_nodes = [cst.SimpleString(f'"{s}"') for s in add] if add else []
+        remove_nodes = (
+            [m.SimpleString(f'"{s}"') for s in remove or []] if remove else []
+        )
+        return ListChangeSet(add=add_nodes, remove=remove_nodes, replace=replace)
+
+
+class ModifyListElements(ScopeableMatcherTransformer):
+    """
+    Modifies the elements of a list (i.e, of modules to stub or exclude),
+    adding and removing elements as specified in the change_set.
+    """
+
+    change_set: ListChangeSet
+
+    def __init__(self, *, change_set: ListChangeSet):
+        self.change_set = change_set
+        super().__init__()
+
+    @m.leave(m.List())
+    def modify_list_elements(self, original_node: cst.List, updated_node: cst.List) -> cst.List:
+        current_elements = [e.value for e in original_node.elements if not any(self.matches(e.value, r) for r in self.change_set.remove)]
+        new_elements = [] if self.change_set.replace else current_elements
+        new_elements.extend(self.change_set.add)
+
+        new_list = cst.List(elements=[cst.Element(value=cst.ensure_type(e, cst.BaseExpression)) for e in new_elements])
+
+        return updated_node.with_changes(elements=new_list.elements)

stubber/codemod/utils.py

@@ -1,56 +1,56 @@
-from __future__ import annotations
-from libcst import matchers as m
-from libcst.matchers._visitors import _gather_constructed_leave_funcs, _gather_constructed_visit_funcs # type: ignore
-from typing import Any, Optional
-from types import FunctionType
-import itertools
-
-
-def shallow_copy_function(func: Any) -> FunctionType:
-    """Create a shallow copy of the given function.
-
-    The returned function is unbound and does not copy
-    attributes defined on the function.
-
-    """
-    return FunctionType(
-        func.__code__,
-        func.__globals__,
-        name=func.__name__,
-        argdefs=getattr(func, "__defaults__", None),
-        closure=getattr(func, "__closure__", None),
-    )
-
-
-class ScopeableMatcherTransformer(m.MatcherDecoratableTransformer):
-    """MatcherDecoratableTransformer that can be reused with different scopes."""
-
-    scope_matcher: Optional[m.BaseMatcherNode]
-
-    def __init__(self):
-        super().__init__()
-
-    def _build_scoped_meth(self, method_name: str, scope_matcher: m.BaseMatcherNode):
-        """Build unbound scoped method from parent class."""
-        bound_meth = getattr(type(self), method_name)
-        matchers = {k: v for k, v in bound_meth.__dict__.items() if k in {"_leave_matcher", "_visit_matcher"}}
-        unbound_meth = shallow_copy_function(bound_meth)
-        unbound_meth.__dict__.update(matchers)
-        return m.call_if_inside(scope_matcher)(unbound_meth)
-
-    def with_scope(self, scope_matcher: m.BaseMatcherNode) -> m.MatcherDecoratableTransformer:
-        """Construct a copy of this matcher with visitors scoped to `scope_matcher.`"""
-        constructed_meths = list(
-            itertools.chain.from_iterable(
-                [*_gather_constructed_leave_funcs(self).values(), *_gather_constructed_visit_funcs(self).values()]
-            )
-        )
-        scoped_meths = {f.__name__: self._build_scoped_meth(f.__name__, scope_matcher) for f in constructed_meths}
-        inst_vars = {k: v for k, v in vars(self).items() if k not in {"_matchers", "_extra_leave_funcs", "_extra_visit_funcs"}}
-        # create a dynamically derived class with the transform meth wrapped with scope check.
-        klass = type(
-            f"{self.__class__.__name__}_{repr(scope_matcher)}",
-            (m.MatcherDecoratableTransformer,),
-            {**inst_vars, **scoped_meths, "scope_matcher": scope_matcher},
-        )
-        return klass()
+from __future__ import annotations
+from libcst import matchers as m
+from libcst.matchers._visitors import _gather_constructed_leave_funcs, _gather_constructed_visit_funcs # type: ignore
+from typing import Any, Optional
+from types import FunctionType
+import itertools
+
+
+def shallow_copy_function(func: Any) -> FunctionType:
+    """Create a shallow copy of the given function.
+
+    The returned function is unbound and does not copy
+    attributes defined on the function.
+
+    """
+    return FunctionType(
+        func.__code__,
+        func.__globals__,
+        name=func.__name__,
+        argdefs=getattr(func, "__defaults__", None),
+        closure=getattr(func, "__closure__", None),
+    )
+
+
+class ScopeableMatcherTransformer(m.MatcherDecoratableTransformer):
+    """MatcherDecoratableTransformer that can be reused with different scopes."""
+
+    scope_matcher: Optional[m.BaseMatcherNode]
+
+    def __init__(self):
+        super().__init__()
+
+    def _build_scoped_meth(self, method_name: str, scope_matcher: m.BaseMatcherNode):
+        """Build unbound scoped method from parent class."""
+        bound_meth = getattr(type(self), method_name)
+        matchers = {k: v for k, v in bound_meth.__dict__.items() if k in {"_leave_matcher", "_visit_matcher"}}
+        unbound_meth = shallow_copy_function(bound_meth)
+        unbound_meth.__dict__.update(matchers)
+        return m.call_if_inside(scope_matcher)(unbound_meth)
+
+    def with_scope(self, scope_matcher: m.BaseMatcherNode) -> m.MatcherDecoratableTransformer:
+        """Construct a copy of this matcher with visitors scoped to `scope_matcher.`"""
+        constructed_meths = list(
+            itertools.chain.from_iterable(
+                [*_gather_constructed_leave_funcs(self).values(), *_gather_constructed_visit_funcs(self).values()]
+            )
+        )
+        scoped_meths = {f.__name__: self._build_scoped_meth(f.__name__, scope_matcher) for f in constructed_meths}
+        inst_vars = {k: v for k, v in vars(self).items() if k not in {"_matchers", "_extra_leave_funcs", "_extra_visit_funcs"}}
+        # create a dynamically derived class with the transform meth wrapped with scope check.
+        klass = type(
+            f"{self.__class__.__name__}_{repr(scope_matcher)}",
+            (m.MatcherDecoratableTransformer,),
+            {**inst_vars, **scoped_meths, "scope_matcher": scope_matcher},
+        )
+        return klass()

stubber/commands/build_cmd.py

@@ -1,94 +1,94 @@
-"""Build stub packages - is a Light version of Publish command"""
-
-from typing import List, Union
-
-import rich_click as click
-from loguru import logger as log
-from tabulate import tabulate
-
-from stubber.commands.cli import stubber_cli
-from stubber.publish.defaults import GENERIC_U
-from stubber.publish.publish import build_multiple
-from stubber.utils.config import CONFIG
-
-
-@stubber_cli.command(name="build")
-@click.option("--family", default="micropython", type=str, show_default=True)
-@click.option(
-    "--version",
-    "--Version",
-    "-V",
-    "versions",
-    multiple=True,
-    default=[CONFIG.stable_version],
-    show_default=True,
-    help="MicroPython version to build, or 'preview' for the latest preview version",
-)
-@click.option(
-    "--port",
-    "-p",
-    "ports",
-    multiple=True,
-    default=["all"],
-    show_default=True,
-    help="multiple: ",
-)
-@click.option(
-    "--board",
-    "-b",
-    "boards",
-    multiple=True,
-    default=[GENERIC_U],  # or "all" ?
-    show_default=True,
-    help="multiple: ",
-)
-@click.option(
-    "--clean",
-    is_flag=True,
-    default=False,
-    help="clean folders after processing and publishing",
-)
-@click.option(
-    "--force",
-    is_flag=True,
-    default=False,
-    help="build package even if no changes detected",
-)
-def cli_build(
-    family: str,
-    versions: Union[str, List[str]],
-    ports: Union[str, List[str]],
-    boards: Union[str, List[str]],
-    clean: bool,
-    force: bool,
-    # stub_type: str,
-):
-    """
-    Commandline interface to publish stubs.
-    """
-
-    # lists please
-    versions = list(versions)
-    ports = list(ports)
-    boards = list(boards)
-
-    if len(versions) > 1:
-        raise NotImplementedError(
-            "Multiple versions are not supported yet\n See https://github.com/Josverl/micropython-stubber/issues/487"
-        )
-
-    # db = get_database(publish_path=CONFIG.publish_path, production=production)
-    log.info(f"Build {family} {versions} {ports} {boards}")
-
-    results = build_multiple(
-        family=family,
-        versions=versions,
-        ports=ports,
-        boards=boards,
-        production=True,  # use production database during build
-        force=force,
-        clean=clean,
-    )
-    # log the number of results with no error
-    log.info(f"Built {len([r for r in results if not r['error']])} stub packages")
-    print(tabulate(results, headers="keys"))
+"""Build stub packages - is a Light version of Publish command"""
+
+from typing import List, Union
+
+import rich_click as click
+from mpflash.logger import log
+from tabulate import tabulate
+
+from stubber.commands.cli import stubber_cli
+from stubber.publish.defaults import GENERIC_U
+from stubber.publish.publish import build_multiple
+from stubber.utils.config import CONFIG
+
+
+@stubber_cli.command(name="build")
+@click.option("--family", default="micropython", type=str, show_default=True)
+@click.option(
+    "--version",
+    "--Version",
+    "-V",
+    "versions",
+    multiple=True,
+    default=[CONFIG.stable_version],
+    show_default=True,
+    help="MicroPython version to build, or 'preview' for the latest preview version",
+)
+@click.option(
+    "--port",
+    "-p",
+    "ports",
+    multiple=True,
+    default=["all"],
+    show_default=True,
+    help="multiple: ",
+)
+@click.option(
+    "--board",
+    "-b",
+    "boards",
+    multiple=True,
+    default=[GENERIC_U],  # or "all" ?
+    show_default=True,
+    help="multiple: ",
+)
+@click.option(
+    "--clean",
+    is_flag=True,
+    default=False,
+    help="clean folders after processing and publishing",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    help="build package even if no changes detected",
+)
+def cli_build(
+    family: str,
+    versions: Union[str, List[str]],
+    ports: Union[str, List[str]],
+    boards: Union[str, List[str]],
+    clean: bool,
+    force: bool,
+    # stub_type: str,
+):
+    """
+    Commandline interface to publish stubs.
+    """
+
+    # lists please
+    versions = list(versions)
+    ports = list(ports)
+    boards = list(boards)
+
+    if len(versions) > 1:
+        raise NotImplementedError(
+            "Multiple versions are not supported yet\n See https://github.com/Josverl/micropython-stubber/issues/487"
+        )
+
+    # db = get_database(publish_path=CONFIG.publish_path, production=production)
+    log.info(f"Build {family} {versions} {ports} {boards}")
+
+    results = build_multiple(
+        family=family,
+        versions=versions,
+        ports=ports,
+        boards=boards,
+        production=True,  # use production database during build
+        force=force,
+        clean=clean,
+    )
+    # log the number of results with no error
+    log.info(f"Built {len([r for r in results if not r['error']])} stub packages")
+    print(tabulate(results, headers="keys"))

stubber/commands/cli.py

@@ -1,55 +1,49 @@
-"""
-command line interface - main group
-"""
-
-import sys
-
-import rich_click as click
-from loguru import logger as log
-from stubber import __version__
-
-
-@click.group(chain=True)
-@click.version_option(package_name="micropython-stubber", prog_name="micropython-stubber✏️ ")
-@click.option(
-    "-V",
-    "-V",
-    "--verbose",
-    count=True,
-    default=0,
-    help="-V for DEBUG, -VV for TRACE",
-    is_eager=True,
-)
-@click.pass_context
-def stubber_cli(ctx: click.Context, verbose: int = 0) -> None:
-    # ensure that ctx.obj exists and is a dict (in case `cli()` is called
-    ctx.ensure_object(dict)
-    # replace std log handler with a custom one capped on INFO level
-    level = set_loglevel(verbose)
-
-    if level != "INFO":
-        log.info(f"Log level set to {level}")
-    # save info in context for other CLICK modules to use
-    ctx.obj["loglevel"] = level
-    ctx.obj["verbose"] = verbose
-
-
-def set_loglevel(verbose: int) -> str:
-    """Set log level based on verbose level
-    Get the level from the verbose setting (0=INFO, 1=DEBUG, 2=TRACE)
-    Set the format string, based on the level.
-    Add the handler to the logger, with the level and format string.
-    Return the level
-    """
-    log.remove()
-    level = {0: "INFO", 1: "DEBUG", 2: "TRACE"}.get(verbose, "TRACE")
-    if level == "INFO":
-        format_str = "<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{module: <18}</cyan> - <level>{message}</level>"
-    else:
-        format_str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
-
-    log.add(
-        sys.stderr, level=level, backtrace=True, diagnose=True, colorize=True, format=format_str
-    )
-    log.info(f"micropython-stubber {__version__}")
-    return level
+"""
+command line interface - main group
+"""
+
+import sys
+
+from mpflash.vendor.click_aliases import ClickAliasedGroup
+import rich_click as click
+from mpflash.logger import log, set_loglevel as mpf_set_loglevel
+from stubber import __version__
+
+
+@click.group(chain=True, cls=ClickAliasedGroup)
+@click.version_option(package_name="micropython-stubber", prog_name="micropython-stubber✏️ ")
+@click.option(
+    "-V",
+    "-V",
+    "--verbose",
+    count=True,
+    default=0,
+    help="-V for DEBUG, -VV for TRACE",
+    is_eager=True,
+)
+@click.pass_context
+def stubber_cli(ctx: click.Context, verbose: int = 0) -> None:
+    # ensure that ctx.obj exists and is a dict (in case `cli()` is called
+    ctx.ensure_object(dict)
+    # replace std log handler with a custom one capped on INFO level
+    level = set_loglevel(verbose)
+
+    if level != "INFO":
+        log.info(f"Log level set to {level}")
+    # save info in context for other CLICK modules to use
+    ctx.obj["loglevel"] = level
+    ctx.obj["verbose"] = verbose
+
+
+def set_loglevel(verbose: int) -> str:
+    """Set log level based on verbose level
+    Get the level from the verbose setting (0=INFO, 1=DEBUG, 2=TRACE)
+    Set the format string, based on the level.
+    Add the handler to the logger, with the level and format string.
+    Return the level
+    """
+    level = {0: "INFO", 1: "DEBUG", 2: "TRACE"}.get(verbose, "TRACE")
+    # reuse mpflash logger
+    mpf_set_loglevel(level)
+    log.info(f"micropython-stubber {__version__}")
+    return level