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

stubber/utils/stubmaker.py

@@ -1,139 +1,139 @@
-"""Generate stub files for micropython modules using mypy/stubgen"""
-
-import re
-import sys
-from pathlib import Path
-
-import mypy.stubgen as stubgen
-from loguru import logger as log
-from mypy.errors import CompileError
-
-# default stubgen options
-STUBGEN_OPT = stubgen.Options(
-    pyversion=(
-        3,
-        8,
-    ),  # documentation uses position-only argument indicator which requires 3.8 or higher
-    no_import=False,
-    include_private=True,
-    doc_dir="",
-    search_path=[],
-    interpreter=sys.executable,
-    parse_only=False,
-    ignore_errors=True,
-    modules=[],
-    packages=[],
-    files=[],
-    output_dir="",
-    verbose=True,
-    quiet=False,
-    export_less=False,
-    inspect=False,  # inspect needs to import the module in CPython, which is not possible for frozen modules
-    include_docstrings=True,  # include existing docstrings with the stubs
-)
-
-
-def generate_pyi_from_file(file: Path) -> bool:
-    """Generate a .pyi stubfile from a single .py module using mypy/stubgen"""
-
-    sg_opt = STUBGEN_OPT
-    # Deal with generator passed in
-    assert isinstance(file, Path)
-
-    sg_opt.files = [str(file)]
-    sg_opt.output_dir = str(file.parent)
-    try:
-        log.debug(f"Calling stubgen on {str(file)}")
-        # TDOD: Stubgen.generate_stubs does not provide a way to return the errors
-        # such as `cannot perform relative import`
-
-        stubgen.generate_stubs(sg_opt)
-        return True
-    except (Exception, CompileError, SystemExit) as e:
-        # the only way to know if an error was encountered by generate_stubs
-        # TODO: Extract info from e.code or e.args[0] and add that to the manifest ?
-        log.warning(e.args[0])
-        return False
-
-
-def generate_pyi_files(modules_folder: Path) -> bool:
-    """
-    Generate typeshed files for all scripts in a folder using mypy/stubgen
-
-    Returns: False if one or more files had an issue generating a stub
-    """
-    # stubgen cannot process folders with duplicate modules ( ie v1.14 and v1.15 )
-    # NOTE: FIX 1 add __init__.py to umqtt
-    if (modules_folder / "umqtt/robust.py").exists():
-        log.debug("add missing : umqtt/__init__.py")
-        with open(modules_folder / "umqtt" / "__init__.py", "a") as f:
-            f.write("")
-
-    # rx_const = re.compile(r"const\(([\w_\"']+)\)")
-    rx_const = re.compile(r"const\(([-*<.,:/\(\) \w_\"']+)\)")
-    # FIX 2 - replace `const(foo)` with `foo`
-    for f in modules_folder.rglob("*.py"):
-        if f.is_file():
-            with open(f, "r") as file:
-                data = file.read()
-            # regex Search for const\(([\w_"']+)\) and replace with (\1)
-            if rx_const.search(data):
-                log.debug(f"replace const() in {f}")
-                data = rx_const.sub(r"\1", data)
-                with open(f, "w") as file:
-                    file.write(data)
-
-    module_list = list(modules_folder.glob("**/modules.json"))
-    r = True
-    if len(module_list) > 1:
-        # try to process each module separately
-        for mod_manifest in module_list:
-            ## generate fyi files for folder
-            r = r and generate_pyi_files(mod_manifest.parent)
-    else:  # one or less module manifests
-        ## generate fyi files for folder
-        log.debug("::group::[stubgen] running stubgen on {0}".format(modules_folder))
-
-        run_per_file = False
-        sg_opt = STUBGEN_OPT
-        sg_opt.files = [str(modules_folder)]
-        sg_opt.output_dir = str(modules_folder)
-        try:
-            stubgen.generate_stubs(sg_opt)
-        except (Exception, CompileError, SystemExit) as e:
-            if isinstance(e, KeyboardInterrupt):
-                raise e
-            # the only way to know if an error was encountered by generate_stubs
-            # mypy.errors.CompileError and others ?
-            # TODO: Extract info from e.code or e.args[0]
-            log.warning(e.args[0])
-            run_per_file = True
-
-        if run_per_file:
-            # in case of failure ( duplicate module in subfolder) then Plan B
-            # - run stubgen on each *.py
-            log.debug("::group::[stubgen] Failure on folder, attempt to run stubgen per file")
-            py_files = list(modules_folder.rglob("*.py"))
-            for py in py_files:
-                generate_pyi_from_file(py)
-                # todo: report failures by adding to module manifest
-
-        # for py missing pyi:
-        py_files = list(modules_folder.rglob("*.py"))
-        pyi_files = list(modules_folder.rglob("*.pyi"))
-
-        work_list = pyi_files.copy()
-        for pyi in work_list:
-            # remove all py files that have been stubbed successfully from the list
-            try:
-                py_files.remove(pyi.with_suffix(".py"))
-                pyi_files.remove(pyi)
-            except ValueError:
-                log.debug(f"no matching py for : {str(pyi)}")
-
-        # note in some cases this will try a file twice - but that is better than failing
-        for py in py_files:
-            r = r and generate_pyi_from_file(py)
-            # todo: report failures by adding to module manifest
-
-    return r
+"""Generate stub files for micropython modules using mypy/stubgen"""
+
+import re
+import sys
+from pathlib import Path
+
+import mypy.stubgen as stubgen
+from mpflash.logger import log
+from mypy.errors import CompileError
+
+# default stubgen options
+STUBGEN_OPT = stubgen.Options(
+    pyversion=(
+        3,
+        8,
+    ),  # documentation uses position-only argument indicator which requires 3.8 or higher
+    no_import=False,
+    include_private=True,
+    doc_dir="",
+    search_path=[],
+    interpreter=sys.executable,
+    parse_only=False,
+    ignore_errors=True,
+    modules=[],
+    packages=[],
+    files=[],
+    output_dir="",
+    verbose=True,
+    quiet=False,
+    export_less=False,
+    inspect=False,  # inspect needs to import the module in CPython, which is not possible for frozen modules
+    include_docstrings=True,  # include existing docstrings with the stubs
+)
+
+
+def generate_pyi_from_file(file: Path) -> bool:
+    """Generate a .pyi stubfile from a single .py module using mypy/stubgen"""
+
+    sg_opt = STUBGEN_OPT
+    # Deal with generator passed in
+    assert isinstance(file, Path)
+
+    sg_opt.files = [str(file)]
+    sg_opt.output_dir = str(file.parent)
+    try:
+        log.debug(f"Calling stubgen on {str(file)}")
+        # TDOD: Stubgen.generate_stubs does not provide a way to return the errors
+        # such as `cannot perform relative import`
+
+        stubgen.generate_stubs(sg_opt)
+        return True
+    except (Exception, CompileError, SystemExit) as e:
+        # the only way to know if an error was encountered by generate_stubs
+        # TODO: Extract info from e.code or e.args[0] and add that to the manifest ?
+        log.warning(e.args[0])
+        return False
+
+
+def generate_pyi_files(modules_folder: Path) -> bool:
+    """
+    Generate typeshed files for all scripts in a folder using mypy/stubgen
+
+    Returns: False if one or more files had an issue generating a stub
+    """
+    # stubgen cannot process folders with duplicate modules ( ie v1.14 and v1.15 )
+    # NOTE: FIX 1 add __init__.py to umqtt
+    if (modules_folder / "umqtt/robust.py").exists():
+        log.debug("add missing : umqtt/__init__.py")
+        with open(modules_folder / "umqtt" / "__init__.py", "a") as f:
+            f.write("")
+
+    # rx_const = re.compile(r"const\(([\w_\"']+)\)")
+    rx_const = re.compile(r"const\(([-*<.,:/\(\) \w_\"']+)\)")
+    # FIX 2 - replace `const(foo)` with `foo`
+    for f in modules_folder.rglob("*.py"):
+        if f.is_file():
+            with open(f, "r") as file:
+                data = file.read()
+            # regex Search for const\(([\w_"']+)\) and replace with (\1)
+            if rx_const.search(data):
+                log.debug(f"replace const() in {f}")
+                data = rx_const.sub(r"\1", data)
+                with open(f, "w") as file:
+                    file.write(data)
+
+    module_list = list(modules_folder.glob("**/modules.json"))
+    r = True
+    if len(module_list) > 1:
+        # try to process each module separately
+        for mod_manifest in module_list:
+            ## generate fyi files for folder
+            r = r and generate_pyi_files(mod_manifest.parent)
+    else:  # one or less module manifests
+        ## generate fyi files for folder
+        log.debug("::group::[stubgen] running stubgen on {0}".format(modules_folder))
+
+        run_per_file = False
+        sg_opt = STUBGEN_OPT
+        sg_opt.files = [str(modules_folder)]
+        sg_opt.output_dir = str(modules_folder)
+        try:
+            stubgen.generate_stubs(sg_opt)
+        except (Exception, CompileError, SystemExit) as e:
+            if isinstance(e, KeyboardInterrupt):
+                raise e
+            # the only way to know if an error was encountered by generate_stubs
+            # mypy.errors.CompileError and others ?
+            # TODO: Extract info from e.code or e.args[0]
+            log.warning(e.args[0])
+            run_per_file = True
+
+        if run_per_file:
+            # in case of failure ( duplicate module in subfolder) then Plan B
+            # - run stubgen on each *.py
+            log.debug("::group::[stubgen] Failure on folder, attempt to run stubgen per file")
+            py_files = list(modules_folder.rglob("*.py"))
+            for py in py_files:
+                generate_pyi_from_file(py)
+                # todo: report failures by adding to module manifest
+
+        # for py missing pyi:
+        py_files = list(modules_folder.rglob("*.py"))
+        pyi_files = list(modules_folder.rglob("*.pyi"))
+
+        work_list = pyi_files.copy()
+        for pyi in work_list:
+            # remove all py files that have been stubbed successfully from the list
+            try:
+                py_files.remove(pyi.with_suffix(".py"))
+                pyi_files.remove(pyi)
+            except ValueError:
+                log.debug(f"no matching py for : {str(pyi)}")
+
+        # note in some cases this will try a file twice - but that is better than failing
+        for py in py_files:
+            r = r and generate_pyi_from_file(py)
+            # todo: report failures by adding to module manifest
+
+    return r

stubber/utils/typed_config_toml.py

@@ -1,77 +1,80 @@
-"""
-typed-config-toml
-
-Extend typed-config to read configuration from .toml files
-
-"""
-# TODO : extend support for . notation in section names
-
-from pathlib import Path
-from typing import Dict, Optional
-
-try:
-    import tomllib  # type: ignore
-except ModuleNotFoundError:
-    import tomli as tomllib  # type: ignore
-assert tomllib
-
-from loguru import logger as log
-from typedconfig.source import ConfigSource
-
-
-class TomlConfigSource(ConfigSource):
-    """Read configuration from a .toml file
-
-    prefix is used to allow for toml nested configuration
-    a common prefix = "tool."
-
-    ```
-    #pyproject.toml
-    [tool.deadparrot]
-    species = "Norwegian Blue"
-    state = "resting"
-    details = ["pinging","Lovely plumage","3"]
-    ```
-    Use the below code to retrieve:
-    ```
-    # TODO sample code
-    ```
-    """
-
-    def __init__(self, filename: str, prefix: Optional[str] = None, must_exist: bool = True):
-        self.filename = filename
-        toml_dict = {}
-        if Path(self.filename).exists():
-            # Read data - will raise an exception if problem with file
-            try:
-                with open(filename, "rb") as f:
-                    toml_dict = tomllib.load(f)
-            except tomllib.TOMLDecodeError:  # pragma: no cover
-                log.warning("unable to read ")
-        elif must_exist:
-            raise FileNotFoundError(f"Could not find config file {self.filename}")
-        if not prefix or len(prefix) == 0:
-            self.data = toml_dict
-        else:
-            # common prefix = "tool."
-            try:
-                self.data = toml_dict[prefix.rstrip(".")]
-            except KeyError:  # pragma: no cover
-                self.data = {}
-
-        # Quick checks on data format
-        assert isinstance(self.data, Dict)
-        for k, v in self.data.items():
-            assert isinstance(k, str)
-            assert isinstance(v, Dict)
-            for v_k, v_v in v.items():  # type: ignore
-                assert isinstance(v_k, str)
-                # do not assume/require that all values are strings
-                # assert isinstance(v_v, str)
-        # Convert all keys to lowercase
-        self.data = {k.lower(): {v_k.lower(): v_v for v_k, v_v in v.items()} for k, v in self.data.items()}
-
-    def get_config_value(self, section_name: str, key_name: str) -> Optional[str]:
-        # Extract info from data which we read in during __init__
-        section = self.data.get(section_name.lower(), None)
-        return None if section is None else section.get(key_name.lower(), None)
+"""
+typed-config-toml
+
+Extend typed-config to read configuration from .toml files
+
+"""
+
+# TODO : extend support for . notation in section names
+
+from pathlib import Path
+from typing import Dict, Optional
+
+try:
+    import tomllib  # type: ignore
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore
+assert tomllib
+
+from mpflash.logger import log
+from typedconfig.source import ConfigSource
+
+
+class TomlConfigSource(ConfigSource):
+    """Read configuration from a .toml file
+
+    prefix is used to allow for toml nested configuration
+    a common prefix = "tool."
+
+    ```
+    #pyproject.toml
+    [tool.deadparrot]
+    species = "Norwegian Blue"
+    state = "resting"
+    details = ["pinging","Lovely plumage","3"]
+    ```
+    Use the below code to retrieve:
+    ```
+    # TODO sample code
+    ```
+    """
+
+    def __init__(self, filename: str, prefix: Optional[str] = None, must_exist: bool = True):
+        self.filename = filename
+        toml_dict = {}
+        if Path(self.filename).exists():
+            # Read data - will raise an exception if problem with file
+            try:
+                with open(filename, "rb") as f:
+                    toml_dict = tomllib.load(f)
+            except tomllib.TOMLDecodeError:  # pragma: no cover
+                log.warning("unable to read ")
+        elif must_exist:
+            raise FileNotFoundError(f"Could not find config file {self.filename}")
+        if not prefix or len(prefix) == 0:
+            self.data = toml_dict
+        else:
+            # common prefix = "tool."
+            try:
+                self.data = toml_dict[prefix.rstrip(".")]
+            except KeyError:  # pragma: no cover
+                self.data = {}
+
+        # Quick checks on data format
+        assert isinstance(self.data, Dict)
+        for k, v in self.data.items():
+            assert isinstance(k, str)
+            assert isinstance(v, Dict)
+            for v_k, v_v in v.items():  # type: ignore
+                assert isinstance(v_k, str)
+                # do not assume/require that all values are strings
+                # assert isinstance(v_v, str)
+        # Convert all keys to lowercase
+        self.data = {
+            k.lower(): {v_k.lower(): v_v for v_k, v_v in v.items()} for k, v in self.data.items()
+        }
+
+    def get_config_value(self, section_name: str, key_name: str) -> Optional[str]:
+        # Extract info from data which we read in during __init__
+        section = self.data.get(section_name.lower(), None)
+        return None if section is None else section.get(key_name.lower(), None)

stubber/variants.py

@@ -1,106 +1,106 @@
-"""
-Create all variants of createstubs.py
-- and minify them 
-- and cross compile them
-"""
-
-import shutil
-from pathlib import Path
-from typing import List, Optional
-
-import libcst as cst
-import libcst.codemod as codemod
-from loguru import logger as log
-
-from stubber.codemod.board import CreateStubsCodemod, CreateStubsVariant
-from stubber.codemod.modify_list import ListChangeSet  # type: ignore
-from stubber.minify import cross_compile, minify
-from stubber.update_module_list import update_module_list
-from stubber.utils.post import run_black
-
-ALL_VARIANTS = list(CreateStubsVariant)
-
-
-def create_variants(
-    base_path: Path,
-    *,
-    target_path: Optional[Path] = None,
-    version: str = "",
-    make_variants: List[CreateStubsVariant] = ALL_VARIANTS[:3],
-    update_modules: bool = True,
-):
-    """
-    Create variants of createstubs.py and optionally minify and cross compile them.
-
-    Parameters
-    ----------
-    base_path : Path
-        Path to the base createstubs.py file
-    target_path : Path, optional
-        Path to write the variants to, by default None
-    version : str, optional
-        Version of mpy-cross to use, by default uses the latest published version
-
-    """
-    if target_path is None:
-        target_path = base_path
-    if update_modules:
-        update_module_list()
-
-    ctx = codemod.CodemodContext()
-    base_file = base_path / "createstubs.py"
-    log.info(f"Reading : {base_file}")
-    base_txt = (base_path / "createstubs.py").read_text(encoding="utf-8")
-    base_module = cst.parse_module(base_txt)
-
-    for var in make_variants:
-        # Transform base to createstubs.py variant
-
-        suffix = "" if var == CreateStubsVariant.BASE else f"_{var.value}"
-
-        variant_path = target_path / f"createstubs{suffix}.py"
-        minified_path = target_path / f"createstubs{suffix}_min.py"
-        mpy_path = target_path / f"createstubs{suffix}_mpy.mpy"  # intentional
-
-        if var == CreateStubsVariant.BASE and target_path != base_path:
-            log.info(f"Copying base file to {variant_path}")
-            variant_path.write_text(base_txt)
-            # copy modules.txt to target_path
-            shutil.copyfile(base_path / "modulelist.txt", target_path / "modulelist.txt")
-
-        if var != CreateStubsVariant.BASE:
-            # No need to create base variant as it is the same as the base file
-            log.info(f"Transforming to {var.value} variant")
-            cm = CreateStubsCodemod(ctx, variant=var)
-            variant = cm.transform_module(base_module)
-
-            # write low_mem_variant.code to file
-            log.info(f"Write variant {var.value} to {variant_path}")
-            with open(variant_path, "w") as f:
-                f.write(variant.code)
-
-            # format file with black
-            run_black(variant_path, capture_output=True)
-            # TODO: check with pyright if it is valid python
-
-        # Minify file with pyminifier
-        log.info(f"Minifying to {minified_path.name}")
-        minify(variant_path, minified_path, keep_report=False, diff=False)
-
-        # str -> path
-        # read minified file
-        minified_txt = minified_path.read_text(encoding="utf-8")
-        cross_compile(minified_txt, mpy_path, version=version)
-
-
-if __name__ == "__main__":
-    # read base createstubs.py
-    base_path = Path.cwd() / "src" / "stubber" / "board"
-    create_variants(base_path)
-
-    # if 0:
-    #     # custom modules (and skip defaults).
-    #     custom_stubs = ListChangeSet.from_strings(add=["mycoolpackage", "othermodule"], replace=True)
-    #     custom_variant = CreateStubsCodemod(ctx, modules=custom_stubs).transform_module(base_module)
-
-    #     print(custom_variant.code)
+"""
+Create all variants of createstubs.py
+- and minify them 
+- and cross compile them
+"""
+
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+import libcst as cst
+import libcst.codemod as codemod
+from mpflash.logger import log
+
+from stubber.codemod.board import CreateStubsCodemod, CreateStubsVariant
+from stubber.codemod.modify_list import ListChangeSet  # type: ignore
+from stubber.minify import cross_compile, minify
+from stubber.update_module_list import update_module_list
+from stubber.utils.post import run_black
+
+ALL_VARIANTS = list(CreateStubsVariant)
+
+
+def create_variants(
+    base_path: Path,
+    *,
+    target_path: Optional[Path] = None,
+    version: str = "",
+    make_variants: List[CreateStubsVariant] = ALL_VARIANTS[:3],
+    update_modules: bool = True,
+):
+    """
+    Create variants of createstubs.py and optionally minify and cross compile them.
+
+    Parameters
+    ----------
+    base_path : Path
+        Path to the base createstubs.py file
+    target_path : Path, optional
+        Path to write the variants to, by default None
+    version : str, optional
+        Version of mpy-cross to use, by default uses the latest published version
+
+    """
+    if target_path is None:
+        target_path = base_path
+    if update_modules:
+        update_module_list()
+
+    ctx = codemod.CodemodContext()
+    base_file = base_path / "createstubs.py"
+    log.info(f"Reading : {base_file}")
+    base_txt = (base_path / "createstubs.py").read_text(encoding="utf-8")
+    base_module = cst.parse_module(base_txt)
+
+    for var in make_variants:
+        # Transform base to createstubs.py variant
+
+        suffix = "" if var == CreateStubsVariant.BASE else f"_{var.value}"
+
+        variant_path = target_path / f"createstubs{suffix}.py"
+        minified_path = target_path / f"createstubs{suffix}_min.py"
+        mpy_path = target_path / f"createstubs{suffix}_mpy.mpy"  # intentional
+
+        if var == CreateStubsVariant.BASE and target_path != base_path:
+            log.info(f"Copying base file to {variant_path}")
+            variant_path.write_text(base_txt)
+            # copy modules.txt to target_path
+            shutil.copyfile(base_path / "modulelist.txt", target_path / "modulelist.txt")
+
+        if var != CreateStubsVariant.BASE:
+            # No need to create base variant as it is the same as the base file
+            log.info(f"Transforming to {var.value} variant")
+            cm = CreateStubsCodemod(ctx, variant=var)
+            variant = cm.transform_module(base_module)
+
+            # write low_mem_variant.code to file
+            log.info(f"Write variant {var.value} to {variant_path}")
+            with open(variant_path, "w") as f:
+                f.write(variant.code)
+
+            # format file with black
+            run_black(variant_path, capture_output=True)
+            # TODO: check with pyright if it is valid python
+
+        # Minify file with pyminifier
+        log.info(f"Minifying to {minified_path.name}")
+        minify(variant_path, minified_path, keep_report=False, diff=False)
+
+        # str -> path
+        # read minified file
+        minified_txt = minified_path.read_text(encoding="utf-8")
+        cross_compile(minified_txt, mpy_path, version=version)
+
+
+if __name__ == "__main__":
+    # read base createstubs.py
+    base_path = Path.cwd() / "src" / "stubber" / "board"
+    create_variants(base_path)
+
+    # if 0:
+    #     # custom modules (and skip defaults).
+    #     custom_stubs = ListChangeSet.from_strings(add=["mycoolpackage", "othermodule"], replace=True)
+    #     custom_variant = CreateStubsCodemod(ctx, modules=custom_stubs).transform_module(base_module)
+
+    #     print(custom_variant.code)