idf-build-apps 2.10.1__tar.gz → 2.10.3__tar.gz

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
           - --use-current-year
         exclude: 'idf_build_apps/vendors/'
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.11.6'
+    rev: 'v0.11.10'
     hooks:
       - id: ruff
         args: ['--fix']

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## v2.10.3 (2025-06-03)
+
+### Fix
+
+- app.target have higher precedence than target while `find_apps`
+- respect FolderRule.DEFAULT_BUILD_TARGETS while validating app
+
+### Refactor
+
+- move `FolderRule.DEFAULT_BUILD_TARGET` into contextvar
+
+## v2.10.2 (2025-05-22)
+
+### Perf
+
+- `most_suitable_rule` stop searching till reached root dir
+- pre-compute rules folder, reduced 50% time on `most_suitable_rule`
+
 ## v2.10.1 (2025-05-05)
 
 ### Fix

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/PKG-INFO

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

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/__init__.py

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

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/app.py

@@ -39,7 +39,7 @@ from .constants import (
     BuildStatus,
 )
 from .manifest.manifest import (
-    FolderRule,
+    DEFAULT_BUILD_TARGETS,
     Manifest,
 )
 from .utils import (
@@ -436,7 +436,7 @@ class App(BaseModel):
         if self.sdkconfig_files_defined_idf_target:
             return [self.sdkconfig_files_defined_idf_target]
 
-        return FolderRule.DEFAULT_BUILD_TARGETS
+        return DEFAULT_BUILD_TARGETS.get()
 
     @property
     def verified_targets(self) -> t.List[str]:
@@ -820,7 +820,7 @@ class MakeApp(App):
         if self.sdkconfig_files_defined_idf_target:
             return [self.sdkconfig_files_defined_idf_target]
 
-        return ['esp8266', *FolderRule.DEFAULT_BUILD_TARGETS]
+        return ['esp8266', *DEFAULT_BUILD_TARGETS.get()]
 
     def _build(
         self,

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/args.py

@@ -29,8 +29,8 @@ 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, SUPPORTED_TARGETS
-from .manifest.manifest import FolderRule, Manifest
+from .constants import ALL_TARGETS, IDF_BUILD_APPS_TOML_FN
+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
 
@@ -519,15 +519,17 @@ 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`',
+        'When not specified, the default value is the targets listed by `idf.py --list-targets`. '
+        'Cannot be used together with --enable-preview-targets',
         default=None,  # type: ignore
     )
     enable_preview_targets: bool = field(
         FieldMetadata(
             action='store_true',
         ),
-        description='When enabled, the default build targets will be set to all apps, '
-        'including the preview targets. As the targets defined in `idf.py --list-targets --preview`',
+        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',
         default=False,  # type: ignore
     )
     disable_targets: t.Optional[t.List[str]] = field(
@@ -570,6 +572,14 @@ 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
         if self.default_build_targets:
             default_build_targets = []
             for target in self.default_build_targets:
@@ -582,21 +592,18 @@ class FindBuildArguments(DependencyDrivenBuildArguments):
                     default_build_targets.append(target)
             self.default_build_targets = default_build_targets
             LOGGER.info('Overriding default build targets to %s', self.default_build_targets)
-            FolderRule.DEFAULT_BUILD_TARGETS = 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)
-            FolderRule.DEFAULT_BUILD_TARGETS = self.default_build_targets
-        else:
-            # restore default build targets
-            FolderRule.DEFAULT_BUILD_TARGETS = SUPPORTED_TARGETS
+            DEFAULT_BUILD_TARGETS.set(self.default_build_targets)  # type: ignore
 
-        if self.disable_targets and FolderRule.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 FolderRule.DEFAULT_BUILD_TARGETS if _target not in self.disable_targets
+                _target for _target in DEFAULT_BUILD_TARGETS.get() if _target not in self.disable_targets
             ]
-            FolderRule.DEFAULT_BUILD_TARGETS = self.default_build_targets
+            DEFAULT_BUILD_TARGETS.set(self.default_build_targets)
 
         if self.override_sdkconfig_files or self.override_sdkconfig_items:
             SESSION_ARGS.set(self)

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/finder.py

@@ -18,6 +18,7 @@ from .args import FindArguments
 from .constants import (
     BuildStatus,
 )
+from .manifest.manifest import DEFAULT_BUILD_TARGETS
 from .utils import (
     config_rules_from_str,
     to_absolute_path,
@@ -33,13 +34,23 @@ def _get_apps_from_path(
     app_cls: t.Type[App] = CMakeApp,
     args: FindArguments,
 ) -> t.List[App]:
-    # trigger test
     def _validate_app(_app: App) -> bool:
         if target not in _app.supported_targets:
             LOGGER.debug('=> Ignored. %s only supports targets: %s', _app, ', '.join(_app.supported_targets))
             _app.build_status = BuildStatus.DISABLED
             return args.include_disabled_apps
 
+        if target == 'all' and _app.target not in DEFAULT_BUILD_TARGETS.get():
+            LOGGER.debug(
+                '=> Ignored. %s is not in the default build targets: %s', _app.target, DEFAULT_BUILD_TARGETS.get()
+            )
+            _app.build_status = BuildStatus.DISABLED
+            return args.include_disabled_apps
+        elif _app.target != target:
+            LOGGER.debug('=> Ignored. %s is not for target %s', _app, target)
+            _app.build_status = BuildStatus.DISABLED
+            return args.include_disabled_apps
+
         _app.check_should_build(
             manifest_rootpath=args.manifest_rootpath,
             modified_manifest_rules_folders=args.modified_manifest_rules_folders,

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/main.py

@@ -31,7 +31,7 @@ from .app import (
     AppDeserializer,
 )
 from .autocompletions import activate_completions
-from .constants import ALL_TARGETS, BuildStatus, completion_instructions
+from .constants import BuildStatus, completion_instructions
 from .finder import (
     _find_apps,
 )
@@ -41,6 +41,7 @@ from .junit import (
     TestSuite,
 )
 from .manifest.manifest import (
+    DEFAULT_BUILD_TARGETS,
     Manifest,
 )
 from .utils import (
@@ -88,8 +89,8 @@ def find_apps(
 
     apps: t.Set[App] = set()
     if find_arguments.target == 'all':
-        targets = ALL_TARGETS
-        LOGGER.info('Searching for apps by all targets')
+        targets = DEFAULT_BUILD_TARGETS.get()
+        LOGGER.info('Searching for apps by default build targets: %s', targets)
     else:
         targets = [find_arguments.target]
         LOGGER.info('Searching for apps by target: %s', find_arguments.target)

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/manifest/__init__.py

@@ -7,11 +7,11 @@ Manifest file
 
 from esp_bool_parser import register_addition_attribute
 
-from .manifest import FolderRule
+from .manifest import DEFAULT_BUILD_TARGETS
 
 
 def folder_rule_attr(target, **kwargs):
-    return 1 if target in FolderRule.DEFAULT_BUILD_TARGETS else 0
+    return 1 if target in DEFAULT_BUILD_TARGETS.get() else 0
 
 
 register_addition_attribute('INCLUDE_DEFAULT', folder_rule_attr)

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/idf_build_apps/manifest/manifest.py

@@ -1,8 +1,10 @@
 # SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
+import contextvars
 import logging
 import os
 import typing as t
+import warnings
 from hashlib import sha512
 
 from esp_bool_parser import BoolStmt, parse_bool_expr
@@ -26,6 +28,16 @@ from ..yaml import (
 
 LOGGER = logging.getLogger(__name__)
 
+# Context variable for default build targets
+DEFAULT_BUILD_TARGETS: contextvars.ContextVar[t.List[str]] = contextvars.ContextVar(
+    'default_build_targets', default=SUPPORTED_TARGETS
+)
+
+
+def reset_default_build_targets() -> None:
+    """Reset DEFAULT_BUILD_TARGETS to the default value (SUPPORTED_TARGETS)"""
+    DEFAULT_BUILD_TARGETS.set(SUPPORTED_TARGETS)
+
 
 class IfClause:
     def __init__(self, stmt: str, temporary: bool = False, reason: t.Optional[str] = None) -> None:
@@ -78,8 +90,65 @@ class SwitchClause:
         )
 
 
-class FolderRule:
-    DEFAULT_BUILD_TARGETS = SUPPORTED_TARGETS
+def _getattr_default_build_targets(name: str) -> t.Any:
+    if name == 'DEFAULT_BUILD_TARGETS':
+        warnings.warn(
+            'FolderRule.DEFAULT_BUILD_TARGETS is deprecated. Use DEFAULT_BUILD_TARGETS.get() directly.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return DEFAULT_BUILD_TARGETS.get()
+    return None
+
+
+def _setattr_default_build_targets(name: str, value: t.Any) -> bool:
+    if name == 'DEFAULT_BUILD_TARGETS':
+        warnings.warn(
+            'FolderRule.DEFAULT_BUILD_TARGETS is deprecated. Use DEFAULT_BUILD_TARGETS.set() directly.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if not isinstance(value, list):
+            raise TypeError('Default build targets must be a list')
+        DEFAULT_BUILD_TARGETS.set(value)
+        return True
+    return False
+
+
+class _FolderRuleMeta(type):
+    """Metaclass to handle class-level assignments to DEFAULT_BUILD_TARGETS"""
+
+    def __getattribute__(cls, name):
+        result = _getattr_default_build_targets(name)
+        if result is not None:
+            return result
+        return super().__getattribute__(name)
+
+    def __setattr__(cls, name, value):
+        if _setattr_default_build_targets(name, value):
+            return
+        super().__setattr__(name, value)
+
+    def __delattr__(cls, name):
+        if name == 'DEFAULT_BUILD_TARGETS':
+            # Don't actually delete anything, just ignore the deletion
+            # This handles monkeypatch teardown issues
+            pass
+        else:
+            super().__delattr__(name)
+
+
+class FolderRule(metaclass=_FolderRuleMeta):
+    def __getattribute__(self, name):  # instance attr
+        result = _getattr_default_build_targets(name)
+        if result is not None:
+            return result
+        return super().__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        if _setattr_default_build_targets(name, value):
+            return
+        super().__setattr__(name, value)
 
     def __init__(
         self,
@@ -254,9 +323,11 @@ class Manifest:
 
     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)
 
+        # Pre-compute rule paths
+        self._rule_paths = {rule.folder: rule for rule in self.rules}
+
     @classmethod
     def from_files(cls, paths: t.Iterable[PathLike], *, root_path: str = os.curdir) -> 'Manifest':
         """
@@ -383,9 +454,17 @@ class Manifest:
 
     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
+
+        while True:
+            if folder in self._rule_paths:
+                return self._rule_paths[folder]
+            folder = os.path.dirname(folder)
+
+            # reached the root path, stop searching
+            if folder == self._root_path:
+                if folder in self._rule_paths:
+                    return self._rule_paths[folder]
+                break
 
         return DefaultRule(folder)
 

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/pyproject.toml

@@ -65,7 +65,7 @@ idf-build-apps = "idf_build_apps:main.main"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "2.10.1"
+version = "2.10.3"
 tag_format = "v$version"
 version_files = [
     "idf_build_apps/__init__.py",

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/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.10.1',
+      version='2.10.3',
       description='Tools for building ESP-IDF related apps.',
       author=None,
       author_email='Fu Hanxi <fuhanxi@espressif.com>',

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/tests/conftest.py

@@ -10,14 +10,13 @@ from idf_build_apps import (
     setup_logging,
 )
 from idf_build_apps.args import apply_config_file
-from idf_build_apps.constants import SUPPORTED_TARGETS
-from idf_build_apps.manifest.manifest import FolderRule
+from idf_build_apps.manifest.manifest import FolderRule, reset_default_build_targets
 
 
 @pytest.fixture(autouse=True)
 def clean_cls_attr(tmp_path):
     App.MANIFEST = None
-    FolderRule.DEFAULT_BUILD_TARGETS = SUPPORTED_TARGETS
+    reset_default_build_targets()
     idf_build_apps.SESSION_ARGS.clean()
     apply_config_file(reset=True)
     os.chdir(tmp_path)

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/tests/test_args.py

@@ -17,8 +17,10 @@ from idf_build_apps.args import (
     FindBuildArguments,
     expand_vars,
 )
-from idf_build_apps.constants import IDF_BUILD_APPS_TOML_FN, PREVIEW_TARGETS, SUPPORTED_TARGETS
+from idf_build_apps.constants import ALL_TARGETS, 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
 
 
 def test_init_attr_deprecated_by():
@@ -162,6 +164,15 @@ 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=['.'])
+
+    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)
+
+
 def test_build_targets_cli(tmp_path, monkeypatch):
     create_project('foo', tmp_path)
     with open(IDF_BUILD_APPS_TOML_FN, 'w') as fw:
@@ -411,6 +422,123 @@ dry_run = false
         assert test_suite.findall('testcase')[0].attrib['name'] == 'bar/build'
 
 
+class TestDefaultBuildTargetsContextVar:
+    def test_direct_contextvar_access(self):
+        # Test initial value
+        assert DEFAULT_BUILD_TARGETS.get() == SUPPORTED_TARGETS
+
+        # Test setting new values
+        test_targets = ['esp32', 'esp32s2']
+        DEFAULT_BUILD_TARGETS.set(test_targets)
+        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)
+
+    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)
+        assert FolderRule.DEFAULT_BUILD_TARGETS == other_targets
+        assert DEFAULT_BUILD_TARGETS.get() == other_targets
+
+        # Test setting via FolderRule
+        test_targets = ['esp32c3', 'esp32c6']
+        FolderRule.DEFAULT_BUILD_TARGETS = test_targets
+        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']
+
+        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
+
+    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=['.']
+        )
+
+        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
+
+        args = FindBuildArguments(enable_preview_targets=True, disable_targets=[disabled_target], paths=['.'])
+
+        expected_targets = [t for t in ALL_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
+        expected_targets = ['esp32', 'esp32s2']
+        assert args.default_build_targets == expected_targets
+        assert DEFAULT_BUILD_TARGETS.get() == expected_targets
+
+    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'])
+        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
+
+        # Third instance uses default behavior
+        FindBuildArguments()
+        assert DEFAULT_BUILD_TARGETS.get() == 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
+
+
 def test_expand_vars(monkeypatch):
     assert expand_vars('Value is $TEST_VAR') == 'Value is '
     monkeypatch.setenv('TEST_VAR', 'test_value')

{idf_build_apps-2.10.1 → idf_build_apps-2.10.3}/tests/test_finder.py

@@ -12,6 +12,7 @@ from conftest import (
     create_project,
 )
 
+import idf_build_apps
 from idf_build_apps.constants import (
     DEFAULT_SDKCONFIG,
     IDF_PATH,
@@ -457,6 +458,21 @@ class TestFindWithSdkconfigFiles:
             except:  # noqa
                 pass
 
+    def test_build_preview_but_sdkconfig_default(self, tmp_path):
+        create_project('foo', tmp_path)
+
+        apps = find_apps(str(tmp_path / 'foo'), 'all', default_build_targets=['esp32'])
+        assert len(apps) == 1
+
+        with open(tmp_path / 'foo' / 'sdkconfig.defaults', 'w') as f:
+            f.write('CONFIG_IDF_TARGET="esp32p4"\n')
+
+        apps = find_apps(str(tmp_path / 'foo'), 'all', default_build_targets=['esp32'])
+        assert len(apps) == 0
+
+        apps = find_apps(str(tmp_path / 'foo'), 'esp32p4', default_build_targets=['esp32p4'])
+        assert len(apps) == 1
+
     def test_with_sdkconfig_defaults_idf_target_but_disabled(self, tmp_path):
         manifest_file = tmp_path / 'manifest.yml'
         manifest_file.write_text(
@@ -540,8 +556,6 @@ class TestFindWithSdkconfigFiles:
         assert len(apps) == 0
 
     def test_with_sdkconfig_override(self, tmp_path):
-        import idf_build_apps
-
         create_project('test1', tmp_path)
         (tmp_path / 'test1' / 'sdkconfig.defaults').write_text(
             """