idf-build-apps 2.12.2__tar.gz → 2.13.0__tar.gz

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/.github/workflows/publish-pypi.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v5
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.7"
       - name: Publish packages

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/.github/workflows/test-build-docs.yml

@@ -9,7 +9,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.7'
       - name: Install dependencies

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/.github/workflows/test-build-idf-apps.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v5
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: '3.7'
       - run: |

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/.pre-commit-config.yaml

@@ -17,13 +17,13 @@ repos:
           - --use-current-year
         exclude: 'idf_build_apps/vendors/'
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.8'
+    rev: 'v0.13.0'
     hooks:
       - id: ruff
         args: ['--fix']
       - id: ruff-format
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 'v1.17.1'
+    rev: 'v1.18.1'
     hooks:
       - id: mypy
         args: ['--warn-unused-ignores']

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## v2.13.0 (2025-09-26)
+
+### ✨ New Features
+
+- support `--additional-build-targets` *(Fu Hanxi - dbbd8d3)*
+
+### 🐛 Bug Fixes
+
+- **find_apps**: ignore target-specific sdkconfig files even without setting CONFIG_IDF_TARGET *(Fu Hanxi - 1861a7a)*
+- record `checked_should_build` *(Fu Hanxi - f37fff1)*
+
+
+## v2.12.3 (2025-09-16)
+
+### Fix
+
+- app behaves normally in set
+
 ## v2.12.2 (2025-08-27)
 
 ### Fix

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idf-build-apps
-Version: 2.12.2
+Version: 2.13.0
 Summary: Tools for building ESP-IDF related apps.
 Author-email: Fu Hanxi <fuhanxi@espressif.com>
 Requires-Python: >=3.7

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/idf_build_apps/__init__.py

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

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/idf_build_apps/app.py

@@ -109,6 +109,7 @@ class App(BaseModel):
     build_status: BuildStatus = BuildStatus.UNKNOWN
     build_comment: t.Optional[str] = None
     test_comment: t.Optional[str] = None
+    checked_should_build: bool = False
 
     _build_duration: float = 0
     _build_timestamp: t.Optional[datetime] = None
@@ -116,6 +117,7 @@ class App(BaseModel):
     __EQ_IGNORE_FIELDS__ = [
         'build_comment',
         'test_comment',
+        'checked_should_build',
     ]
     __EQ_TUNE_FIELDS__ = {
         'app_dir': lambda x: (os.path.realpath(os.path.expanduser(x))),
@@ -163,9 +165,6 @@ class App(BaseModel):
         self._kwargs = kwargs
         self._initialize_hook(**kwargs)
 
-        # private attrs, won't be dumped to json
-        self._checked_should_build = False
-
         self._sdkconfig_files, self._sdkconfig_files_defined_target = self._process_sdkconfig_files()
 
     @classmethod
@@ -750,12 +749,12 @@ class App(BaseModel):
                         self.build_comment += '\n'.join(f'- {clause}' for clause in rule.enable)
 
             self.build_status = BuildStatus.DISABLED
-            self._checked_should_build = True
+            self.checked_should_build = True
             return
 
         if not check_app_dependencies:
             self.build_status = BuildStatus.SHOULD_BE_BUILT
-            self._checked_should_build = True
+            self.checked_should_build = True
             return
 
         if (
@@ -765,26 +764,26 @@ class App(BaseModel):
         ):
             self.build_status = BuildStatus.SHOULD_BE_BUILT
             self.build_comment = 'current build modifies the related manifest rules'
-            self._checked_should_build = True
+            self.checked_should_build = True
             return
 
         if self.is_modified(modified_files):
             self.build_status = BuildStatus.SHOULD_BE_BUILT
             self.build_comment = 'current build modifies this app'
-            self._checked_should_build = True
+            self.checked_should_build = True
             return
 
         # if didn't modify any components, and no `depends_filepatterns` defined, skip
         if modified_components == [] and not self.depends_filepatterns:
             self.build_status = BuildStatus.SKIPPED
             self.build_comment = 'current build does not modify any components'
-            self._checked_should_build = True
+            self.checked_should_build = True
             return
 
         # if no special rules defined, we left it unknown and decide with idf.py reconfigure
         if not self.depends_components and not self.depends_filepatterns:
             # keep unknown
-            self._checked_should_build = True
+            self.checked_should_build = True
             self.build_comment = 'no special rules defined, run idf.py reconfigure to decide'
             return
 
@@ -795,7 +794,7 @@ class App(BaseModel):
         # depends components?
         if self.depends_components and modified_components is not None:
             if set(self.depends_components).intersection(set(modified_components)):
-                self._checked_should_build = True
+                self.checked_should_build = True
                 self.build_status = BuildStatus.SHOULD_BE_BUILT
                 self.build_comment = (
                     f'Requires components: {", ".join(self.depends_components)}. '
@@ -806,7 +805,7 @@ class App(BaseModel):
         # or depends file patterns?
         if self.depends_filepatterns and modified_files is not None:
             if files_matches_patterns(modified_files, self.depends_filepatterns, manifest_rootpath):
-                self._checked_should_build = True
+                self.checked_should_build = True
                 self.build_status = BuildStatus.SHOULD_BE_BUILT
                 self.build_comment = (
                     f'Requires file patterns: {", ".join(self.depends_filepatterns)}. '
@@ -817,7 +816,7 @@ class App(BaseModel):
         # special rules defined, but not matched
         self.build_status = BuildStatus.SKIPPED
         self.build_comment = 'current build does not modify any components or files required by this app'
-        self._checked_should_build = True
+        self.checked_should_build = True
 
     def check_should_test(self) -> None:
         """Check if testing is disabled for this app and set test_disable_reason."""
@@ -955,7 +954,7 @@ class CMakeApp(App):
             check_app_dependencies=check_app_dependencies,
         )
 
-        if not self._checked_should_build:
+        if not self.checked_should_build:
             self.check_should_build(
                 manifest_rootpath=manifest_rootpath,
                 modified_components=modified_components,

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/idf_build_apps/args.py

@@ -29,7 +29,7 @@ from pydantic_settings import (
 from typing_extensions import Concatenate, ParamSpec
 
 from . import SESSION_ARGS, App, CMakeApp, MakeApp, setup_logging
-from .constants import ALL_TARGETS, IDF_BUILD_APPS_TOML_FN
+from .constants import ALL_TARGETS, IDF_BUILD_APPS_TOML_FN, PREVIEW_TARGETS, SUPPORTED_TARGETS
 from .manifest.manifest import DEFAULT_BUILD_TARGETS, Manifest, reset_default_build_targets
 from .utils import InvalidCommand, files_matches_patterns, semicolon_separated_str_to_list, to_absolute_path, to_list
 from .vendors.pydantic_sources import PyprojectTomlConfigSettingsSource, TomlConfigSettingsSource
@@ -563,17 +563,22 @@ class FindBuildArguments(DependencyDrivenBuildArguments):
             nargs='+',
         ),
         description='space-separated list of the default enabled build targets for the apps. '
-        'When not specified, the default value is the targets listed by `idf.py --list-targets`. '
-        'Cannot be used together with --enable-preview-targets',
+        'When not specified, the default value is the targets listed by `idf.py --list-targets`.',
+        default=None,  # type: ignore
+    )
+    additional_build_targets: t.Optional[t.List[str]] = field(
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            nargs='+',
+        ),
+        description='space-separated list of additional build targets to add to the default enabled build targets',
         default=None,  # type: ignore
     )
     enable_preview_targets: bool = field(
         FieldMetadata(
             action='store_true',
         ),
-        description='When enabled, all targets will be enabled by default, '
-        'including the preview targets. As the targets defined in `idf.py --list-targets --preview`. '
-        'Cannot be used together with --default-build-targets',
+        description='When enabled, PREVIEW_TARGETS will be added to the default enabled build targets',
         default=False,  # type: ignore
     )
     disable_targets: t.Optional[t.List[str]] = field(
@@ -616,39 +621,44 @@ class FindBuildArguments(DependencyDrivenBuildArguments):
             LOGGER.debug('--target is missing. Set --target as "all".')
             self.target = 'all'
 
-        # Validate mutual exclusivity of enable_preview_targets and default_build_targets
-        if self.enable_preview_targets and self.default_build_targets:
-            raise InvalidCommand(
-                'Cannot specify both --enable-preview-targets and --default-build-targets at the same time. '
-                'Please use only one of these options.'
-            )
-
         reset_default_build_targets()  # reset first then judge again
+
+        # Build the target set by combining the options
+        default_build_targets: t.List[str] = []
+        # Step 1: Determine base targets
         if self.default_build_targets:
-            default_build_targets = []
-            for target in self.default_build_targets:
-                if target not in ALL_TARGETS:
-                    LOGGER.warning(
-                        f'Ignoring... Unrecognizable target {target} specified with "--default-build-targets". '
-                        f'Current ESP-IDF available targets: {ALL_TARGETS}'
-                    )
-                elif target not in default_build_targets:
-                    default_build_targets.append(target)
-            self.default_build_targets = default_build_targets
-            LOGGER.info('Overriding default build targets to %s', self.default_build_targets)
-            DEFAULT_BUILD_TARGETS.set(self.default_build_targets)
-        elif self.enable_preview_targets:
-            self.default_build_targets = deepcopy(ALL_TARGETS)
-            LOGGER.info('Overriding default build targets to %s', self.default_build_targets)
-            DEFAULT_BUILD_TARGETS.set(self.default_build_targets)
-
-        if self.disable_targets and DEFAULT_BUILD_TARGETS.get():
-            LOGGER.info('Disable targets: %s', self.disable_targets)
-            self.default_build_targets = [
-                _target for _target in DEFAULT_BUILD_TARGETS.get() if _target not in self.disable_targets
-            ]
-            DEFAULT_BUILD_TARGETS.set(self.default_build_targets)
+            LOGGER.info('--default-build-targets is set, using `%s`', self.default_build_targets)
+            default_build_targets = deepcopy(self.default_build_targets)
+        elif SUPPORTED_TARGETS:
+            LOGGER.info('Using default SUPPORTED_TARGETS: %s', SUPPORTED_TARGETS)
+            default_build_targets = deepcopy(SUPPORTED_TARGETS)
+
+        if self.enable_preview_targets:
+            LOGGER.info('--enable-preview-targets is set, adding preview targets `%s`', PREVIEW_TARGETS)
+            default_build_targets.extend(PREVIEW_TARGETS)
+
+        if self.additional_build_targets:
+            LOGGER.info('--additional-build-targets is set, adding `%s`', self.additional_build_targets)
+            default_build_targets.extend(self.additional_build_targets)
+
+        res = []
+        for _t in set(default_build_targets):
+            if _t not in ALL_TARGETS:
+                LOGGER.warning(
+                    f'Ignoring... Unrecognizable target {_t} specified. '
+                    f'Current ESP-IDF available targets: {ALL_TARGETS}'
+                )
+                continue
+
+            if self.disable_targets and _t in self.disable_targets:
+                LOGGER.info(f'Ignoring... Target {_t} is in the disabled targets list.')
+                continue
+
+            res.append(_t)
+        self.default_build_targets = sorted(res)
+        DEFAULT_BUILD_TARGETS.set(self.default_build_targets)
 
+        # Override sdkconfig files/items
         if self.override_sdkconfig_files or self.override_sdkconfig_items:
             SESSION_ARGS.set(self)
 

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/idf_build_apps/finder.py

@@ -16,6 +16,7 @@ from .app import (
 )
 from .args import FindArguments
 from .constants import (
+    ALL_TARGETS,
     BuildStatus,
 )
 from .utils import (
@@ -26,6 +27,14 @@ from .utils import (
 LOGGER = logging.getLogger(__name__)
 
 
+def _is_target_specific(filepath: str) -> bool:
+    for target in ALL_TARGETS:
+        if filepath.endswith(f'.{target}'):
+            return True
+
+    return False
+
+
 def _get_apps_from_path(
     path: str,
     target: str,
@@ -55,8 +64,8 @@ def _get_apps_from_path(
             sdkconfig_paths_matched = True  # skip the next block for no wildcard config rules
 
         for sdkconfig_path in sdkconfig_paths:
-            if sdkconfig_path.endswith(f'.{target}'):
-                LOGGER.debug('=> Skipping sdkconfig %s which is target-specific', sdkconfig_path)
+            if _is_target_specific(sdkconfig_path):
+                LOGGER.debug('=> Skipping sdkconfig file `%s` which is target-specific', sdkconfig_path)
                 continue
 
             # Figure out the config name

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/idf_build_apps/utils.py

@@ -386,6 +386,9 @@ class BaseModel(_BaseModel):
         hash_list = []
 
         self_model_dump = self.model_dump()
+        for _field in self.__EQ_IGNORE_FIELDS__:
+            self_model_dump.pop(_field, None)
+
         for _field in self.__EQ_TUNE_FIELDS__:
             self_model_dump[_field] = self.__EQ_TUNE_FIELDS__[_field](self_model_dump[_field])
 

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/pyproject.toml

@@ -64,9 +64,17 @@ changelog = "https://github.com/espressif/idf-build-apps/blob/main/CHANGELOG.md"
 idf-build-apps = "idf_build_apps:main.main"
 
 [tool.commitizen]
-name = "cz_conventional_commits"
-version = "2.12.2"
+name = "czespressif"
+version = "2.13.0"
+
 tag_format = "v$version"
+version_scheme = "pep440"
+
+update_changelog_on_bump = true
+changelog_merge_prerelease = true
+
+types_in_changelog = ["BREAKING CHANGE", "feat", "fix", "refactor", "change", "perf", "docs"]
+
 version_files = [
     "idf_build_apps/__init__.py",
 ]

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/setup.py

@@ -38,7 +38,7 @@ entry_points = \
 {'console_scripts': ['idf-build-apps = idf_build_apps:main.main']}
 
 setup(name='idf-build-apps',
-      version='2.12.2',
+      version='2.13.0',
       description='Tools for building ESP-IDF related apps.',
       author=None,
       author_email='Fu Hanxi <fuhanxi@espressif.com>',

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/tests/test_args.py

@@ -17,10 +17,9 @@ from idf_build_apps.args import (
     FindBuildArguments,
     expand_vars,
 )
-from idf_build_apps.constants import ALL_TARGETS, IDF_BUILD_APPS_TOML_FN, PREVIEW_TARGETS, SUPPORTED_TARGETS
+from idf_build_apps.constants import IDF_BUILD_APPS_TOML_FN, PREVIEW_TARGETS, SUPPORTED_TARGETS
 from idf_build_apps.main import main
-from idf_build_apps.manifest.manifest import DEFAULT_BUILD_TARGETS, FolderRule
-from idf_build_apps.utils import InvalidCommand
+from idf_build_apps.manifest.manifest import DEFAULT_BUILD_TARGETS, FolderRule, reset_default_build_targets
 
 
 def test_init_attr_deprecated_by():
@@ -171,13 +170,42 @@ modified_files = [
     assert args.deactivate_dependency_driven_build_by_components == ['baz']
 
 
-def test_mutual_exclusivity_validation():
-    # Test that both options together raise InvalidCommand
-    with pytest.raises(InvalidCommand) as exc_info:
-        FindBuildArguments(enable_preview_targets=True, default_build_targets=['esp32'], paths=['.'])
+def test_combination_validation():
+    """Test that target options can now be combined"""
+    # Mock targets for consistent testing
+    mock_supported = ['esp32', 'esp32s2']
+    mock_preview = ['esp32h2']
+    mock_all = mock_supported + mock_preview
 
-    assert 'Cannot specify both --enable-preview-targets and --default-build-targets' in str(exc_info.value)
-    assert 'Please use only one of these options' in str(exc_info.value)
+    import idf_build_apps.args
+    import idf_build_apps.constants
+
+    original_supported = idf_build_apps.constants.SUPPORTED_TARGETS
+    original_preview = idf_build_apps.constants.PREVIEW_TARGETS
+    original_all = idf_build_apps.constants.ALL_TARGETS
+
+    try:
+        idf_build_apps.constants.SUPPORTED_TARGETS = mock_supported
+        idf_build_apps.constants.PREVIEW_TARGETS = mock_preview
+        idf_build_apps.constants.ALL_TARGETS = mock_all
+        idf_build_apps.args.SUPPORTED_TARGETS = mock_supported
+        idf_build_apps.args.PREVIEW_TARGETS = mock_preview
+        idf_build_apps.args.ALL_TARGETS = mock_all
+
+        # Test combination: default + preview
+        args = FindBuildArguments(enable_preview_targets=True, default_build_targets=['esp32'], paths=['.'])
+
+        # Should combine: ['esp32'] + ['esp32h2'] = ['esp32', 'esp32h2']
+        expected = ['esp32', 'esp32h2']
+        assert args.default_build_targets == expected
+
+    finally:
+        idf_build_apps.constants.SUPPORTED_TARGETS = original_supported
+        idf_build_apps.constants.PREVIEW_TARGETS = original_preview
+        idf_build_apps.constants.ALL_TARGETS = original_all
+        idf_build_apps.args.SUPPORTED_TARGETS = original_supported
+        idf_build_apps.args.PREVIEW_TARGETS = original_preview
+        idf_build_apps.args.ALL_TARGETS = original_all
 
 
 def test_build_targets_cli(tmp_path, monkeypatch):
@@ -430,9 +458,34 @@ dry_run = false
 
 
 class TestDefaultBuildTargetsContextVar:
+    SUPPORTED_TARGETS = ['esp32', 'esp32s2']
+    PREVIEW_TARGETS = ['esp32h2', 'esp32p4']
+    ALL_TARGETS = SUPPORTED_TARGETS + PREVIEW_TARGETS + ['esp32s3', 'esp32c3']
+
+    @pytest.fixture(autouse=True)
+    def setup(self, monkeypatch):
+        import idf_build_apps.args
+        import idf_build_apps.constants
+        import idf_build_apps.manifest.manifest
+
+        # reset_default_build_targets() need .manifest.manifest
+        monkeypatch.setattr(idf_build_apps.manifest.manifest, 'SUPPORTED_TARGETS', self.SUPPORTED_TARGETS)
+        monkeypatch.setattr(idf_build_apps.constants, 'SUPPORTED_TARGETS', self.SUPPORTED_TARGETS)
+        monkeypatch.setattr(idf_build_apps.args, 'SUPPORTED_TARGETS', self.SUPPORTED_TARGETS)
+
+        monkeypatch.setattr(idf_build_apps.constants, 'PREVIEW_TARGETS', self.PREVIEW_TARGETS)
+        monkeypatch.setattr(idf_build_apps.args, 'PREVIEW_TARGETS', self.PREVIEW_TARGETS)
+
+        monkeypatch.setattr(idf_build_apps.manifest.manifest, 'ALL_TARGETS', self.SUPPORTED_TARGETS)
+        monkeypatch.setattr(idf_build_apps.constants, 'ALL_TARGETS', self.ALL_TARGETS)
+        monkeypatch.setattr(idf_build_apps.args, 'ALL_TARGETS', self.ALL_TARGETS)
+
+        reset_default_build_targets()
+
+        yield
+
     def test_direct_contextvar_access(self):
-        # Test initial value
-        assert DEFAULT_BUILD_TARGETS.get() == SUPPORTED_TARGETS
+        assert DEFAULT_BUILD_TARGETS.get() == self.SUPPORTED_TARGETS
 
         # Test setting new values
         test_targets = ['esp32', 'esp32s2']
@@ -440,14 +493,10 @@ class TestDefaultBuildTargetsContextVar:
         assert DEFAULT_BUILD_TARGETS.get() == test_targets
 
         # Test setting to ALL_TARGETS
-        DEFAULT_BUILD_TARGETS.set(ALL_TARGETS)
-        assert DEFAULT_BUILD_TARGETS.get() == ALL_TARGETS
-        assert len(DEFAULT_BUILD_TARGETS.get()) == len(SUPPORTED_TARGETS) + len(PREVIEW_TARGETS)
+        DEFAULT_BUILD_TARGETS.set(self.ALL_TARGETS)
+        assert DEFAULT_BUILD_TARGETS.get() == self.ALL_TARGETS
 
     def test_folder_rule_backward_compatibility(self):
-        # Test initial access
-        assert FolderRule.DEFAULT_BUILD_TARGETS == SUPPORTED_TARGETS
-
         # Test setting via contextvar
         other_targets = ['esp32h2', 'esp32p4']
         DEFAULT_BUILD_TARGETS.set(other_targets)
@@ -460,37 +509,29 @@ class TestDefaultBuildTargetsContextVar:
         assert DEFAULT_BUILD_TARGETS.get() == test_targets
         assert FolderRule.DEFAULT_BUILD_TARGETS == test_targets
 
-    def test_default_build_targets_option(self):
-        """Test that --default-build-targets option works correctly"""
-        test_targets = ['esp32', 'esp32s2', 'esp32c3']
+    def test_default_behavior(self):
+        args = FindBuildArguments(paths=['.'])
+
+        assert args.enable_preview_targets is False
+        assert args.default_build_targets == self.SUPPORTED_TARGETS
+        assert DEFAULT_BUILD_TARGETS.get() == self.SUPPORTED_TARGETS
 
+    def test_default_build_targets_option(self):
+        test_targets = ['esp32', 'esp32c3', 'esp32s2']
         args = FindBuildArguments(default_build_targets=test_targets, paths=['.'])
 
         assert args.default_build_targets == test_targets
         assert DEFAULT_BUILD_TARGETS.get() == test_targets
-        assert FolderRule.DEFAULT_BUILD_TARGETS == test_targets
 
     def test_enable_preview_targets_option(self):
-        """Test that --enable-preview-targets option works correctly"""
         args = FindBuildArguments(enable_preview_targets=True, paths=['.'])
 
         assert args.enable_preview_targets is True
-        assert args.default_build_targets == ALL_TARGETS
-        assert DEFAULT_BUILD_TARGETS.get() == ALL_TARGETS
-        assert FolderRule.DEFAULT_BUILD_TARGETS == ALL_TARGETS
-        assert len(DEFAULT_BUILD_TARGETS.get()) == len(SUPPORTED_TARGETS) + len(PREVIEW_TARGETS)
-
-    def test_default_behavior(self):
-        """Test default behavior when no special options are provided"""
-        args = FindBuildArguments(paths=['.'])
-
-        assert args.enable_preview_targets is False
-        assert args.default_build_targets is None
-        assert DEFAULT_BUILD_TARGETS.get() == SUPPORTED_TARGETS
-        assert FolderRule.DEFAULT_BUILD_TARGETS == SUPPORTED_TARGETS
+        expected_targets = sorted(self.SUPPORTED_TARGETS + self.PREVIEW_TARGETS)
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
 
     def test_disable_targets_with_default_build_targets(self):
-        """Test --disable-targets option works with --default-build-targets"""
         args = FindBuildArguments(
             default_build_targets=['esp32', 'esp32s2', 'esp32c3'], disable_targets=['esp32s2'], paths=['.']
         )
@@ -498,23 +539,19 @@ class TestDefaultBuildTargetsContextVar:
         expected_targets = ['esp32', 'esp32c3']
         assert args.default_build_targets == expected_targets
         assert DEFAULT_BUILD_TARGETS.get() == expected_targets
-        assert FolderRule.DEFAULT_BUILD_TARGETS == expected_targets
 
     def test_disable_targets_with_enable_preview_targets(self):
-        """Test --disable-targets option works with --enable-preview-targets"""
-        disabled_target = PREVIEW_TARGETS[0]  # Disable first preview target
-
+        disabled_target = 'esp32h2'
         args = FindBuildArguments(enable_preview_targets=True, disable_targets=[disabled_target], paths=['.'])
 
-        expected_targets = [t for t in ALL_TARGETS if t != disabled_target]
+        expected_targets = sorted(
+            [_t for _t in [*self.SUPPORTED_TARGETS, *self.PREVIEW_TARGETS] if _t != disabled_target]
+        )
         assert args.default_build_targets == expected_targets
         assert DEFAULT_BUILD_TARGETS.get() == expected_targets
-        assert len(DEFAULT_BUILD_TARGETS.get()) == len(ALL_TARGETS) - 1
 
     def test_invalid_targets_filtering(self):
-        """Test that invalid targets are filtered out and warnings are logged"""
         invalid_targets = ['esp32', 'invalid_target', 'esp32s2', 'another_invalid']
-
         args = FindBuildArguments(default_build_targets=invalid_targets, paths=['.'])
 
         # Only valid targets should remain
@@ -525,25 +562,110 @@ class TestDefaultBuildTargetsContextVar:
     def test_contextvar_isolation_between_instances(self):
         """Test that the contextvar behaves correctly across multiple argument instances"""
         # First instance sets default_build_targets
-        FindBuildArguments(default_build_targets=['esp32', 'esp32s2'])
+        FindBuildArguments(default_build_targets=['esp32', 'esp32s2'], paths=['.'])
         assert DEFAULT_BUILD_TARGETS.get() == ['esp32', 'esp32s2']
 
-        # Second instance sets enable_preview_targets
-        FindBuildArguments(enable_preview_targets=True)
-        assert DEFAULT_BUILD_TARGETS.get() == ALL_TARGETS
+        # Second instance sets enable_preview_targets (should combine with SUPPORTED_TARGETS)
+        FindBuildArguments(enable_preview_targets=True, paths=['.'])
+        assert DEFAULT_BUILD_TARGETS.get() == sorted(self.SUPPORTED_TARGETS + self.PREVIEW_TARGETS)
 
-        # Third instance uses default behavior
-        FindBuildArguments()
-        assert DEFAULT_BUILD_TARGETS.get() == SUPPORTED_TARGETS
+        FindBuildArguments(paths=['.'])
+        assert DEFAULT_BUILD_TARGETS.get() == self.SUPPORTED_TARGETS
 
     def test_empty_default_build_targets(self):
-        """Test behavior with empty default_build_targets list"""
         args = FindBuildArguments(default_build_targets=[])
 
         # Empty list is treated as falsy, so it falls back to default behavior
-        assert args.default_build_targets == []
-        assert DEFAULT_BUILD_TARGETS.get() == SUPPORTED_TARGETS
-        assert FolderRule.DEFAULT_BUILD_TARGETS == SUPPORTED_TARGETS
+        assert args.default_build_targets == self.SUPPORTED_TARGETS
+        assert DEFAULT_BUILD_TARGETS.get() == self.SUPPORTED_TARGETS
+
+    def test_additional_build_targets_option(self):
+        """Test that --additional-build-targets option works correctly"""
+        additional_targets = ['esp32h2', 'esp32p4']
+        args = FindBuildArguments(additional_build_targets=additional_targets, paths=['.'])
+
+        expected_targets = sorted(self.SUPPORTED_TARGETS + additional_targets)
+        assert args.additional_build_targets == additional_targets
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_additional_build_targets_with_existing_target(self):
+        existing_target = 'esp32'  # From self.SUPPORTED_TARGETS
+        new_target = 'esp32h2'  # From self.ALL_TARGETS but not in self.SUPPORTED_TARGETS
+        additional_targets = [existing_target, new_target]
+
+        args = FindBuildArguments(additional_build_targets=additional_targets, paths=['.'])
+
+        # Should only add the new target, not duplicate the existing one
+        expected_targets = sorted([*self.SUPPORTED_TARGETS, new_target])
+        assert args.additional_build_targets == additional_targets
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_additional_build_targets_with_invalid_target(self):
+        invalid_targets = [
+            'esp32',
+            'invalid_target',
+            'esp32h2',
+        ]  # esp32 is already supported, invalid_target doesn't exist
+
+        args = FindBuildArguments(additional_build_targets=invalid_targets, paths=['.'])
+
+        # Should only add valid targets not already in SUPPORTED_TARGETS
+        expected_targets = sorted([*self.SUPPORTED_TARGETS, 'esp32h2'])
+        assert args.additional_build_targets == invalid_targets
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_disable_targets_with_additional_build_targets(self):
+        additional_target = 'esp32h2'  # From self.ALL_TARGETS but not in self.SUPPORTED_TARGETS
+        disabled_target = 'esp32'  # From self.SUPPORTED_TARGETS
+
+        args = FindBuildArguments(
+            additional_build_targets=[additional_target], disable_targets=[disabled_target], paths=['.']
+        )
+
+        expected_targets = ['esp32h2', 'esp32s2']
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_combination_default_and_additional(self):
+        args = FindBuildArguments(
+            default_build_targets=['esp32', 'esp32s2'], additional_build_targets=['esp32h2'], paths=['.']
+        )
+
+        expected_targets = ['esp32', 'esp32h2', 'esp32s2']
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_combination_preview_and_additional(self):
+        args = FindBuildArguments(enable_preview_targets=True, additional_build_targets=['esp32p4'], paths=['.'])
+
+        # Should combine: SUPPORTED_TARGETS + PREVIEW_TARGETS + additional
+        # self.PREVIEW_TARGETS contains 'esp32p4', so it's not really additional
+        expected_targets = sorted(self.SUPPORTED_TARGETS + self.PREVIEW_TARGETS)
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_combination_all_three_options(self):
+        args = FindBuildArguments(
+            default_build_targets=['esp32'],
+            enable_preview_targets=True,
+            additional_build_targets=['esp32p4', 'esp32c3'],
+            paths=['.'],
+        )
+
+        # Should combine: ['esp32'] + PREVIEW_TARGETS + ['esp32p4', 'esp32c3']
+        expected_targets = sorted({'esp32', *self.PREVIEW_TARGETS, 'esp32p4', 'esp32c3'})
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    def test_empty_additional_build_targets(self):
+        args = FindBuildArguments(additional_build_targets=[], paths=['.'])
+
+        assert args.additional_build_targets == []
+        assert args.default_build_targets == self.SUPPORTED_TARGETS
+        assert DEFAULT_BUILD_TARGETS.get() == self.SUPPORTED_TARGETS
 
 
 def test_expand_vars(monkeypatch):

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/tests/test_finder.py

@@ -504,6 +504,7 @@ class TestFindWithSdkconfigFiles:
         (tmp_path / 'test1' / 'sdkconfig.defaults').touch()
         (tmp_path / 'test1' / 'sdkconfig.defaults_new').touch()
         (tmp_path / 'test1' / 'sdkconfig.ci.foo').touch()
+        (tmp_path / 'test1' / 'sdkconfig.ci.foo.esp32p4').touch()
 
         apps = find_apps(str(tmp_path / 'test1'), 'esp32', recursive=True, config_rules_str='sdkconfig.ci.*=')
         assert len(apps) == 1

{idf_build_apps-2.12.2 → idf_build_apps-2.13.0}/tests/test_utils.py

@@ -8,6 +8,7 @@ from pathlib import (
 import pytest
 
 from idf_build_apps.utils import (
+    BaseModel,
     files_matches_patterns,
     get_parallel_start_stop,
     rmdir,
@@ -142,3 +143,19 @@ def test_files_matches_patterns(tmp_path):
         os.chdir(temp_dir)
         for f in matched_files:
             assert files_matches_patterns(f, abs_pat)
+
+
+def test_base_model_hashable():
+    class Foo(BaseModel):
+        foo: str
+        bar: str
+
+        __EQ_IGNORE_FIELDS__ = ['bar']
+
+    a = Foo(foo='foo', bar='bar')
+    b = Foo(foo='foo', bar='rab')
+
+    assert a == b
+    assert hash(a) == hash(b)
+    s = {a, b}
+    assert len(s) == 1