micropython-stubber 1.14.1__py3-none-any.whl → 1.15.1__py3-none-any.whl

stubber/publish/stubpacker.py

@@ -22,6 +22,7 @@ from packaging.version import Version, parse
 from pysondb import PysonDB
 
 from stubber.publish.bump import bump_version
+from stubber.publish.defaults import GENERIC_U, default_board
 from stubber.publish.enums import StubSource
 from stubber.publish.pypi import Version, get_pypi_versions
 from stubber.utils.config import CONFIG
@@ -36,7 +37,6 @@ STUB_SKIPPER = {
     StubSource.FIRMWARE: ["builtins"],
     StubSource.DOC: [],
     StubSource.CORE: [],
-    
 }
 
 
@@ -49,6 +49,7 @@ class StubPackage:
         - package_path - the path to the folder where the package info will be stored ('./publish').
         - pkg_version - the version of the package as used on PyPi (semver). Is stored directly in the `pyproject.toml` file
         - pyproject - the contents of the `pyproject.toml` file
+
     methods:
         - from_json - load the package from json
         - to_json - return the package as json
@@ -66,6 +67,9 @@ class StubPackage:
     def __init__(
         self,
         package_name: str,
+        port: str,
+        *,
+        board: str = GENERIC_U,
         version: str = "0.0.1",
         description: str = "MicroPython stubs",
         stubs: Optional[StubSources] = None,
@@ -89,9 +93,10 @@ class StubPackage:
             STUB_PATH - root-relative path to the folder where the stubs are stored ('./stubs').
 
         """
+        self.port = port
+        self.board = board
         if json_data is not None:
             self.from_dict(json_data)
-
         else:
             # store essentials
             # self.package_path = package_path
@@ -163,19 +168,19 @@ class StubPackage:
         except FileNotFoundError as e:
             raise FileNotFoundError(f"pyproject.toml file not found at {_toml}") from e
 
-    def update_pkg_version(self, production: bool) -> str:
+    def next_pkg_version(self, production: bool) -> str:
         """Get the next version for the package"""
-        return (
-            self.get_prerelease_package_version(production)
-            if self.mpy_version == "latest"
-            else self.get_next_package_version(production)
-        )
+        if self.mpy_version == "latest":
+            next_ver = self.get_prerelease_package_version(production)
+        else:
+            next_ver = self.get_next_package_version(production)
+        return next_ver
 
     def get_prerelease_package_version(self, production: bool = False) -> str:
         """Get the next prerelease version for the package."""
         rc = 1
         if describe := get_git_describe(CONFIG.mpy_path.as_posix()):
-            # use versiontag and the nummer of commits since the last tag
+            # use versiontag and the number of commits since the last tag
             # "v1.19.1-841-g3446"
             # 'v1.22.0-preview-19-g8eb7721b4'
             parts = describe.split("-", 3)
@@ -189,7 +194,8 @@ class StubPackage:
                 base = Version(ver)
             return str(bump_version(base, rc=rc))
         else:
-            raise ValueError("cannot determine next version number micropython")
+            return "99.99.99post99"
+            # raise ValueError("cannot determine next version number micropython")
 
     def get_next_package_version(self, prod: bool = False, rc=False) -> str:
         """Get the next version for the package."""
@@ -233,7 +239,7 @@ class StubPackage:
     def to_dict(self) -> dict:
         """return the package as a dict to store in the jsondb
 
-        need to simplify some of the Objects to allow serialisation to json
+        need to simplify some of the Objects to allow serialization to json
         - the paths to posix paths
         - the version (semver) to a string
         - toml file to list of lines
@@ -288,16 +294,15 @@ class StubPackage:
         self.create_readme()
         self.create_license()
 
-    @staticmethod
-    def update_sources(stub_sources: StubSources) -> StubSources:
+    def update_sources(self) -> StubSources:
         """
         Update the stub sources to:
         - FIRMWARE: prefer -merged stubs over bare firmware stubs
         - FROZEN: fallback to use the GENERIC folder for the frozen sources if no board specific folder exists
         """
         updated_sources = []
-        for stub_type, fw_path in stub_sources:
-            # prefer -merged stubs over bare firmwre stubs
+        for stub_type, fw_path in self.stub_sources:
+            # prefer -merged stubs over bare firmware stubs
             if stub_type == StubSource.FIRMWARE:
                 # Check if -merged folder exists and use that instead
                 if fw_path.name.endswith("-merged"):
@@ -313,7 +318,20 @@ class StubPackage:
                 if (CONFIG.stub_path / fw_path).exists():
                     updated_sources.append((stub_type, fw_path))
                 else:
-                    updated_sources.append((stub_type, fw_path.with_name("GENERIC")))
+                    if fw_path.with_name("GENERIC").exists():
+                        updated_sources.append((stub_type, fw_path.with_name("GENERIC")))
+            elif stub_type == StubSource.MERGED:
+                # Use the default board folder instead of the GENERIC board folder (if it exists)
+                if self.board.upper() == GENERIC_U:
+                    family = fw_path.name.split("-")[0]
+                    # TODO: use function the get the path
+                    default_path = Path(
+                        f"{family}-{clean_version(self.mpy_version, flat=True)}-{self.port}-{default_board(self.port, self.mpy_version)}-merged"
+                    )
+                    if (CONFIG.stub_path / default_path).exists():
+                        fw_path = default_path
+                updated_sources.append((stub_type, fw_path))
+                # ---------
             else:
                 updated_sources.append((stub_type, fw_path))
         return updated_sources
@@ -329,7 +347,7 @@ class StubPackage:
         """
         try:
             # update to -merged and fallback to GENERIC
-            self.stub_sources = self.update_sources(self.stub_sources)
+            self.stub_sources = self.update_sources()
             # Check if all stub source folders exist
             for stub_type, src_path in self.stub_sources:
                 if not (CONFIG.stub_path / src_path).exists():
@@ -459,6 +477,7 @@ class StubPackage:
             try:
                 with open(CONFIG.template_path / "pyproject.toml", "rb") as f:
                     _pyproject = tomllib.load(f)
+                # note: can be 'latest' which is not semver
                 _pyproject["tool"]["poetry"]["version"] = self.mpy_version
             except FileNotFoundError as e:
                 log.error(f"Could not find template pyproject.toml file {e}")
@@ -571,7 +590,7 @@ class StubPackage:
             return False
         # todo: call poetry directly to improve error handling
         try:
-            log.trace(f"poetry {parameters} starting")
+            log.debug(f"poetry {parameters} starting")
             subprocess.run(
                 ["poetry"] + parameters,
                 cwd=self.package_path,
@@ -581,7 +600,7 @@ class StubPackage:
                 universal_newlines=True,
             )
             log.trace(f"poetry {parameters} completed")
-        except (NotADirectoryError, FileNotFoundError) as e:  # pragma: no cover
+        except (NotADirectoryError, FileNotFoundError) as e:  # pragma: no cover # InvalidVersion
             log.error("Exception on process, {}".format(e))
             return False
         except subprocess.CalledProcessError as e:  # pragma: no cover
@@ -638,24 +657,24 @@ class StubPackage:
         Check if (all) the packages sources exist.
         """
         ok = True
-        for name, path in self.update_sources(self.stub_sources):
-            if (CONFIG.stub_path / path).exists():
+        for stub_type, src_path in self.update_sources():
+            if (CONFIG.stub_path / src_path).exists():
                 continue
-            if name == StubSource.FROZEN:
+            if stub_type == StubSource.FROZEN:
                 # not a blocking issue if there are no frozen stubs, perhaps this port/board does not have any
                 continue
             # todo: below is a workaround for different types, but where is the source of this difference coming from?
             msg = (
-                f"{self.package_name}: source '{name.value}' not found: {CONFIG.stub_path / path}"
-                if isinstance(name, StubSource)  # type: ignore
-                else f"{self.package_name}: source '{name}' not found: {CONFIG.stub_path / path}"
+                f"{self.package_name}: source '{stub_type.value}' not found: {CONFIG.stub_path / src_path}"
+                if isinstance(stub_type, StubSource)  # type: ignore
+                else f"{self.package_name}: source '{stub_type}' not found: {CONFIG.stub_path / src_path}"
             )
             self.status["error"] = msg
             log.debug(msg)
             ok = False
         return ok
 
-    def update_package(self) -> bool:
+    def update_package(self, production: bool) -> bool:
         """Update the package .pyi files, if all the sources are available"""
         log.info(f"- Update {self.package_path.name}")
         log.trace(f"{self.package_path.as_posix()}")
@@ -673,12 +692,13 @@ class StubPackage:
         try:
             self.update_package_files()
             self.update_included_stubs()
-            self.check()
+            # for a new package the version could be 'latest', which is not a valid semver, so update
+            self.pkg_version = self.next_pkg_version(production)
+            return self.check()
         except Exception as e:  # pragma: no cover
             log.error(f"{self.package_name}: {e}")
             self.status["error"] = str(e)
             return False
-        return True
 
     def build(
         self,
@@ -699,10 +719,12 @@ class StubPackage:
         """
         log.info(f"Build: {self.package_path.name}")
 
-        ok = self.update_package()
+        ok = self.update_package(production)
         self.status["version"] = self.pkg_version
         if not ok:
-            log.info(f"{self.package_name}: skip - Could not update package")
+            log.info(f"{self.package_name}: skip - Could not build/update package")
+            if not self.status["error"]:
+                self.status["error"] = "Could not build/update package"
             return False
         # If there are changes to the package, then publish it
         if self.is_changed():
@@ -714,7 +736,7 @@ class StubPackage:
         if self.is_changed() or force:
             #  Build the distribution files
             old_ver = self.pkg_version
-            self.pkg_version = self.update_pkg_version(production)
+            self.pkg_version = self.next_pkg_version(production)
             self.status["version"] = self.pkg_version
             # to get the next version
             log.debug(
@@ -768,10 +790,10 @@ class StubPackage:
             log.debug(f"{self.package_name}: skip publishing")
             return False
 
-        self.update_pkg_version(production=production)
+        self.next_pkg_version(production=production)
         # Publish the package to PyPi, Test-PyPi or Github
         if self.is_changed() or force:
-            if self.mpy_version == "latest":
+            if self.mpy_version == "latest" and production and not force:
                 log.warning(
                     "version: `latest` package will only be available on Github, and not published to PyPi."
                 )

stubber/rst/lookup.py

@@ -16,29 +16,15 @@ __all__ = [
     "RST_DOC_FIXES",
     "DOCSTUB_SKIP",
     "U_MODULES",
-    "DEFAULT_BOARDS",
-    # "FORCE_NON_DETECED",
 ]
 
 # all possible Types needed for the stubs - exxess types should be removed later , and otherwise won't do much harm
 TYPING_IMPORT: List[str] = [
-    "from typing import IO, Any, Callable, Coroutine, Dict, Generator, Iterator, List, NoReturn, Optional, Tuple, Union, NamedTuple, TypeVar, Iterator",
+    "from typing import IO, Any, Callable, Coroutine, Dict, Generator, Iterator, List, NoReturn, Optional, Tuple, Union, NamedTuple, TypeVar",
     "from _typeshed import Incomplete",
 ]
 
 
-# The default board for the ports  modules documented with base name only
-# TODO: these are not yest used in the stubber logic
-# ESP32-GENERIC is curently hardcoded
-DEFAULT_BOARDS: Dict[str, List[str]] = {
-    "stm32": ["stm32-PYBV11"],
-    "esp32": ["esp32-GENERIC", "esp32"],
-    "esp8266": ["esp8266-GENERIC", "esp8266"],
-    "rp2": ["rp2-PICO", "rp2-PICO_W"],
-    "samd": ["samd-SEEED_WIO_TERMINAL"],
-}
-
-
 @dataclass
 class Fix:
     """A fix for a parameter or return type in the documentation that is needed to render it to a valid type annotation
@@ -142,6 +128,9 @@ LOOKUP_LIST = {
     "machine.Signal.value": ("int", 0.95),
     "machine.soft_reset": ("NoReturn", 0.95),  # never returns
     "machine.UART.irq": ("Incomplete", 0.95),  # no IRQ type defined
+    "machine.UART.write": ("Union[int,None]", 0.95),
+    "machine.UART.readinto": ("Union[int,None]", 0.95),
+    "machine.UART.readline": ("Union[str,None]", 0.95),
     "math.isnan": ("bool", 0.95),
     "micropython.opt_level": ("Incomplete", 0.95),  # Not clear in docstring
     # since 1.19 const can also be string , bytes or tuple
@@ -180,7 +169,7 @@ LOOKUP_LIST = {
     "_onewire.writebit": ("None", 0.95),
     "_onewire.crc8": ("int", 0.95),
     # espnow
-    "espnow.ESPNow.recv": ("List", 0.95),  # list / ? tuple of bytestrings
+    "espnow.ESPNow.recv": ("Union[List, Tuple[None,None]]", 0.95),  # list / ? tuple of bytestrings
 }
 
 
@@ -526,6 +515,8 @@ CHILD_PARENT_CLASS = {
     # ESPNow
     "ESPNow": "ESPNowBase,Iterator",
     "AIOESPNow": "ESPNow",
+    # array
+    "array": "List",
 }
 
 

stubber/rst/reader.py

@@ -219,14 +219,43 @@ class RSTReader(FileReadWriter):
 
         # return _l.startswith("..") and not any(_l.startswith(a) for a in self.docstring_anchors)
 
-    @property
-    def at_heading(self) -> bool:
+    # @property
+    def at_heading(self, large=False) -> bool:
         "stop at heading"
-        _l = self.rst_text[min(self.line_no + 1, self.max_line - 1)]
+        u_line = self.rst_text[min(self.line_no + 1, self.max_line - 1)].rstrip()
         # Heading  ---, ==, ~~~
-        return _l.startswith("--") or _l.startswith("==") or _l.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()
+            if line:
+                # module docstrings can be a bit larger than normal
+                if not large and len(line) == len(u_line):
+                    # heading is same length as underlined
+                    # for most docstrings that is a sensible boundary
+                    return True
+                line = line.split()[0]
+                # stopwords in headings
+                return line.lower() in [
+                    "classes",
+                    "functions",
+                    "methods",
+                    "constants",
+                    "exceptions",
+                    "constructors",
+                    "class",
+                    "common",
+                    "general",
+                    # below are tuning based on module level docstrings
+                    "time",
+                    "pio",
+                    "memory",
+                ]
+        return False
 
-    def read_docstring(self) -> List[str]:
+    def read_docstring(self, large: bool = False) -> List[str]:
         """Read a textblock that will be used as a docstring, or used to process a toc tree
         The textblock is terminated at the following RST line structures/tags
             .. <anchor>
@@ -245,7 +274,7 @@ class RSTReader(FileReadWriter):
             while (
                 self.line_no < len(self.rst_text)
                 and not self.at_anchor  # stop at next anchor ( however .. note: and a few other anchors should be added)
-                and not self.at_heading  # stop at next heading
+                and not self.at_heading(large)  # stop at next heading
             ):
                 line = self.rst_text[self.line_no]
                 block.append(line.rstrip())
@@ -471,7 +500,7 @@ class RSTParser(RSTReader):
         self.current_module = module_name
         self.current_function = self.current_class = ""
         # get module docstring
-        docstr = self.read_docstring()
+        docstr = self.read_docstring(large=True)
 
         if len(docstr) > 0:
             # Add link to online documentation
@@ -479,7 +508,9 @@ class RSTParser(RSTReader):
             if "nightly" in self.source_tag:
                 version = "latest"
             else:
-                version = self.source_tag.replace("_", ".")
+                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"

stubber/stubs_from_docs.py

@@ -9,13 +9,8 @@ from typing import List, Optional
 
 from loguru import logger as log
 
-from stubber.utils.post import run_autoflake, run_black
-
 from stubber import utils
-from stubber.rst import (
-    DOCSTUB_SKIP,
-    U_MODULES,
-)
+from stubber.rst import DOCSTUB_SKIP, U_MODULES
 from stubber.rst.reader import RSTWriter
 
 
@@ -26,6 +21,7 @@ def generate_from_rst(
     release: Optional[str] = None,
     pattern: str = "*.rst",
     suffix: str = ".py",
+    black: bool = True,
 ) -> int:
     # sourcery skip: remove-redundant-exception, simplify-single-exception-tuple
     if not dst_path.exists():
@@ -44,8 +40,9 @@ def generate_from_rst(
     clean_destination(dst_path)
     make_docstubs(dst_path, v_tag, release, suffix, files)
 
-    run_autoflake(dst_path, process_pyi=True)
-    run_black(dst_path)
+    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)
 
     # Generate a module manifest for the docstubs
     utils.make_manifest(

stubber/utils/post.py

@@ -3,21 +3,22 @@ import subprocess
 from pathlib import Path
 from typing import List
 
+import autoflake
 from loguru import logger as log
 
 from .stubmaker import generate_pyi_files
 
-# # log = logging.getLogger(__name__)
 
-
-def do_post_processing(stub_paths: List[Path], pyi: bool, black: bool):
+def do_post_processing(stub_paths: List[Path], stubgen: bool, black: bool, autoflake: bool):
     "Common post processing"
     for path in stub_paths:
-        if pyi:
+        if stubgen:
             log.debug("Generate type hint files (pyi) in folder: {}".format(path))
             generate_pyi_files(path)
         if black:
             run_black(path)
+        if autoflake:
+            run_autoflake(path, process_pyi=True)
 
 
 def run_black(path: Path, capture_output: bool = False):
@@ -42,41 +43,34 @@ def run_autoflake(path: Path, capture_output: bool = False, process_pyi: bool =
     needs to be run BEFORE black otherwise it does not recognize long import from`s.
     note: is run file-by-file to include processing .pyi files
     """
-    ret = 0
-    cmd = [
-        "autoflake",
-        "-r",
-        "--in-place",
-        # "--remove-all-unused-imports",
-        # "--ignore-init-module-imports",
-        path.as_posix(),
-        "-v",
-        "-v",  # show some feedback
-    ]
-    log.debug("Running autoflake on: {}".format(path))
-    # subprocess.run(cmd, capture_output=log.level >= logging.INFO)
-    result = subprocess.run(cmd, capture_output=capture_output)
-    if result.returncode != 0:  # pragma: no cover
-        log.warning(f"autoflake failed on: {path}")
-        ret = result.returncode
-
+    if not path.exists():
+        log.warning(f"Path does not exist: {path}")
+        return -1
+    log.info(f"Running autoflake on: {path}")
+    # create a list of files to be formatted
+    files: List[str] = []
+    files.extend([str(f) for f in path.rglob("*.py")])
     if process_pyi:
-        for file in list(path.rglob("*.pyi")):
-            cmd = [
-                "autoflake",
-                "-r",
-                "--in-place",
-                # "--remove-all-unused-imports",
-                # "--ignore-init-module-imports",
-                file.as_posix(),
-                "-v",
-                "-v",  # show some feedback
-            ]
-            log.debug("Running autoflake on: {}".format(path))
-            # subprocess.run(cmd, capture_output=log.level >= logging.INFO)
-            result = subprocess.run(cmd, capture_output=capture_output)
-            if result.returncode != 0:
-                log.warning(f"autoflake failed on: {file}")
-                ret = result.returncode
+        files.extend([str(f) for f in path.rglob("*.pyi")])
 
-    return ret
+    # build an argument list
+    autoflake_args = {
+        "write_to_stdout": False,  # print changed text to stdout
+        "in_place": True,  # make changes to files instead of printing diffs
+        "remove_all_unused_imports": False,
+        "ignore_init_module_imports": False,  # exclude __init__.py when removing unused imports
+        "expand_star_imports": False,
+        "remove_duplicate_keys": False,
+        "remove_unused_variables": False,  # remove all unused imports (not just those from the standard library)
+        "remove_rhs_for_unused_variables": False,
+        "ignore_pass_statements": False,  # remove pass when superfluous
+        "ignore_pass_after_docstring": False,  # ignore pass statements after a newline ending on '"""'
+        "check": False,  # return error code if changes are needed
+        "check_diff": False,
+        "quiet": False,
+    }
+    # format the files
+    exit_status = 0
+    for name in files:
+        log.debug(f"Running autoflake on: {name}")
+        exit_status |= autoflake.fix_file(name, args=autoflake_args)

stubber/utils/repos.py

@@ -39,7 +39,7 @@ def switch(tag: str, *, mpy_path: Path, mpy_lib_path: Path):
         git.switch_branch(repo=mpy_path, branch="master")
     else:
         git.checkout_tag(repo=mpy_path, tag=tag)
-    match_lib_with_mpy(version_tag=tag, lib_path=mpy_lib_path)
+    match_lib_with_mpy(version_tag=tag, mpy_path=mpy_path, lib_path=mpy_lib_path)
 
 
 def read_micropython_lib_commits(filename: str = "data/micropython_tags.csv"):
@@ -62,30 +62,39 @@ def read_micropython_lib_commits(filename: str = "data/micropython_tags.csv"):
         reader = csv.DictReader(ntf.file, skipinitialspace=True)  # dialect="excel",
         rows = list(reader)
         # create a dict version --> commit_hash
-        version_commit = {row["version"].split("/")[-1]: row["lib_commit_hash"] for row in rows if row["version"].startswith("refs/tags/")}
+        version_commit = {
+            row["version"].split("/")[-1]: row["lib_commit_hash"]
+            for row in rows
+            if row["version"].startswith("refs/tags/")
+        }
     # add default
     version_commit = defaultdict(lambda: "master", version_commit)
     return version_commit
 
 
-def match_lib_with_mpy(version_tag: str, lib_path: Path):
+def match_lib_with_mpy(version_tag: str, mpy_path: Path, lib_path: Path) -> bool:
     micropython_lib_commits = read_micropython_lib_commits()
     # Make sure that the correct micropython-lib release is checked out
     #  check if micropython-lib has matching tags
     if version_tag == "latest":
-        git.checkout_commit("master", lib_path)
+        # micropython-lib is now a submodule
+        result = git.checkout_commit("master", lib_path)
+        if not result:
+            log.error("Could not checkout micropython-lib @master")
+            return False
+
+        return git.sync_submodules(mpy_path)
     elif Version(version_tag) >= Version("v1.20.0"):
-        # TODO:if version is v1.12.0 or newer
-        #   then use submodules to checkout the correct version of micropython-lib
-        #   git submodule update lib/micropython-lib
-        #   or use the new git tags to checkout the correct version of micropython-lib
-        # else
-        # clean the submodules for just to be sure
-        #   git submodule foreach --recursive git clean -xfd
-        #   use the micropython_tags.csv to find the correct commit hash
-        return git.checkout_tag(version_tag, lib_path)
+        # micropython-lib is now a submodule
+        result = git.checkout_tag(version_tag, lib_path)
+        if not result:
+            log.error("Could not checkout micropython-lib @master")
+            return False
+        return git.sync_submodules(mpy_path)
     else:
-        log.info(f"Matching repo's:  Micropython {version_tag} needs micropython-lib:{micropython_lib_commits[version_tag]}")
+        log.info(
+            f"Matching repo's:  Micropython {version_tag} needs micropython-lib:{micropython_lib_commits[version_tag]}"
+        )
         return git.checkout_commit(micropython_lib_commits[version_tag], lib_path)
 
 
@@ -107,10 +116,16 @@ def fetch_repos(tag: str, mpy_path: Path, mpy_lib_path: Path):
         git.switch_branch(repo=mpy_path, branch="master")
     else:
         git.checkout_tag(repo=mpy_path, tag=tag)
-    result = match_lib_with_mpy(version_tag=tag, lib_path=mpy_lib_path)
+    result = match_lib_with_mpy(version_tag=tag, mpy_path=mpy_path, lib_path=mpy_lib_path)
 
-    log.info(f"{mpy_path} {git.get_local_tag(mpy_path)}")
-    log.info(f"{mpy_lib_path} {git.get_local_tag(mpy_lib_path)}")
+    log.info(f"{str(mpy_path):<40} {git.get_local_tag(mpy_path)}")
+    log.info(f"{str(mpy_lib_path):<40} {git.get_local_tag(mpy_lib_path)}")
+    try:
+        sub_mod_path = mpy_path / "lib/micropython-lib"
+        if (sub_mod_path / ".git").exists():
+            log.info(f"{str(sub_mod_path):<40} {git.get_local_tag(sub_mod_path)}")
+    except Exception:
+        pass
     return result