idf-build-apps 2.4.2__py3-none-any.whl → 2.5.0__py3-none-any.whl

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,23 @@ class BoolExpr(Stmt):
     pass
 
 
-class BoolAnd(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]
 
-    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)
-
-
-class BoolOr(BoolExpr):
-    def __init__(self, t: ParseResults):
-        self.left: BoolStmt = t[0][0]
-        self.right: BoolStmt = t[0][2]
+        if t[0][1] == 'and':
+            self.operation = lambda l, r: l and r  # noqa: E741
+        if t[0][1] == 'or':
+            self.operation = lambda l, r: l or r  # noqa: E741
 
     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 +227,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

@@ -1,10 +1,10 @@
 # SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
-
 import logging
 import os
+import pickle
 import typing as t
-import warnings
+from hashlib import sha512
 
 from pyparsing import (
     ParseException,
@@ -17,6 +17,8 @@ from ..constants import (
 from ..utils import (
     InvalidIfClause,
     InvalidManifest,
+    PathLike,
+    to_absolute_path,
 )
 from ..yaml import (
     parse,
@@ -33,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)
@@ -127,7 +136,26 @@ class FolderRule:
         self.depends_filepatterns = _clause_to_switch_or_list(depends_filepatterns)
 
     def __hash__(self) -> int:
-        return hash(self.folder)
+        return hash(self.sha)
+
+    @property
+    def sha(self) -> str:
+        """
+        SHA of the FolderRule instance
+
+        :return: SHA value
+        """
+        sha = sha512()
+        for obj in [
+            self.enable,
+            self.disable,
+            self.disable_test,
+            self.depends_components,
+            self.depends_filepatterns,
+        ]:
+            sha.update(pickle.dumps(obj, protocol=4))  # protocol 4 by default is set in Python 3.8
+
+        return sha.hexdigest()
 
     def __repr__(self) -> str:
         return f'FolderRule({self.folder})'
@@ -207,23 +235,28 @@ class DefaultRule(FolderRule):
 
 class Manifest:
     # could be reassigned later
-    ROOTPATH = os.curdir
     CHECK_MANIFEST_RULES = False
 
-    def __init__(
-        self,
-        rules: t.Iterable[FolderRule],
-    ) -> None:
+    def __init__(self, rules: t.Iterable[FolderRule], *, root_path: str = os.curdir) -> None:
         self.rules = sorted(rules, key=lambda x: x.folder)
 
+        self._root_path = to_absolute_path(root_path)
+
     @classmethod
-    def from_files(cls, paths: t.List[str]) -> 'Manifest':
-        # folder, defined_at dict
-        _known_folders: t.Dict[str, str] = dict()
+    def from_files(cls, paths: t.Iterable[PathLike], *, root_path: str = os.curdir) -> 'Manifest':
+        """
+        Create a Manifest instance from multiple manifest files
+
+        :param paths: manifest file paths
+        :param root_path: root path for relative paths in manifest files
+        :return: Manifest instance
+        """
+        # folder, defined as dict
+        _known_folders: t.Dict[str, PathLike] = dict()
 
         rules: t.List[FolderRule] = []
         for path in paths:
-            _manifest = cls.from_file(path)
+            _manifest = cls.from_file(path, root_path=root_path)
 
             for rule in _manifest.rules:
                 if rule.folder in _known_folders:
@@ -231,43 +264,106 @@ class Manifest:
                     if cls.CHECK_MANIFEST_RULES:
                         raise InvalidManifest(msg)
                     else:
-                        warnings.warn(msg)
+                        LOGGER.warning(msg)
 
                 _known_folders[rule.folder] = path
 
             rules.extend(_manifest.rules)
 
-        return Manifest(rules)
+        return Manifest(rules, root_path=root_path)
 
     @classmethod
-    def from_file(cls, path: str) -> 'Manifest':
+    def from_file(cls, path: PathLike, *, root_path: str = os.curdir) -> 'Manifest':
+        """
+        Create a Manifest instance from a manifest file
+
+        :param path: path to the manifest file
+        :param root_path: root path for relative paths in manifest file
+        :return: Manifest instance
+        """
         manifest_dict = parse(path)
 
         rules: t.List[FolderRule] = []
         for folder, folder_rule in manifest_dict.items():
-            # not a folder, but a anchor
+            # not a folder, but an anchor
             if folder.startswith('.'):
                 continue
 
             if not os.path.isabs(folder):
-                folder = os.path.join(cls.ROOTPATH, folder)
+                folder = os.path.join(root_path, folder)
 
             if not os.path.exists(folder):
                 msg = f'Folder "{folder}" does not exist. Please check your manifest file {path}'
                 if cls.CHECK_MANIFEST_RULES:
                     raise InvalidManifest(msg)
                 else:
-                    warnings.warn(msg)
+                    LOGGER.warning(msg)
 
             try:
                 rules.append(FolderRule(folder, **folder_rule if folder_rule else {}))
             except InvalidIfClause as e:
                 raise InvalidManifest(f'Invalid manifest file {path}: {e}')
 
-        return Manifest(rules)
+        return Manifest(rules, root_path=root_path)
+
+    def dump_sha_values(self, sha_filepath: str) -> None:
+        """
+        Dump the (relative path of the folder, SHA of the FolderRule instance) pairs
+        for all rules to the file in format: ``<relative_path>:<SHA>``
+
+        :param sha_filepath: output file path
+        :return: None
+        """
+        with open(sha_filepath, 'w') as fw:
+            for rule in self.rules:
+                fw.write(f'{os.path.relpath(rule.folder, self._root_path)}:{rule.sha}\n')
+
+    def diff_sha_with_filepath(self, sha_filepath: str, use_abspath: bool = False) -> t.Set[str]:
+        """
+        Compare the SHA recorded in the file with the current Manifest instance.
+
+        :param sha_filepath: dumped SHA file path
+        :param use_abspath: whether to return the absolute path of the folders
+        :return: Set of folders that have different SHA values
+        """
+        recorded__rel_folder__sha__dict = dict()
+        with open(sha_filepath) as fr:
+            for line in fr:
+                line = line.strip()
+                if line:
+                    try:
+                        folder, sha_value = line.strip().rsplit(':', maxsplit=1)
+                    except ValueError:
+                        raise InvalidManifest(f'Invalid line in SHA file: {line}. Expected format: <folder>:<SHA>')
+
+                    recorded__rel_folder__sha__dict[folder] = sha_value
+
+        self__rel_folder__sha__dict = {os.path.relpath(rule.folder, self._root_path): rule.sha for rule in self.rules}
+
+        diff_folders = set()
+        if use_abspath:
+
+            def _path(x):
+                return os.path.join(self._root_path, x)
+        else:
+
+            def _path(x):
+                return x
+
+        for folder, sha_value in recorded__rel_folder__sha__dict.items():
+            if folder not in self__rel_folder__sha__dict:
+                diff_folders.add(_path(folder))
+            elif sha_value != self__rel_folder__sha__dict[folder]:
+                diff_folders.add(_path(folder))
+
+        for folder in self__rel_folder__sha__dict:
+            if folder not in recorded__rel_folder__sha__dict:
+                diff_folders.add(_path(folder))
+
+        return diff_folders
 
-    def _most_suitable_rule(self, _folder: str) -> FolderRule:
-        folder = os.path.abspath(_folder)
+    def most_suitable_rule(self, _folder: str) -> FolderRule:
+        folder = to_absolute_path(_folder)
         for rule in self.rules[::-1]:
             if os.path.commonpath([folder, rule.folder]) == rule.folder:
                 return rule
@@ -277,17 +373,17 @@ class Manifest:
     def enable_build_targets(
         self, folder: str, default_sdkconfig_target: t.Optional[str] = None, config_name: t.Optional[str] = None
     ) -> t.List[str]:
-        return self._most_suitable_rule(folder).enable_build_targets(default_sdkconfig_target, config_name)
+        return self.most_suitable_rule(folder).enable_build_targets(default_sdkconfig_target, config_name)
 
     def enable_test_targets(
         self, folder: str, default_sdkconfig_target: t.Optional[str] = None, config_name: t.Optional[str] = None
     ) -> t.List[str]:
-        return self._most_suitable_rule(folder).enable_test_targets(default_sdkconfig_target, config_name)
+        return self.most_suitable_rule(folder).enable_test_targets(default_sdkconfig_target, config_name)
 
     def depends_components(
         self, folder: str, default_sdkconfig_target: t.Optional[str] = None, config_name: t.Optional[str] = None
     ) -> t.List[str]:
-        res = self._most_suitable_rule(folder).depends_components
+        res = self.most_suitable_rule(folder).depends_components
         if isinstance(res, list):
             return res
         return res.get_value(default_sdkconfig_target or '', config_name or '')
@@ -295,7 +391,7 @@ class Manifest:
     def depends_filepatterns(
         self, folder: str, default_sdkconfig_target: t.Optional[str] = None, config_name: t.Optional[str] = None
     ) -> t.List[str]:
-        res = self._most_suitable_rule(folder).depends_filepatterns
+        res = self.most_suitable_rule(folder).depends_filepatterns
         if isinstance(res, list):
             return res
         return res.get_value(default_sdkconfig_target or '', config_name or '')

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,
@@ -21,6 +22,24 @@ from pydantic import BaseModel as _BaseModel
 
 LOGGER = logging.getLogger(__name__)
 
+if sys.version_info < (3, 8):
+    from typing_extensions import (
+        Literal,
+    )
+else:
+    from typing import (
+        Literal,  # noqa
+    )
+
+if sys.version_info < (3, 11):
+    from typing_extensions import (
+        Self,
+    )
+else:
+    from typing import (
+        Self,  # noqa
+    )
+
 
 class ConfigRule:
     def __init__(self, file_name: str, config_name: str = '') -> None:
@@ -106,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
@@ -365,3 +384,10 @@ class BaseModel(_BaseModel):
                 hash_list.append(v)
 
         return hash((type(self), *tuple(hash_list)))
+
+
+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.4.2.dist-info → idf_build_apps-2.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: idf-build-apps
-Version: 2.4.2
+Version: 2.5.0
 Summary: Tools for building ESP-IDF related apps.
 Author-email: Fu Hanxi <fuhanxi@espressif.com>
 Requires-Python: >=3.7
@@ -18,8 +18,9 @@ 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 ; extra == "dev" and ( python_version < '3.8')
+Requires-Dist: typing-extensions; python_version < '3.11'
 Requires-Dist: sphinx ; extra == "doc"
 Requires-Dist: sphinx-rtd-theme ; extra == "doc"
 Requires-Dist: sphinx_copybutton ; extra == "doc"
@@ -32,7 +33,6 @@ Project-URL: changelog, https://github.com/espressif/idf-build-apps/blob/master/
 Project-URL: documentation, https://docs.espressif.com/projects/idf-build-apps
 Project-URL: homepage, https://github.com/espressif/idf-build-apps
 Project-URL: repository, https://github.com/espressif/idf-build-apps
-Provides-Extra: dev
 Provides-Extra: doc
 Provides-Extra: test
 
@@ -113,5 +113,5 @@ Thanks for your contribution! Please refer to our [Contributing Guide](CONTRIBUT
 [hello-world]: https://github.com/espressif/esp-idf/tree/master/examples/get-started/hello_world
 [supported-targets]: https://github.com/espressif/esp-idf/tree/v5.0#esp-idf-release-and-soc-compatibility
 [doc]: https://docs.espressif.com/projects/idf-build-apps/en/latest/
-[api-doc]: https://docs.espressif.com/projects/idf-build-apps/en/latest/api/modules.html
+[api-doc]: https://docs.espressif.com/projects/idf-build-apps/en/latest/references/api/modules.html
 

idf_build_apps-2.5.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+idf_build_apps/__init__.py,sha256=1tAmsSMb7Trrua4-819N1AqwwqDEfk9YN4iWCmwUGOU,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=XUXN-lemfvR93XOUedO8JybSgLCD71EdkDBGuOE8jnQ,6526
+idf_build_apps/manifest/manifest.py,sha256=1RpD6k-u-51dJIKl4PT3JtQd_3_vKBTwrK4f2a6zFf0,14360
+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.0.dist-info/entry_points.txt,sha256=3pVUirUEsb6jsDRikkQWNUt4hqLK2ci1HvW_Vf8b6uE,59
+idf_build_apps-2.5.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+idf_build_apps-2.5.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+idf_build_apps-2.5.0.dist-info/METADATA,sha256=1qLRKtlKQmat-zA054RMia_mMilScx-nClcbMZPdtfg,4610
+idf_build_apps-2.5.0.dist-info/RECORD,,

idf_build_apps/build_apps_args.py

@@ -1,64 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
-# SPDX-License-Identifier: Apache-2.0
-
-import typing as t
-
-from pydantic import (
-    computed_field,
-)
-
-from .utils import (
-    BaseModel,
-)
-
-
-class BuildAppsArgs(BaseModel):
-    PARALLEL_INDEX_PLACEHOLDER: t.ClassVar[str] = '@p'  # replace it with the parallel index
-
-    parallel_index: int = 1
-    parallel_count: int = 1
-
-    _junitxml: t.Optional[str] = None
-    _collect_app_info: t.Optional[str] = None
-    _collect_size_info: t.Optional[str] = None
-
-    def __init__(
-        self,
-        *,
-        collect_app_info: t.Optional[str] = None,
-        collect_size_info: t.Optional[str] = None,
-        junitxml: t.Optional[str] = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self._junitxml = junitxml
-        self._collect_app_info = collect_app_info
-        self._collect_size_info = collect_size_info
-
-    @computed_field  # type: ignore
-    @property
-    def collect_app_info(self) -> t.Optional[str]:
-        if self._collect_app_info:
-            return self.expand(self._collect_app_info)
-
-        return None
-
-    @computed_field  # type: ignore
-    @property
-    def collect_size_info(self) -> t.Optional[str]:
-        if self._collect_size_info:
-            return self.expand(self._collect_size_info)
-
-        return None
-
-    @computed_field  # type: ignore
-    @property
-    def junitxml(self) -> t.Optional[str]:
-        if self._junitxml:
-            return self.expand(self._junitxml)
-
-        return None
-
-    def expand(self, path):
-        return path.replace(self.PARALLEL_INDEX_PLACEHOLDER, str(self.parallel_index))