micropython-stubber 1.23.3__py3-none-any.whl → 1.24.1__py3-none-any.whl

stubber/rst/reader.py

@@ -69,10 +69,12 @@ from typing import List, Optional, Tuple
 
 from mpflash.logger import log
 from mpflash.versions import V_PREVIEW
+
 from stubber.rst import (
     CHILD_PARENT_CLASS,
     MODULE_GLUE,
     PARAM_FIXES,
+    PARAM_RE_FIXES,
     RST_DOC_FIXES,
     TYPING_IMPORT,
     ClassSourceDict,
@@ -83,14 +85,17 @@ from stubber.rst import (
 from stubber.rst.lookup import Fix
 from stubber.utils.config import CONFIG
 
-SEPERATOR = "::"
+SEPARATOR = "::"
+USE_SUBMODULES = True
 
 
 class FileReadWriter:
     """base class for reading rst files"""
 
     def __init__(self):
-        self.filename = ""
+        self.filename: str = ""
+        # self.modulename: str = ""
+        # self.out_file: str = "__init__.pyi"
         # input buffer
         self.rst_text: List[str] = []
         self.max_line = 0
@@ -111,6 +116,8 @@ class FileReadWriter:
         # some lines now may have \n sin them , so re-join and re-split the lines
         self.rst_text = "".join(self.rst_text).splitlines(keepends=True)
 
+        self.modulename = filename.stem
+        self.out_file = "__init__.pyi"
         self.filename = filename.as_posix()  # use fwd slashes in origin
         self.max_line = len(self.rst_text) - 1
 
@@ -148,7 +155,11 @@ class FileReadWriter:
         """
         append = 0
         newline = self.rst_text[self.line_no]
-        while not self.is_balanced(newline) and self.line_no >= 0 and (self.line_no + append + 1) <= self.max_line:
+        while (
+            not self.is_balanced(newline)
+            and self.line_no >= 0
+            and (self.line_no + append + 1) <= self.max_line
+        ):
             append += 1
             # concat the lines
             newline += self.rst_text[self.line_no + append]
@@ -177,6 +188,7 @@ class RSTReader(FileReadWriter):
         self.current_module = ""
         self.current_class = ""
         self.current_function = ""  # function & method
+        self.clean_rst = True
         super().__init__()
 
     def read_file(self, filename: Path):
@@ -215,11 +227,13 @@ class RSTReader(FileReadWriter):
         # return _l.startswith("..") and not any(_l.startswith(a) for a in self.docstring_anchors)
 
     # @property
-    def at_heading(self, large=False) -> bool:
+    def at_heading(self, large: bool = False) -> bool:
         "stop at heading"
         u_line = self.rst_text[min(self.line_no + 1, self.max_line - 1)].rstrip()
         # Heading  ---, ==, ~~~
-        underlined = u_line.startswith("---") or u_line.startswith("===") or u_line.startswith("~~~")
+        underlined = (
+            u_line.startswith("---") or u_line.startswith("===") or u_line.startswith("~~~")
+        )
         if underlined and self.line_no > 0:
             # check if previous line is a heading
             line = self.rst_text[self.line_no].strip()
@@ -278,22 +292,23 @@ class RSTReader(FileReadWriter):
         # remove empty lines at beginning/end of block
         block = self.clean_docstr(block)
         # add clickable hyperlinks to CPython docpages
-        block = self.add_link_to_docsstr(block)
+        block = self.add_link_to_docstr(block)
         # make sure the first char of the first line is a capital
         if len(block) > 0 and len(block[0]) > 0:
             block[0] = block[0][0].upper() + block[0][1:]
         return block
 
-    @staticmethod
-    def clean_docstr(block: List[str]):
+    # @staticmethod
+    def clean_docstr(self, block: List[str]):
         """Clean up a docstring"""
-        # if a Quoted Literal Block , then remove the first character of each line
-        # https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html#quoted-literal-blocks
-        if block and len(block[0]) > 0 and block[0][0] != " ":
-            q_char = block[0][0]
-            if all(l.startswith(q_char) for l in block):
-                # all lines start with the same character, so skip that character
-                block = [l[1:] for l in block]
+        if self.clean_rst:
+            # if a Quoted Literal Block , then remove the first character of each line
+            # https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html#quoted-literal-blocks
+            if block and len(block[0]) > 0 and block[0][0] != " ":
+                q_char = block[0][0]
+                if all(l.startswith(q_char) for l in block):
+                    # all lines start with the same character, so skip that character
+                    block = [l[1:] for l in block]
         # rstrip all lines
         block = [l.rstrip() for l in block]
         # remove empty lines at beginning/end of block
@@ -301,7 +316,6 @@ class RSTReader(FileReadWriter):
             block = block[1:]
         while len(block) and len(block[-1]) == 0:
             block = block[:-1]
-
         # Clean up Synopsis
         if len(block) and ":synopsis:" in block[0]:
             block[0] = re.sub(
@@ -311,15 +325,18 @@ class RSTReader(FileReadWriter):
             )
         return block
 
-    @staticmethod
-    def add_link_to_docsstr(block: List[str]):
-        """Add clickable hyperlinks to CPython docpages"""
+    def add_link_to_docstr(self, block: List[str]):
+        """Add clickable hyperlinks to CPython docpages,
+        and clean the docstring from rst constructs"""
+        if not self.clean_rst:
+            return block
+
         for i in range(len(block)):
             # hyperlink to Cpython doc pages
             # https://regex101.com/r/5RN8rj/1
             # Link to python 3 documentation
             _l = re.sub(
-                r"(\s*\|see_cpython_module\|\s+:mod:`python:(?P<mod>[\w|\s]*)`)[.]?",
+                r"(\s*\|see_cpython_module\|\s+:mod:`python:(?P<mod>[\w|]*)\s?`)[.]?",
                 r"\g<1> https://docs.python.org/3/library/\g<mod>.html .",
                 block[i],
             )
@@ -333,7 +350,10 @@ class RSTReader(FileReadWriter):
             # Clean up note and other docstring anchors
             _l = _l.replace(".. note:: ", "``Note:`` ")
             _l = _l.replace(".. data:: ", "")
-            _l = _l.replace(".. admonition:: ", "")
+            _l = _l.replace(".. admonition:: ", "Admonition:")
+            # remove rst highlights from docstrings
+            _l = _l.replace(":class: attention\n", "")
+            # Sphinx directive to link to CPython documentation
             _l = _l.replace("|see_cpython_module|", "CPython module:")
             # clean up unsupported escape sequences in rst
             _l = _l.replace(r"\ ", " ")
@@ -347,7 +367,7 @@ class RSTReader(FileReadWriter):
         return m[1] if m else ""
 
     def strip_prefixes(self, name: str, strip_mod: bool = True, strip_class: bool = False):
-        "Remove the modulename. and or the classname. from the begining of a name"
+        "Remove the modulename. and or the classname. from the beginning of a name"
         prefixes = self.module_names if strip_mod else []
         if strip_class and self.current_class != "":
             prefixes += [self.current_class]
@@ -364,12 +384,6 @@ class RSTParser(RSTReader):
     """
 
     target = ".py"  # py/pyi
-    # TODO: Move to lookup.py
-    PARAM_RE_FIXES = [
-        Fix(r"\[angle, time=0\]", "[angle], time=0", is_re=True),  # fix: method:: Servo.angle([angle, time=0])
-        Fix(r"\[speed, time=0\]", "[speed], time=0", is_re=True),  # fix: .. method:: Servo.speed([speed, time=0])
-        Fix(r"\[service_id, key=None, \*, \.\.\.\]", "[service_id], [key], *, ...", is_re=True),  # fix: network - AbstractNIC.connect
-    ]
 
     def __init__(self, v_tag: str) -> None:
         super().__init__()
@@ -398,7 +412,7 @@ class RSTParser(RSTReader):
 
         ## Deal with SQUARE brackets first ( Documentation meaning := [optional])
 
-        for fix in self.PARAM_RE_FIXES:
+        for fix in PARAM_RE_FIXES:
             params = self.apply_fix(fix, params, name)
 
         # ###########################################################################################################
@@ -432,7 +446,9 @@ class RSTParser(RSTReader):
     def apply_fix(fix: Fix, params: str, name: str = ""):
         if fix.name and fix.name != name:
             return params
-        return re.sub(fix.from_, fix.to, params) if fix.is_re else params.replace(fix.from_, fix.to)
+        return (
+            re.sub(fix.from_, fix.to, params) if fix.is_re else params.replace(fix.from_, fix.to)
+        )
 
     def create_update_class(self, name: str, params: str, docstr: List[str]):
         # a bit of a hack: assume no classes in classes  or functions in function
@@ -442,7 +458,9 @@ class RSTParser(RSTReader):
             class_def = self.output_dict[full_name]
         else:
             parent = CHILD_PARENT_CLASS[name] if name in CHILD_PARENT_CLASS.keys() else ""
-            if parent == "" and (name.endswith("Error") or name.endswith("Exception")):
+            if parent == "" and (
+                name.endswith("Error") or name.endswith("Exception") or name in {"GeneratorExit"}
+            ):
                 parent = "Exception"
             class_def = ClassSourceDict(
                 f"class {name}({parent}):",
@@ -467,12 +485,25 @@ class RSTParser(RSTReader):
         toctree = self.read_docstring()
         # cleanup toctree
         toctree = [x.strip() for x in toctree if f"{self.current_module}." in x]
-        # Now parse all files mentioned in the toc
-        for file in toctree:
-            #
-            file_path = CONFIG.mpy_path / "docs" / "library" / file.strip()
-            self.read_file(file_path)
-            self.parse()
+
+        if USE_SUBMODULES:
+            # add sub modules imports
+            for file in toctree:
+                submod_name = file.replace(".rst", "")
+                rel_name = submod_name.replace(f"{self.modulename}.", ".")
+                assumed_class = rel_name.lstrip(".")  # .capitalize()
+
+                # absolute class import with class name based on the module name
+                self.output_dict.add_import(f"from {submod_name} import {assumed_class}")
+
+        else:
+            # Now parse all files mentioned in the toc
+            # sub modules are now processed as individual files
+            for file in toctree:
+                #
+                file_path = CONFIG.mpy_path / "docs" / "library" / file.strip()
+                self.read_file(file_path)
+                self.parse()
         # reset this file to done
         self.rst_text = []
         self.line_no = 1
@@ -480,7 +511,7 @@ class RSTParser(RSTReader):
     def parse_module(self):
         "parse a module tag and set the module's docstring"
         log.trace(f"# {self.line.rstrip()}")
-        module_name = self.line.split(SEPERATOR)[-1].strip()
+        module_name = self.line.split(SEPARATOR)[-1].strip()
 
         self.current_module = module_name
         self.current_function = self.current_class = ""
@@ -493,31 +524,40 @@ class RSTParser(RSTReader):
             if "nightly" in self.source_tag:
                 version = V_PREVIEW
             else:
-                version = self.source_tag.replace("_", ".")  # TODO Use clean_version(self.source_tag)
-            docstr[0] = f"{docstr[0]}.\n\nMicroPython module: https://docs.micropython.org/en/{version}/library/{module_name}.html"
+                version = self.source_tag.replace("_", ".")
+                # documentation is not available for patch versions, so use only the major.minor.0
+                version = ".".join(version.split(".")[:2]) + ".0"
+                # TODO Use clean_version(self.source_tag)
+            docstr[0] = (
+                f"{docstr[0]}.\n\nMicroPython module: https://docs.micropython.org/en/{version}/library/{module_name}.html"
+            )
 
         self.output_dict.name = module_name
         self.output_dict.add_comment(f"# source version: {self.source_tag}")
         self.output_dict.add_comment(f"# origin module:: {self.filename}")
         self.output_dict.add_docstr(docstr)
-        # Add additional imports to allow one module te refer to another
+        # Add additional imports to allow one module to refer to another
         if module_name in MODULE_GLUE.keys():
             self.output_dict.add_import(MODULE_GLUE[module_name])
 
     def parse_current_module(self):
         log.trace(f"# {self.line.rstrip()}")
-        module_name = self.line.split(SEPERATOR)[-1].strip()
-        mod_comment = f"# + module: {self.current_module}.rst"
-        self.current_module = module_name
+        # module_name = self.line.split(SEPARATOR)[-1].strip()
+        # mod_comment = f"# + module: {self.current_module}.rst"
+        # now that each .rst is a (sub) module we can process them as such
+        # log.debug(mod_comment)
+        # self.current_module = module_name
         self.current_function = self.current_class = ""
-        log.debug(mod_comment)
-        self.output_dict.name = module_name
-        self.output_dict.add_comment(mod_comment)
+        self.output_dict.name = self.current_module
+        # self.output_dict.add_comment(mod_comment)
         self.line_no += 1  # advance as we did not read any docstring
+        # Add additional imports to allow one module to refer to another
+        if self.current_module in MODULE_GLUE.keys():
+            self.output_dict.add_import(MODULE_GLUE[self.current_module])
 
     def parse_function(self):
         log.trace(f"# {self.line.rstrip()}")
-        # this_function = self.line.split(SEPERATOR)[-1].strip()
+        # this_function = self.line.split(SEPARATOR)[-1].strip()
         # name = this_function
 
         # Get one or more names
@@ -526,7 +566,9 @@ class RSTParser(RSTReader):
 
         for this_function in function_names:
             # Parse return type from docstring
-            ret_type = return_type_from_context(docstring=docstr, signature=this_function, module=self.current_module)
+            ret_type = return_type_from_context(
+                docstring=docstr, signature=this_function, module=self.current_module
+            )
 
             # defaults
             name = params = ""
@@ -548,7 +590,7 @@ class RSTParser(RSTReader):
             # fixup parameters
             params = self.fix_parameters(params, name)
             # ASSUME no functions in classes,
-            # so with ther cursor at a function this probably means that we are no longer in a class
+            # so with the cursor at a function this probably means that we are no longer in a class
             self.leave_class()
 
             fn_def = FunctionSourceDict(
@@ -560,7 +602,7 @@ class RSTParser(RSTReader):
 
     def parse_class(self):
         log.trace(f"# {self.line.rstrip()}")
-        this_class = self.line.split(SEPERATOR)[-1].strip()  # raw
+        this_class = self.line.split(SEPARATOR)[-1].strip()  # raw
         if "(" in this_class:
             name, params = this_class.split("(", 2)
         else:
@@ -632,7 +674,9 @@ class RSTParser(RSTReader):
             params = self.fix_parameters(params, f"{class_name}.{name}")
 
             # parse return type from docstring
-            ret_type = return_type_from_context(docstring=docstr, signature=f"{class_name}.{name}", module=self.current_module)
+            ret_type = return_type_from_context(
+                docstring=docstr, signature=f"{class_name}.{name}", module=self.current_module
+            )
             # methods have 4 flavours
             #   - __init__              (self,  <params>) -> None:
             #   - classmethod           (cls,   <params>) -> <ret_type>:
@@ -692,7 +736,7 @@ class RSTParser(RSTReader):
 
     def parse_exception(self):
         log.trace(f"# {self.line.rstrip()}")
-        name = self.line.split(SEPERATOR)[1].strip()
+        name = self.line.split(SEPARATOR)[1].strip()
         if name == "Exception":
             # no need to redefine Exception
             self.line_no += 1
@@ -709,9 +753,9 @@ class RSTParser(RSTReader):
         "get the constant/function/class name from a line with an identifier"
         # '.. data:: espnow.MAX_DATA_LEN(=250)\n'
         if line:
-            return line.split(SEPERATOR)[-1].strip()
+            return line.split(SEPARATOR)[-1].strip()
         else:
-            return self.line.split(SEPERATOR)[-1].strip()
+            return self.line.split(SEPARATOR)[-1].strip()
 
     def parse_names(self, oneliner: bool = True):
         """get a list of constant/function/class names from and following a line with an identifier
@@ -734,7 +778,7 @@ class RSTParser(RSTReader):
             log.trace("Sequence detected")
             names.append(self.parse_name(self.rst_text[self.line_no + counter]))
             counter += 1
-        # now advance the linecounter
+        # now advance the line counter
         self.line_no += counter - 1
         # clean up before returning
         names = [n.strip() for n in names if n.strip() != "etc."]  # remove etc.
@@ -753,7 +797,9 @@ class RSTParser(RSTReader):
 
         # deal with documentation wildcards
         for name in names:
-            r_type = return_type_from_context(docstring=docstr, signature=name, module=self.current_module, literal=True)
+            r_type = return_type_from_context(
+                docstring=docstr, signature=name, module=self.current_module, literal=True
+            )
             if r_type in ["None"]:  # None does not make sense
                 r_type = "Incomplete"  # Default to Incomplete/ Unknown / int
             name = self.strip_prefixes(name)
@@ -800,9 +846,10 @@ class RSTWriter(RSTParser):
     def __init__(self, v_tag="v1.xx"):
         super().__init__(v_tag=v_tag)
 
-    def write_file(self, filename: Path) -> bool:
+    def write_file(self, target: Path) -> bool:
         self.prepare_output()
-        return super().write_file(filename)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        return super().write_file(target)
 
     def prepare_output(self):
         "Remove trailing spaces and commas from the output."

stubber/rst/rst_utils.py

@@ -318,6 +318,7 @@ def distill_return(return_text: str) -> List[Dict]:
         match_string,
         [
             "tuple",
+            "a tuple",
             "a pair",
             "1-tuple",
             "2-tuple",
@@ -459,7 +460,7 @@ def _type_from_context(
     - then parses the docstring to find references to known types and give then a rating though a hand coded model ()
     - builds a list return type candidates
     - selects the highest ranking candidate
-    - the default Type is 'Any'
+    - the default Type is 'Incomplete'
     """
 
     if isinstance(docstring, list):
@@ -494,19 +495,31 @@ def _type_from_context(
 
     # ------------------------------------------------------
     # lookup returns that cannot be found based on the docstring from the lookup list
-    try:
-        function_name = function_re.findall(signature)[0]
-    except IndexError:
-        function_name = signature.strip().strip(":()")
-
-    function_name = ".".join((module, function_name))
-
-    if function_name in LOOKUP_LIST.keys():
-        sig_type = LOOKUP_LIST[function_name][0]
+    if "(" in signature:
+        # method / function / class
+        try:
+            item_name = function_re.findall(signature)[0]
+        except IndexError:
+            item_name = signature.strip().strip(":()")
+    else:
+        # module or class attribute
+        item_name = signature.replace(".. data::", "").strip()
+
+    mod_last = module.split(".")[-1]
+    item_first = item_name.split(".")[0]
+    name_repeat = mod_last == item_first
+    if name_repeat:
+        # avoid machine.UART.UART.irq or pyb.pyb.hid_mouse
+        item_name = f"{module}.{item_name}".replace(f"{mod_last}.{item_first}", mod_last)
+    else:
+        item_name = f"{module}.{item_name}"
+
+    if item_name in LOOKUP_LIST.keys():
+        sig_type = LOOKUP_LIST[item_name][0]
         return {
             "type": sig_type,
             "confidence": C_LOOKUP * WEIGHT_LOOPUPS,
-            "match": function_name,
+            "match": item_name,
         }
     # ------------------------------------------------------
     # parse the docstring for simple start verbs,

stubber/stubber.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""Create, Process, and Maintain stubs ✏️  for MicroPython"""
+"""Create, Process, Merge and Maintain stubs ✏️  for MicroPython"""
 
 
 from stubber.commands.build_cmd import cli_build

stubber/stubs_from_docs.py

@@ -20,8 +20,10 @@ def generate_from_rst(
     v_tag: str,
     release: Optional[str] = None,
     pattern: str = "*.rst",
-    suffix: str = ".py",
+    suffix: str = ".pyi",
     black: bool = True,
+    autoflake: bool = True,
+    clean_rst: bool = True,
 ) -> int:
     dst_path.mkdir(parents=True, exist_ok=True)
     if not release:
@@ -32,15 +34,15 @@ def generate_from_rst(
 
     files = get_rst_sources(rst_path, pattern)
 
-    # simplify debugging
-    # files = [f for f in files if f.name == "collections.rst"]
+    # reduce files for test/debugging
+    # files = [f for f in files if "machine" in f.name]
 
     clean_destination(dst_path)
-    make_docstubs(dst_path, v_tag, release, suffix, files)
+    make_docstubs(dst_path, v_tag, release, suffix, files, clean_rst=clean_rst)
 
     log.info("::group:: start post processing of retrieved stubs")
     # do not run stubgen
-    utils.do_post_processing([dst_path], stubgen=False, black=black, autoflake=True)
+    utils.do_post_processing([dst_path], stubgen=False, black=black, autoflake=autoflake)
 
     # Generate a module manifest for the docstubs
     utils.make_manifest(
@@ -65,26 +67,42 @@ def clean_destination(dst_path: Path):
 
 def get_rst_sources(rst_path: Path, pattern: str) -> List[Path]:
     """Get the list of rst files to process"""
-    files = [f for f in rst_path.glob(pattern) if f.stem != "index" and "." not in f.stem]
+    files = [f for f in rst_path.glob(pattern) if f.stem != "index"]  # and "." not in f.stem]
 
     # - excluded modules, ones that offer little advantage  or cause much problems
     files = [f for f in files if f.name not in DOCSTUB_SKIP]
     return files
 
 
-def make_docstubs(dst_path: Path, v_tag: str, release: str, suffix: str, files: List[Path]):
+def make_docstubs(
+    dst_path: Path, v_tag: str, release: str, suffix: str, files: List[Path], clean_rst: bool
+):
     """Create the docstubs"""
 
     for file in files:
         reader = RSTWriter(v_tag)
+        reader.clean_rst = clean_rst
         reader.source_release = release
         log.debug(f"Reading: {file}")
         reader.read_file(file)
         reader.parse()
-        fname = (dst_path / file.name).with_suffix(suffix)
-        reader.write_file(fname)
-        if file.stem in U_MODULES:
-            # create umod.py file and mod.py file
-            fname = (dst_path / ("u" + file.name)).with_suffix(suffix)
-            reader.write_file(fname)
+        # Destination = "module.__init__.pyi"
+        if "." in file.stem:
+            target = dst_path / f"{(file.stem).replace('.', '/')}{suffix}"
+        else:
+            target = dst_path / file.stem / f"__init__{suffix}"
+        # fname = (dst_path / file.name).with_suffix(suffix)
+        reader.write_file(target)
         del reader
+    for name in U_MODULES:
+        # create a file "umodule.pyi" for each module
+        # and add a line : from module import *
+        # this is to allow the use of the u modules in the code
+
+        # create the file
+        target = dst_path / f"u{name}.pyi"
+        with open(target, "w") as f:
+            f.write(f"# {name} module\n")
+            f.write("# Allow the use of micro-module notation \n\n")
+            f.write(f"from {name} import *  # type: ignore\n")
+            f.flush()

stubber/update_module_list.py

@@ -23,7 +23,7 @@ def read_modules(path: Optional[Path] = None) -> Set[str]:
     read text files with modules per firmware.
     each contains the output of help("modules")
     - lines starting with # are comments.
-    - split the other lines at whitespace seperator,
+    - split the other lines at whitespace separator,
     - and add each module to a set
     """
     path = Path(path or "./data")
@@ -73,7 +73,7 @@ def update_module_list():
         "upip_utarfile",
         "upysh",
         "uasyncio",
-        "builtins",
+        # "builtins", # may be used for type hints
         "re",
     }
     log.info("Update the module list in createstubs.py")

stubber/utils/config.py

@@ -1,20 +1,20 @@
 """stubber configuration"""
 
 from pathlib import Path
-from typing import List
+from typing import List, Optional, Union
 
 from mpflash.logger import log
+from mpflash.versions import get_preview_mp_version, get_stable_mp_version, micropython_versions
 from typedconfig.config import Config, key, section
 from typedconfig.source import EnvironmentConfigSource
 
-import mpflash.basicgit as git
-from mpflash.versions import V_PREVIEW
-
 from .typed_config_toml import TomlConfigSource
 
 
 @section("micropython-stubber")
 class StubberConfig(Config):
+    _config_path = None
+
     "stubber configuration class"
     # relative to stubs folder
     fallback_path: Path = key(
@@ -45,9 +45,13 @@ class StubberConfig(Config):
     stable_version: str = key(
         key_name="stable-version", cast=str, required=False, default="1.20.0"
     )
-
     "last published stable"
 
+    preview_version: str = key(
+        key_name="preview-version", cast=str, required=False, default="preview"
+    )
+    "current preview version"
+
     all_versions = key(
         key_name="all-versions",
         cast=list,
@@ -79,6 +83,15 @@ class StubberConfig(Config):
         "return the stubs path in the microypthon-stubs repo"
         return self.mpy_stubs_path / "publish" / "template"
 
+    @property
+    def config_path(self) -> Path:
+        "return the config path"
+        return self._config_path
+
+    @config_path.setter
+    def config_path(self, value: Path):
+        self._config_path = value
+
     def post_read_hook(self) -> dict:
         config_updates = {}
         # relative to stubs
@@ -94,32 +107,39 @@ class StubberConfig(Config):
         # read the versions from the git tags
         all_versions = []
         try:
-            all_versions = git.get_tags("micropython/micropython", minver="v1.17")
+            all_versions = micropython_versions(minver="v1.17")
         except Exception as e:
             log.warning(f"Could not read micropython versions from git: {e}")
             all_versions = ["1.19", "1.19.1", "1.20.0", "1.21.0"]
         config_updates.update(all_versions=all_versions)
         config_updates.update(
-            stable_version=[v for v in all_versions if not v.endswith(V_PREVIEW)][-1]
+            stable_version=get_stable_mp_version(),
+            preview_version=get_preview_mp_version(),
         )  # second last version - last version is the preview version
         return config_updates
 
 
-def readconfig(filename: str = "pyproject.toml", prefix: str = "tool.", must_exist: bool = True):
+def readconfig(
+    location: Optional[Path] = None,
+    filename: str = "pyproject.toml",
+    prefix: str = "tool.",
+    must_exist: bool = True,
+):
     "read the configuration from the pyproject.toml file"
     # locate the pyproject.toml file
-    path = Path.cwd()
+    config_path = location or Path.cwd()
     use_toml = True
-    while not (path / filename).exists():
-        path = path.parent
-        if path == path.parent:
+    while not (config_path / filename).exists():
+        config_path = config_path.parent
+        if config_path == config_path.parent:
             log.trace(f"Could not find config file: {filename}")
             use_toml = False
             break
 
-    filename = str(path / filename)
+    filename = str(config_path / filename)
 
     config = StubberConfig()
+    config.config_path = config_path.absolute()
     # add provider sources to the config
     config.add_source(EnvironmentConfigSource())
     if use_toml: