idf-build-apps 2.6.0__py3-none-any.whl → 2.6.2__py3-none-any.whl

idf_build_apps/__init__.py

@@ -8,7 +8,7 @@ Tools for building ESP-IDF related apps.
 # ruff: noqa: E402
 # avoid circular imports
 
-__version__ = '2.6.0'
+__version__ = '2.6.2'
 
 from .session_args import (
     SessionArgs,

idf_build_apps/args.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 
 import argparse
@@ -115,8 +115,9 @@ def get_meta(f: FieldInfo) -> t.Optional[FieldMetadata]:
 class BaseArguments(BaseSettings):
     """Base settings class for all settings classes"""
 
+    CONFIG_FILE_PATH: t.ClassVar[t.Optional[Path]] = None
+
     model_config = SettingsConfigDict(
-        toml_file=IDF_BUILD_APPS_TOML_FN,
         # these below two are supported in pydantic 2.6
         pyproject_toml_table_header=('tool', 'idf-build-apps'),
         pyproject_toml_depth=sys.maxsize,
@@ -132,11 +133,15 @@ class BaseArguments(BaseSettings):
         dotenv_settings: PydanticBaseSettingsSource,  # noqa: ARG003
         file_secret_settings: PydanticBaseSettingsSource,  # noqa: ARG003
     ) -> t.Tuple[PydanticBaseSettingsSource, ...]:
-        return (
-            init_settings,
-            TomlConfigSettingsSource(settings_cls),
-            PyprojectTomlConfigSettingsSource(settings_cls),
-        )
+        sources: t.Tuple[PydanticBaseSettingsSource, ...] = (init_settings,)
+        if cls.CONFIG_FILE_PATH is None:
+            sources += (TomlConfigSettingsSource(settings_cls, toml_file=Path(IDF_BUILD_APPS_TOML_FN)),)
+            sources += (PyprojectTomlConfigSettingsSource(settings_cls, toml_file=Path('pyproject.toml')),)
+        else:
+            sources += (TomlConfigSettingsSource(settings_cls, toml_file=Path(cls.CONFIG_FILE_PATH)),)
+            sources += (PyprojectTomlConfigSettingsSource(settings_cls, toml_file=Path(cls.CONFIG_FILE_PATH)),)
+
+        return sources
 
     @field_validator('*', mode='before')
     @classmethod
@@ -874,12 +879,20 @@ def add_args_to_obj_doc_as_params(argument_cls: t.Type[GlobalArguments], obj: t.
     _obj.__doc__ = _doc_str
 
 
-def apply_config_file(config_file: t.Optional[str]) -> None:
+def apply_config_file(config_file: t.Optional[str] = None, reset: bool = False) -> None:
     def _subclasses(klass: t.Type[T]) -> t.Set[t.Type[T]]:
         return set(klass.__subclasses__()).union([s for c in klass.__subclasses__() for s in _subclasses(c)])
 
-    if config_file:
-        BaseArguments.model_config['toml_file'] = str(config_file)
-        # modify all subclasses
+    if reset:
+        BaseArguments.CONFIG_FILE_PATH = None
         for cls in _subclasses(BaseArguments):
-            cls.model_config['toml_file'] = str(config_file)
+            cls.CONFIG_FILE_PATH = None
+
+    if config_file:
+        if os.path.isfile(config_file):
+            p = Path(config_file)
+            BaseArguments.CONFIG_FILE_PATH = p
+            for cls in _subclasses(BaseArguments):
+                cls.CONFIG_FILE_PATH = p
+        else:
+            LOGGER.warning(f'Config file {config_file} does not exist. Ignoring...')

idf_build_apps/constants.py

@@ -1,70 +1,25 @@
-# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 
 import enum
-import importlib
-import logging
 import os
-import re
-import sys
-import typing as t
 
-from .utils import (
-    to_version,
-)
+import esp_bool_parser
 
-LOGGER = logging.getLogger(__name__)
-
-_idf_env = os.getenv('IDF_PATH') or ''
-if not _idf_env:
-    LOGGER.warning('IDF_PATH environment variable is not set. Entering test mode...')
-    LOGGER.warning('- Setting IDF_PATH to current directory...')
-IDF_PATH = os.path.abspath(_idf_env)
+IDF_PATH = esp_bool_parser.IDF_PATH
 IDF_PY = os.path.join(IDF_PATH, 'tools', 'idf.py')
 IDF_SIZE_PY = os.path.join(IDF_PATH, 'tools', 'idf_size.py')
+
 PROJECT_DESCRIPTION_JSON = 'project_description.json'
 DEFAULT_SDKCONFIG = 'sdkconfig.defaults'
 
-
-_idf_py_actions = os.path.join(IDF_PATH, 'tools', 'idf_py_actions')
-sys.path.append(_idf_py_actions)
-try:
-    _idf_py_constant_py = importlib.import_module('constants')
-except ModuleNotFoundError:
-    LOGGER.warning(
-        '- Set supported/preview targets to empty list... (ESP-IDF constants.py module not found under %s)',
-        _idf_py_actions,
-    )
-    _idf_py_constant_py = object()  # type: ignore
-SUPPORTED_TARGETS = getattr(_idf_py_constant_py, 'SUPPORTED_TARGETS', [])
-PREVIEW_TARGETS = getattr(_idf_py_constant_py, 'PREVIEW_TARGETS', [])
-ALL_TARGETS = SUPPORTED_TARGETS + PREVIEW_TARGETS
-
-
-def _idf_version_from_cmake() -> t.Tuple[int, int, int]:
-    version_path = os.path.join(IDF_PATH, 'tools', 'cmake', 'version.cmake')
-    if not os.path.isfile(version_path):
-        LOGGER.warning('- Setting ESP-IDF version to 1.0.0... (ESP-IDF version.cmake not exists at %s)', version_path)
-        return 1, 0, 0
-
-    regex = re.compile(r'^\s*set\s*\(\s*IDF_VERSION_([A-Z]{5})\s+(\d+)')
-    ver = {}
-    try:
-        with open(version_path) as f:
-            for line in f:
-                m = regex.match(line)
-
-                if m:
-                    ver[m.group(1)] = m.group(2)
-
-        return int(ver['MAJOR']), int(ver['MINOR']), int(ver['PATCH'])
-    except (KeyError, OSError):
-        raise ValueError(f'Cannot find ESP-IDF version in {version_path}')
-
-
-IDF_VERSION_MAJOR, IDF_VERSION_MINOR, IDF_VERSION_PATCH = _idf_version_from_cmake()
-
-IDF_VERSION = to_version(f'{IDF_VERSION_MAJOR}.{IDF_VERSION_MINOR}.{IDF_VERSION_PATCH}')
+SUPPORTED_TARGETS = esp_bool_parser.SUPPORTED_TARGETS
+PREVIEW_TARGETS = esp_bool_parser.PREVIEW_TARGETS
+ALL_TARGETS = esp_bool_parser.ALL_TARGETS
+IDF_VERSION_MAJOR = esp_bool_parser.IDF_VERSION_MAJOR
+IDF_VERSION_MINOR = esp_bool_parser.IDF_VERSION_MINOR
+IDF_VERSION_PATCH = esp_bool_parser.IDF_VERSION_PATCH
+IDF_VERSION = esp_bool_parser.IDF_VERSION
 
 
 class BuildStatus(str, enum.Enum):

idf_build_apps/main.py

@@ -1,6 +1,6 @@
 # PYTHON_ARGCOMPLETE_OK
 
-# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 
 import argparse
@@ -68,7 +68,8 @@ def find_apps(
 
     :return: list of found apps
     """
-    apply_config_file(config_file)
+    if config_file:
+        apply_config_file(config_file)
 
     # compatible with old usage
     ## `preserve`
@@ -132,7 +133,8 @@ def build_apps(
 
     :return: exit code
     """
-    apply_config_file(config_file)
+    if config_file:
+        apply_config_file(config_file)
 
     # compatible with old usage
     ## `check_app_dependencies`
@@ -385,8 +387,8 @@ def main():
     kwargs = vars(args)
     action = kwargs.pop('action')
     config_file = kwargs.pop('config_file')
-
-    apply_config_file(config_file)
+    if config_file:
+        apply_config_file(config_file)
 
     if action == 'dump-manifest-sha':
         arguments = DumpManifestShaArguments(**drop_none_kwargs(kwargs))

idf_build_apps/manifest/__init__.py

@@ -1,6 +1,17 @@
-# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 
 """
 Manifest file
 """
+
+from esp_bool_parser import register_addition_attribute
+
+from .manifest import FolderRule
+
+
+def folder_rule_attr(target, **kwargs):
+    return 1 if target in FolderRule.DEFAULT_BUILD_TARGETS else 0
+
+
+register_addition_attribute('INCLUDE_DEFAULT', folder_rule_attr)

idf_build_apps/manifest/manifest.py

@@ -1,11 +1,11 @@
-# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 import logging
 import os
-import pickle
 import typing as t
 from hashlib import sha512
 
+from esp_bool_parser import BoolStmt, parse_bool_expr
 from pyparsing import (
     ParseException,
 )
@@ -23,10 +23,6 @@ from ..utils import (
 from ..yaml import (
     parse,
 )
-from .if_parser import (
-    BOOL_EXPR,
-    BoolStmt,
-)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -34,7 +30,8 @@ LOGGER = logging.getLogger(__name__)
 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]
+            self.stmt: BoolStmt = parse_bool_expr(stmt)
+            self._stmt: str = stmt
         except (ParseException, InvalidIfClause) as ex:
             raise InvalidIfClause(f'Invalid if clause: {stmt}. {ex}')
 
@@ -51,6 +48,9 @@ class IfClause:
                 f'    reason: lack of ci runners'
             )
 
+    def __repr__(self):
+        return f'IfClause(stmt={self._stmt!r}, temporary={self.temporary!r}, reason={self.reason!r})'
+
     def get_value(self, target: str, config_name: str) -> t.Any:
         return self.stmt.get_value(target, config_name)
 
@@ -69,6 +69,14 @@ class SwitchClause:
                 return content
         return self.default_clause
 
+    def __repr__(self) -> str:
+        return (
+            f'SwitchClause('
+            f'if_clauses={self.if_clauses!r}, '
+            f'contents={self.contents!r}, '
+            f'default_clause={self.default_clause!r})'
+        )
+
 
 class FolderRule:
     DEFAULT_BUILD_TARGETS = SUPPORTED_TARGETS
@@ -153,7 +161,7 @@ class FolderRule:
             self.depends_components,
             self.depends_filepatterns,
         ]:
-            sha.update(pickle.dumps(obj, protocol=4))  # protocol 4 by default is set in Python 3.8
+            sha.update(repr(obj).encode())
 
         return sha.hexdigest()
 

idf_build_apps/manifest/soc_header.py

@@ -1,141 +1,6 @@
-# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
-import logging
-import os.path
-import typing as t
-from pathlib import (
-    Path,
-)
 
-from pyparsing import (
-    CaselessLiteral,
-    Char,
-    Combine,
-    Group,
-    Literal,
-    MatchFirst,
-    OneOrMore,
-    Optional,
-    ParseException,
-    ParseResults,
-    QuotedString,
-    Word,
-    alphas,
-    hexnums,
-    nums,
-)
+import esp_bool_parser
 
-from ..constants import (
-    ALL_TARGETS,
-    IDF_PATH,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-# Group for parsing literal suffix of a numbers, e.g. 100UL
-_literal_symbol = Group(CaselessLiteral('L') | CaselessLiteral('U'))
-_literal_suffix = OneOrMore(_literal_symbol)
-
-# Define name
-_name = Word(alphas, alphas + nums + '_')
-
-# Define value, either a hex, int or a string
-_hex_value = Combine(Literal('0x') + Word(hexnums) + Optional(_literal_suffix).suppress())('hex_value')
-_str_value = QuotedString('"')('str_value')
-_int_value = Combine(Optional('-') + Word(nums))('int_value') + ~Char('.') + Optional(_literal_suffix)('literal_suffix')
-
-# Remove optional parenthesis around values
-_value = Optional('(').suppress() + MatchFirst([_hex_value, _str_value, _int_value])('value') + Optional(')').suppress()
-
-_define_expr = '#define' + Optional(_name)('name') + Optional(_value)
-
-
-def get_defines(header_path: str) -> t.List[str]:
-    defines = []
-    LOGGER.debug('Reading macros from %s...', header_path)
-    with open(header_path) as f:
-        output = f.read()
-
-    for line in output.split('\n'):
-        line = line.strip()
-        if len(line):
-            defines.append(line)
-
-    return defines
-
-
-def parse_define(define_line: str) -> ParseResults:
-    res = _define_expr.parseString(define_line)
-
-    return res
-
-
-class SocHeader(dict):
-    CAPS_HEADER_FILEPATTERN = '*_caps.h'
-
-    def __init__(self, target: str) -> None:
-        if target != 'linux':
-            soc_header_dict = self._parse_soc_header(target)
-        else:
-            soc_header_dict = {}
-
-        super().__init__(**soc_header_dict)
-
-    @staticmethod
-    def _get_dirs_from_candidates(candidates: t.List[str]) -> t.List[str]:
-        dirs = []
-        for d in candidates:
-            if not os.path.isdir(d):
-                LOGGER.debug('folder "%s" not found. Skipping...', os.path.abspath(d))
-            else:
-                dirs.append(d)
-
-        return dirs
-
-    @classmethod
-    def _parse_soc_header(cls, target: str) -> t.Dict[str, t.Any]:
-        soc_headers_dirs = cls._get_dirs_from_candidates(
-            [
-                # master c5 mp
-                os.path.abspath(os.path.join(IDF_PATH, 'components', 'soc', target, 'mp', 'include', 'soc')),
-                # other branches
-                os.path.abspath(os.path.join(IDF_PATH, 'components', 'soc', target, 'include', 'soc')),
-                # release/v4.2
-                os.path.abspath(os.path.join(IDF_PATH, 'components', 'soc', 'soc', target, 'include', 'soc')),
-            ]
-        )
-        esp_rom_headers_dirs = cls._get_dirs_from_candidates(
-            [
-                # master c5 mp
-                os.path.abspath(os.path.join(IDF_PATH, 'components', 'esp_rom', target, 'mp', target)),
-                # others
-                os.path.abspath(os.path.join(IDF_PATH, 'components', 'esp_rom', target)),
-            ]
-        )
-
-        header_files: t.List[str] = []
-        for d in [*soc_headers_dirs, *esp_rom_headers_dirs]:
-            LOGGER.debug('Checking dir %s', d)
-            header_files += [str(p.resolve()) for p in Path(d).glob(cls.CAPS_HEADER_FILEPATTERN)]
-
-        output_dict = {}
-        for f in header_files:
-            LOGGER.debug('Checking header file %s', f)
-            for line in get_defines(f):
-                try:
-                    res = parse_define(line)
-                except ParseException:
-                    LOGGER.debug('Failed to parse: %s', line)
-                    continue
-
-                if 'str_value' in res:
-                    output_dict[res.name] = res.str_value
-                elif 'int_value' in res:
-                    output_dict[res.name] = int(res.int_value)
-                elif 'hex_value' in res:
-                    output_dict[res.name] = int(res.hex_value, 16)
-
-        return output_dict
-
-
-SOC_HEADERS: t.Dict[str, SocHeader] = {target: SocHeader(target) for target in ALL_TARGETS}
+SOC_HEADERS = esp_bool_parser.SOC_HEADERS

idf_build_apps/vendors/pydantic_sources.py

@@ -17,6 +17,7 @@ Modifications:
 - recursively find TOML file.
 """
 
+import logging
 import os
 import sys
 from abc import ABC, abstractmethod
@@ -30,6 +31,7 @@ from idf_build_apps.constants import IDF_BUILD_APPS_TOML_FN
 
 PathType = Union[Path, str, List[Union[Path, str]], Tuple[Union[Path, str], ...]]
 DEFAULT_PATH = Path('')
+LOGGER = logging.getLogger(__name__)
 
 
 class ConfigFileSourceMixin(ABC):
@@ -93,17 +95,19 @@ class TomlConfigSettingsSource(InitSettingsSource, ConfigFileSourceMixin):
         :param depth: Number of directories up the tree to check of a pyproject.toml.
         """
         if provided and Path(provided).is_file():
-            return provided.resolve()
+            fp = provided.resolve()
+            LOGGER.debug(f'Loading config file: {fp}')
+            return fp
 
         rv = Path.cwd()
         count = -1
         while count < depth:
-            if str(rv) == rv.root:
+            if len(rv.parts) == 1:
                 break
 
             fp = rv / filename
             if fp.is_file():
-                print(f'Loading config file: {fp}')
+                LOGGER.debug(f'Loading config file: {fp}')
                 return fp
 
             rv = rv.parent

{idf_build_apps-2.6.0.dist-info → idf_build_apps-2.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: idf-build-apps
-Version: 2.6.0
+Version: 2.6.2
 Summary: Tools for building ESP-IDF related apps.
 Author-email: Fu Hanxi <fuhanxi@espressif.com>
 Requires-Python: >=3.7
@@ -21,6 +21,7 @@ Requires-Dist: pydantic~=2.0
 Requires-Dist: pydantic_settings
 Requires-Dist: argcomplete>=3
 Requires-Dist: typing-extensions; python_version < '3.11'
+Requires-Dist: esp-bool-parser>=0.1.2,<1
 Requires-Dist: sphinx ; extra == "doc"
 Requires-Dist: sphinx-rtd-theme ; extra == "doc"
 Requires-Dist: sphinx_copybutton ; extra == "doc"

{idf_build_apps-2.6.0.dist-info → idf_build_apps-2.6.2.dist-info}/RECORD

@@ -1,28 +1,27 @@
-idf_build_apps/__init__.py,sha256=VMMqqRp30Golk7dqGCARNL8mR9oZaz86HOXoySoXvIY,650
+idf_build_apps/__init__.py,sha256=m6Rv6NFbCuro2DEeChOgSIDFGQahhbsPVd6IEqQJY74,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=7-rphv1hhbjJRfE_agBUyQbJaiUhsjsBo6C3eDmug2k,34101
+idf_build_apps/args.py,sha256=zB08ctBXFz1UkPv4r7kE6E6sBezCFrrzt99HKRDiRTA,34821
 idf_build_apps/autocompletions.py,sha256=g-bx0pzXoFKI0VQqftkHyGVWN6MLjuFOdozeuAf45yo,2138
-idf_build_apps/constants.py,sha256=07ve2FtWuLBuc_6LFzbs1XncB1VNi9HJUqGjQQauRNM,3952
+idf_build_apps/constants.py,sha256=HU0rtKqhvLj9nMsy6XvyQMjMEBliNi9xaS2D8CQEPsE,2421
 idf_build_apps/finder.py,sha256=hY6uSMB2s65MqMKIDBSHABOfa93mOLT7x5hlMxC43EQ,5794
 idf_build_apps/log.py,sha256=pyvT7N4MWzGjIXph5mThQCGBiSt53RNPW0WrFfLr0Kw,2650
-idf_build_apps/main.py,sha256=Z_hetbOavgCJZQPaP01_jx57fR1w0DefiFz0J2cCwp0,16498
+idf_build_apps/main.py,sha256=SZauvC_DNEsl1Twc5xQxHSSPt8sgYsNOZjN4UjHk0gQ,16569
 idf_build_apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=NXZxQD4tdbSVKjKMNx1kO2H3IoEiysXkDoDjLEf1RO8,1303
-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=8vlsAjNsTxxb85RFJxVJTe11ealNQ8n5abUdNuC9ULo,4369
+idf_build_apps/manifest/__init__.py,sha256=LYGR9doEKGPEdsJPuHnmJmV-qw2kuAipV0bodkhY_JE,399
+idf_build_apps/manifest/manifest.py,sha256=5BIzNzGAk0w5qOCTMGsmvKcN4DQLwUi6JVGt2G4JKQs,14793
+idf_build_apps/manifest/soc_header.py,sha256=_F6H5-HP6ateAqKUGlRGH-SUtQ8NJ1RI0hBeCFvsDYA,172
 idf_build_apps/vendors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-idf_build_apps/vendors/pydantic_sources.py,sha256=2e-zA_aHe7NVXMoPKU_0Z9Lg9lw80TFWQ-2PZf10FMs,4419
+idf_build_apps/vendors/pydantic_sources.py,sha256=cxSIPRc3eI5peVMhDxwf58YaGhuG4SCwPRVX2znFEek,4553
 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.6.0.dist-info/entry_points.txt,sha256=3pVUirUEsb6jsDRikkQWNUt4hqLK2ci1HvW_Vf8b6uE,59
-idf_build_apps-2.6.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-idf_build_apps-2.6.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-idf_build_apps-2.6.0.dist-info/METADATA,sha256=StRvId-xGrePTaC0FjO9O58mazLMSD0EZGrPDSOOxvs,4652
-idf_build_apps-2.6.0.dist-info/RECORD,,
+idf_build_apps-2.6.2.dist-info/entry_points.txt,sha256=3pVUirUEsb6jsDRikkQWNUt4hqLK2ci1HvW_Vf8b6uE,59
+idf_build_apps-2.6.2.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+idf_build_apps-2.6.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+idf_build_apps-2.6.2.dist-info/METADATA,sha256=mKkCtbqE575AjE9JLBbTUeRQ9Cs1gcep0FHeHl0tN8s,4693
+idf_build_apps-2.6.2.dist-info/RECORD,,

idf_build_apps/manifest/if_parser.py

@@ -1,240 +0,0 @@
-# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
-# SPDX-License-Identifier: Apache-2.0
-import operator
-import os
-from ast import (
-    literal_eval,
-)
-from typing import (
-    Any,
-)
-
-from packaging.version import (
-    Version,
-)
-from pyparsing import (
-    Keyword,
-    Literal,
-    MatchFirst,
-    ParseResults,
-    QuotedString,
-    Suppress,
-    Word,
-    alphas,
-    delimitedList,
-    hexnums,
-    infixNotation,
-    nums,
-    opAssoc,
-)
-
-from ..constants import (
-    IDF_VERSION,
-    IDF_VERSION_MAJOR,
-    IDF_VERSION_MINOR,
-    IDF_VERSION_PATCH,
-)
-from ..utils import (
-    InvalidIfClause,
-    InvalidInput,
-    to_version,
-)
-from .soc_header import (
-    SOC_HEADERS,
-)
-
-
-class Stmt:
-    """
-    Statement
-    """
-
-    def get_value(self, target: str, config_name: str) -> Any:
-        """
-        Lazy calculated. All subclasses of `Stmt` should implement this function.
-
-        :param target: ESP-IDF target
-        :type target: str
-        :param config_name: config name
-        :type target: str
-        :return: the value of the statement
-        """
-        raise NotImplementedError('Please implement this function in sub classes')
-
-
-class ChipAttr(Stmt):
-    """
-    Attributes defined in SOC Header Files and other keywords as followed:
-
-    - IDF_TARGET: target
-    - INCLUDE_DEFAULT: take the default build targets into account or not
-    - IDF_VERSION_MAJOR: major version of ESP-IDF
-    - IDF_VERSION_MINOR: minor version of ESP-IDF
-    - IDF_VERSION_PATCH: patch version of ESP-IDF
-    - CONFIG_NAME: config name defined in the config rules
-    """
-
-    def __init__(self, t: ParseResults):
-        self.attr: str = t[0]
-
-    def get_value(self, target: str, config_name: str) -> Any:
-        from .manifest import FolderRule  # lazy-load
-
-        if self.attr == 'IDF_TARGET':
-            return target
-
-        if self.attr == 'INCLUDE_DEFAULT':
-            return 1 if target in FolderRule.DEFAULT_BUILD_TARGETS else 0
-
-        if self.attr == 'IDF_VERSION':
-            return IDF_VERSION
-
-        if self.attr == 'IDF_VERSION_MAJOR':
-            return IDF_VERSION_MAJOR
-
-        if self.attr == 'IDF_VERSION_MINOR':
-            return IDF_VERSION_MINOR
-
-        if self.attr == 'IDF_VERSION_PATCH':
-            return IDF_VERSION_PATCH
-
-        if self.attr == 'CONFIG_NAME':
-            return config_name
-
-        if self.attr in SOC_HEADERS[target]:
-            return SOC_HEADERS[target][self.attr]
-
-        # for non-keyword cap words, check if it is defined in the environment variables
-        if self.attr in os.environ:
-            return os.environ[self.attr]
-
-        return 0  # default return 0 as false
-
-
-class Integer(Stmt):
-    def __init__(self, t: ParseResults):
-        self.expr: str = t[0]
-
-    def get_value(self, target: str, config_name: str) -> Any:  # noqa: ARG002
-        return literal_eval(self.expr)
-
-
-class String(Stmt):
-    def __init__(self, t: ParseResults):
-        self.expr: str = t[0]
-
-    def get_value(self, target: str, config_name: str) -> Any:  # noqa: ARG002
-        return literal_eval(f'"{self.expr}"')  # double quotes is swallowed by QuotedString
-
-
-class List_(Stmt):
-    def __init__(self, t: ParseResults):
-        self.expr = t
-
-    def get_value(self, target: str, config_name: str) -> Any:
-        return [item.get_value(target, config_name) for item in self.expr]
-
-
-class BoolStmt(Stmt):
-    _OP_DICT = {
-        '==': operator.eq,
-        '!=': operator.ne,
-        '>': operator.gt,
-        '>=': operator.ge,
-        '<': operator.lt,
-        '<=': operator.le,
-        'not in': lambda x, y: x not in y,
-        'in': lambda x, y: x in y,
-    }
-
-    def __init__(self, t: ParseResults):
-        self.left: Stmt = t[0]
-        self.comparison: str = t[1]
-        self.right: Stmt = t[2]
-
-    def get_value(self, target: str, config_name: str) -> Any:
-        _l = self.left.get_value(target, config_name)
-        _r = self.right.get_value(target, config_name)
-
-        if self.comparison not in ['in', 'not in']:
-            # will use version comparison if any of the operands is a Version
-            if any(isinstance(x, Version) for x in [_l, _r]):
-                _l = to_version(_l)
-                _r = to_version(_r)
-        else:
-            # use str for "in" and "not in" operator
-            if isinstance(_l, Version):
-                _l = str(_l)
-            if isinstance(_r, Version):
-                _r = str(_r)
-
-        if self.comparison in self._OP_DICT:
-            return self._OP_DICT[self.comparison](_l, _r)
-
-        raise InvalidInput(f'Unsupported comparison operator: "{self.comparison}"')
-
-
-class BoolExpr(Stmt):
-    pass
-
-
-def _and(_l, _r):
-    return _l and _r
-
-
-def _or(_l, _r):
-    return _l or _r
-
-
-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.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)
-
-DECIMAL_NUMBER = Word(nums)
-HEX_NUMBER = Literal('0x') + Word(hexnums)
-INTEGER = (HEX_NUMBER | DECIMAL_NUMBER).setParseAction(Integer)
-
-STRING = QuotedString('"').setParseAction(String)
-
-LIST = Suppress('[') + delimitedList(INTEGER | STRING).setParseAction(List_) + Suppress(']')
-
-BOOL_OPERAND = CAP_WORD | INTEGER | STRING | LIST
-
-EQ = Keyword('==').setParseAction(lambda t: t[0])
-NE = Keyword('!=').setParseAction(lambda t: t[0])
-LE = Keyword('<=').setParseAction(lambda t: t[0])
-LT = Keyword('<').setParseAction(lambda t: t[0])
-GE = Keyword('>=').setParseAction(lambda t: t[0])
-GT = Keyword('>').setParseAction(lambda t: t[0])
-NOT_IN = Keyword('not in').setParseAction(lambda t: t[0])
-IN = Keyword('in').setParseAction(lambda t: t[0])
-
-BOOL_STMT = BOOL_OPERAND + (EQ | NE | LE | LT | GE | GT | NOT_IN | IN) + BOOL_OPERAND
-BOOL_STMT.setParseAction(BoolStmt)
-
-AND = Keyword('and')
-OR = Keyword('or')
-
-BOOL_EXPR = infixNotation(
-    BOOL_STMT,
-    [
-        (MatchFirst((AND, OR)), 2, opAssoc.LEFT, BoolOrAnd),
-    ],
-)