idf-build-apps 2.5.0rc0__py3-none-any.whl → 2.5.0rc2__py3-none-any.whl

idf_build_apps/args.py

@@ -1,45 +1,40 @@
 # SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
-"""
-Arguments used in the CLI, and functions.
-
-The reason that does not use pydantic models, but dataclasses
-
-- poor autocomplete in IDE when using pydantic custom Fields with extra metadata
-- pydantic Field alias is nice, but hard to customize, when
-    - the deprecated field has a different nargs
-"""
 
 import argparse
+import enum
 import inspect
 import logging
 import os
 import re
+import sys
 import typing as t
 from copy import deepcopy
-from dataclasses import InitVar, asdict, dataclass, field, fields
-from enum import Enum
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from pydantic import AliasChoices, Field, computed_field, field_validator
+from pydantic.fields import FieldInfo
+from pydantic_core.core_schema import ValidationInfo
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+)
+from typing_extensions import Concatenate, ParamSpec
 
-from . import SESSION_ARGS, setup_logging
-from .app import App
-from .config import get_valid_config
+from . import SESSION_ARGS, App, setup_logging
 from .constants import ALL_TARGETS
 from .manifest.manifest import FolderRule, Manifest
-from .utils import (
-    InvalidCommand,
-    Self,
-    drop_none_kwargs,
-    files_matches_patterns,
-    semicolon_separated_str_to_list,
-    to_absolute_path,
-    to_list,
-)
+from .utils import InvalidCommand, files_matches_patterns, semicolon_separated_str_to_list, to_absolute_path, to_list
+from .vendors.pydantic_sources import PyprojectTomlConfigSettingsSource, TomlConfigSettingsSource
 
 LOGGER = logging.getLogger(__name__)
 
 
-class _Field(Enum):
-    UNSET = 'UNSET'
+class ValidateMethod(str, enum.Enum):
+    TO_LIST = 'to_list'
 
 
 @dataclass
@@ -48,7 +43,7 @@ class FieldMetadata:
     dataclass field metadata. All fields are optional.
     Some fields are used in argparse while running :func:`add_args_to_parser`.
 
-    :param description: description of the field
+    :param validate_method: validate method for the field
     :param deprecates: deprecates field names, used in argparse
     :param shorthand: shorthand for the argument, used in argparse
     :param action: action for the argument, used in argparse
@@ -56,10 +51,10 @@ class FieldMetadata:
     :param choices: choices for the argument, used in argparse
     :param type: type for the argument, used in argparse
     :param required: whether the argument is required, used in argparse
-    :param default: default value, used in argparse
     """
 
-    description: t.Optional[str] = None
+    # validate method
+    validate_method: t.Optional[t.List[str]] = None
     # the field description will be copied from the deprecates field if not specified
     deprecates: t.Optional[t.Dict[str, t.Dict[str, t.Any]]] = None
     shorthand: t.Optional[str] = None
@@ -73,243 +68,200 @@ class FieldMetadata:
     default: t.Any = None
 
 
-@dataclass
-class GlobalArguments:
-    """
-    Global arguments used in all commands
-    """
+P = ParamSpec('P')
+T = t.TypeVar('T')
 
-    config_file: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Path to the configuration file',
-                shorthand='-c',
-            )
-        ),
-    )
-    verbose: int = field(
-        default=0,
-        metadata=asdict(
-            FieldMetadata(
-                description='Verbosity level. By default set to WARNING. Specify -v for INFO, -vv for DEBUG',
-                shorthand='-v',
-                action='count',
-            )
-        ),
-    )
-    log_file: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Path to the log file, if not specified logs will be printed to stderr',
-            )
-        ),
-    )
-    no_color: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Disable colored output',
-                action='store_true',
-            )
-        ),
-    )
 
-    _depr_name_to_new_name_dict: t.ClassVar[t.Dict[str, str]] = {}  # record deprecated field <-> new field
+def _wrap_with_metadata(
+    _: t.Callable[P, t.Any],
+) -> t.Callable[[t.Callable[..., T]], t.Callable[Concatenate[t.Optional[FieldMetadata], P], T]]:
+    """Patch the function signature with metadata args"""
 
-    def __new__(cls, *args, **kwargs):  # noqa: ARG003
-        for f in fields(cls):
-            _metadata = FieldMetadata(**f.metadata)
-            if _metadata.deprecates:
-                for depr_name in _metadata.deprecates:
-                    cls._depr_name_to_new_name_dict[depr_name] = f.name
+    def return_func(func: t.Callable[..., T]) -> t.Callable[Concatenate[t.Optional[FieldMetadata], P], T]:
+        return t.cast(t.Callable[Concatenate[t.Optional[FieldMetadata], P], T], func)
 
-        return super().__new__(cls)
+    return return_func
 
-    @classmethod
-    def from_dict(cls, d: t.Dict[str, t.Any]) -> Self:
-        """
-        Create an instance from a dictionary. Ignore unknown keys.
 
-        :param d: dictionary
-        :return: instance
-        """
-        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+@_wrap_with_metadata(Field)
+def field(meta: t.Optional[FieldMetadata], *args, **kwargs):
+    """field with metadata"""
+    f = Field(*args, **kwargs)
+    f.metadata.append(meta)
+    return f
 
-    def __post_init__(self):
-        self.apply_config()
 
-    def apply_config(self) -> None:
-        """
-        Apply the configuration file to the arguments
-        """
-        config_dict = get_valid_config(custom_path=self.config_file) or {}
+def get_meta(f: FieldInfo) -> t.Optional[FieldMetadata]:
+    """
+    Get the metadata of the field
 
-        # set log fields first
-        self.verbose = config_dict.pop('verbose', self.verbose)
-        self.log_file = config_dict.pop('log_file', self.log_file)
-        self.no_color = config_dict.pop('no_color', self.no_color)
-        setup_logging(self.verbose, self.log_file, not self.no_color)
+    :param f: field
+    :return: metadata of the field if exists, None otherwise
+    """
+    for m in f.metadata:
+        if isinstance(m, FieldMetadata):
+            return m
 
-        if config_dict:
-            for name, value in config_dict.items():
-                if hasattr(self, name):
-                    setattr(self, name, value)
+    return None
 
-                if name in self._depr_name_to_new_name_dict:
-                    self.set_deprecated_field(self._depr_name_to_new_name_dict[name], name, value)
 
-    def set_deprecated_field(self, new_k: str, depr_k: str, depr_v: t.Any) -> None:
-        if depr_v == _Field.UNSET:
-            return
+class BaseArguments(BaseSettings):
+    """Base settings class for all settings classes"""
 
-        LOGGER.warning(
-            f'Field `{depr_k}` is deprecated. Will be removed in the next major release. '
-            f'Use field `{new_k}` instead.'
+    model_config = SettingsConfigDict(
+        toml_file='.idf_build_apps.toml',
+        pyproject_toml_table_header=('tool', 'idf-build-apps'),
+        pyproject_toml_depth=sys.maxsize,
+    )
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: t.Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,  # noqa: ARG003
+        dotenv_settings: PydanticBaseSettingsSource,  # noqa: ARG003
+        file_secret_settings: PydanticBaseSettingsSource,  # noqa: ARG003
+    ) -> t.Tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            TomlConfigSettingsSource(settings_cls),
+            PyprojectTomlConfigSettingsSource(settings_cls),
         )
-        if getattr(self, new_k) is not None:
-            LOGGER.warning(f'Field `{new_k}` is already set. Ignoring deprecated field `{depr_k}`')
-            return
 
-        setattr(self, new_k, depr_v)
+    @field_validator('*', mode='before')
+    @classmethod
+    def validate_by_validate_methods(cls, v: t.Any, info: ValidationInfo):
+        if info.field_name and info.field_name in cls.model_fields:
+            f = cls.model_fields[info.field_name]
+            meta = get_meta(f)
+            if meta and meta.validate_method and ValidateMethod.TO_LIST in meta.validate_method:
+                return to_list(v)
 
+        return v
 
-@dataclass
-class DependencyDrivenBuildArguments(GlobalArguments):
-    """
-    Arguments used in the dependency-driven build feature.
-    """
 
-    manifest_file: InitVar[t.Optional[t.List[str]]] = _Field.UNSET
-    manifest_files: t.Optional[t.List[str]] = field(
+class GlobalArguments(BaseArguments):
+    verbose: int = field(
+        FieldMetadata(
+            shorthand='-v',
+            action='count',
+        ),
+        description='Verbosity level. By default set to WARNING. Specify -v for INFO, -vv for DEBUG',
+        default=0,
+    )
+    log_file: t.Optional[str] = field(
+        None,
+        description='Path to the log file, if not specified logs will be printed to stderr',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={
-                    'manifest_file': {
-                        'nargs': '+',
-                    },
+    )
+    no_color: bool = field(
+        FieldMetadata(
+            action='store_true',
+        ),
+        description='Disable colored output',
+        default=False,
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
+
+        setup_logging(self.verbose, self.log_file, not self.no_color)
+
+
+class DependencyDrivenBuildArguments(GlobalArguments):
+    manifest_files: t.Optional[t.List[t.Union[Path, str]]] = field(
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            deprecates={
+                'manifest_file': {
+                    'nargs': '+',
                 },
-                description='Path to the manifest files which contains the build test rules of the apps',
-                nargs='+',
-            )
+            },
+            nargs='+',
         ),
+        description='Path to the manifest files which contains the build test rules of the apps',
+        validation_alias=AliasChoices('manifest_files', 'manifest_file'),
+        default=None,
     )
     manifest_rootpath: str = field(
+        None,
+        description='Root path to resolve the relative paths defined in the manifest files. '
+        'By default set to the current directory',
         default=os.curdir,
-        metadata=asdict(
-            FieldMetadata(
-                description='Root path to resolve the relative paths defined in the manifest files. '
-                'By default set to the current directory',
-            )
-        ),
     )
     modified_components: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='semicolon-separated list of modified components',
-                type=semicolon_separated_str_to_list,
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            type=semicolon_separated_str_to_list,
         ),
+        description='semicolon-separated list of modified components',
+        default=None,
     )
     modified_files: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='semicolon-separated list of modified files',
-                type=semicolon_separated_str_to_list,
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            type=semicolon_separated_str_to_list,
         ),
+        description='semicolon-separated list of modified files',
+        default=None,
     )
-    ignore_app_dependencies_components: InitVar[t.Optional[t.List[str]]] = _Field.UNSET
     deactivate_dependency_driven_build_by_components: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={
-                    'ignore_app_dependencies_components': {
-                        'type': semicolon_separated_str_to_list,
-                        'shorthand': '-ic',
-                    }
-                },
-                description='semicolon-separated list of components. '
-                'dependency-driven build feature will be deactivated when any of these components are modified',
-                type=semicolon_separated_str_to_list,
-                shorthand='-dc',
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            deprecates={
+                'ignore_app_dependencies_components': {
+                    'type': semicolon_separated_str_to_list,
+                    'shorthand': '-ic',
+                }
+            },
+            type=semicolon_separated_str_to_list,
+            shorthand='-dc',
+        ),
+        description='semicolon-separated list of components. '
+        'dependency-driven build feature will be deactivated when any of these components are modified',
+        validation_alias=AliasChoices(
+            'deactivate_dependency_driven_build_by_components', 'ignore_app_dependencies_components'
         ),
+        default=None,
     )
-    ignore_app_dependencies_filepatterns: InitVar[t.Optional[t.List[str]]] = _Field.UNSET
     deactivate_dependency_driven_build_by_filepatterns: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={
-                    'ignore_app_dependencies_filepatterns': {
-                        'type': semicolon_separated_str_to_list,
-                        'shorthand': '-if',
-                    }
-                },
-                description='semicolon-separated list of file patterns. '
-                'dependency-driven build feature will be deactivated when any of matched files are modified',
-                type=semicolon_separated_str_to_list,
-                shorthand='-df',
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            deprecates={
+                'ignore_app_dependencies_filepatterns': {
+                    'type': semicolon_separated_str_to_list,
+                    'shorthand': '-if',
+                }
+            },
+            type=semicolon_separated_str_to_list,
+            shorthand='-df',
+        ),
+        description='semicolon-separated list of file patterns. '
+        'dependency-driven build feature will be deactivated when any of matched files are modified',
+        validation_alias=AliasChoices(
+            'deactivate_dependency_driven_build_by_filepatterns', 'ignore_app_dependencies_filepatterns'
         ),
+        default=None,
     )
     check_manifest_rules: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Check if all folders defined in the manifest files exist. Fail if not',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Check if all folders defined in the manifest files exist. Fail if not',
+        default=False,
     )
     compare_manifest_sha_filepath: t.Optional[str] = field(
+        None,
+        description='Path to the file containing the sha256 hash of the manifest rules. '
+        'Compare the hash with the current manifest rules. '
+        'All matched apps will be built if the corresponding manifest rule is modified',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Path to the file containing the sha256 hash of the manifest rules. '
-                'Compare the hash with the current manifest rules. '
-                'All matched apps will be built if the cooresponding manifest rule is modified',
-            )
-        ),
     )
 
-    def __post_init__(
-        self,
-        manifest_file: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_components: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_filepatterns: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-    ):
-        super().__post_init__()
-
-        self.set_deprecated_field('manifest_files', 'manifest_file', manifest_file)
-        self.set_deprecated_field(
-            'deactivate_dependency_driven_build_by_components',
-            'ignore_app_dependencies_components',
-            ignore_app_dependencies_components,
-        )
-        self.set_deprecated_field(
-            'deactivate_dependency_driven_build_by_filepatterns',
-            'ignore_app_dependencies_filepatterns',
-            ignore_app_dependencies_filepatterns,
-        )
-
-        self.manifest_files = to_list(self.manifest_files)
-        self.modified_components = to_list(self.modified_components)
-        self.modified_files = to_list(self.modified_files)
-        self.deactivate_dependency_driven_build_by_components = to_list(
-            self.deactivate_dependency_driven_build_by_components
-        )
-        self.deactivate_dependency_driven_build_by_filepatterns = to_list(
-            self.deactivate_dependency_driven_build_by_filepatterns
-        )
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
 
-        # Validation
         Manifest.CHECK_MANIFEST_RULES = self.check_manifest_rules
         if self.manifest_files:
             App.MANIFEST = Manifest.from_files(
@@ -379,234 +331,156 @@ class DependencyDrivenBuildArguments(GlobalArguments):
         return None
 
 
-def _os_curdir_as_list() -> t.List[str]:
-    return [os.curdir]
-
-
-@dataclass
 class FindBuildArguments(DependencyDrivenBuildArguments):
-    """
-    Arguments used in both find and build commands
-    """
-
     paths: t.List[str] = field(
-        default_factory=_os_curdir_as_list,
-        metadata=asdict(
-            FieldMetadata(
-                default=os.curdir,
-                description='Paths to the directories containing the apps. By default set to the current directory',
-                shorthand='-p',
-                nargs='*',
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            shorthand='-p',
+            nargs='*',
         ),
+        description='Paths to the directories containing the apps. By default set to the current directory',
+        default=os.curdir,
     )
     target: str = field(
-        default='all',
-        metadata=asdict(
-            FieldMetadata(
-                description='Filter the apps by target. By default set to "all"',
-                shorthand='-t',
-            )
+        FieldMetadata(
+            shorthand='-t',
         ),
+        description='Filter the apps by target. By default set to "all"',
+        default='all',
     )
     build_system: t.Union[str, t.Type[App]] = field(
-        default='cmake',
-        metadata=asdict(
-            FieldMetadata(
-                description='Filter the apps by build system. By default set to "cmake"',
-                choices=['cmake', 'make'],
-            )
+        FieldMetadata(
+            choices=['cmake', 'make'],
         ),
+        description='Filter the apps by build system. By default set to "cmake"',
+        default='cmake',
     )
     recursive: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Search for apps recursively under the specified paths',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Search for apps recursively under the specified paths',
+        default=False,
     )
-    exclude_list: InitVar[t.Optional[t.List[str]]] = _Field.UNSET
     exclude: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Ignore the specified directories while searching recursively',
-                nargs='+',
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            nargs='+',
         ),
+        description='Ignore the specified directories while searching recursively',
+        validation_alias=AliasChoices('exclude', 'exclude_list'),
+        default=None,
     )
     work_dir: t.Optional[str] = field(
+        None,
+        description='Copy the app to this directory before building. '
+        'By default set to the app directory. Can expand placeholders',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Copy the app to this directory before building. '
-                'By default set to the app directory. Can expand placeholders',
-            )
-        ),
     )
     build_dir: str = field(
+        None,
+        description='Build directory for the app. By default set to "build". '
+        'When set to relative path, it will be treated as relative to the app directory. '
+        'Can expand placeholders',
         default='build',
-        metadata=asdict(
-            FieldMetadata(
-                description='Build directory for the app. By default set to "build". '
-                'When set to relative path, it will be treated as relative to the app directory. '
-                'Can expand placeholders',
-            )
-        ),
     )
-    build_log: InitVar[t.Optional[str]] = _Field.UNSET
     build_log_filename: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={'build_log': {}},
-                description='Log filename under the build directory instead of stdout. Can expand placeholders',
-            )
+        FieldMetadata(
+            deprecates={'build_log': {}},
         ),
+        description='Log filename under the build directory instead of stdout. Can expand placeholders',
+        validation_alias=AliasChoices('build_log_filename', 'build_log'),
+        default=None,
     )
-    size_file: InitVar[t.Optional[str]] = _Field.UNSET
     size_json_filename: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={'size_file': {}},
-                description='`idf.py size` output file under the build directory when specified. '
-                'Can expand placeholders',
-            )
+        FieldMetadata(
+            deprecates={'size_file': {}},
         ),
+        description='`idf.py size` output file under the build directory when specified. ' 'Can expand placeholders',
+        validation_alias=AliasChoices('size_json_filename', 'size_file'),
+        default=None,
     )
-    config: InitVar[t.Union[t.List[str], str, None]] = _Field.UNSET  # cli  # type: ignore
-    config_rules_str: InitVar[t.Union[t.List[str], str, None]] = _Field.UNSET  # func  # type: ignore
     config_rules: t.Optional[t.List[str]] = field(
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            deprecates={
+                'config': {'nargs': '+'},
+            },
+            nargs='+',
+        ),
+        description='Defines the rules of building the project with pre-set sdkconfig files. '
+        'Supports FILENAME[=NAME] or FILEPATTERN format. '
+        'FILENAME is the filename of the sdkconfig file, relative to the app directory. '
+        'Optional NAME is the name of the configuration. '
+        'if not specified, the filename is used as the name. '
+        'FILEPATTERN is the filename of the sdkconfig file with a single wildcard character (*). '
+        'The NAME is the value matched by the wildcard',
+        validation_alias=AliasChoices('config_rules', 'config_rules_str', 'config'),
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={
-                    'config': {'nargs': '+'},
-                },
-                description='Defines the rules of building the project with pre-set sdkconfig files. '
-                'Supports FILENAME[=NAME] or FILEPATTERN format. '
-                'FILENAME is the filename of the sdkconfig file, relative to the app directory. '
-                'Optional NAME is the name of the configuration. '
-                'if not specified, the filename is used as the name. '
-                'FILEPATTERN is the filename of the sdkconfig file with a single wildcard character (*). '
-                'The NAME is the value matched by the wildcard',
-                nargs='+',
-            )
-        ),
     )
     override_sdkconfig_items: t.Optional[str] = field(
+        None,
+        description='A comma-separated list of key=value pairs to override the sdkconfig items',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='A comma-separated list of key=value pairs to override the sdkconfig items',
-            )
-        ),
     )
     override_sdkconfig_files: t.Optional[str] = field(
+        None,
+        description='A comma-separated list of sdkconfig files to override the sdkconfig items. '
+        'When set to relative path, it will be treated as relative to the current directory',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='A comma-separated list of sdkconfig files to override the sdkconfig items. '
-                'When set to relative path, it will be treated as relative to the current directory',
-            )
-        ),
     )
     sdkconfig_defaults: t.Optional[str] = field(
+        None,
+        description='A semicolon-separated list of sdkconfig files passed to `idf.py -DSDKCONFIG_DEFAULTS`. '
+        'SDKCONFIG_DEFAULTS environment variable is used when not specified',
         default=os.getenv('SDKCONFIG_DEFAULTS', None),
-        metadata=asdict(
-            FieldMetadata(
-                description='A semicolon-separated list of sdkconfig files passed to `idf.py -DSDKCONFIG_DEFAULTS`. '
-                'SDKCONFIG_DEFAULTS environment variable is used when not specified',
-            )
-        ),
     )
     check_warnings: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Check for warnings in the build output. Fail if any warnings are found',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Check for warnings in the build output. Fail if any warnings are found',
+        default=False,
     )
     default_build_targets: t.Optional[t.List[str]] = field(
+        None,
+        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`',
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                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`',
-            )
-        ),
     )
     enable_preview_targets: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                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`',
-                action='store_true',
-            )
+        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`',
+        default=False,
     )
     include_skipped_apps: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Include the skipped apps in the output, together with the enabled ones',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Include the skipped apps in the output, together with the enabled ones',
+        default=False,
     )
     include_disabled_apps: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Include the disabled apps in the output, together with the enabled ones',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Include the disabled apps in the output, together with the enabled ones',
+        default=False,
     )
     include_all_apps: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Include skipped, and disabled apps in the output, together with the enabled ones',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Include skipped, and disabled apps in the output, together with the enabled ones',
+        default=False,
     )
 
-    def __post_init__(  # type: ignore
-        self,
-        manifest_file: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_components: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_filepatterns: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        exclude_list: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        build_log: t.Optional[str] = _Field.UNSET,  # type: ignore
-        size_file: t.Optional[str] = _Field.UNSET,  # type: ignore
-        config: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        config_rules_str: t.Union[t.List[str], str, None] = _Field.UNSET,  # type: ignore
-    ):
-        super().__post_init__(
-            manifest_file=manifest_file,
-            ignore_app_dependencies_components=ignore_app_dependencies_components,
-            ignore_app_dependencies_filepatterns=ignore_app_dependencies_filepatterns,
-        )
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
 
-        self.set_deprecated_field('exclude', 'exclude_list', exclude_list)
-        self.set_deprecated_field('build_log_filename', 'build_log', build_log)
-        self.set_deprecated_field('size_json_filename', 'size_file', size_file)
-        self.set_deprecated_field('config_rules', 'config', config)
-        self.set_deprecated_field('config_rules', 'config_rules_str', config_rules_str)
-
-        self.paths = to_list(self.paths)
-        self.config_rules = to_list(self.config_rules)
-        self.exclude = to_list(self.exclude)
-
-        # Validation
         if not self.paths:
             raise InvalidCommand('At least one path must be specified')
 
@@ -636,54 +510,26 @@ class FindBuildArguments(DependencyDrivenBuildArguments):
             SESSION_ARGS.set(self)
 
 
-@dataclass
 class FindArguments(FindBuildArguments):
-    """
-    Arguments used in the find command
-    """
-
     output: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Record the found apps to the specified file instead of stdout',
-                shorthand='-o',
-            )
+        FieldMetadata(
+            shorthand='-o',
         ),
+        description='Record the found apps to the specified file instead of stdout',
+        default=None,
     )
     output_format: str = field(
-        default='raw',
-        metadata=asdict(
-            FieldMetadata(
-                description='Output format of the found apps. '
-                'In "raw" format, each line is a json string serialized from the app model. '
-                'In "json" format, the output is a json list of the serialized app models',
-                choices=['raw', 'json'],
-            )
+        FieldMetadata(
+            choices=['raw', 'json'],
         ),
+        description='Output format of the found apps. '
+        'In "raw" format, each line is a json string serialized from the app model. '
+        'In "json" format, the output is a json list of the serialized app models',
+        default='raw',
     )
 
-    def __post_init__(  # type: ignore
-        self,
-        manifest_file: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_components: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_filepatterns: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        exclude_list: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        build_log: t.Optional[str] = _Field.UNSET,  # type: ignore
-        size_file: t.Optional[str] = _Field.UNSET,  # type: ignore
-        config: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        config_rules_str: t.Union[t.List[str], str, None] = _Field.UNSET,  # type: ignore
-    ):
-        super().__post_init__(
-            manifest_file=manifest_file,
-            ignore_app_dependencies_components=ignore_app_dependencies_components,
-            ignore_app_dependencies_filepatterns=ignore_app_dependencies_filepatterns,
-            exclude_list=exclude_list,
-            build_log=build_log,
-            size_file=size_file,
-            config=config,
-            config_rules_str=config_rules_str,
-        )
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
 
         if self.include_all_apps:
             self.include_skipped_apps = True
@@ -694,207 +540,183 @@ class FindArguments(FindBuildArguments):
             self.output_format = 'json'
 
 
-@dataclass
 class BuildArguments(FindBuildArguments):
     build_verbose: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Enable verbose output of the build system',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Enable verbose output of the build system',
+        default=False,
     )
     parallel_count: int = field(
-        default=1,
-        metadata=asdict(
-            FieldMetadata(
-                description='Number of parallel build jobs in total. '
-                'Specified together with --parallel-index. '
-                'The given apps will be divided into parallel_count parts, '
-                'and the current run will build the parallel_index-th part',
-                type=int,
-            )
+        FieldMetadata(
+            type=int,
         ),
+        description='Number of parallel build jobs in total. '
+        'Specified together with --parallel-index. '
+        'The given apps will be divided into parallel_count parts, '
+        'and the current run will build the parallel_index-th part',
+        default=1,
     )
     parallel_index: int = field(
-        default=1,
-        metadata=asdict(
-            FieldMetadata(
-                description='Index (1-based) of the parallel build job. '
-                'Specified together with --parallel-count. '
-                'The given apps will be divided into parallel_count parts, '
-                'and the current run will build the parallel_index-th part',
-                type=int,
-            )
+        FieldMetadata(
+            type=int,
         ),
+        description='Index (1-based) of the parallel build job. '
+        'Specified together with --parallel-count. '
+        'The given apps will be divided into parallel_count parts, '
+        'and the current run will build the parallel_index-th part',
+        default=1,
     )
     dry_run: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Skip the actual build, only print the build process',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Skip the actual build, only print the build process',
+        default=False,
     )
     keep_going: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Continue building the next app when the current build fails',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Continue building the next app when the current build fails',
+        default=False,
     )
     no_preserve: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Do not preserve the build directory after a successful build',
-                action='store_true',
-            )
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Do not preserve the build directory after a successful build',
+        default=False,
     )
-    collect_size_info: t.Optional[str] = field(
+    ignore_warning_strs: t.Optional[t.List[str]] = field(
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            deprecates={
+                'ignore_warning_str': {'nargs': '+'},
+            },
+            nargs='+',
+        ),
+        description='space-separated list of patterns. '
+        'Ignore the warnings in the build output that match the patterns',
+        validation_alias=AliasChoices('ignore_warning_strs', 'ignore_warning_str'),
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='[INTERNAL CI USE] record size json filepath of the built apps to the specified file. '
-                'Each line is a json string. Can expand placeholders @p',
-            )
-        ),
     )
-    collect_app_info: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='[INTERNAL CI USE] record serialized app model of the built apps to the specified file. '
-                'Each line is a json string. Can expand placeholders @p',
-            )
+    ignore_warning_files: t.Optional[t.List[str]] = field(
+        FieldMetadata(
+            deprecates={'ignore_warning_file': {}},
+            nargs='+',
         ),
-    )
-    ignore_warning_str: InitVar[t.Optional[t.List[str]]] = _Field.UNSET
-    ignore_warning_strings: t.Optional[t.List[str]] = field(
+        description='Path to the files containing the patterns to ignore the warnings in the build output',
+        validation_alias=AliasChoices('ignore_warning_files', 'ignore_warning_file'),
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={
-                    'ignore_warning_str': {'nargs': '+'},
-                },
-                description='space-separated list of patterns. '
-                'Ignore the warnings in the build output that match the patterns',
-                nargs='+',
-            )
+    )
+    copy_sdkconfig: bool = field(
+        FieldMetadata(
+            action='store_true',
         ),
+        description='Copy the sdkconfig file to the build directory',
+        default=False,
     )
-    ignore_warning_file: InitVar[t.Optional[str]] = _Field.UNSET
-    ignore_warning_files: t.Optional[t.List[str]] = field(
+
+    # Attrs that support placeholders
+    collect_size_info_filename: t.Optional[str] = field(
+        None,
+        description='Record size json filepath of the built apps to the specified file. '
+        'Each line is a json string. Can expand placeholders @p',
+        validation_alias=AliasChoices('collect_size_info_filename', 'collect_size_info'),
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                deprecates={'ignore_warning_file': {}},
-                description='Path to the files containing the patterns to ignore the warnings in the build output',
-                nargs='+',
-            )
-        ),
+        exclude=True,  # computed field is used
     )
-    copy_sdkconfig: bool = field(
-        default=False,
-        metadata=asdict(
-            FieldMetadata(
-                description='Copy the sdkconfig file to the build directory',
-                action='store_true',
-            )
-        ),
+    collect_app_info_filename: t.Optional[str] = field(
+        None,
+        description='Record serialized app model of the built apps to the specified file. '
+        'Each line is a json string. Can expand placeholders @p',
+        validation_alias=AliasChoices('collect_app_info_filename', 'collect_app_info'),
+        default=None,
+        exclude=True,  # computed field is used
     )
-    junitxml: t.Optional[str] = field(
+    junitxml_filename: t.Optional[str] = field(
+        None,
+        description='Path to the junitxml file to record the build results. Can expand placeholder @p',
+        validation_alias=AliasChoices('junitxml_filename', 'junitxml'),
         default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Path to the junitxml file to record the build results. Can expand placeholder @p',
-            )
-        ),
+        exclude=True,  # computed field is used
     )
+    # used for expanding placeholders
+    PARALLEL_INDEX_PLACEHOLDER: t.ClassVar[str] = '@p'  # replace it with the parallel index
 
-    def __post_init__(  # type: ignore
-        self,
-        manifest_file: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_components: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_app_dependencies_filepatterns: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        exclude_list: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        build_log: t.Optional[str] = _Field.UNSET,  # type: ignore
-        size_file: t.Optional[str] = _Field.UNSET,  # type: ignore
-        config: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        config_rules_str: t.Union[t.List[str], str, None] = _Field.UNSET,  # type: ignore
-        ignore_warning_str: t.Optional[t.List[str]] = _Field.UNSET,  # type: ignore
-        ignore_warning_file: t.Optional[str] = _Field.UNSET,  # type: ignore
-    ):
-        super().__post_init__(
-            manifest_file=manifest_file,
-            ignore_app_dependencies_components=ignore_app_dependencies_components,
-            ignore_app_dependencies_filepatterns=ignore_app_dependencies_filepatterns,
-            exclude_list=exclude_list,
-            build_log=build_log,
-            size_file=size_file,
-            config=config,
-            config_rules_str=config_rules_str,
-        )
-
-        self.set_deprecated_field('ignore_warning_strings', 'ignore_warning_str', ignore_warning_str)
-        self.set_deprecated_field('ignore_warning_files', 'ignore_warning_file', ignore_warning_file)
-
-        self.ignore_warning_strings = to_list(self.ignore_warning_strings) or []
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
 
         ignore_warnings_regexes = []
-        if self.ignore_warning_strings:
-            for s in self.ignore_warning_strings:
+        if self.ignore_warning_strs:
+            for s in self.ignore_warning_strs:
                 ignore_warnings_regexes.append(re.compile(s))
         if self.ignore_warning_files:
             for s in self.ignore_warning_files:
                 ignore_warnings_regexes.append(re.compile(s.strip()))
         App.IGNORE_WARNS_REGEXES = ignore_warnings_regexes
 
+    @computed_field  # type: ignore
+    @property
+    def collect_size_info(self) -> t.Optional[str]:
+        if self.collect_size_info_filename:
+            return self.collect_size_info_filename.replace(self.PARALLEL_INDEX_PLACEHOLDER, str(self.parallel_index))
+
+        return None
 
-@dataclass
-class DumpManifestShaArguments(GlobalArguments):
-    """
-    Arguments used in the dump-manifest-sha command
-    """
+    @computed_field  # type: ignore
+    @property
+    def collect_app_info(self) -> t.Optional[str]:
+        if self.collect_app_info_filename:
+            return self.collect_app_info_filename.replace(self.PARALLEL_INDEX_PLACEHOLDER, str(self.parallel_index))
 
+        return None
+
+    @computed_field  # type: ignore
+    @property
+    def junitxml(self) -> t.Optional[str]:
+        if self.junitxml_filename:
+            return self.junitxml_filename.replace(self.PARALLEL_INDEX_PLACEHOLDER, str(self.parallel_index))
+
+        return None
+
+
+class DumpManifestShaArguments(GlobalArguments):
     manifest_files: t.Optional[t.List[str]] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Path to the manifest files which contains the build test rules of the apps',
-                nargs='+',
-                required=True,
-            )
+        FieldMetadata(
+            validate_method=[ValidateMethod.TO_LIST],
+            nargs='+',
+            required=True,
         ),
+        description='Path to the manifest files which contains the build test rules of the apps',
+        default=None,
     )
+
     output: t.Optional[str] = field(
-        default=None,
-        metadata=asdict(
-            FieldMetadata(
-                description='Record the sha256 hash of the manifest rules to the specified file',
-                shorthand='-o',
-                required=True,
-            )
+        FieldMetadata(
+            shorthand='-o',
+            required=True,
         ),
+        description='Path to the output file to record the sha256 hash of the manifest rules',
+        default=None,
     )
 
-    def __post_init__(self):
-        super().__post_init__()
+    def model_post_init(self, __context: Any) -> None:
+        super().model_post_init(__context)
 
-        # Validation
-        self.manifest_files = to_list(self.manifest_files)
         if not self.manifest_files:
             raise InvalidCommand('Manifest files are required to dump the SHA values.')
         if not self.output:
             raise InvalidCommand('Output file is required to dump the SHA values.')
 
 
-def add_arguments_to_parser(argument_cls: t.Type[GlobalArguments], parser: argparse.ArgumentParser) -> None:
+def _snake_case_to_cli_arg_name(s: str) -> str:
+    return f'--{s.replace("_", "-")}'
+
+
+def add_args_to_parser(argument_cls: t.Type[BaseArguments], parser: argparse.ArgumentParser) -> None:
     """
     Add arguments to the parser from the argument class.
 
@@ -903,48 +725,50 @@ def add_arguments_to_parser(argument_cls: t.Type[GlobalArguments], parser: argpa
     :param argument_cls: argument class
     :param parser: argparse parser
     """
-    name_fields_dict = {f.name: f for f in fields(argument_cls)}
-
-    def _snake_case_to_cli_arg_name(s: str) -> str:
-        return f'--{s.replace("_", "-")}'
-
-    for name, f in name_fields_dict.items():
-        _meta = FieldMetadata(**f.metadata)
-
-        desp = _meta.description
-        # add deprecated fields
-        if _meta.deprecates:
-            for depr_k, depr_kwargs in _meta.deprecates.items():
-                depr_kwargs['help'] = f'[DEPRECATED by {_snake_case_to_cli_arg_name(name)}] {desp}'
-                short_name = depr_kwargs.pop('shorthand', None)
-                _names = [_snake_case_to_cli_arg_name(depr_k)]
-                if short_name:
-                    _names.append(short_name)
-                parser.add_argument(*_names, **depr_kwargs)
-
-        # args
-        args = [_snake_case_to_cli_arg_name(name)]
-        if _meta.shorthand:
-            args.append(_meta.shorthand)
-
-        # kwargs passed to add_argument
-        kwargs = drop_none_kwargs(
-            {
-                'help': desp,
-                'action': _meta.action,
-                'nargs': _meta.nargs,
-                'choices': _meta.choices,
-                'type': _meta.type,
-                'required': _meta.required,
-            }
-        )
-        # default None is important for argparse
-        kwargs['default'] = _meta.default or getattr(f, 'default', None)
+    for f_name, f in argument_cls.model_fields.items():
+        f_meta = get_meta(f)
+        if f_meta and f_meta.deprecates:
+            for dep_f_name, dep_f_kwargs in f_meta.deprecates.items():
+                _names = [_snake_case_to_cli_arg_name(dep_f_name)]
+                _shorthand = dep_f_kwargs.pop('shorthand', None)
+                if _shorthand:
+                    _names.append(_shorthand)
+
+                parser.add_argument(
+                    *_names,
+                    **dep_f_kwargs,
+                    help=f'[Deprecated] Use {_snake_case_to_cli_arg_name(f_name)} instead',
+                )
 
-        parser.add_argument(*args, **kwargs)
+        names = [_snake_case_to_cli_arg_name(f_name)]
+        if f_meta and f_meta.shorthand:
+            names.append(f_meta.shorthand)
+
+        kwargs: t.Dict[str, t.Any] = {}
+        if f_meta:
+            if f_meta.type:
+                kwargs['type'] = f_meta.type
+            if f_meta.required:
+                kwargs['required'] = True
+            if f_meta.action:
+                kwargs['action'] = f_meta.action
+            if f_meta.nargs:
+                kwargs['nargs'] = f_meta.nargs
+            if f_meta.choices:
+                kwargs['choices'] = f_meta.choices
+            if f_meta.default:
+                kwargs['default'] = f_meta.default
+        if 'default' not in kwargs:
+            kwargs['default'] = f.default
+
+        parser.add_argument(
+            *names,
+            **kwargs,
+            help=f.description,
+        )
 
 
-def add_arguments_to_obj_doc_as_params(argument_cls: t.Type[GlobalArguments], obj: t.Any = None) -> None:
+def add_args_to_obj_doc_as_params(argument_cls: t.Type[GlobalArguments], obj: t.Any = None) -> None:
     """
     Add arguments to the function as parameters.
 
@@ -952,14 +776,24 @@ def add_arguments_to_obj_doc_as_params(argument_cls: t.Type[GlobalArguments], ob
     :param obj: object to add the docstring to
     """
     _obj = obj or argument_cls
-    _docs_s = _obj.__doc__ or ''
-    _docs_s += '\n'
+    _doc_str = _obj.__doc__ or ''
+    _doc_str += '\n'
 
-    for f in fields(argument_cls):
+    for f_name, f in argument_cls.model_fields.items():
         # typing generic alias is not a class
-        _annotation = f.type.__name__ if inspect.isclass(f.type) else f.type
+        _annotation = f.annotation.__name__ if inspect.isclass(f.annotation) else f.annotation
+        _doc_str += f'    :param {f_name}: {f.description}\n'
+        _doc_str += f'    :type {f_name}: {_annotation}\n'
+
+    _obj.__doc__ = _doc_str
+
 
-        _docs_s += f'    :param {f.name}: {f.metadata.get("description", "")}\n'
-        _docs_s += f'    :type {f.name}: {_annotation}\n'
+def apply_config_file(config_file: t.Optional[str]) -> 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)])
 
-    _obj.__doc__ = _docs_s
+    if config_file:
+        BaseArguments.model_config['toml_file'] = str(config_file)
+        # modify all subclasses
+        for cls in _subclasses(BaseArguments):
+            cls.model_config['toml_file'] = str(config_file)