idf-build-apps 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

idf_build_apps/constants.py

@@ -119,3 +119,4 @@ fish:
     # Not required to be in the config file, only run once
     register-python-argcomplete --shell fish idf-build-apps >~/.config/fish/completions/idf-build-apps.fish
 """
+IDF_BUILD_APPS_TOML_FN = '.idf_build_apps.toml'

idf_build_apps/finder.py

@@ -31,7 +31,7 @@ def _get_apps_from_path(
     target: str,
     *,
     app_cls: t.Type[App] = CMakeApp,
-    args: FindArguments = FindArguments(),
+    args: FindArguments,
 ) -> t.List[App]:
     def _validate_app(_app: App) -> bool:
         if target not in _app.supported_targets:
@@ -133,7 +133,7 @@ def _find_apps(
     target: str,
     *,
     app_cls: t.Type[App] = CMakeApp,
-    args: FindArguments = FindArguments(),
+    args: FindArguments,
 ) -> t.List[App]:
     LOGGER.debug(
         'Looking for %s apps in %s%s with target %s',

idf_build_apps/main.py

@@ -10,7 +10,6 @@ import os
 import sys
 import textwrap
 import typing as t
-from dataclasses import asdict
 
 import argcomplete
 from pydantic import (
@@ -18,7 +17,13 @@ from pydantic import (
     create_model,
 )
 
-from idf_build_apps.args import BuildArguments, DumpManifestShaArguments, FindArguments, add_arguments_to_parser
+from idf_build_apps.args import (
+    BuildArguments,
+    DumpManifestShaArguments,
+    FindArguments,
+    add_args_to_parser,
+    apply_config_file,
+)
 
 from .app import (
     App,
@@ -55,6 +60,7 @@ def find_apps(
     target: t.Optional[str] = None,
     *,
     find_arguments: t.Optional[FindArguments] = None,
+    config_file: t.Optional[str] = None,
     **kwargs,
 ) -> t.List[App]:
     """
@@ -62,6 +68,17 @@ def find_apps(
 
     :return: list of found apps
     """
+    apply_config_file(config_file)
+
+    # compatible with old usage
+    ## `preserve`
+    if 'preserve' in kwargs:
+        LOGGER.warning(
+            'Passing "preserve" directly is deprecated. '
+            'Pass "no_preserve" instead to disable preserving the build directory'
+        )
+        kwargs['no_preserve'] = not kwargs.pop('preserve')
+
     if find_arguments is None:
         find_arguments = FindArguments(
             paths=to_list(paths),  # type: ignore
@@ -104,21 +121,40 @@ def find_apps(
 
 
 def build_apps(
-    apps: t.Union[t.List[App], App, None] = None, *, build_arguments: t.Optional[BuildArguments] = None, **kwargs
+    apps: t.Union[t.List[App], App, None] = None,
+    *,
+    build_arguments: t.Optional[BuildArguments] = None,
+    config_file: t.Optional[str] = None,
+    **kwargs,
 ) -> int:
     """
     Build all the specified apps. For all kwargs, please refer to `BuildArguments`
 
     :return: exit code
     """
-    apps = to_list(apps)
+    apply_config_file(config_file)
+
+    # compatible with old usage
+    ## `check_app_dependencies`
+    if 'check_app_dependencies' in kwargs:
+        LOGGER.warning(
+            'Passing "check_app_dependencies" directly is deprecated. '
+            'Pass "modified_components" instead to enable dependency-driven build feature'
+        )
+        kwargs.pop('check_app_dependencies')
+
     if build_arguments is None:
         build_arguments = BuildArguments(
             **kwargs,
         )
 
+    apps = to_list(apps)
     if apps is None:
-        apps = find_apps(find_arguments=FindArguments.from_dict(asdict(build_arguments)))
+        apps = find_apps(
+            find_arguments=FindArguments(
+                **{k: v for k, v in build_arguments.model_dump().items() if k in FindArguments.model_fields}
+            )
+        )
 
     test_suite = TestSuite('build_apps')
 
@@ -255,6 +291,9 @@ def get_parser() -> argparse.ArgumentParser:
     )
     actions = parser.add_subparsers(dest='action', required=True)
 
+    common_args = argparse.ArgumentParser(add_help=False)
+    common_args.add_argument('--config-file', help='Path to the config file')
+
     ########
     # Find #
     ########
@@ -266,8 +305,9 @@ def get_parser() -> argparse.ArgumentParser:
         'By default, print the found apps in stdout. '
         'To find apps for all chips use the `--target` option with the `all` argument.',
         formatter_class=IdfBuildAppsCliFormatter,
+        parents=[common_args],
     )
-    add_arguments_to_parser(FindArguments, find_parser)
+    add_args_to_parser(FindArguments, find_parser)
 
     #########
     # Build #
@@ -278,8 +318,9 @@ def get_parser() -> argparse.ArgumentParser:
         description='Build the application in the given path or paths for specified chips. '
         '`--path` and `--target` options must be provided.',
         formatter_class=IdfBuildAppsCliFormatter,
+        parents=[common_args],
     )
-    add_arguments_to_parser(BuildArguments, build_parser)
+    add_args_to_parser(BuildArguments, build_parser)
 
     ###############
     # Completions #
@@ -314,8 +355,9 @@ def get_parser() -> argparse.ArgumentParser:
         'dump-manifest-sha',
         help='Dump the manifest files SHA values. '
         'This could be useful in CI to check if the manifest files are changed.',
+        parents=[common_args],
     )
-    add_arguments_to_parser(DumpManifestShaArguments, dump_manifest_parser)
+    add_args_to_parser(DumpManifestShaArguments, dump_manifest_parser)
 
     return parser
 
@@ -340,15 +382,20 @@ def main():
         handle_completions(args)
         sys.exit(0)
 
-    if args.action == 'dump-manifest-sha':
-        arguments = DumpManifestShaArguments.from_dict(drop_none_kwargs(vars(args)))
+    kwargs = vars(args)
+    action = kwargs.pop('action')
+    config_file = kwargs.pop('config_file')
+
+    apply_config_file(config_file)
+
+    if action == 'dump-manifest-sha':
+        arguments = DumpManifestShaArguments(**drop_none_kwargs(kwargs))
         Manifest.from_files(arguments.manifest_files).dump_sha_values(arguments.output)
         sys.exit(0)
-
-    if args.action == 'find':
-        arguments = FindArguments.from_dict(drop_none_kwargs(vars(args)))
+    elif action == 'find':
+        arguments = FindArguments(**drop_none_kwargs(kwargs))
     else:
-        arguments = BuildArguments.from_dict(drop_none_kwargs(vars(args)))
+        arguments = BuildArguments(**drop_none_kwargs(kwargs))
 
     # real call starts here
     # build also needs to find first
@@ -395,7 +442,8 @@ def main():
         for app in failed_apps:
             print(f'  {app}')
 
-    sys.exit(ret_code)
+    if ret_code != 0:
+        sys.exit(ret_code)
 
 
 def json_to_app(json_str: str, extra_classes: t.Optional[t.List[t.Type[App]]] = None) -> App:

idf_build_apps/manifest/if_parser.py

@@ -1,6 +1,5 @@
 # SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
-
 import operator
 import os
 from ast import (
@@ -16,6 +15,7 @@ from packaging.version import (
 from pyparsing import (
     Keyword,
     Literal,
+    MatchFirst,
     ParseResults,
     QuotedString,
     Suppress,
@@ -35,6 +35,7 @@ from ..constants import (
     IDF_VERSION_PATCH,
 )
 from ..utils import (
+    InvalidIfClause,
     InvalidInput,
     to_version,
 )
@@ -177,22 +178,31 @@ class BoolExpr(Stmt):
     pass
 
 
-class BoolAnd(BoolExpr):
-    def __init__(self, t: ParseResults):
-        self.left: BoolStmt = t[0][0]
-        self.right: BoolStmt = t[0][2]
+def _and(_l, _r):
+    return _l and _r
 
-    def get_value(self, target: str, config_name: str) -> Any:
-        return self.left.get_value(target, config_name) and self.right.get_value(target, config_name)
+
+def _or(_l, _r):
+    return _l or _r
 
 
-class BoolOr(BoolExpr):
+class BoolOrAnd(BoolExpr):
     def __init__(self, t: ParseResults):
+        if len(t[0]) > 3:
+            raise InvalidIfClause(
+                'Chaining "and"/"or" is not allowed. Please use paratheses instead. '
+                'For example: "a and b and c" should be "(a and b) and c".'
+            )
         self.left: BoolStmt = t[0][0]
         self.right: BoolStmt = t[0][2]
 
+        if t[0][1] == 'and':
+            self.operation = _and
+        if t[0][1] == 'or':
+            self.operation = _or
+
     def get_value(self, target: str, config_name: str) -> Any:
-        return self.left.get_value(target, config_name) or self.right.get_value(target, config_name)
+        return self.operation(self.left.get_value(target, config_name), self.right.get_value(target, config_name))
 
 
 CAP_WORD = Word(alphas.upper(), nums + alphas.upper() + '_').setParseAction(ChipAttr)
@@ -225,7 +235,6 @@ OR = Keyword('or')
 BOOL_EXPR = infixNotation(
     BOOL_STMT,
     [
-        (AND, 2, opAssoc.LEFT, BoolAnd),
-        (OR, 2, opAssoc.LEFT, BoolOr),
+        (MatchFirst((AND, OR)), 2, opAssoc.LEFT, BoolOrAnd),
     ],
 )

idf_build_apps/manifest/manifest.py

@@ -17,6 +17,7 @@ from ..constants import (
 from ..utils import (
     InvalidIfClause,
     InvalidManifest,
+    PathLike,
     to_absolute_path,
 )
 from ..yaml import (
@@ -34,14 +35,21 @@ class IfClause:
     def __init__(self, stmt: str, temporary: bool = False, reason: t.Optional[str] = None) -> None:
         try:
             self.stmt: BoolStmt = BOOL_EXPR.parseString(stmt)[0]
-        except ParseException:
-            raise InvalidIfClause(f'Invalid if statement: {stmt}')
+        except (ParseException, InvalidIfClause) as ex:
+            raise InvalidIfClause(f'Invalid if clause: {stmt}. {ex}')
 
         self.temporary = temporary
         self.reason = reason
 
         if self.temporary is True and not self.reason:
-            raise InvalidIfClause('"reason" must be set when "temporary: true"')
+            raise InvalidIfClause(
+                f'Invalid if clause "{stmt}". '
+                f'"reason" must be set when "temporary: true". '
+                f'For example:\n'
+                f'  - if: {stmt}\n'
+                f'    temporary: true\n'
+                f'    reason: lack of ci runners'
+            )
 
     def get_value(self, target: str, config_name: str) -> t.Any:
         return self.stmt.get_value(target, config_name)
@@ -145,7 +153,7 @@ class FolderRule:
             self.depends_components,
             self.depends_filepatterns,
         ]:
-            sha.update(pickle.dumps(obj))
+            sha.update(pickle.dumps(obj, protocol=4))  # protocol 4 by default is set in Python 3.8
 
         return sha.hexdigest()
 
@@ -235,7 +243,7 @@ class Manifest:
         self._root_path = to_absolute_path(root_path)
 
     @classmethod
-    def from_files(cls, paths: t.Iterable[str], *, root_path: str = os.curdir) -> 'Manifest':
+    def from_files(cls, paths: t.Iterable[PathLike], *, root_path: str = os.curdir) -> 'Manifest':
         """
         Create a Manifest instance from multiple manifest files
 
@@ -244,10 +252,11 @@ class Manifest:
         :return: Manifest instance
         """
         # folder, defined as dict
-        _known_folders: t.Dict[str, str] = dict()
+        _known_folders: t.Dict[str, PathLike] = dict()
 
         rules: t.List[FolderRule] = []
         for path in paths:
+            LOGGER.debug('Loading manifest file %s', path)
             _manifest = cls.from_file(path, root_path=root_path)
 
             for rule in _manifest.rules:
@@ -265,7 +274,7 @@ class Manifest:
         return Manifest(rules, root_path=root_path)
 
     @classmethod
-    def from_file(cls, path: str, *, root_path: str = os.curdir) -> 'Manifest':
+    def from_file(cls, path: PathLike, *, root_path: str = os.curdir) -> 'Manifest':
         """
         Create a Manifest instance from a manifest file
 
@@ -343,11 +352,14 @@ class Manifest:
                 return x
 
         for folder, sha_value in recorded__rel_folder__sha__dict.items():
+            # removed
             if folder not in self__rel_folder__sha__dict:
                 diff_folders.add(_path(folder))
+            # modified
             elif sha_value != self__rel_folder__sha__dict[folder]:
                 diff_folders.add(_path(folder))
 
+        # new
         for folder in self__rel_folder__sha__dict:
             if folder not in recorded__rel_folder__sha__dict:
                 diff_folders.add(_path(folder))

idf_build_apps/utils.py

@@ -13,6 +13,7 @@ import typing as t
 from copy import (
     deepcopy,
 )
+from pathlib import Path
 
 from packaging.version import (
     Version,
@@ -124,7 +125,7 @@ class InvalidManifest(SystemExit):
     """Invalid manifest file"""
 
 
-def rmdir(path: str, exclude_file_patterns: t.Union[t.List[str], str, None] = None) -> None:
+def rmdir(path: t.Union[Path, str], exclude_file_patterns: t.Union[t.List[str], str, None] = None) -> None:
     if not exclude_file_patterns:
         shutil.rmtree(path, ignore_errors=True)
         return
@@ -387,3 +388,6 @@ class BaseModel(_BaseModel):
 
 def drop_none_kwargs(d: dict) -> dict:
     return {k: v for k, v in d.items() if v is not None}
+
+
+PathLike = t.Union[str, Path]

idf_build_apps/vendors/pydantic_sources.py

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: 2022 Samuel Colvin and other contributors
+# SPDX-License-Identifier: MIT
+
+"""
+Partially copied from https://github.com/pydantic/pydantic-settings v2.5.2
+since python 3.7 version got dropped at pydantic-settings 2.1.0
+but the feature we need introduced in 2.2.0
+
+For contributing history please refer to the original github page
+For the full license text refer to
+https://github.com/pydantic/pydantic-settings/blob/9b73e924cab136d876907af0c6836dcca09ac35c/LICENSE
+
+Modifications:
+- use toml instead of tomli when python < 3.11
+- stop using global variables
+- fix some warnings
+"""
+
+import os
+import sys
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
+
+from pydantic_settings import InitSettingsSource
+from pydantic_settings.main import BaseSettings
+
+PathType = Union[Path, str, List[Union[Path, str]], Tuple[Union[Path, str], ...]]
+DEFAULT_PATH: PathType = Path('')
+
+
+class ConfigFileSourceMixin(ABC):
+    def _read_files(self, files: Optional[PathType]) -> Dict[str, Any]:
+        if files is None:
+            return {}
+        if isinstance(files, (str, os.PathLike)):
+            files = [files]
+        kwargs: Dict[str, Any] = {}
+        for file in files:
+            file_path = Path(file).expanduser()
+            if file_path.is_file():
+                kwargs.update(self._read_file(file_path))
+        return kwargs
+
+    @abstractmethod
+    def _read_file(self, path: Path) -> Dict[str, Any]:
+        pass
+
+
+class TomlConfigSettingsSource(InitSettingsSource, ConfigFileSourceMixin):
+    """
+    A source class that loads variables from a TOML file
+    """
+
+    def __init__(
+        self,
+        settings_cls: Type[BaseSettings],
+        toml_file: Optional[PathType] = DEFAULT_PATH,
+    ):
+        self.toml_file_path = toml_file if toml_file != DEFAULT_PATH else settings_cls.model_config.get('toml_file')
+        self.toml_data = self._read_files(self.toml_file_path)
+        super().__init__(settings_cls, self.toml_data)
+
+    def _read_file(self, file_path: Path) -> Dict[str, Any]:
+        if sys.version_info < (3, 11):
+            import toml
+
+            with open(file_path) as toml_file:
+                return toml.load(toml_file)
+        else:
+            import tomllib
+
+            with open(file_path, 'rb') as toml_file:
+                return tomllib.load(toml_file)
+
+
+class PyprojectTomlConfigSettingsSource(TomlConfigSettingsSource):
+    """
+    A source class that loads variables from a `pyproject.toml` file.
+    """
+
+    def __init__(
+        self,
+        settings_cls: Type[BaseSettings],
+        toml_file: Optional[Path] = None,
+    ) -> None:
+        self.toml_file_path = self._pick_pyproject_toml_file(
+            toml_file, settings_cls.model_config.get('pyproject_toml_depth', 0)
+        )
+        self.toml_table_header: Tuple[str, ...] = settings_cls.model_config.get(
+            'pyproject_toml_table_header', ('tool', 'pydantic-settings')
+        )
+        self.toml_data = self._read_files(self.toml_file_path)
+        for key in self.toml_table_header:
+            self.toml_data = self.toml_data.get(key, {})
+        super(TomlConfigSettingsSource, self).__init__(settings_cls, self.toml_data)
+
+    @staticmethod
+    def _pick_pyproject_toml_file(provided: Optional[Path], depth: int) -> Path:
+        """Pick a `pyproject.toml` file path to use.
+
+        Args:
+            provided: Explicit path provided when instantiating this class.
+            depth: Number of directories up the tree to check of a pyproject.toml.
+
+        """
+        if provided:
+            return provided.resolve()
+        rv = Path.cwd() / 'pyproject.toml'
+        count = 0
+        if not rv.is_file():
+            child = rv.parent.parent / 'pyproject.toml'
+            while count < depth:
+                if child.is_file():
+                    return child
+                if str(child.parent) == rv.root:
+                    break  # end discovery after checking system root once
+                child = child.parent.parent / 'pyproject.toml'
+                count += 1
+        return rv

idf_build_apps/yaml/parser.py

@@ -5,6 +5,8 @@ import typing as t
 
 import yaml
 
+from ..utils import PathLike
+
 
 def parse_postfixes(manifest_dict: t.Dict):
     for folder, folder_rule in manifest_dict.items():
@@ -60,7 +62,7 @@ def parse_postfixes(manifest_dict: t.Dict):
         manifest_dict[folder] = updated_folder
 
 
-def parse(path: str) -> t.Dict:
+def parse(path: PathLike) -> t.Dict:
     with open(path) as f:
         manifest_dict = yaml.safe_load(f) or {}
     parse_postfixes(manifest_dict)

{idf_build_apps-2.5.0rc1.dist-info → idf_build_apps-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: idf-build-apps
-Version: 2.5.0rc1
+Version: 2.5.1
 Summary: Tools for building ESP-IDF related apps.
 Author-email: Fu Hanxi <fuhanxi@espressif.com>
 Requires-Python: >=3.7
@@ -18,6 +18,7 @@ Requires-Dist: pyyaml
 Requires-Dist: packaging
 Requires-Dist: toml; python_version < '3.11'
 Requires-Dist: pydantic~=2.0
+Requires-Dist: pydantic_settings
 Requires-Dist: argcomplete>=3
 Requires-Dist: typing-extensions; python_version < '3.11'
 Requires-Dist: sphinx ; extra == "doc"

idf_build_apps-2.5.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+idf_build_apps/__init__.py,sha256=hPsqVwLnkcGIEQNAReIvWhXRDoov8t70997wSn1zJ0g,650
+idf_build_apps/__main__.py,sha256=8E-5xHm2MlRun0L88XJleNh5U50dpE0Q1nK5KqomA7I,182
+idf_build_apps/app.py,sha256=F-MKOsaz7cJ0H2wsEE4gpO4kkkEdkyFmIZBHDoM2qgs,37359
+idf_build_apps/args.py,sha256=Y4Wwoi8XYLjf8lWmCUm197NSzSBa4eC95QAyx4q7-6Q,31668
+idf_build_apps/autocompletions.py,sha256=g-bx0pzXoFKI0VQqftkHyGVWN6MLjuFOdozeuAf45yo,2138
+idf_build_apps/constants.py,sha256=07ve2FtWuLBuc_6LFzbs1XncB1VNi9HJUqGjQQauRNM,3952
+idf_build_apps/finder.py,sha256=kfZaGWJfPUwWAbaOj_W3Fu97SIIFEsv1R_dJucjbFHw,5691
+idf_build_apps/log.py,sha256=pyvT7N4MWzGjIXph5mThQCGBiSt53RNPW0WrFfLr0Kw,2650
+idf_build_apps/main.py,sha256=Z_hetbOavgCJZQPaP01_jx57fR1w0DefiFz0J2cCwp0,16498
+idf_build_apps/session_args.py,sha256=2WDTy40IFAc0KQ57HaeBcYj_k10eUXRKkDOWLrFCaHY,2985
+idf_build_apps/utils.py,sha256=s4D8P7QA17XcaCUQ_EoiNOW_VpU3cPQgiZVV9KQ8I30,10171
+idf_build_apps/junit/__init__.py,sha256=IxvdaS6eSXp7kZxRuXqyZyGxuA_A1nOW1jF1HMi8Gns,231
+idf_build_apps/junit/report.py,sha256=T7dVU3Sz5tqjfbcFW7wjsb65PDH6C2HFf73ePJqBhMs,6555
+idf_build_apps/junit/utils.py,sha256=j0PYhFTZjXtTwkENdeL4bFJcX24ktf1CsOOVXz65yNo,1297
+idf_build_apps/manifest/__init__.py,sha256=Q2-cb3ngNjnl6_zWhUfzZZB10f_-Rv2JYNck3Lk7UkQ,133
+idf_build_apps/manifest/if_parser.py,sha256=AAEyYPgcBWL2ToCmcvhx3fl8ebYdC5-LMvvDkYtWn8o,6546
+idf_build_apps/manifest/manifest.py,sha256=6F6Nt93eaoBOHlGHZtv2hHT8Zw0HmJf0d_MESlgye6M,14478
+idf_build_apps/manifest/soc_header.py,sha256=PzJ37xFspt5f0AXWvAFNA_avHZA9fMXHBrwDYLi3qEI,4344
+idf_build_apps/vendors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idf_build_apps/vendors/pydantic_sources.py,sha256=2IN6opo6qjCwaqhERFbgA4PtEwqKaTtEkccy5_fYAT0,4130
+idf_build_apps/yaml/__init__.py,sha256=W-3z5no07RQ6eYKGyOAPA8Z2CLiMPob8DD91I4URjrA,162
+idf_build_apps/yaml/parser.py,sha256=b3LvogO6do-eJPRsYzT-8xk8AT2MnXpLCzQutJqyC7M,2128
+idf_build_apps-2.5.1.dist-info/entry_points.txt,sha256=3pVUirUEsb6jsDRikkQWNUt4hqLK2ci1HvW_Vf8b6uE,59
+idf_build_apps-2.5.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+idf_build_apps-2.5.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+idf_build_apps-2.5.1.dist-info/METADATA,sha256=lvliMyMStV-5w_77UputZgbH9ZL2aDagexjxU6OUi-I,4610
+idf_build_apps-2.5.1.dist-info/RECORD,,

idf_build_apps/config.py

@@ -1,108 +0,0 @@
-# SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
-# SPDX-License-Identifier: Apache-2.0
-
-import os
-import typing as t
-from pathlib import (
-    Path,
-)
-
-from .utils import (
-    to_absolute_path,
-)
-
-
-class InvalidTomlError(SystemExit):
-    def __init__(self, filepath: t.Union[str, Path], msg: str) -> None:
-        super().__init__(f'Failed parsing toml file "{filepath}" with error: {msg}')
-
-
-PYPROJECT_TOML_FN = 'pyproject.toml'
-IDF_BUILD_APPS_TOML_FN = '.idf_build_apps.toml'
-
-
-def load_toml(filepath: t.Union[str, Path]) -> dict:
-    try:
-        import tomllib  # type: ignore # python 3.11
-
-        try:
-            with open(str(filepath), 'rb') as fr:
-                return tomllib.load(fr)
-        except Exception as e:
-            raise InvalidTomlError(filepath, str(e))
-    except ImportError:
-        import toml
-
-        try:
-            return toml.load(str(filepath))
-        except Exception as e:
-            raise InvalidTomlError(filepath, str(e))
-
-
-def _get_config_from_file(filepath: str) -> t.Tuple[t.Optional[dict], str]:
-    config = None
-    if os.path.isfile(filepath):
-        if os.path.basename(filepath) == PYPROJECT_TOML_FN:
-            tool = load_toml(filepath).get('tool', None)
-            if tool:
-                config = tool.get('idf-build-apps', None)
-        elif config is None:
-            config = load_toml(filepath)
-
-    return config, filepath
-
-
-def _get_config_from_path(dirpath: str) -> t.Tuple[t.Optional[dict], str]:
-    config = None
-    filepath = dirpath
-    if os.path.isfile(os.path.join(dirpath, PYPROJECT_TOML_FN)):
-        config, filepath = _get_config_from_file(os.path.join(dirpath, PYPROJECT_TOML_FN))
-
-    if config is None and os.path.isfile(os.path.join(dirpath, IDF_BUILD_APPS_TOML_FN)):
-        config, filepath = _get_config_from_file(os.path.join(dirpath, IDF_BUILD_APPS_TOML_FN))
-
-    return config, filepath
-
-
-def get_valid_config(starts_from: str = os.getcwd(), custom_path: t.Optional[str] = None) -> t.Optional[dict]:
-    """
-    Get the valid config from the current directory or its parent directories.
-
-    If the custom path is provided, it will be used to get the config file.
-
-    Otherwise, the search will start from the current working directory and go up to the root directory.
-
-    The search will stop in the following cases:
-
-    - A valid config file is found.
-    - A `.git` directory is found.
-    - The root directory is reached.
-
-    :param starts_from: starting directory to search for the config file. Default is the current working directory.
-    :param custom_path: custom path to the config file.
-    :return: the valid config dict if found, otherwise None.
-    """
-    root_dir = to_absolute_path('/')
-    cur_dir = to_absolute_path(starts_from)
-
-    config = None
-    if custom_path and os.path.isfile(custom_path):
-        config, filepath = _get_config_from_file(to_absolute_path(custom_path))
-        if config is not None:
-            # use print here since the verbose settings may be set in the config file
-            print(f'Using custom config file: {filepath}')
-            return config
-
-    while cur_dir != root_dir and config is None:
-        config, filepath = _get_config_from_path(cur_dir)
-        if config is not None:
-            # use print here since the verbose settings may be set in the config file
-            print(f'Using config file: {filepath}')
-            return config
-
-        if os.path.exists(os.path.join(cur_dir, '.git')):
-            break
-
-        cur_dir = os.path.abspath(os.path.join(cur_dir, '..'))
-
-    return None