esphome 2025.9.3__py3-none-any.whl → 2025.10.0b2__py3-none-any.whl

esphome/components/esp32/__init__.py

@@ -36,9 +36,8 @@ from esphome.const import (
     __version__,
 )
 from esphome.core import CORE, HexInt, TimePeriod
-from esphome.cpp_generator import RawExpression
 import esphome.final_validate as fv
-from esphome.helpers import copy_file_if_changed, mkdir_p, write_file_if_changed
+from esphome.helpers import copy_file_if_changed, write_file_if_changed
 from esphome.types import ConfigType
 from esphome.writer import clean_cmake_cache
 
@@ -157,8 +156,6 @@ def set_core_data(config):
     conf = config[CONF_FRAMEWORK]
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "esp-idf"
-        CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] = {}
-        CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
     elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
         CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "arduino"
         if variant not in ARDUINO_ALLOWED_VARIANTS:
@@ -166,6 +163,8 @@ def set_core_data(config):
                 f"ESPHome does not support using the Arduino framework for the {variant}. Please use the ESP-IDF framework instead.",
                 path=[CONF_FRAMEWORK, CONF_TYPE],
             )
+    CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] = {}
+    CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
         config[CONF_FRAMEWORK][CONF_VERSION]
     )
@@ -236,8 +235,6 @@ SdkconfigValueType = bool | int | HexInt | str | RawSdkconfigValue
 
 def add_idf_sdkconfig_option(name: str, value: SdkconfigValueType):
     """Set an esp-idf sdkconfig value."""
-    if not CORE.using_esp_idf:
-        raise ValueError("Not an esp-idf project")
     CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS][name] = value
 
 
@@ -252,8 +249,6 @@ def add_idf_component(
     submodules: list[str] | None = None,
 ):
     """Add an esp-idf component to the project."""
-    if not CORE.using_esp_idf:
-        raise ValueError("Not an esp-idf project")
     if not repo and not ref and not path:
         raise ValueError("Requires at least one of repo, ref or path")
     if refresh or submodules or components:
@@ -277,14 +272,14 @@ def add_idf_component(
         }
 
 
-def add_extra_script(stage: str, filename: str, path: str):
+def add_extra_script(stage: str, filename: str, path: Path):
     """Add an extra script to the project."""
     key = f"{stage}:{filename}"
     if add_extra_build_file(filename, path):
         cg.add_platformio_option("extra_scripts", [key])
 
 
-def add_extra_build_file(filename: str, path: str) -> bool:
+def add_extra_build_file(filename: str, path: Path) -> bool:
     """Add an extra build file to the project."""
     if filename not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
         CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES][filename] = {
@@ -301,14 +296,9 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
     return f"pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/{str(ver)}/esp32-{str(ver)}.zip"
 
 
-def _format_framework_espidf_version(
-    ver: cv.Version, release: str, for_platformio: bool
-) -> str:
-    # format the given arduino (https://github.com/espressif/esp-idf/releases) version to
+def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
+    # format the given espidf (https://github.com/pioarduino/esp-idf/releases) version to
     # a PIO platformio/framework-espidf value
-    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
-    if for_platformio:
-        return f"platformio/framework-espidf@~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
     if release:
         return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}.{release}/esp-idf-v{str(ver)}.zip"
     return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.zip"
@@ -322,154 +312,115 @@ def _format_framework_espidf_version(
 
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
-RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 2, 1)
-# The platform-espressif32 version to use for arduino frameworks
-#  - https://github.com/pioarduino/platform-espressif32/releases
-ARDUINO_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
+ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
+    "recommended": cv.Version(3, 2, 1),
+    "latest": cv.Version(3, 3, 2),
+    "dev": cv.Version(3, 3, 2),
+}
+ARDUINO_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 0): cv.Version(55, 3, 30, "2"),
+    cv.Version(3, 2, 1): cv.Version(54, 3, 21, "2"),
+    cv.Version(3, 2, 0): cv.Version(54, 3, 20),
+    cv.Version(3, 1, 3): cv.Version(53, 3, 13),
+    cv.Version(3, 1, 2): cv.Version(53, 3, 12),
+    cv.Version(3, 1, 1): cv.Version(53, 3, 11),
+    cv.Version(3, 1, 0): cv.Version(53, 3, 10),
+}
 
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
-#  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
-RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 4, 2)
-# The platformio/espressif32 version to use for esp-idf frameworks
-#  - https://github.com/platformio/platform-espressif32/releases
-#  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32
-ESP_IDF_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
-
-# List based on https://registry.platformio.org/tools/platformio/framework-espidf/versions
-SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
-    cv.Version(5, 3, 1),
-    cv.Version(5, 3, 0),
-    cv.Version(5, 2, 2),
-    cv.Version(5, 2, 1),
-    cv.Version(5, 1, 2),
-    cv.Version(5, 1, 1),
-    cv.Version(5, 1, 0),
-    cv.Version(5, 0, 2),
-    cv.Version(5, 0, 1),
-    cv.Version(5, 0, 0),
-]
+ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
+    "recommended": cv.Version(5, 4, 2),
+    "latest": cv.Version(5, 5, 1),
+    "dev": cv.Version(5, 5, 1),
+}
+ESP_IDF_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
+    cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
+    cv.Version(5, 4, 0): cv.Version(54, 3, 21, "2"),
+    cv.Version(5, 3, 2): cv.Version(53, 3, 13),
+    cv.Version(5, 3, 1): cv.Version(53, 3, 13),
+    cv.Version(5, 3, 0): cv.Version(53, 3, 13),
+    cv.Version(5, 1, 6): cv.Version(51, 3, 7),
+    cv.Version(5, 1, 5): cv.Version(51, 3, 7),
+}
 
-# pioarduino versions that don't require a release number
-# List based on https://github.com/pioarduino/esp-idf/releases
-SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
-    cv.Version(5, 5, 0),
-    cv.Version(5, 4, 2),
-    cv.Version(5, 4, 1),
-    cv.Version(5, 4, 0),
-    cv.Version(5, 3, 3),
-    cv.Version(5, 3, 2),
-    cv.Version(5, 3, 1),
-    cv.Version(5, 3, 0),
-    cv.Version(5, 1, 5),
-    cv.Version(5, 1, 6),
-]
+# The platform-espressif32 version
+#  - https://github.com/pioarduino/platform-espressif32/releases
+PLATFORM_VERSION_LOOKUP = {
+    "recommended": cv.Version(54, 3, 21, "2"),
+    "latest": cv.Version(55, 3, 31, "1"),
+    "dev": cv.Version(55, 3, 31, "1"),
+}
 
 
-def _arduino_check_versions(value):
+def _check_versions(value):
     value = value.copy()
-    lookups = {
-        "dev": (cv.Version(3, 2, 1), "https://github.com/espressif/arduino-esp32.git"),
-        "latest": (cv.Version(3, 2, 1), None),
-        "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
-    }
-
-    if value[CONF_VERSION] in lookups:
-        if CONF_SOURCE in value:
+
+    if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
+        if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
             raise cv.Invalid(
-                "Framework version needs to be explicitly specified when custom source is used."
+                "Version needs to be explicitly set when a custom source or platform_version is used."
             )
 
-        version, source = lookups[value[CONF_VERSION]]
+        platform_lookup = PLATFORM_VERSION_LOOKUP[value[CONF_VERSION]]
+        value[CONF_PLATFORM_VERSION] = _parse_platform_version(str(platform_lookup))
+
+        if value[CONF_TYPE] == FRAMEWORK_ARDUINO:
+            version = ARDUINO_FRAMEWORK_VERSION_LOOKUP[value[CONF_VERSION]]
+        else:
+            version = ESP_IDF_FRAMEWORK_VERSION_LOOKUP[value[CONF_VERSION]]
     else:
         version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
-        source = value.get(CONF_SOURCE, None)
 
     value[CONF_VERSION] = str(version)
-    value[CONF_SOURCE] = source or _format_framework_arduino_version(version)
-
-    value[CONF_PLATFORM_VERSION] = value.get(
-        CONF_PLATFORM_VERSION, _parse_platform_version(str(ARDUINO_PLATFORM_VERSION))
-    )
-
-    if value[CONF_SOURCE].startswith("http"):
-        # prefix is necessary or platformio will complain with a cryptic error
-        value[CONF_SOURCE] = f"framework-arduinoespressif32@{value[CONF_SOURCE]}"
 
-    if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
-        _LOGGER.warning(
-            "The selected Arduino framework version is not the recommended one. "
-            "If there are connectivity or build issues please remove the manual version."
+    if value[CONF_TYPE] == FRAMEWORK_ARDUINO:
+        if version < cv.Version(3, 0, 0):
+            raise cv.Invalid("Only Arduino 3.0+ is supported.")
+        recommended_version = ARDUINO_FRAMEWORK_VERSION_LOOKUP["recommended"]
+        platform_lookup = ARDUINO_PLATFORM_VERSION_LOOKUP.get(version)
+        value[CONF_SOURCE] = value.get(
+            CONF_SOURCE, _format_framework_arduino_version(version)
         )
-
-    return value
-
-
-def _esp_idf_check_versions(value):
-    value = value.copy()
-    lookups = {
-        "dev": (cv.Version(5, 4, 2), "https://github.com/espressif/esp-idf.git"),
-        "latest": (cv.Version(5, 2, 2), None),
-        "recommended": (RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION, None),
-    }
-
-    if value[CONF_VERSION] in lookups:
-        if CONF_SOURCE in value:
-            raise cv.Invalid(
-                "Framework version needs to be explicitly specified when custom source is used."
+        if value[CONF_SOURCE].startswith("http"):
+            value[CONF_SOURCE] = (
+                f"pioarduino/framework-arduinoespressif32@{value[CONF_SOURCE]}"
             )
-
-        version, source = lookups[value[CONF_VERSION]]
     else:
-        version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
-        source = value.get(CONF_SOURCE, None)
-
-    if version < cv.Version(5, 0, 0):
-        raise cv.Invalid("Only ESP-IDF 5.0+ is supported.")
-
-    # flag this for later *before* we set value[CONF_PLATFORM_VERSION] below
-    has_platform_ver = CONF_PLATFORM_VERSION in value
-
-    value[CONF_PLATFORM_VERSION] = value.get(
-        CONF_PLATFORM_VERSION, _parse_platform_version(str(ESP_IDF_PLATFORM_VERSION))
-    )
-
-    if (
-        is_platformio := _platform_is_platformio(value[CONF_PLATFORM_VERSION])
-    ) and version not in SUPPORTED_PLATFORMIO_ESP_IDF_5X:
-        raise cv.Invalid(
-            f"ESP-IDF {str(version)} not supported by platformio/espressif32"
+        if version < cv.Version(5, 0, 0):
+            raise cv.Invalid("Only ESP-IDF 5.0+ is supported.")
+        recommended_version = ESP_IDF_FRAMEWORK_VERSION_LOOKUP["recommended"]
+        platform_lookup = ESP_IDF_PLATFORM_VERSION_LOOKUP.get(version)
+        value[CONF_SOURCE] = value.get(
+            CONF_SOURCE,
+            _format_framework_espidf_version(version, value.get(CONF_RELEASE, None)),
         )
+        if value[CONF_SOURCE].startswith("http"):
+            value[CONF_SOURCE] = f"pioarduino/framework-espidf@{value[CONF_SOURCE]}"
 
-    if (
-        version in SUPPORTED_PLATFORMIO_ESP_IDF_5X
-        and version not in SUPPORTED_PIOARDUINO_ESP_IDF_5X
-    ) and not has_platform_ver:
-        raise cv.Invalid(
-            f"ESP-IDF {value[CONF_VERSION]} may be supported by platformio/espressif32; please specify '{CONF_PLATFORM_VERSION}'"
-        )
+    if CONF_PLATFORM_VERSION not in value:
+        if platform_lookup is None:
+            raise cv.Invalid(
+                "Framework version not recognized; please specify platform_version"
+            )
+        value[CONF_PLATFORM_VERSION] = _parse_platform_version(str(platform_lookup))
 
-    if (
-        not is_platformio
-        and CONF_RELEASE not in value
-        and version not in SUPPORTED_PIOARDUINO_ESP_IDF_5X
-    ):
-        raise cv.Invalid(
-            f"ESP-IDF {value[CONF_VERSION]} is not available with pioarduino; you may need to specify '{CONF_RELEASE}'"
+    if version != recommended_version:
+        _LOGGER.warning(
+            "The selected framework version is not the recommended one. "
+            "If there are connectivity or build issues please remove the manual version."
         )
 
-    value[CONF_VERSION] = str(version)
-    value[CONF_SOURCE] = source or _format_framework_espidf_version(
-        version, value.get(CONF_RELEASE, None), is_platformio
-    )
-
-    if value[CONF_SOURCE].startswith("http"):
-        # prefix is necessary or platformio will complain with a cryptic error
-        value[CONF_SOURCE] = f"framework-espidf@{value[CONF_SOURCE]}"
-
-    if version != RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION:
+    if value[CONF_PLATFORM_VERSION] != _parse_platform_version(
+        str(PLATFORM_VERSION_LOOKUP["recommended"])
+    ):
         _LOGGER.warning(
-            "The selected ESP-IDF framework version is not the recommended one. "
+            "The selected platform version is not the recommended one. "
             "If there are connectivity or build issues please remove the manual version."
         )
 
@@ -479,26 +430,14 @@ def _esp_idf_check_versions(value):
 def _parse_platform_version(value):
     try:
         ver = cv.Version.parse(cv.version_number(value))
-        if ver.major >= 50:  # a pioarduino version
-            release = f"{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
-            if ver.extra:
-                release += f"-{ver.extra}"
-            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{release}/platform-espressif32.zip"
-        # if platform version is a valid version constraint, prefix the default package
-        cv.platformio_version_constraint(value)
-        return f"platformio/espressif32@{value}"
+        release = f"{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
+        if ver.extra:
+            release += f"-{ver.extra}"
+        return f"https://github.com/pioarduino/platform-espressif32/releases/download/{release}/platform-espressif32.zip"
     except cv.Invalid:
         return value
 
 
-def _platform_is_platformio(value):
-    try:
-        ver = cv.Version.parse(cv.version_number(value))
-        return ver.major < 50
-    except cv.Invalid:
-        return "platformio" in value
-
-
 def _detect_variant(value):
     board = value.get(CONF_BOARD)
     variant = value.get(CONF_VARIANT)
@@ -588,24 +527,6 @@ def final_validate(config):
     return config
 
 
-ARDUINO_FRAMEWORK_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_SOURCE): cv.string_strict,
-            cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
-            cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
-                {
-                    cv.Optional(
-                        CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
-                    ): cv.boolean,
-                }
-            ),
-        }
-    ),
-    _arduino_check_versions,
-)
-
 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
 CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
 CONF_ENABLE_LWIP_MDNS_QUERIES = "enable_lwip_mdns_queries"
@@ -624,9 +545,14 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
     return config
 
 
-ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
+FRAMEWORK_ESP_IDF = "esp-idf"
+FRAMEWORK_ARDUINO = "arduino"
+FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
+            cv.Optional(CONF_TYPE, default=FRAMEWORK_ARDUINO): cv.one_of(
+                FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO
+            ),
             cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
             cv.Optional(CONF_RELEASE): cv.string_strict,
             cv.Optional(CONF_SOURCE): cv.string_strict,
@@ -690,7 +616,7 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
             ),
         }
     ),
-    _esp_idf_check_versions,
+    _check_versions,
 )
 
 
@@ -720,6 +646,7 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
         + "Why change? ESP-IDF offers:\n"
         + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller binaries\n")
         + color(AnsiFore.GREEN, "  🚀 Better performance and optimization\n")
+        + color(AnsiFore.GREEN, "  ⚡ 2-3x faster compile times\n")
         + color(AnsiFore.GREEN, "  📦 Custom-built firmware for your exact needs\n")
         + color(
             AnsiFore.GREEN,
@@ -727,7 +654,6 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
         )
         + "\n"
         + "Trade-offs:\n"
-        + color(AnsiFore.YELLOW, "  ⏱️  Compile times are ~25% longer\n")
         + color(AnsiFore.YELLOW, "  🔄 Some components need migration\n")
         + "\n"
         + "What should I do?\n"
@@ -757,32 +683,18 @@ def _set_default_framework(config):
         config = config.copy()
 
         variant = config[CONF_VARIANT]
+        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
         if variant in ARDUINO_ALLOWED_VARIANTS:
-            config[CONF_FRAMEWORK] = ARDUINO_FRAMEWORK_SCHEMA({})
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
-            # Show the migration message
             _show_framework_migration_message(
                 config.get(CONF_NAME, "This device"), variant
             )
         else:
-            config[CONF_FRAMEWORK] = ESP_IDF_FRAMEWORK_SCHEMA({})
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ESP_IDF
 
     return config
 
 
-FRAMEWORK_ESP_IDF = "esp-idf"
-FRAMEWORK_ARDUINO = "arduino"
-FRAMEWORK_SCHEMA = cv.typed_schema(
-    {
-        FRAMEWORK_ESP_IDF: ESP_IDF_FRAMEWORK_SCHEMA,
-        FRAMEWORK_ARDUINO: ARDUINO_FRAMEWORK_SCHEMA,
-    },
-    lower=True,
-    space="-",
-)
-
-
 FLASH_SIZES = [
     "2MB",
     "4MB",
@@ -837,6 +749,8 @@ async def to_code(config):
 
     conf = config[CONF_FRAMEWORK]
     cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
+    if CONF_SOURCE in conf:
+        cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
 
     if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
@@ -847,142 +761,146 @@ async def to_code(config):
     add_extra_script(
         "post",
         "post_build.py",
-        os.path.join(os.path.dirname(__file__), "post_build.py.script"),
+        Path(__file__).parent / "post_build.py.script",
     )
 
-    freq = config[CONF_CPU_FREQUENCY][:-3]
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_platformio_option("framework", "espidf")
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
-        cg.add_build_flag("-Wno-nonnull-compare")
-
-        cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
-
-        add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
-        add_idf_sdkconfig_option(
-            f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
+    else:
+        cg.add_platformio_option("framework", "arduino, espidf")
+        cg.add_build_flag("-DUSE_ARDUINO")
+        cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
+        cg.add_platformio_option(
+            "board_build.embed_txtfiles",
+            [
+                "managed_components/espressif__esp_insights/server_certs/https_server.crt",
+                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt",
+                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt",
+                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt",
+            ],
         )
-        add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
-        add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
-        add_idf_sdkconfig_option(
-            "CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv"
+        cg.add_define(
+            "USE_ARDUINO_VERSION_CODE",
+            cg.RawExpression(
+                f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
+            ),
         )
+        add_idf_sdkconfig_option("CONFIG_AUTOSTART_ARDUINO", True)
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
 
-        # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
-        add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)
-
-        # Setup watchdog
-        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_PANIC", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
-        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
-
-        # Disable dynamic log level control to save memory
-        add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
-
-        # Set default CPU frequency
-        add_idf_sdkconfig_option(f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{freq}", True)
-
-        # Apply LWIP optimization settings
-        advanced = conf[CONF_ADVANCED]
-        # DHCP server: only disable if explicitly set to false
-        # WiFi component handles its own optimization when AP mode is not used
-        if (
-            CONF_ENABLE_LWIP_DHCP_SERVER in advanced
-            and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
-        ):
-            add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-        if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
-            add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-        if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
-            add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
-        if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
-            add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
-            add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
-
-        # Apply LWIP core locking for better socket performance
-        # This is already enabled by default in Arduino framework, where it provides
-        # significant performance benefits. Our benchmarks show socket operations are
-        # 24-200% faster with core locking enabled:
-        # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
-        # - Up to 200% slower under load when all operations queue through tcpip_thread
-        # Enabling this makes ESP-IDF socket performance match Arduino framework.
-        if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-        if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
-            add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
-
-        cg.add_platformio_option("board_build.partitions", "partitions.csv")
-        if CONF_PARTITIONS in config:
-            add_extra_build_file(
-                "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
-            )
+    cg.add_build_flag("-Wno-nonnull-compare")
 
-        if assertion_level := advanced.get(CONF_ASSERTION_LEVEL):
-            for key, flag in ASSERTION_LEVELS.items():
-                add_idf_sdkconfig_option(flag, assertion_level == key)
+    add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
+    add_idf_sdkconfig_option(
+        f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
+    )
+    add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
+    add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
+    add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv")
 
-        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-        compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
-        for key, flag in COMPILER_OPTIMIZATIONS.items():
-            add_idf_sdkconfig_option(flag, compiler_optimization == key)
+    # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
+    add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)
 
-        add_idf_sdkconfig_option(
-            "CONFIG_LWIP_ESP_LWIP_ASSERT",
-            conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
-        )
+    # Setup watchdog
+    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT", True)
+    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_PANIC", True)
+    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
+    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
 
-        if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
-            add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
-            add_idf_sdkconfig_option(
-                "CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False
-            )
-        if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
-            _LOGGER.warning(
-                "Using experimental features in ESP-IDF may result in unexpected failures."
-            )
-            add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
+    # Disable dynamic log level control to save memory
+    add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
 
-        cg.add_define(
-            "USE_ESP_IDF_VERSION_CODE",
-            cg.RawExpression(
-                f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
-            ),
+    # Set default CPU frequency
+    add_idf_sdkconfig_option(
+        f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{config[CONF_CPU_FREQUENCY][:-3]}", True
+    )
+
+    # Apply LWIP optimization settings
+    advanced = conf[CONF_ADVANCED]
+    # DHCP server: only disable if explicitly set to false
+    # WiFi component handles its own optimization when AP mode is not used
+    # When using Arduino with Ethernet, DHCP server functions must be available
+    # for the Network library to compile, even if not actively used
+    if (
+        CONF_ENABLE_LWIP_DHCP_SERVER in advanced
+        and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
+        and not (
+            conf[CONF_TYPE] == FRAMEWORK_ARDUINO
+            and "ethernet" in CORE.loaded_integrations
         )
+    ):
+        add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
+    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
+        add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
+    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
+        add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
+    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
+        add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
+        add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
+
+    # Apply LWIP core locking for better socket performance
+    # This is already enabled by default in Arduino framework, where it provides
+    # significant performance benefits. Our benchmarks show socket operations are
+    # 24-200% faster with core locking enabled:
+    # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
+    # - Up to 200% slower under load when all operations queue through tcpip_thread
+    # Enabling this makes ESP-IDF socket performance match Arduino framework.
+    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
+        add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
+    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
+        add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
+
+    cg.add_platformio_option("board_build.partitions", "partitions.csv")
+    if CONF_PARTITIONS in config:
+        add_extra_build_file(
+            "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
+        )
+
+    if assertion_level := advanced.get(CONF_ASSERTION_LEVEL):
+        for key, flag in ASSERTION_LEVELS.items():
+            add_idf_sdkconfig_option(flag, assertion_level == key)
+
+    add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
+    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
+    for key, flag in COMPILER_OPTIMIZATIONS.items():
+        add_idf_sdkconfig_option(flag, compiler_optimization == key)
+
+    add_idf_sdkconfig_option(
+        "CONFIG_LWIP_ESP_LWIP_ASSERT",
+        conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
+    )
 
-        add_idf_sdkconfig_option(
-            f"CONFIG_LOG_DEFAULT_LEVEL_{conf[CONF_LOG_LEVEL]}", True
+    if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
+        add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
+        add_idf_sdkconfig_option("CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False)
+    if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+        _LOGGER.warning(
+            "Using experimental features in ESP-IDF may result in unexpected failures."
         )
+        add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
 
-        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
-            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
+    cg.add_define(
+        "USE_ESP_IDF_VERSION_CODE",
+        cg.RawExpression(
+            f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
+        ),
+    )
 
-        for component in conf[CONF_COMPONENTS]:
-            add_idf_component(
-                name=component[CONF_NAME],
-                repo=component.get(CONF_SOURCE),
-                ref=component.get(CONF_REF),
-                path=component.get(CONF_PATH),
-            )
-    elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
-        cg.add_platformio_option("framework", "arduino")
-        cg.add_build_flag("-DUSE_ARDUINO")
-        cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
-        cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
+    add_idf_sdkconfig_option(f"CONFIG_LOG_DEFAULT_LEVEL_{conf[CONF_LOG_LEVEL]}", True)
 
-        if CONF_PARTITIONS in config:
-            cg.add_platformio_option("board_build.partitions", config[CONF_PARTITIONS])
-        else:
-            cg.add_platformio_option("board_build.partitions", "partitions.csv")
+    for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
+        add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 
-        cg.add_define(
-            "USE_ARDUINO_VERSION_CODE",
-            cg.RawExpression(
-                f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
-            ),
+    for component in conf[CONF_COMPONENTS]:
+        add_idf_component(
+            name=component[CONF_NAME],
+            repo=component.get(CONF_SOURCE),
+            ref=component.get(CONF_REF),
+            path=component.get(CONF_PATH),
         )
-        cg.add(RawExpression(f"setCpuFrequencyMhz({freq})"))
 
 
 APP_PARTITION_SIZES = {
@@ -1056,13 +974,14 @@ def _write_sdkconfig():
         )
         + "\n"
     )
+
     if write_file_if_changed(internal_path, contents):
         # internal changed, update real one
         write_file_if_changed(sdk_path, contents)
 
 
 def _write_idf_component_yml():
-    yml_path = Path(CORE.relative_build_path("src/idf_component.yml"))
+    yml_path = CORE.relative_build_path("src/idf_component.yml")
     if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
         components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
         dependencies = {}
@@ -1080,51 +999,48 @@ def _write_idf_component_yml():
         contents = ""
     if write_file_if_changed(yml_path, contents):
         dependencies_lock = CORE.relative_build_path("dependencies.lock")
-        if os.path.isfile(dependencies_lock):
-            os.remove(dependencies_lock)
+        if dependencies_lock.is_file():
+            dependencies_lock.unlink()
         clean_cmake_cache()
 
 
 # Called by writer.py
 def copy_files():
-    if (
-        CORE.using_arduino
-        and "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]
-    ):
-        write_file_if_changed(
-            CORE.relative_build_path("partitions.csv"),
-            get_arduino_partition_csv(
-                CORE.platformio_options.get("board_upload.flash_size")
-            ),
-        )
-    if CORE.using_esp_idf:
-        _write_sdkconfig()
-        _write_idf_component_yml()
-        if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
+    _write_sdkconfig()
+    _write_idf_component_yml()
+
+    if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
+        if CORE.using_arduino:
+            write_file_if_changed(
+                CORE.relative_build_path("partitions.csv"),
+                get_arduino_partition_csv(
+                    CORE.platformio_options.get("board_upload.flash_size")
+                ),
+            )
+        else:
             write_file_if_changed(
                 CORE.relative_build_path("partitions.csv"),
                 get_idf_partition_csv(
                     CORE.platformio_options.get("board_upload.flash_size")
                 ),
             )
-        # IDF build scripts look for version string to put in the build.
-        # However, if the build path does not have an initialized git repo,
-        # and no version.txt file exists, the CMake script fails for some setups.
-        # Fix by manually pasting a version.txt file, containing the ESPHome version
-        write_file_if_changed(
-            CORE.relative_build_path("version.txt"),
-            __version__,
-        )
+    # IDF build scripts look for version string to put in the build.
+    # However, if the build path does not have an initialized git repo,
+    # and no version.txt file exists, the CMake script fails for some setups.
+    # Fix by manually pasting a version.txt file, containing the ESPHome version
+    write_file_if_changed(
+        CORE.relative_build_path("version.txt"),
+        __version__,
+    )
 
     for file in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES].values():
-        if file[KEY_PATH].startswith("http"):
+        name: str = file[KEY_NAME]
+        path: Path = file[KEY_PATH]
+        if str(path).startswith("http"):
             import requests
 
-            mkdir_p(CORE.relative_build_path(os.path.dirname(file[KEY_NAME])))
-            with open(CORE.relative_build_path(file[KEY_NAME]), "wb") as f:
-                f.write(requests.get(file[KEY_PATH], timeout=30).content)
+            CORE.relative_build_path(name).parent.mkdir(parents=True, exist_ok=True)
+            content = requests.get(path, timeout=30).content
+            CORE.relative_build_path(name).write_bytes(content)
         else:
-            copy_file_if_changed(
-                file[KEY_PATH],
-                CORE.relative_build_path(file[KEY_NAME]),
-            )
+            copy_file_if_changed(path, CORE.relative_build_path(name))