Pick the nRF52 ELF layout by SDK version

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

AGENTS.md

@@ -737,7 +737,9 @@ file does, and it is the authority when they disagree. The most useful starting
 
         6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
 
-        7. **Detection:** Look for these patterns in compiler output:
+        7. **Never use `new (std::nothrow)`:** On ESP-IDF exceptions are disabled, so a failed nothrow allocation aborts instead of returning `nullptr`. Use `RAMAllocator` from `esphome/core/helpers.h`; CI rejects `std::nothrow`.
+
+        8. **Detection:** Look for these patterns in compiler output:
            - Large code sections with STL symbols (vector, map, set)
            - `alloc`, `realloc`, `dealloc` in symbol names
            - `_M_realloc_insert`, `_M_default_append` (vector reallocation)

CODEOWNERS

@@ -422,6 +422,7 @@ esphome/components/pn7150_i2c/* @jesserockz @kbx81
 esphome/components/pn7160/* @jesserockz @kbx81
 esphome/components/pn7160_i2c/* @jesserockz @kbx81
 esphome/components/pn7160_spi/* @jesserockz @kbx81
+esphome/components/pn71xx/* @jesserockz @kbx81
 esphome/components/power_supply/* @esphome/core
 esphome/components/preferences/* @esphome/core
 esphome/components/provisioning/* @esphome/core
@@ -429,6 +430,7 @@ esphome/components/psram/* @esphome/core
 esphome/components/pulse_meter/* @cstaahl @stevebaxter @TrentHouliston
 esphome/components/pvvx_mithermometer/* @pasiz
 esphome/components/pylontech/* @functionpointer
+esphome/components/pzem6l24/* @nuttytree
 esphome/components/qmi8658/* @clydebarrow
 esphome/components/qmp6988/* @andrewpc
 esphome/components/qr_code/* @wjtje
@@ -548,6 +550,7 @@ esphome/components/sx126x/* @swoboda1337
 esphome/components/sx127x/* @swoboda1337
 esphome/components/sy6970/* @linkedupbits
 esphome/components/syslog/* @clydebarrow
+esphome/components/systa_bus/* @Mat931
 esphome/components/t6615/* @tylermenezes
 esphome/components/tas2780/* @remcom
 esphome/components/tc74/* @sethgirvan
@@ -562,6 +565,7 @@ esphome/components/template/datetime/* @rfdarter
 esphome/components/template/event/* @nohat
 esphome/components/template/fan/* @ssieb
 esphome/components/text/* @mauritskorse
+esphome/components/tfluna/* @candrews
 esphome/components/thermopro_ble/* @sittner
 esphome/components/thermostat/* @kbx81
 esphome/components/time/* @esphome/core
@@ -638,6 +642,7 @@ esphome/components/wts01/* @alepee
 esphome/components/x9c/* @EtienneMD
 esphome/components/xdb401/* @RT530
 esphome/components/xgzp68xx/* @gcormier
+esphome/components/xiaomi_body_scale/* @dckiller51
 esphome/components/xiaomi_hhccjcy10/* @fariouche
 esphome/components/xiaomi_lywsd02mmc/* @juanluss31
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.15.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.16.0
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/__main__.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Protocol
 # cause them to be loaded before external components are processed, resulting
 # in the built-in version being used instead of the external component one.
 from esphome import const, platform_hooks
+from esphome.build_helpers.native import analysis_backend, native_backend
 from esphome.const import (
     ALLOWED_NAME_CHARS,
     ARGUMENT_HELP_DEVICE,
@@ -817,7 +818,9 @@ def write_cpp_file() -> int:
         from esphome.build_gen import espidf
 
         espidf.write_project()
-    else:
+    elif not CORE.using_native_toolchain:
+        # Other native builds generate their project at compile time;
+        # never write a platformio.ini for them
         from esphome.build_gen import platformio
 
         platformio.write_project()
@@ -859,20 +862,14 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
         toolchain.create_factory_bin()
         toolchain.create_ota_bin()
         toolchain.create_elf_copy()
-        from esphome.build_helpers.idedata import IDEDATA_BEST_EFFORT_ERRORS
+        from esphome.build_helpers.idedata import warn_if_idedata_missing
 
-        try:
-            if toolchain.get_idedata() is None:
-                _LOGGER.warning("No idedata was generated for this build")
-        except IDEDATA_BEST_EFFORT_ERRORS as err:
-            # The firmware already built; an idedata failure must not fail
-            # a successful build.
-            _LOGGER.warning(
-                "Could not generate idedata: %s (IDE, clang-tidy, and "
-                "memory-analysis data will be unavailable for this build)",
-                err,
-            )
-            _LOGGER.debug("Idedata failure detail", exc_info=True)
+        warn_if_idedata_missing(toolchain.get_idedata)
+    elif CORE.using_native_toolchain:
+        raise EsphomeError(
+            f"Toolchain '{CORE.toolchain.value}' resolved but no platform "
+            "backend claimed the build"
+        )
     else:
         from esphome.platformio import toolchain
 
@@ -975,12 +972,15 @@ def upload_using_esptool(
 
     if file is not None:
         flash_images = [FlashImage(path=file, offset="0x0")]
-    elif CORE.using_toolchain_esp_idf:
-        from esphome.espidf import toolchain
-
-        flash_images = [
-            FlashImage(path=toolchain.get_factory_firmware_path(), offset="0x0")
-        ]
+    elif (native := native_backend()) is not None:
+        # Every native backend supplies its own 0x0 flash image (bootloader
+        # and partitions included where the target needs them)
+        image = native.get_factory_firmware_path()
+        if not image.is_file():
+            raise EsphomeError(
+                f"{image} does not exist; compile the configuration first"
+            )
+        flash_images = [FlashImage(path=image, offset="0x0")]
     else:
         from esphome.platformio import toolchain
 
@@ -1343,8 +1343,12 @@ def _upload_via_native_api(
     # fall back to a plaintext upload
     noise_psk = None
     plaintext_fallback = False
+    allow_plaintext_upload = False
     if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None:
         noise_psk = encryption_conf.get(CONF_KEY)
+        allow_plaintext_upload = bool(
+            encryption_conf.get(espota2.CONF_ALLOW_PLAINTEXT_UPLOAD)
+        )
         if not noise_psk:
             raise EsphomeError(
                 "OTA encryption is configured but no key was resolved; "
@@ -1395,6 +1399,7 @@ def _upload_via_native_api(
         ota_type,
         noise_psk,
         plaintext_fallback=plaintext_fallback,
+        allow_plaintext_upload=allow_plaintext_upload,
     )
 
 
@@ -1965,12 +1970,12 @@ def command_update_all(args: ArgsProtocol) -> int | None:
 def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
     import json
 
-    if CORE.using_toolchain_esp_idf:
-        # Native ESP-IDF derives idedata from the build's compile_commands.json,
-        # so the configuration must already be compiled.
-        from esphome.espidf import toolchain as espidf_toolchain
+    native_toolchain = native_backend()
 
-        idedata = espidf_toolchain.get_idedata()
+    if native_toolchain is not None:
+        # Native toolchains derive idedata from the build's
+        # compile_commands.json, so the configuration must already be compiled.
+        idedata = native_toolchain.get_idedata()
         if idedata is None:
             _LOGGER.error(
                 "No idedata available; compile the configuration first",
@@ -2009,6 +2014,17 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
     from esphome.analyze_memory.cli import MemoryAnalyzerCLI
     from esphome.analyze_memory.ram_strings import RamStringsAnalyzer
 
+    # Refuse an unsupported toolchain before paying for a full compile
+    analysis_toolchain = analysis_backend()
+    if analysis_toolchain is None and not CORE.using_toolchain_platformio:
+        _LOGGER.error(
+            "analyze-memory is not supported with the '%s' toolchain on %s; "
+            "re-run with --toolchain platformio",
+            CORE.toolchain.value if CORE.toolchain else "unresolved",
+            CORE.target_platform,
+        )
+        return 1
+
     # Always compile to ensure fresh data (fast if no changes - just relinks)
     exit_code = write_cpp(config)
     if exit_code != 0:
@@ -2020,13 +2036,30 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
 
     # Get idedata for analysis
     idedata = None
-    if CORE.using_toolchain_esp_idf:
-        from esphome.espidf import toolchain
+    if analysis_toolchain is not None:
+        objdump = analysis_toolchain.get_objdump_path()
+        readelf = analysis_toolchain.get_readelf_path()
+        for tool in (objdump, readelf):
+            if not tool.is_file():
+                # The analyzer would silently fall back to host
+                # binutils, which cannot read the target ELF
+                _LOGGER.error(
+                    "%s is missing; the toolchain install may be incomplete "
+                    "(recompile, or run 'esphome clean-all' if it persists)",
+                    tool,
+                )
+                return 1
+        objdump_path = str(objdump)
+        readelf_path = str(readelf)
 
-        objdump_path = str(toolchain.get_objdump_path())
-        readelf_path = str(toolchain.get_readelf_path())
-
-        firmware_elf = toolchain.get_elf_path()
+        firmware_elf = analysis_toolchain.get_elf_path()
+        if not firmware_elf.is_file():
+            # The analyzer swallows tool failures, so a missing ELF would
+            # produce an exit-0 zeroed report
+            _LOGGER.error(
+                "%s is missing; compile the configuration first", firmware_elf
+            )
+            return 1
     else:
         from esphome.platformio import toolchain
 

esphome/analyze_memory/toolchain.py

@@ -68,12 +68,16 @@ def idedata_candidates(build_path: Path) -> list[Path]:
         The candidate idedata JSON paths, most specific first
     """
     name = build_path.name
+    data_dir = build_path.parent.parent / "idedata"
+    # Native backends suffix the cache by toolchain (<name>.arduino.json)
+    suffixed = sorted(data_dir.glob(f"{name}.*.json")) if data_dir.is_dir() else []
     return [
         # In .pioenvs for test builds
         build_path / ".pioenvs" / name / "idedata.json",
         # Both toolchains cache it in the data dir, which holds this build dir:
         # <data_dir>/idedata/<name>.json next to <data_dir>/build/<name>
         build_path.parent.parent / "idedata" / f"{name}.json",
+        *suffixed,
         # Regular builds, invoked from the config dir or from anywhere
         Path.cwd() / ".esphome" / "idedata" / f"{name}.json",
         Path.home() / ".esphome" / "idedata" / f"{name}.json",

esphome/arduino8266/toolchain.py

@@ -0,0 +1,266 @@
+"""Native Arduino ESP8266 build driver (the PlatformIO ``run`` equivalent)."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+import subprocess
+from typing import TYPE_CHECKING
+
+from esphome.build_helpers.ccache import resolve_ccache_path
+from esphome.const import (
+    CONF_COMPILE_PROCESS_LIMIT,
+    CONF_ESPHOME,
+    KEY_CORE,
+    KEY_FRAMEWORK_VERSION,
+)
+from esphome.core import CORE, EsphomeError
+from esphome.helpers import write_file
+from esphome.types import ConfigType
+
+if TYPE_CHECKING:
+    from esphome.arduino8266.framework import InstalledPaths
+
+_LOGGER = logging.getLogger(__name__)
+
+# ESP8266 user RAM (matches upload.maximum_ram_size in every board manifest)
+_MAX_RAM_SIZE = 81920
+
+
+def _warn_ignored_platformio_options() -> None:
+    """Warn for component-added platformio options the native build drops."""
+    from esphome.core.config import NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS
+
+    consumed = NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS
+    for key in sorted(CORE.platformio_options or {}):
+        if key not in consumed:
+            _LOGGER.warning(
+                "platformio_options->%s is ignored when building with the "
+                "native 'arduino' toolchain",
+                key,
+            )
+
+
+_RAM_SECTIONS = (".data", ".rodata", ".bss")
+_FLASH_SECTIONS = (".irom0.text", ".text", ".text1", ".data", ".rodata")
+
+
+def get_build_dir() -> Path:
+    return CORE.relative_pioenvs_path(CORE.name)
+
+
+def get_elf_path() -> Path:
+    return get_build_dir() / "firmware.elf"
+
+
+def _toolchain_tool(name: str) -> Path:
+    # Imported here, not at module scope: the serial upload/logs fast path
+    # resolves this module for its artifact paths alone, and framework
+    # pulls in the whole package-download stack
+    from esphome.arduino8266 import framework
+
+    return framework.toolchain_tool(framework.get_toolchain_path(), name)
+
+
+def get_factory_firmware_path() -> Path:
+    """The image to serial-flash at 0x0 (same bytes as firmware.bin: the
+    8266 factory copy exists for artifact-contract parity, not content)."""
+    return get_build_dir() / "firmware.factory.bin"
+
+
+def get_addr2line_path() -> Path:
+    return _toolchain_tool("addr2line")
+
+
+def get_objdump_path() -> Path:
+    return _toolchain_tool("objdump")
+
+
+def get_readelf_path() -> Path:
+    return _toolchain_tool("readelf")
+
+
+def run_compile(config: ConfigType, verbose: bool) -> int:
+    from esphome.arduino8266 import framework
+    from esphome.build_gen import arduino8266 as build_gen
+
+    _warn_ignored_platformio_options()
+    paths = framework.check_and_install(CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION])
+    # Resolved once: the probe is not free and three consumers need it
+    ccache = resolve_ccache_path()
+    build_gen.write_project(paths, ccache)
+
+    build_dir = get_build_dir()
+    env = framework.get_build_env(paths.toolchain, ccache)
+
+    # The DB is a pure function of build.ninja; regenerate when it is older
+    compdb = build_dir / "compile_commands.json"
+    ninja_file = build_dir / "build.ninja"
+    if not compdb.is_file() or compdb.stat().st_mtime < ninja_file.stat().st_mtime:
+        _write_compile_commands(paths.ninja, build_dir, env)
+
+    cmd = [str(paths.ninja)]
+    if verbose:
+        cmd.append("-v")
+    if jobs := config[CONF_ESPHOME].get(CONF_COMPILE_PROCESS_LIMIT):
+        cmd += ["-j", str(jobs)]
+    # Explicit targets: a generator defect that drops them fails loudly
+    # instead of a green no-op run leaving stale artifacts in place
+    targets = ["firmware.factory.bin", "firmware.ota.bin"]
+    cmd += targets
+
+    # cwd, not -C: drops ninja's "Entering directory" banner
+    _LOGGER.debug("Running: %s", " ".join(cmd))
+    rc = subprocess.run(
+        cmd, cwd=build_dir, env=env, check=False, close_fds=False
+    ).returncode
+    if rc != 0:
+        return rc
+
+    # ninja already refused missing targets; existence covers a rule that
+    # ran but wrote elsewhere
+    build_dir_artifacts = (
+        get_elf_path(),
+        build_dir / "firmware.bin",
+        get_factory_firmware_path(),
+        build_dir / "firmware.ota.bin",
+    )
+    for artifact in build_dir_artifacts:
+        if not artifact.is_file():
+            _LOGGER.error("Build produced no %s", artifact)
+            return 1
+
+    if not _print_size_summary(build_dir, paths):
+        # Cause already warned; name the consequence for CI harnesses
+        _LOGGER.warning("Firmware size summary unavailable for this build")
+    from esphome.build_helpers.idedata import warn_if_idedata_missing
+
+    warn_if_idedata_missing(lambda: get_idedata(ccache))
+    return 0
+
+
+def _write_compile_commands(
+    ninja_path: Path, build_dir: Path, env: dict[str, str]
+) -> None:
+    compdb = build_dir / "compile_commands.json"
+    result = subprocess.run(
+        [str(ninja_path), "-C", str(build_dir), "-t", "compdb", "c", "cxx", "asm"],
+        env=env,
+        capture_output=True,
+        text=True,
+        check=False,
+        close_fds=False,
+    )
+    if result.returncode != 0:
+        # Drop any stale database so consumers (IDE integration, clang-tidy,
+        # the memory analyzer) can't silently read outdated data.
+        compdb.unlink(missing_ok=True)
+        raise EsphomeError(f"Could not generate compile_commands.json: {result.stderr}")
+    try:
+        entries = json.loads(result.stdout)
+    except ValueError as err:
+        compdb.unlink(missing_ok=True)
+        raise EsphomeError(
+            f"ninja produced an unparsable compile database: {err} "
+            f"(output starts {result.stdout[:120]!r})"
+        ) from err
+    if not entries:
+        # compdb exits 0 with [] for unknown rule names; a renamed compile
+        # rule must fail the build, not silently strand every consumer
+        compdb.unlink(missing_ok=True)
+        raise EsphomeError(
+            "ninja produced an empty compile database; the generator's rule "
+            "names no longer match"
+        )
+    write_file(compdb, result.stdout)
+
+
+def _parse_app_size(build_dir: Path, paths: InstalledPaths) -> int | None:
+    """Read the app flash budget (irom0_0_seg length) from the linker script."""
+    from esphome.build_gen.arduino8266 import get_flash_ld_path
+    from esphome.components.esp8266.build_surgery import segment_length
+
+    # Warnings, not debug: without the app size the Flash summary line is
+    # dropped and CI's memory-impact extraction loses its flash metric.
+    ld_path = get_flash_ld_path(build_dir, paths)
+    try:
+        ld_text = ld_path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as err:
+        # A corrupt script degrades the same way, never aborts the build
+        _LOGGER.warning("Cannot read linker script for the Flash summary: %s", err)
+        return None
+    if not (app_size := segment_length(ld_text, "irom0_0_seg")):
+        _LOGGER.warning("No usable irom0_0_seg in %s; skipping Flash summary", ld_path)
+        return None
+    return app_size
+
+
+def _print_size_summary(build_dir: Path, paths: InstalledPaths) -> bool:
+    """Print the RAM/Flash lines ``ci_memory_impact_extract.py`` parses;
+    False when skipped."""
+    from esphome.arduino8266.framework import toolchain_tool
+    from esphome.build_helpers.size_summary import print_size_line
+
+    try:
+        result = subprocess.run(
+            [
+                str(toolchain_tool(paths.toolchain, "size")),
+                "-A",
+                "-d",
+                str(build_dir / "firmware.elf"),
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+            close_fds=False,
+        )
+    except (OSError, subprocess.CalledProcessError) as err:
+        # The summary is a bonus artifact like idedata; a truncated
+        # toolchain extraction must not discard an already-linked build
+        _LOGGER.warning("Could not summarize firmware size: %s", err)
+        return False
+    # -d prints decimal sizes; anything else trips the missing-sections guard
+    sections = {
+        parts[0]: int(parts[1])
+        for line in result.stdout.splitlines()
+        if (parts := line.split())[:1] and parts[0].startswith(".") and len(parts) >= 2
+        if parts[1].isdigit()
+    }
+    if missing := set(_RAM_SECTIONS + _FLASH_SECTIONS) - set(sections):
+        # A defaulted 0 would print a confidently wrong total for CI's metric
+        _LOGGER.warning(
+            "Size output is missing section(s) %s; skipping the size summary",
+            ", ".join(sorted(missing)),
+        )
+        return False
+    # Resolve the flash budget before printing: a RAM line without its
+    # Flash line would skew CI's memory-impact extraction
+    app_size = _parse_app_size(build_dir, paths)
+    if not app_size:
+        return False
+    ram = sum(sections[s] for s in _RAM_SECTIONS)
+    flash = sum(sections[s] for s in _FLASH_SECTIONS)
+    print_size_line("RAM", ram, _MAX_RAM_SIZE)
+    print_size_line("Flash", flash, app_size)
+    return True
+
+
+def get_idedata(ccache: str | None = None) -> dict | None:
+    """Derive idedata from the build's compile_commands.json (same
+    contract as ``espidf.toolchain.get_idedata``)."""
+    from esphome.build_helpers.idedata import load_or_build_idedata
+
+    # A disabled ccache resolves to None without spawning anything, so
+    # re-resolving here costs nothing when the caller has no answer
+    launcher = ccache or resolve_ccache_path()
+    return load_or_build_idedata(
+        get_build_dir() / "compile_commands.json",
+        get_elf_path(),
+        # Suffixed so a platformio->arduino->platformio round trip on one
+        # config never serves the other toolchain's cache shape
+        CORE.relative_internal_path("idedata", f"{CORE.name}.arduino.json"),
+        # The compile DB's commands carry the same ccache prefix the ninja
+        # rules were generated with
+        launcher=str(launcher) if launcher else None,
+    )

esphome/automation.py

@@ -239,9 +239,9 @@ class ApplyCall:
 
     Each arg is ``(conf_key, type_)`` or ``(conf_key, type_, const_fn)``. A ``conf_key`` may be a
     path into nested sections. A plain ``str`` ``type_`` is raw C++ type text and may use
-    ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda bypasses
-    it. The statement is skipped when none of its keys is set, always emitted when it has no
-    keys, and a partial set is a config error.
+    ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda or an
+    id bypasses it. The statement is skipped when none of its keys is set, always emitted when it
+    has no keys, and a partial set is a config error.
     """
 
     target: str
@@ -280,8 +280,8 @@ class ApplyField:
     Double a literal brace in a template. ``conf_key`` may be a path into nested sections.
     ``type_`` may be a C++ type string using ``{parent}`` when the type is only known per
     instance. ``const_fn(config, value)`` renders a constant's argument text when ``cg.safe_exp``
-    is not the right spelling (unit conversion belongs in the validator); a lambda bypasses it,
-    so the target must also take a plain ``type_``. An absent key emits nothing.
+    is not the right spelling (unit conversion belongs in the validator); a lambda or an id
+    bypasses it, so the target must also take a plain ``type_``. An absent key emits nothing.
     """
 
     conf_key: str | tuple[str, ...]
@@ -380,6 +380,9 @@ async def _render_values(
             expr = call_lambda(inner)
             bare = compare and isinstance(expr, cg.RawExpression)
             exprs.append(f"({expr})" if bare else str(expr))
+        elif isinstance(value, ID):
+            # Qualified like the parent, so a trigger arg named like the id cannot shadow it.
+            exprs.append(f"::{await cg.get_variable(value)}")
         elif const_fn is not None:
             exprs.append(const_fn(config, value))
         else:
@@ -402,6 +405,7 @@ def register_apply_action(
 
     Generates one stateless function for ``ApplyAction<Ts...>``: the parent (read from
     ``id_key``) and constants are baked in, lambdas are called inline with the trigger args.
+    A constant that is an id (``cv.use_id`` under ``cv.templatable``) is the object it names.
     With ``call`` every statement targets the call object ``auto apply_call = parent->call()``,
     and ``apply_call.perform()`` is appended.
     """

esphome/build_gen/arduino8266.py

@@ -1132,7 +1132,8 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
         "rule elf2bin",
         # --flash_size deliberately stays board-derived, as under
         # PlatformIO (which reads upload.maximum_size, not the ldscript).
-        f"  command = $python {_q(framework / 'tools' / 'elf2bin.py')} --eboot {_q(framework / 'bootloaders' / 'eboot' / 'eboot.elf')} --app $in --flash_mode {flash_mode} --flash_freq {_FLASH_FREQ_MHZ} --flash_size {_flash_size_str(BOARDS[board][KEY_FLASH_SIZE])} --path {_q(toolchain_bin)} --out $out",
+        # -W: the framework's own elf2bin.py trips SyntaxWarning on 3.12+.
+        f"  command = $python -W ignore::SyntaxWarning {_q(framework / 'tools' / 'elf2bin.py')} --eboot {_q(framework / 'bootloaders' / 'eboot' / 'eboot.elf')} --app $in --flash_mode {flash_mode} --flash_freq {_FLASH_FREQ_MHZ} --flash_size {_flash_size_str(BOARDS[board][KEY_FLASH_SIZE])} --path {_q(toolchain_bin)} --out $out",
         "  description = BIN $out",
         "rule copy",
         "  command = $python $buildtool copy $in $out",

esphome/build_helpers/idedata.py

@@ -11,6 +11,7 @@ consumers (IDE integration, clang-tidy) expect:
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import json
 import logging
 import os
@@ -21,6 +22,8 @@ import subprocess
 from esphome.core import EsphomeError
 from esphome.helpers import write_file
 
+_LOGGER = logging.getLogger(__name__)
+
 # Everything idedata generation may raise after a successful link; idedata
 # is a bonus artifact, so consumers warn instead of failing the build
 IDEDATA_BEST_EFFORT_ERRORS = (
@@ -31,7 +34,21 @@ IDEDATA_BEST_EFFORT_ERRORS = (
     ValueError,
 )
 
-_LOGGER = logging.getLogger(__name__)
+
+def warn_if_idedata_missing(get_idedata: Callable[[], dict | None]) -> None:
+    """Run an idedata generator, downgrading any failure to a warning:
+    the firmware already built."""
+    try:
+        if get_idedata() is None:
+            _LOGGER.warning("No idedata was generated for this build")
+    except IDEDATA_BEST_EFFORT_ERRORS as err:
+        _LOGGER.warning(
+            "Could not generate idedata: %s (IDE, clang-tidy, and "
+            "memory-analysis data will be unavailable for this build)",
+            err,
+        )
+        _LOGGER.debug("Idedata failure detail", exc_info=True)
+
 
 # C++ translation-unit suffixes used to identify ESPHome source files.
 _CXX_SUFFIXES = (".cpp", ".cc")

esphome/build_helpers/native.py

@@ -0,0 +1,52 @@
+"""Resolution of the native (non-PlatformIO) build backend for a config.
+
+Kept deliberately light: the serial upload and logs fast path resolves a
+backend for its artifact paths alone, so importing this must not pull in a
+platform component package or the backend itself.
+"""
+
+from __future__ import annotations
+
+import importlib
+from types import ModuleType
+
+from esphome.const import Toolchain
+from esphome.core import CORE, EsphomeError
+
+# Native build backend per (target platform, toolchain)
+NATIVE_TOOLCHAIN_MODULES = {
+    ("esp32", Toolchain.ESP_IDF): "esphome.espidf.toolchain",
+    ("esp8266", Toolchain.ARDUINO): "esphome.arduino8266.toolchain",
+}
+
+
+def native_backend() -> ModuleType | None:
+    """The native build backend module for the resolved toolchain."""
+    if not CORE.using_native_toolchain:
+        return None
+    key = (CORE.target_platform, CORE.toolchain)
+    if (module_path := NATIVE_TOOLCHAIN_MODULES.get(key)) is None:
+        # Degrading to the PlatformIO path would build with the wrong backend
+        raise EsphomeError(
+            f"Toolchain '{CORE.toolchain.value}' has no native build backend "
+            f"module for platform {CORE.target_platform}"
+        )
+    return importlib.import_module(module_path)
+
+
+# Binutils and the linked image for memory analysis, for toolchains that build
+# without PlatformIO but have no native build backend (which supplies them)
+ANALYSIS_TOOLCHAIN_MODULES = {
+    ("nrf52", Toolchain.SDK_NRF): "esphome.components.nrf52.toolchain",
+}
+
+
+def analysis_backend() -> ModuleType | None:
+    """The module giving objdump, readelf and the ELF of a non-PlatformIO build.
+
+    None means PlatformIO's idedata supplies them (or nothing can).
+    """
+    if (native := native_backend()) is not None:
+        return native
+    module_path = ANALYSIS_TOOLCHAIN_MODULES.get((CORE.target_platform, CORE.toolchain))
+    return importlib.import_module(module_path) if module_path else None

esphome/components/ags10/ags10.cpp

@@ -106,6 +106,20 @@ bool AGS10Component::set_zero_point_with_factory_defaults() { return this->set_z
 
 bool AGS10Component::set_zero_point_with_current_resistance() { return this->set_zero_point_with(ZP_CURRENT); }
 
+void AGS10Component::set_zero_point(AGS10SetZeroPointActionMode mode, uint16_t value) {
+  switch (mode) {
+    case FACTORY_DEFAULT:
+      this->set_zero_point_with_factory_defaults();
+      break;
+    case CURRENT_VALUE:
+      this->set_zero_point_with_current_resistance();
+      break;
+    case CUSTOM_VALUE:
+      this->set_zero_point_with(value);
+      break;
+  }
+}
+
 bool AGS10Component::set_zero_point_with(uint16_t value) {
   std::array<uint8_t, 5> data{0x00, 0x0C, (uint8_t) ((value >> 8) & 0xFF), (uint8_t) (value & 0xFF), 0};
   data[4] = crc8(data.data(), 4, 0xFF, 0x31, true);

esphome/components/ags10/ags10.h

@@ -2,11 +2,19 @@
 
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/sensor/sensor.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 
 namespace esphome::ags10 {
 
+enum AGS10SetZeroPointActionMode {
+  // Zero-point reset.
+  FACTORY_DEFAULT,
+  // Zero-point calibration with current resistance.
+  CURRENT_VALUE,
+  // Zero-point calibration with custom resistance.
+  CUSTOM_VALUE,
+};
+
 class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
  public:
   /**
@@ -47,6 +55,11 @@ class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
    */
   bool set_zero_point_with_current_resistance();
 
+  /**
+   * Sets zero-point by mode; the value is only used for CUSTOM_VALUE.
+   */
+  void set_zero_point(AGS10SetZeroPointActionMode mode, uint16_t value);
+
   /**
    * Sets zero-point with the value.
    */
@@ -100,39 +113,4 @@ class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
   template<size_t N> optional<std::array<uint8_t, N>> read_and_check_(uint8_t a_register);
 };
 
-template<typename... Ts> class AGS10NewI2cAddressAction final : public Action<Ts...>, public Parented<AGS10Component> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, new_address)
-
-  void play(const Ts &...x) override { this->parent_->new_i2c_address(this->new_address_.value(x...)); }
-};
-
-enum AGS10SetZeroPointActionMode {
-  // Zero-point reset.
-  FACTORY_DEFAULT,
-  // Zero-point calibration with current resistance.
-  CURRENT_VALUE,
-  // Zero-point calibration with custom resistance.
-  CUSTOM_VALUE,
-};
-
-template<typename... Ts> class AGS10SetZeroPointAction final : public Action<Ts...>, public Parented<AGS10Component> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, value)
-  TEMPLATABLE_VALUE(AGS10SetZeroPointActionMode, mode)
-
-  void play(const Ts &...x) override {
-    switch (this->mode_.value(x...)) {
-      case FACTORY_DEFAULT:
-        this->parent_->set_zero_point_with_factory_defaults();
-        break;
-      case CURRENT_VALUE:
-        this->parent_->set_zero_point_with_current_resistance();
-        break;
-      case CUSTOM_VALUE:
-        this->parent_->set_zero_point_with(this->value_.value(x...));
-        break;
-    }
-  }
-};
 }  // namespace esphome::ags10

esphome/components/ags10/sensor.py

@@ -17,8 +17,6 @@ from esphome.const import (
     UNIT_OHM,
     UNIT_PARTS_PER_BILLION,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CONF_RESISTANCE = "resistance"
@@ -28,12 +26,6 @@ DEPENDENCIES = ["i2c"]
 ags10_ns = cg.esphome_ns.namespace("ags10")
 AGS10Component = ags10_ns.class_("AGS10Component", cg.PollingComponent, i2c.I2CDevice)
 
-# Actions
-AGS10NewI2cAddressAction = ags10_ns.class_(
-    "AGS10NewI2cAddressAction", automation.Action
-)
-AGS10SetZeroPointAction = ags10_ns.class_("AGS10SetZeroPointAction", automation.Action)
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -91,24 +83,11 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "ags10.new_i2c_address",
-    AGS10NewI2cAddressAction,
     AGS10_NEW_I2C_ADDRESS_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_ADDRESS, "new_i2c_address", cg.uint8),
 )
-async def ags10newi2caddress_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    address = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
-    cg.add(var.set_new_address(address))
-    return var
-
 
 AGS10SetZeroPointActionMode = ags10_ns.enum("AGS10SetZeroPointActionMode")
 AGS10_SET_ZERO_POINT_ACTION_MODE = {
@@ -128,24 +107,11 @@ AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "ags10.set_zero_point",
-    AGS10SetZeroPointAction,
     AGS10_SET_ZERO_POINT_SCHEMA,
-    synchronous=True,
+    automation.ApplyCall(
+        "set_zero_point({}, {})",
+        ((CONF_MODE, AGS10SetZeroPointActionMode), (CONF_VALUE, cg.uint16)),
+    ),
 )
-async def ags10setzeropoint_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    mode = await cg.templatable(
-        config.get(CONF_MODE), args, AGS10SetZeroPointActionMode
-    )
-    cg.add(var.set_mode(mode))
-    value = await cg.templatable(config[CONF_VALUE], args, cg.uint16)
-    cg.add(var.set_value(value))
-    return var

esphome/components/aic3204/audio_dac.py

@@ -4,8 +4,6 @@ from esphome.components import i2c
 from esphome.components.audio_dac import AudioDac
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MODE
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@kbx81"]
@@ -14,7 +12,6 @@ DEPENDENCIES = ["i2c"]
 aic3204_ns = cg.esphome_ns.namespace("aic3204")
 AIC3204 = aic3204_ns.class_("AIC3204", AudioDac, cg.Component, i2c.I2CDevice)
 
-SetAutoMuteAction = aic3204_ns.class_("SetAutoMuteAction", automation.Action)
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -36,25 +33,11 @@ SET_AUTO_MUTE_ACTION_SCHEMA = cv.maybe_simple_value(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "aic3204.set_auto_mute_mode",
-    SetAutoMuteAction,
     SET_AUTO_MUTE_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_MODE, "set_auto_mute_mode", cg.uint8),
 )
-async def aic3204_set_volume_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config.get(CONF_MODE), args, cg.uint8)
-    cg.add(var.set_auto_mute_mode(template_))
-
-    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/aic3204/automation.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "aic3204.h"
-
-namespace esphome::aic3204 {
-
-template<typename... Ts> class SetAutoMuteAction final : public Action<Ts...> {
- public:
-  explicit SetAutoMuteAction(AIC3204 *aic3204) : aic3204_(aic3204) {}
-
-  TEMPLATABLE_VALUE(uint8_t, auto_mute_mode)
-
-  void play(const Ts &...x) override { this->aic3204_->set_auto_mute_mode(this->auto_mute_mode_.value(x...)); }
-
- protected:
-  AIC3204 *aic3204_;
-};
-
-}  // namespace esphome::aic3204

esphome/components/alarm_control_panel/__init__.py

@@ -41,14 +41,6 @@ StateAnyForwarder = alarm_control_panel_ns.class_("StateAnyForwarder")
 StateEnterForwarder = alarm_control_panel_ns.class_("StateEnterForwarder")
 AlarmControlPanelState = alarm_control_panel_ns.enum("AlarmControlPanelState")
 
-PendingAction = alarm_control_panel_ns.class_("PendingAction", automation.Action)
-TriggeredAction = alarm_control_panel_ns.class_("TriggeredAction", automation.Action)
-ChimeAction = alarm_control_panel_ns.class_("ChimeAction", automation.Action)
-ReadyAction = alarm_control_panel_ns.class_("ReadyAction", automation.Action)
-
-AlarmControlPanelCondition = alarm_control_panel_ns.class_(
-    "AlarmControlPanelCondition", automation.Condition
-)
 
 _ALARM_CONTROL_PANEL_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
@@ -208,65 +200,22 @@ for _name, _arm in (
     )
 
 
-@automation.register_action(
-    "alarm_control_panel.pending",
-    PendingAction,
-    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def alarm_action_pending_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "alarm_control_panel.triggered",
-    TriggeredAction,
-    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def alarm_action_trigger_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "alarm_control_panel.chime",
-    ChimeAction,
-    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def alarm_action_chime_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "alarm_control_panel.ready",
-    ReadyAction,
-    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_condition(
-    "alarm_control_panel.ready",
-    AlarmControlPanelCondition,
-    ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
-)
-async def alarm_action_ready_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_condition(
-    "alarm_control_panel.is_armed",
-    AlarmControlPanelCondition,
-    ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
-)
-async def alarm_control_panel_is_armed_to_code(
-    config, condition_id, template_arg, args
+for _name, _call in (
+    ("alarm_control_panel.pending", "pending()"),
+    ("alarm_control_panel.triggered", "triggered()"),
 ):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(condition_id, template_arg, paren)
+    automation.register_apply_action(
+        _name,
+        ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+        automation.ApplyCall(_call),
+        call="make_call",
+    )
+
+
+for _name in ("alarm_control_panel.ready", "alarm_control_panel.is_armed"):
+    automation.register_apply_condition(
+        _name, ALARM_CONTROL_PANEL_CONDITION_SCHEMA, "is_armed_pending_or_triggered()"
+    )
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -130,6 +130,12 @@ class AlarmControlPanel : public EntityBase {
 
   // is the state one of the armed states
   bool is_state_armed(AlarmControlPanelState state);
+  /// Armed, pending (entry delay) or triggered; not ARMING (exit delay). Backs the is_armed and ready
+  /// conditions.
+  bool is_armed_pending_or_triggered() {
+    auto state = this->get_state();
+    return this->is_state_armed(state) || state == ACP_STATE_PENDING || state == ACP_STATE_TRIGGERED;
+  }
 
  protected:
   friend AlarmControlPanelCall;

esphome/components/alarm_control_panel/automation.h

@@ -27,36 +27,4 @@ static_assert(std::is_trivially_copyable_v<StateAnyForwarder>);
 static_assert(sizeof(StateEnterForwarder<ACP_STATE_TRIGGERED>) <= sizeof(void *));
 static_assert(std::is_trivially_copyable_v<StateEnterForwarder<ACP_STATE_TRIGGERED>>);
 
-template<typename... Ts> class PendingAction final : public Action<Ts...> {
- public:
-  explicit PendingAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
-
-  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().pending().perform(); }
-
- protected:
-  AlarmControlPanel *alarm_control_panel_;
-};
-
-template<typename... Ts> class TriggeredAction final : public Action<Ts...> {
- public:
-  explicit TriggeredAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
-
-  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().triggered().perform(); }
-
- protected:
-  AlarmControlPanel *alarm_control_panel_;
-};
-
-template<typename... Ts> class AlarmControlPanelCondition final : public Condition<Ts...> {
- public:
-  AlarmControlPanelCondition(AlarmControlPanel *parent) : parent_(parent) {}
-  bool check(const Ts &...x) override {
-    return this->parent_->is_state_armed(this->parent_->get_state()) ||
-           this->parent_->get_state() == ACP_STATE_PENDING || this->parent_->get_state() == ACP_STATE_TRIGGERED;
-  }
-
- protected:
-  AlarmControlPanel *parent_;
-};
-
 }  // namespace esphome::alarm_control_panel

esphome/components/animation/animation.h

@@ -1,8 +1,6 @@
 #pragma once
 #include "esphome/components/image/image.h"
 
-#include "esphome/core/automation.h"
-
 namespace esphome::animation {
 
 class Animation final : public image::Image {
@@ -35,32 +33,4 @@ class Animation final : public image::Image {
   int loop_current_iteration_;
 };
 
-template<typename... Ts> class AnimationNextFrameAction final : public Action<Ts...> {
- public:
-  AnimationNextFrameAction(Animation *parent) : parent_(parent) {}
-  void play(const Ts &...x) override { this->parent_->next_frame(); }
-
- protected:
-  Animation *parent_;
-};
-
-template<typename... Ts> class AnimationPrevFrameAction final : public Action<Ts...> {
- public:
-  AnimationPrevFrameAction(Animation *parent) : parent_(parent) {}
-  void play(const Ts &...x) override { this->parent_->prev_frame(); }
-
- protected:
-  Animation *parent_;
-};
-
-template<typename... Ts> class AnimationSetFrameAction final : public Action<Ts...> {
- public:
-  AnimationSetFrameAction(Animation *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(uint16_t, frame)
-  void play(const Ts &...x) override { this->parent_->set_frame(this->frame_.value(x...)); }
-
- protected:
-  Animation *parent_;
-};
-
 }  // namespace esphome::animation

esphome/components/animation/image.py

@@ -6,8 +6,6 @@ from esphome.components.file.image import image_schema, write_image
 from esphome.components.image import Image_, validate_settings
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_REPEAT
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@syndlex"]
@@ -26,17 +24,6 @@ animation_ns = cg.esphome_ns.namespace("animation")
 
 Animation_ = animation_ns.class_("Animation", Image_)
 
-# Actions
-NextFrameAction = animation_ns.class_(
-    "AnimationNextFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
-PrevFrameAction = animation_ns.class_(
-    "AnimationPrevFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
-SetFrameAction = animation_ns.class_(
-    "AnimationSetFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
-
 ANIMATION_SCHEMA = image_schema(Animation_).extend(
     {
         cv.Optional(CONF_LOOP): cv.All(
@@ -72,28 +59,17 @@ SET_FRAME_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
-    "animation.next_frame", NextFrameAction, NEXT_FRAME_SCHEMA, synchronous=True
+automation.register_apply_action(
+    "animation.next_frame", NEXT_FRAME_SCHEMA, automation.ApplyCall("next_frame()")
 )
-@automation.register_action(
-    "animation.prev_frame", PrevFrameAction, PREV_FRAME_SCHEMA, synchronous=True
+automation.register_apply_action(
+    "animation.prev_frame", PREV_FRAME_SCHEMA, automation.ApplyCall("prev_frame()")
 )
-@automation.register_action(
-    "animation.set_frame", SetFrameAction, SET_FRAME_SCHEMA, synchronous=True
+automation.register_apply_action(
+    "animation.set_frame",
+    SET_FRAME_SCHEMA,
+    automation.ApplyField(CONF_FRAME, "set_frame", cg.uint16),
 )
-async def animation_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    if (frame := config.get(CONF_FRAME)) is not None:
-        template_ = await cg.templatable(frame, args, cg.uint16)
-        cg.add(var.set_frame(template_))
-    return var
 
 
 async def setup_animation(config: ConfigType) -> None:

esphome/components/api/api.proto

@@ -803,6 +803,9 @@ message SwitchStateResponse {
   fixed32 key = 1 [(force) = true];
   bool state = 2;
   uint32 device_id = 3 [(field_ifdef) = "USE_DEVICES"];
+  // If the switch does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 4;
 }
 message SwitchCommandRequest {
   option (id) = 33;
@@ -1244,6 +1247,9 @@ message ClimateStateResponse {
   float current_humidity = 14;
   float target_humidity = 15;
   uint32 device_id = 16 [(field_ifdef) = "USE_DEVICES"];
+  // If the climate device does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 17;
 }
 message ClimateCommandRequest {
   option (id) = 48;
@@ -1330,6 +1336,9 @@ message WaterHeaterStateResponse {
   uint32 state = 6;
   float target_temperature_low = 7;
   float target_temperature_high = 8;
+  // If the water heater does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 9;
 }
 
 // Bitmask for WaterHeaterCommandRequest.has_fields

esphome/components/api/api_connection.cpp

@@ -709,6 +709,7 @@ uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection
   auto *a_switch = static_cast<switch_::Switch *>(entity);
   SwitchStateResponse resp;
   resp.state = a_switch->state;
+  resp.missing_state = !a_switch->has_state();
   return fill_and_encode_entity_state(a_switch, resp, conn, remaining_size);
 }
 
@@ -754,6 +755,7 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
   auto traits = climate->get_traits();
   resp.mode = static_cast<enums::ClimateMode>(climate->mode);
   resp.action = static_cast<enums::ClimateAction>(climate->action);
+  resp.missing_state = !climate->has_state();
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE))
     resp.current_temperature = climate->current_temperature;
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
@@ -1447,6 +1449,7 @@ uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConne
   auto *wh = static_cast<water_heater::WaterHeater *>(entity);
   WaterHeaterStateResponse resp;
   resp.mode = static_cast<enums::WaterHeaterMode>(wh->get_mode());
+  resp.missing_state = !wh->has_state();
   resp.current_temperature = wh->get_current_temperature();
   resp.target_temperature = wh->get_target_temperature();
   resp.target_temperature_low = wh->get_target_temperature_low();

esphome/components/api/api_pb2.cpp

@@ -938,6 +938,7 @@ uint8_t *SwitchStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buf
 #ifdef USE_DEVICES
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.missing_state);
   return pos;
 }
 uint32_t SwitchStateResponse::calc_size_msg(const void *self) {
@@ -948,6 +949,7 @@ uint32_t SwitchStateResponse::calc_size_msg(const void *self) {
 #ifdef USE_DEVICES
   size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
+  size += ProtoSize::calc_bool(1, msg.missing_state);
   return size;
 }
 void SwitchCommandRequest::decode_field(void *self, uint32_t tag, const uint8_t *data, proto_varint_value_t scalar) {
@@ -1630,6 +1632,7 @@ uint8_t *ClimateStateResponse::encode_msg(const void *self, ProtoWriteBuffer &bu
 #ifdef USE_DEVICES
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 16, msg.device_id);
 #endif
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 17, msg.missing_state);
   return pos;
 }
 uint32_t ClimateStateResponse::calc_size_msg(const void *self) {
@@ -1652,6 +1655,7 @@ uint32_t ClimateStateResponse::calc_size_msg(const void *self) {
 #ifdef USE_DEVICES
   size += ProtoSize::calc_uint32(2, msg.device_id);
 #endif
+  size += ProtoSize::calc_bool(2, msg.missing_state);
   return size;
 }
 void ClimateCommandRequest::decode_field(void *self, uint32_t tag, const uint8_t *data, proto_varint_value_t scalar) {
@@ -1806,6 +1810,7 @@ uint8_t *WaterHeaterStateResponse::encode_msg(const void *self, ProtoWriteBuffer
   if (uint32_t raw = float_to_raw(msg.target_temperature_high); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.missing_state);
   return pos;
 }
 uint32_t WaterHeaterStateResponse::calc_size_msg(const void *self) {
@@ -1821,6 +1826,7 @@ uint32_t WaterHeaterStateResponse::calc_size_msg(const void *self) {
   size += ProtoSize::calc_uint32(1, msg.state);
   size += ProtoSize::calc_float(1, msg.target_temperature_low);
   size += ProtoSize::calc_float(1, msg.target_temperature_high);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
   return size;
 }
 void WaterHeaterCommandRequest::decode_field(void *self, uint32_t tag, const uint8_t *data,

esphome/components/api/api_pb2.h

@@ -1109,11 +1109,12 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
 class SwitchStateResponse final : public StateResponseProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 26;
-  static constexpr uint8_t ESTIMATED_SIZE = 11;
+  static constexpr uint8_t ESTIMATED_SIZE = 13;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("switch_state_response"); }
 #endif
   bool state{false};
+  bool missing_state{false};
   static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
@@ -1690,7 +1691,7 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
 class ClimateStateResponse final : public StateResponseProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 47;
-  static constexpr uint8_t ESTIMATED_SIZE = 68;
+  static constexpr uint8_t ESTIMATED_SIZE = 71;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("climate_state_response"); }
 #endif
@@ -1707,6 +1708,7 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
   StringRef custom_preset{nullptr, 0};  // null until set, encode only
   float current_humidity{0.0f};
   float target_humidity{0.0f};
+  bool missing_state{false};
   static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
@@ -1786,7 +1788,7 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
 class WaterHeaterStateResponse final : public StateResponseProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 133;
-  static constexpr uint8_t ESTIMATED_SIZE = 35;
+  static constexpr uint8_t ESTIMATED_SIZE = 37;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("water_heater_state_response"); }
 #endif
@@ -1796,6 +1798,7 @@ class WaterHeaterStateResponse final : public StateResponseProtoMessage {
   uint32_t state{0};
   float target_temperature_low{0.0f};
   float target_temperature_high{0.0f};
+  bool missing_state{false};
   static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);

esphome/components/api/api_pb2_dump.cpp

@@ -1342,6 +1342,7 @@ const char *SwitchStateResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
   return out.c_str();
 }
 const char *SwitchCommandRequest::dump_to(DumpBuffer &out) const {
@@ -1684,6 +1685,7 @@ const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
   return out.c_str();
 }
 const char *ClimateCommandRequest::dump_to(DumpBuffer &out) const {
@@ -1751,6 +1753,7 @@ const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("state"), this->state);
   dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
   dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
   return out.c_str();
 }
 const char *WaterHeaterCommandRequest::dump_to(DumpBuffer &out) const {

esphome/components/async_tcp/async_tcp_socket.cpp

@@ -6,7 +6,6 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/log.h"
 #include <cerrno>
-#include <sys/select.h>
 
 namespace esphome::async_tcp {
 
@@ -42,7 +41,15 @@ bool AsyncClient::connect(const char *host, uint16_t port) {
     return false;
   }
 
-  socket_->setblocking(false);
+  if (socket_->setblocking(false) != 0) {
+    // Capture before the log and close() clobber errno
+    const int saved_errno = errno;
+    ESP_LOGE(TAG, "Failed to set nonblocking: errno %d", saved_errno);
+    close();
+    if (error_cb_)
+      error_cb_(error_arg_, this, saved_errno);
+    return false;
+  }
 
   int err = socket_->connect((struct sockaddr *) &addr, addrlen);
   if (err == 0) {
@@ -97,45 +104,22 @@ void AsyncClient::loop() {
     return;
 
   if (connecting_) {
-    // For connecting, we need to check writability, not readability
-    // The Application's select() only monitors read FDs, so we do our own check here
-    // For ESP platforms lwip_select() might be faster, but this code isn't used
-    // on those platforms anyway. If it was, we'd fix the Application select()
-    // to report writability instead of doing it this way.
-    int fd = socket_->get_fd();
-    if (fd < 0) {
-      ESP_LOGW(TAG, "Invalid socket fd");
-      close();
-      return;
-    }
-
-    fd_set writefds;
-    FD_ZERO(&writefds);
-    FD_SET(fd, &writefds);
-
-    struct timeval tv = {0, 0};
-    int ret = select(fd + 1, nullptr, &writefds, nullptr, &tv);
-
-    if (ret > 0 && FD_ISSET(fd, &writefds)) {
-      int error = 0;
-      socklen_t len = sizeof(error);
-      if (socket_->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0) {
+    int err = 0;
+    switch (socket::poll_connect(*socket_, err)) {
+      case socket::ConnectPollResult::CONNECT_POLL_RESULT_PENDING:
+        break;
+      case socket::ConnectPollResult::CONNECT_POLL_RESULT_CONNECTED:
         connecting_ = false;
         connected_ = true;
         if (connect_cb_)
           connect_cb_(connect_arg_, this);
-      } else {
-        ESP_LOGW(TAG, "Connection failed: %d", error);
+        break;
+      case socket::ConnectPollResult::CONNECT_POLL_RESULT_ERROR:
+        ESP_LOGW(TAG, "Connection failed: %d", err);
         close();
         if (error_cb_)
-          error_cb_(error_arg_, this, error);
-      }
-    } else if (ret < 0) {
-      const int err = errno;
-      ESP_LOGE(TAG, "Select error: %d", err);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, err);
+          error_cb_(error_arg_, this, err);
+        break;
     }
   } else if (connected_) {
     // For connected sockets, use the Application's select() results

esphome/components/audio_adc/__init__.py

@@ -1,9 +1,8 @@
 from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_MIC_GAIN
-from esphome.core import ID, CoroPriority, coroutine_with_priority
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.const import CONF_MIC_GAIN
+from esphome.core import CoroPriority, coroutine_with_priority
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@kbx81"]
@@ -12,8 +11,6 @@ IS_PLATFORM_COMPONENT = True
 audio_adc_ns = cg.esphome_ns.namespace("audio_adc")
 AudioAdc = audio_adc_ns.class_("AudioAdc")
 
-SetMicGainAction = audio_adc_ns.class_("SetMicGainAction", automation.Action)
-
 
 SET_MIC_GAIN_ACTION_SCHEMA = cv.maybe_simple_value(
     {
@@ -24,25 +21,11 @@ SET_MIC_GAIN_ACTION_SCHEMA = cv.maybe_simple_value(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "audio_adc.set_mic_gain",
-    SetMicGainAction,
     SET_MIC_GAIN_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_MIC_GAIN, "set_mic_gain", cg.float_),
 )
-async def audio_adc_set_mic_gain_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config.get(CONF_MIC_GAIN), args, cg.float_)
-    cg.add(var.set_mic_gain(template_))
-
-    return var
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/audio_adc/automation.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "audio_adc.h"
-
-namespace esphome::audio_adc {
-
-template<typename... Ts> class SetMicGainAction final : public Action<Ts...> {
- public:
-  explicit SetMicGainAction(AudioAdc *audio_adc) : audio_adc_(audio_adc) {}
-
-  TEMPLATABLE_VALUE(float, mic_gain)
-
-  void play(const Ts &...x) override { this->audio_adc_->set_mic_gain(this->mic_gain_.value(x...)); }
-
- protected:
-  AudioAdc *audio_adc_;
-};
-
-}  // namespace esphome::audio_adc

esphome/components/binary_sensor/__init__.py

@@ -134,9 +134,6 @@ MultiClickTriggerBase = binary_sensor_ns.class_(
 MultiClickTrigger = binary_sensor_ns.class_("MultiClickTrigger", MultiClickTriggerBase)
 MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")
 
-BinarySensorInvalidateAction = binary_sensor_ns.class_(
-    "BinarySensorInvalidateAction", automation.Action
-)
 
 # Filters
 Filter = binary_sensor_ns.class_("Filter")
@@ -655,20 +652,16 @@ async def to_code(config):
     cg.add_global(binary_sensor_ns.using)
 
 
-@automation.register_action(
+automation.register_apply_action(
     "binary_sensor.invalidate_state",
-    BinarySensorInvalidateAction,
     cv.maybe_simple_value(
         {
             cv.Required(CONF_ID): cv.use_id(BinarySensor),
         },
         key=CONF_ID,
     ),
-    synchronous=True,
+    automation.ApplyCall("invalidate_state()"),
 )
-async def binary_sensor_invalidate_state_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 # automation.cpp only implements the click/double_click/multi_click triggers

esphome/components/binary_sensor/automation.h

@@ -120,14 +120,4 @@ template<size_t N> class MultiClickTrigger final : public MultiClickTriggerBase
   std::array<MultiClickTriggerEvent, N> timing_storage_{};
 };
 
-template<typename... Ts> class BinarySensorInvalidateAction final : public Action<Ts...> {
- public:
-  explicit BinarySensorInvalidateAction(BinarySensor *sensor) : sensor_(sensor) {}
-
-  void play(const Ts &...x) override { this->sensor_->invalidate_state(); }
-
- protected:
-  BinarySensor *sensor_;
-};
-
 }  // namespace esphome::binary_sensor

esphome/components/bl0906/bl0906.h

@@ -2,7 +2,6 @@
 
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/datatypes.h"
 
@@ -47,8 +46,6 @@ struct sbe24_t {  // NOLINT(readability-identifier-naming,altera-struct-pack-ali
   int8_t h{0};
 } __attribute__((packed));
 
-template<typename... Ts> class ResetEnergyAction;
-
 class BL0906;
 
 using ActionCallbackFuncPtr = void (BL0906::*)();
@@ -85,9 +82,10 @@ class BL0906 final : public PollingComponent, public uart::UARTDevice {
   void setup() override;
   void dump_config() override;
 
- protected:
-  template<typename... Ts> friend class ResetEnergyAction;
+  /// Queue an energy counter reset for the next poll
+  void reset_energy() { this->enqueue_action_(&BL0906::reset_energy_); }
 
+ protected:
   void reset_energy_();
 
   void read_data_(uint8_t address, float reference, sensor::Sensor *sensor);
@@ -103,9 +101,4 @@ class BL0906 final : public PollingComponent, public uart::UARTDevice {
   std::vector<ActionCallbackFuncPtr> action_queue_{};
 };
 
-template<typename... Ts> class ResetEnergyAction final : public Action<Ts...>, public Parented<BL0906> {
- public:
-  void play(const Ts &...x) override { this->parent_->enqueue_action_(&BL0906::reset_energy_); }
-};
-
 }  // namespace esphome::bl0906

esphome/components/bl0906/sensor.py

@@ -32,8 +32,6 @@ from esphome.const import (
     UNIT_VOLT,
     UNIT_WATT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 # Import ICONS not included in esphome's const.py, from the local components const.py
@@ -45,7 +43,6 @@ CONF_TOTAL_ENERGY = "total_energy"
 
 bl0906_ns = cg.esphome_ns.namespace("bl0906")
 BL0906 = bl0906_ns.class_("BL0906", cg.PollingComponent, uart.UARTDevice)
-ResetEnergyAction = bl0906_ns.class_("ResetEnergyAction", automation.Action)
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -138,25 +135,15 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "bl0906.reset_energy",
-    ResetEnergyAction,
     maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(BL0906),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("reset_energy()"),
 )
-async def reset_energy_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/ble_client/__init__.py

@@ -207,26 +207,20 @@ BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
+automation.register_simple_action(
     "ble_client.disconnect",
     BLEDisconnectAction,
     BLE_CONNECT_ACTION_SCHEMA,
     synchronous=False,
 )
-async def ble_disconnect_to_code(config, action_id, template_arg, args):
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
-@automation.register_action(
+automation.register_simple_action(
     "ble_client.connect",
     BLEConnectAction,
     BLE_CONNECT_ACTION_SCHEMA,
     synchronous=False,
 )
-async def ble_connect_to_code(config, action_id, template_arg, args):
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 @automation.register_action(
@@ -328,15 +322,12 @@ async def passkey_reply_to_code(config, action_id, template_arg, args):
     return var
 
 
-@automation.register_action(
+automation.register_simple_action(
     "ble_client.remove_bond",
     BLERemoveBondAction,
     BLE_REMOVE_BOND_ACTION_SCHEMA,
     synchronous=True,
 )
-async def remove_bond_to_code(config, action_id, template_arg, args):
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 async def to_code(config):

esphome/components/bm8563/bm8563.h

@@ -34,24 +34,4 @@ class BM8563 final : public time::RealTimeClock, public i2c::I2CDevice {
   uint8_t byte_to_bcd2_(uint8_t value);
 };
 
-template<typename... Ts> class WriteAction final : public Action<Ts...>, public Parented<BM8563> {
- public:
-  void play(const Ts &...x) override { this->parent_->write_time(); }
-};
-
-template<typename... Ts> class ReadAction final : public Action<Ts...>, public Parented<BM8563> {
- public:
-  void play(const Ts &...x) override { this->parent_->read_time(); }
-};
-
-template<typename... Ts> class TimerAction final : public Action<Ts...>, public Parented<BM8563> {
- public:
-  TEMPLATABLE_VALUE(uint32_t, duration)
-
-  void play(const Ts &...x) override {
-    auto duration = this->duration_.value(x...);
-    this->parent_->start_timer(duration);
-  }
-};
-
 }  // namespace esphome::bm8563

esphome/components/bm8563/time.py

@@ -3,8 +3,6 @@ import esphome.codegen as cg
 from esphome.components import i2c, time
 import esphome.config_validation as cv
 from esphome.const import CONF_DURATION, CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["i2c"]
@@ -13,9 +11,6 @@ I2C_ADDR = 0x51
 
 bm8563_ns = cg.esphome_ns.namespace("bm8563")
 BM8563 = bm8563_ns.class_("BM8563", time.RealTimeClock, i2c.I2CDevice)
-WriteAction = bm8563_ns.class_("WriteAction", automation.Action)
-ReadAction = bm8563_ns.class_("ReadAction", automation.Action)
-TimerAction = bm8563_ns.class_("TimerAction", automation.Action)
 
 CONFIG_SCHEMA = (
     time.TIME_SCHEMA.extend(
@@ -28,70 +23,30 @@ CONFIG_SCHEMA = (
 )
 
 
-@automation.register_action(
-    "bm8563.write_time",
-    WriteAction,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(BM8563),
-        }
-    ),
-    synchronous=True,
+BM8563_ACTION_SCHEMA = automation.maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(BM8563),
+    }
 )
-async def bm8563_write_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
+automation.register_apply_action(
+    "bm8563.write_time", BM8563_ACTION_SCHEMA, automation.ApplyCall("write_time()")
+)
 
-@automation.register_action(
+automation.register_apply_action(
+    "bm8563.read_time", BM8563_ACTION_SCHEMA, automation.ApplyCall("read_time()")
+)
+
+automation.register_apply_action(
     "bm8563.start_timer",
-    TimerAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(BM8563),
             cv.Required(CONF_DURATION): cv.templatable(cv.positive_time_period_seconds),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_DURATION, "start_timer", cg.uint32),
 )
-async def bm8563_start_timer_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.uint32)
-    cg.add(var.set_duration(template_))
-    return var
-
-
-@automation.register_action(
-    "bm8563.read_time",
-    ReadAction,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(BM8563),
-        }
-    ),
-    synchronous=True,
-)
-async def bm8563_read_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/button/__init__.py

@@ -16,14 +16,14 @@ from esphome.const import (
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
     entity_duplicate_validator,
     queue_entity_register,
     setup_device_class,
     setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
+from esphome.cpp_generator import MockObj, MockObjClass
 from esphome.types import ConfigType, SafeExpType
 
 CODEOWNERS = ["@esphome/core"]
@@ -40,8 +40,6 @@ button_ns = cg.esphome_ns.namespace("button")
 Button = button_ns.class_("Button", cg.EntityBase)
 ButtonPtr = Button.operator("ptr")
 
-PressAction = button_ns.class_("PressAction", automation.Action)
-
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 
@@ -123,17 +121,9 @@ BUTTON_PRESS_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action(
-    "button.press", PressAction, BUTTON_PRESS_SCHEMA, synchronous=True
+automation.register_apply_action(
+    "button.press", BUTTON_PRESS_SCHEMA, automation.ApplyCall("press()")
 )
-async def button_press_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/button/automation.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "esphome/components/button/button.h"
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-
-namespace esphome::button {
-
-template<typename... Ts> class PressAction final : public Action<Ts...> {
- public:
-  explicit PressAction(Button *button) : button_(button) {}
-
-  void play(const Ts &...x) override { this->button_->press(); }
-
- protected:
-  Button *button_;
-};
-
-}  // namespace esphome::button

esphome/components/cc1101/__init__.py

@@ -351,10 +351,6 @@ async def to_code(config):
 
 
 # Actions
-BeginTxAction = ns.class_("BeginTxAction", automation.Action)
-BeginRxAction = ns.class_("BeginRxAction", automation.Action)
-ResetAction = ns.class_("ResetAction", automation.Action)
-SetIdleAction = ns.class_("SetIdleAction", automation.Action)
 SendPacketAction = ns.class_(
     "SendPacketAction", automation.Action, cg.Parented.template(CC1101Component)
 )
@@ -364,22 +360,15 @@ CC1101_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
-    "cc1101.begin_tx", BeginTxAction, CC1101_ACTION_SCHEMA, synchronous=True
-)
-@automation.register_action(
-    "cc1101.begin_rx", BeginRxAction, CC1101_ACTION_SCHEMA, synchronous=True
-)
-@automation.register_action(
-    "cc1101.reset", ResetAction, CC1101_ACTION_SCHEMA, synchronous=True
-)
-@automation.register_action(
-    "cc1101.set_idle", SetIdleAction, CC1101_ACTION_SCHEMA, synchronous=True
-)
-async def cc1101_action_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
+for _name, _call in (
+    ("cc1101.begin_tx", "begin_tx()"),
+    ("cc1101.begin_rx", "begin_rx()"),
+    ("cc1101.reset", "reset()"),
+    ("cc1101.set_idle", "set_idle()"),
+):
+    automation.register_apply_action(
+        _name, CC1101_ACTION_SCHEMA, automation.ApplyCall(_call)
+    )
 
 
 def validate_raw_data(value):

esphome/components/cc1101/cc1101.h

@@ -130,26 +130,6 @@ class CC1101Component final : public Component,
 };
 
 // Action Wrappers
-template<typename... Ts> class BeginTxAction final : public Action<Ts...>, public Parented<CC1101Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->begin_tx(); }
-};
-
-template<typename... Ts> class BeginRxAction final : public Action<Ts...>, public Parented<CC1101Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->begin_rx(); }
-};
-
-template<typename... Ts> class ResetAction final : public Action<Ts...>, public Parented<CC1101Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->reset(); }
-};
-
-template<typename... Ts> class SetIdleAction final : public Action<Ts...>, public Parented<CC1101Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->set_idle(); }
-};
-
 template<typename... Ts> class SendPacketAction final : public Action<Ts...>, public Parented<CC1101Component> {
  public:
   void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) { this->data_func_ = func; }

esphome/components/climate/climate.cpp

@@ -435,6 +435,7 @@ void Climate::save_state_(const ClimateTraits &traits) {
 }
 
 void Climate::publish_state() {
+  this->set_has_state(true);
   ESP_LOGV(TAG, "'%s' >>", this->name_.c_str());
   auto traits = this->get_traits();
 

esphome/components/cm1106/cm1106.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -23,14 +22,4 @@ class CM1106Component final : public PollingComponent, public uart::UARTDevice {
   bool cm1106_write_command_(const uint8_t *command, size_t command_len, uint8_t *response, size_t response_len);
 };
 
-template<typename... Ts> class CM1106CalibrateZeroAction final : public Action<Ts...> {
- public:
-  CM1106CalibrateZeroAction(CM1106Component *cm1106) : cm1106_(cm1106) {}
-
-  void play(const Ts &...x) override { this->cm1106_->calibrate_zero(400); }
-
- protected:
-  CM1106Component *cm1106_;
-};
-
 }  // namespace esphome::cm1106

esphome/components/cm1106/sensor.py

@@ -13,8 +13,6 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     UNIT_PARTS_PER_MILLION,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["uart"]
@@ -24,10 +22,6 @@ cm1106_ns = cg.esphome_ns.namespace("cm1106")
 CM1106Component = cm1106_ns.class_(
     "CM1106Component", cg.PollingComponent, uart.UARTDevice
 )
-CM1106CalibrateZeroAction = cm1106_ns.class_(
-    "CM1106CalibrateZeroAction",
-    automation.Action,
-)
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -72,18 +66,8 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "cm1106.calibrate_zero",
-    CM1106CalibrateZeroAction,
     CALIBRATION_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyCall("calibrate_zero(400)"),
 )
-async def cm1106_calibration_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    """Service code generation entry point."""
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/const/__init__.py

@@ -23,6 +23,7 @@ CONF_ENABLE_OTA_DOWNGRADE_PROTECTION = "enable_ota_downgrade_protection"
 CONF_ENABLED = "enabled"
 CONF_GYROSCOPE_ODR = "gyroscope_odr"
 CONF_GYROSCOPE_RANGE = "gyroscope_range"
+CONF_HOST = "host"
 CONF_HUMIDITY_SOURCE = "humidity_source"
 CONF_IAQ = "iaq"
 CONF_IGNORE_NOT_FOUND = "ignore_not_found"

esphome/components/const/css_colors.py

@@ -0,0 +1,152 @@
+"""Standard CSS named colors, as 0xRRGGBB values."""
+
+CSS_COLORS: dict[str, int] = {
+    "aliceblue": 0xF0F8FF,
+    "antiquewhite": 0xFAEBD7,
+    "aqua": 0x00FFFF,
+    "aquamarine": 0x7FFFD4,
+    "azure": 0xF0FFFF,
+    "beige": 0xF5F5DC,
+    "bisque": 0xFFE4C4,
+    "black": 0x000000,
+    "blanchedalmond": 0xFFEBCD,
+    "blue": 0x0000FF,
+    "blueviolet": 0x8A2BE2,
+    "brown": 0xA52A2A,
+    "burlywood": 0xDEB887,
+    "cadetblue": 0x5F9EA0,
+    "chartreuse": 0x7FFF00,
+    "chocolate": 0xD2691E,
+    "coral": 0xFF7F50,
+    "cornflowerblue": 0x6495ED,
+    "cornsilk": 0xFFF8DC,
+    "crimson": 0xDC143C,
+    "cyan": 0x00FFFF,
+    "darkblue": 0x00008B,
+    "darkcyan": 0x008B8B,
+    "darkgoldenrod": 0xB8860B,
+    "darkgray": 0xA9A9A9,
+    "darkgreen": 0x006400,
+    "darkgrey": 0xA9A9A9,
+    "darkkhaki": 0xBDB76B,
+    "darkmagenta": 0x8B008B,
+    "darkolivegreen": 0x556B2F,
+    "darkorange": 0xFF8C00,
+    "darkorchid": 0x9932CC,
+    "darkred": 0x8B0000,
+    "darksalmon": 0xE9967A,
+    "darkseagreen": 0x8FBC8F,
+    "darkslateblue": 0x483D8B,
+    "darkslategray": 0x2F4F4F,
+    "darkslategrey": 0x2F4F4F,
+    "darkturquoise": 0x00CED1,
+    "darkviolet": 0x9400D3,
+    "deeppink": 0xFF1493,
+    "deepskyblue": 0x00BFFF,
+    "dimgray": 0x696969,
+    "dimgrey": 0x696969,
+    "dodgerblue": 0x1E90FF,
+    "firebrick": 0xB22222,
+    "floralwhite": 0xFFFAF0,
+    "forestgreen": 0x228B22,
+    "fuchsia": 0xFF00FF,
+    "gainsboro": 0xDCDCDC,
+    "ghostwhite": 0xF8F8FF,
+    "goldenrod": 0xDAA520,
+    "gold": 0xFFD700,
+    "gray": 0x808080,
+    "green": 0x008000,
+    "greenyellow": 0xADFF2F,
+    "grey": 0x808080,
+    "honeydew": 0xF0FFF0,
+    "hotpink": 0xFF69B4,
+    "indianred": 0xCD5C5C,
+    "indigo": 0x4B0082,
+    "ivory": 0xFFFFF0,
+    "khaki": 0xF0E68C,
+    "lavenderblush": 0xFFF0F5,
+    "lavender": 0xE6E6FA,
+    "lawngreen": 0x7CFC00,
+    "lemonchiffon": 0xFFFACD,
+    "lightblue": 0xADD8E6,
+    "lightcoral": 0xF08080,
+    "lightcyan": 0xE0FFFF,
+    "lightgoldenrodyellow": 0xFAFAD2,
+    "lightgray": 0xD3D3D3,
+    "lightgreen": 0x90EE90,
+    "lightgrey": 0xD3D3D3,
+    "lightpink": 0xFFB6C1,
+    "lightsalmon": 0xFFA07A,
+    "lightseagreen": 0x20B2AA,
+    "lightskyblue": 0x87CEFA,
+    "lightslategray": 0x778899,
+    "lightslategrey": 0x778899,
+    "lightsteelblue": 0xB0C4DE,
+    "lightyellow": 0xFFFFE0,
+    "lime": 0x00FF00,
+    "limegreen": 0x32CD32,
+    "linen": 0xFAF0E6,
+    "magenta": 0xFF00FF,
+    "maroon": 0x800000,
+    "mediumaquamarine": 0x66CDAA,
+    "mediumblue": 0x0000CD,
+    "mediumorchid": 0xBA55D3,
+    "mediumpurple": 0x9370DB,
+    "mediumseagreen": 0x3CB371,
+    "mediumslateblue": 0x7B68EE,
+    "mediumspringgreen": 0x00FA9A,
+    "mediumturquoise": 0x48D1CC,
+    "mediumvioletred": 0xC71585,
+    "midnightblue": 0x191970,
+    "mintcream": 0xF5FFFA,
+    "mistyrose": 0xFFE4E1,
+    "moccasin": 0xFFE4B5,
+    "navajowhite": 0xFFDEAD,
+    "navy": 0x000080,
+    "oldlace": 0xFDF5E6,
+    "olive": 0x808000,
+    "olivedrab": 0x6B8E23,
+    "orange": 0xFFA500,
+    "orangered": 0xFF4500,
+    "orchid": 0xDA70D6,
+    "palegoldenrod": 0xEEE8AA,
+    "palegreen": 0x98FB98,
+    "paleturquoise": 0xAFEEEE,
+    "palevioletred": 0xDB7093,
+    "papayawhip": 0xFFEFD5,
+    "peachpuff": 0xFFDAB9,
+    "peru": 0xCD853F,
+    "pink": 0xFFC0CB,
+    "plum": 0xDDA0DD,
+    "powderblue": 0xB0E0E6,
+    "purple": 0x800080,
+    "rebeccapurple": 0x663399,
+    "red": 0xFF0000,
+    "rosybrown": 0xBC8F8F,
+    "royalblue": 0x4169E1,
+    "saddlebrown": 0x8B4513,
+    "salmon": 0xFA8072,
+    "sandybrown": 0xF4A460,
+    "seagreen": 0x2E8B57,
+    "seashell": 0xFFF5EE,
+    "sienna": 0xA0522D,
+    "silver": 0xC0C0C0,
+    "skyblue": 0x87CEEB,
+    "slateblue": 0x6A5ACD,
+    "slategray": 0x708090,
+    "slategrey": 0x708090,
+    "snow": 0xFFFAFA,
+    "springgreen": 0x00FF7F,
+    "steelblue": 0x4682B4,
+    "tan": 0xD2B48C,
+    "teal": 0x008080,
+    "thistle": 0xD8BFD8,
+    "tomato": 0xFF6347,
+    "turquoise": 0x40E0D0,
+    "violet": 0xEE82EE,
+    "wheat": 0xF5DEB3,
+    "white": 0xFFFFFF,
+    "whitesmoke": 0xF5F5F5,
+    "yellow": 0xFFFF00,
+    "yellowgreen": 0x9ACD32,
+}

esphome/components/cs5460a/cs5460a.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/spi/spi.h"
 
@@ -108,14 +107,4 @@ class CS5460AComponent final : public Component,
   uint32_t prev_raw_energy_{0};
 };
 
-template<typename... Ts> class CS5460ARestartAction final : public Action<Ts...> {
- public:
-  CS5460ARestartAction(CS5460AComponent *cs5460a) : cs5460a_(cs5460a) {}
-
-  void play(const Ts &...x) override { cs5460a_->restart(); }
-
- protected:
-  CS5460AComponent *cs5460a_;
-};
-
 }  // namespace esphome::cs5460a

esphome/components/cs5460a/sensor.py

@@ -17,8 +17,6 @@ from esphome.const import (
     UNIT_VOLT,
     UNIT_WATT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@balrog-kun"]
@@ -32,7 +30,6 @@ PGA_GAIN_OPTIONS = {
 }
 
 CS5460AComponent = cs5460a_ns.class_("CS5460AComponent", spi.SPIDevice, cg.Component)
-CS5460ARestartAction = cs5460a_ns.class_("CS5460ARestartAction", automation.Action)
 
 CONF_SAMPLES = "samples"
 CONF_PHASE_OFFSET = "phase_offset"
@@ -131,21 +128,12 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_power_sensor(sens))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "cs5460a.restart",
-    CS5460ARestartAction,
     maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(CS5460AComponent),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("restart()"),
 )
-async def restart_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/deep_sleep/__init__.py

@@ -214,16 +214,6 @@ def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
 deep_sleep_ns = cg.esphome_ns.namespace("deep_sleep")
 DeepSleepComponent = deep_sleep_ns.class_("DeepSleepComponent", cg.Component)
 EnterDeepSleepAction = deep_sleep_ns.class_("EnterDeepSleepAction", automation.Action)
-PreventDeepSleepAction = deep_sleep_ns.class_(
-    "PreventDeepSleepAction",
-    automation.Action,
-    cg.Parented.template(DeepSleepComponent),
-)
-AllowDeepSleepAction = deep_sleep_ns.class_(
-    "AllowDeepSleepAction",
-    automation.Action,
-    cg.Parented.template(DeepSleepComponent),
-)
 
 WakeupPinMode = deep_sleep_ns.enum("WakeupPinMode")
 WAKEUP_PIN_MODES = {
@@ -490,27 +480,15 @@ async def deep_sleep_enter_to_code(
     return var
 
 
-@automation.register_action(
-    "deep_sleep.prevent",
-    PreventDeepSleepAction,
-    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
-    synchronous=True,
-)
-@automation.register_action(
-    "deep_sleep.allow",
-    AllowDeepSleepAction,
-    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
-    synchronous=True,
-)
-async def deep_sleep_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
+for _name, _call in (
+    ("deep_sleep.prevent", "prevent_deep_sleep()"),
+    ("deep_sleep.allow", "allow_deep_sleep()"),
+):
+    automation.register_apply_action(
+        _name,
+        automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
+        automation.ApplyCall(_call),
+    )
 
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(

esphome/components/deep_sleep/deep_sleep_component.h

@@ -121,8 +121,6 @@ class Ext1WakeTrigger : public Trigger<>, public Component {
 
 template<typename... Ts> class EnterDeepSleepAction;
 
-template<typename... Ts> class PreventDeepSleepAction;
-
 /** This component allows setting up the node to go into deep sleep mode to conserve battery.
  *
  * To set this component up, first set *when* the deep sleep should trigger using set_run_cycles
@@ -298,15 +296,4 @@ template<typename... Ts> class EnterDeepSleepAction final : public Action<Ts...>
 #endif
 };
 
-template<typename... Ts>
-class PreventDeepSleepAction final : public Action<Ts...>, public Parented<DeepSleepComponent> {
- public:
-  void play(const Ts &...x) override { this->parent_->prevent_deep_sleep(); }
-};
-
-template<typename... Ts> class AllowDeepSleepAction final : public Action<Ts...>, public Parented<DeepSleepComponent> {
- public:
-  void play(const Ts &...x) override { this->parent_->allow_deep_sleep(); }
-};
-
 }  // namespace esphome::deep_sleep

esphome/components/dfplayer/__init__.py

@@ -12,9 +12,6 @@ CODEOWNERS = ["@glmnet"]
 
 dfplayer_ns = cg.esphome_ns.namespace("dfplayer")
 DFPlayer = dfplayer_ns.class_("DFPlayer", cg.Component)
-DFPlayerIsPlayingCondition = dfplayer_ns.class_(
-    "DFPlayerIsPlayingCondition", automation.Condition
-)
 
 MULTI_CONF = True
 CONF_FOLDER = "folder"
@@ -199,16 +196,12 @@ automation.register_apply_action(
 )
 
 
-@automation.register_condition(
+automation.register_apply_condition(
     "dfplayer.is_playing",
-    DFPlayerIsPlayingCondition,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
         }
     ),
+    "is_playing()",
 )
-async def dfplayer_is_playing_to_code(config, condition_id, template_arg, args):
-    var = cg.new_Pvariable(condition_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var

esphome/components/dfplayer/dfplayer.h

@@ -77,9 +77,4 @@ class DFPlayer final : public uart::UARTDevice, public Component {
   CallbackManager<void()> on_finished_playback_callback_;
 };
 
-template<typename... Ts> class DFPlayerIsPlayingCondition final : public Condition<Ts...>, public Parented<DFPlayer> {
- public:
-  bool check(const Ts &...x) override { return this->parent_->is_playing(); }
-};
-
 }  // namespace esphome::dfplayer

esphome/components/dfrobot_sen0395/__init__.py

@@ -20,9 +20,6 @@ DfrobotSen0395Component = dfrobot_sen0395_ns.class_(
 )
 
 # Actions
-DfrobotSen0395ResetAction = dfrobot_sen0395_ns.class_(
-    "DfrobotSen0395ResetAction", automation.Action
-)
 DfrobotSen0395SettingsAction = dfrobot_sen0395_ns.class_(
     "DfrobotSen0395SettingsAction", automation.Action
 )
@@ -49,26 +46,15 @@ async def to_code(config: ConfigType) -> None:
     await uart.register_uart_device(var, config)
 
 
-@automation.register_action(
+automation.register_apply_action(
     "dfrobot_sen0395.reset",
-    DfrobotSen0395ResetAction,
     maybe_simple_id(
         {
             cv.GenerateID(): cv.use_id(DfrobotSen0395Component),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("reset_system()"),
 )
-async def dfrobot_sen0395_reset_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    return var
 
 
 def range_segment_list(input: Any) -> list:

esphome/components/dfrobot_sen0395/automation.h

@@ -7,12 +7,6 @@
 
 namespace esphome::dfrobot_sen0395 {
 
-template<typename... Ts>
-class DfrobotSen0395ResetAction final : public Action<Ts...>, public Parented<DfrobotSen0395Component> {
- public:
-  void play(const Ts &...x) { this->parent_->enqueue(make_unique<ResetSystemCommand>()); }
-};
-
 template<typename... Ts>
 class DfrobotSen0395SettingsAction final : public Action<Ts...>, public Parented<DfrobotSen0395Component> {
  public:

esphome/components/dfrobot_sen0395/dfrobot_sen0395.h

@@ -94,6 +94,8 @@ class DfrobotSen0395Component final : public uart::UARTDevice, public Component
 #endif
 
   int8_t enqueue(std::unique_ptr<Command> cmd);
+  /// Queue a sensor reset
+  void reset_system() { this->enqueue(make_unique<ResetSystemCommand>()); }
 
  protected:
 #ifdef USE_BINARY_SENSOR

esphome/components/display/__init__.py

@@ -39,9 +39,6 @@ DisplayPage = display_ns.class_("DisplayPage")
 DisplayPagePtr = DisplayPage.operator("ptr")
 DisplayRef = Display.operator("ref")
 DisplayPageShowAction = display_ns.class_("DisplayPageShowAction", automation.Action)
-DisplayIsDisplayingPageCondition = display_ns.class_(
-    "DisplayIsDisplayingPageCondition", automation.Condition
-)
 DisplayOnPageChangeTrigger = display_ns.class_(
     "DisplayOnPageChangeTrigger", automation.Trigger
 )
@@ -301,9 +298,8 @@ automation.register_apply_action(
 )
 
 
-@automation.register_condition(
+automation.register_apply_condition(
     "display.is_displaying_page",
-    DisplayIsDisplayingPageCondition,
     cv.maybe_simple_value(
         {
             cv.GenerateID(CONF_ID): cv.use_id(Display),
@@ -311,13 +307,8 @@ automation.register_apply_action(
         },
         key=CONF_PAGE_ID,
     ),
+    automation.ApplyCall("get_active_page() == {}", ((CONF_PAGE_ID, DisplayPagePtr),)),
 )
-async def display_is_displaying_page_to_code(config, condition_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    page = await cg.get_variable(config[CONF_PAGE_ID])
-    var = cg.new_Pvariable(condition_id, template_arg, paren)
-    cg.add(var.set_page(page))
-    return var
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/display/display.h

@@ -848,18 +848,6 @@ template<typename... Ts> class DisplayPageShowAction final : public Action<Ts...
   }
 };
 
-template<typename... Ts> class DisplayIsDisplayingPageCondition final : public Condition<Ts...> {
- public:
-  DisplayIsDisplayingPageCondition(Display *parent) : parent_(parent) {}
-
-  void set_page(DisplayPage *page) { this->page_ = page; }
-  bool check(const Ts &...x) override { return this->parent_->get_active_page() == this->page_; }
-
- protected:
-  Display *parent_;
-  DisplayPage *page_;
-};
-
 class DisplayOnPageChangeTrigger final : public Trigger<DisplayPage *, DisplayPage *> {
  public:
   explicit DisplayOnPageChangeTrigger(Display *parent) { parent->add_on_page_change_trigger(this); }

esphome/components/display_menu_base/__init__.py

@@ -55,18 +55,6 @@ MenuItemSwitch = display_menu_base_ns.class_("MenuItemSwitch")
 MenuItemCommand = display_menu_base_ns.class_("MenuItemCommand")
 MenuItemCustom = display_menu_base_ns.class_("MenuItemCustom")
 
-UpAction = display_menu_base_ns.class_("UpAction", automation.Action)
-DownAction = display_menu_base_ns.class_("DownAction", automation.Action)
-LeftAction = display_menu_base_ns.class_("LeftAction", automation.Action)
-RightAction = display_menu_base_ns.class_("RightAction", automation.Action)
-EnterAction = display_menu_base_ns.class_("EnterAction", automation.Action)
-ShowAction = display_menu_base_ns.class_("ShowAction", automation.Action)
-HideAction = display_menu_base_ns.class_("HideAction", automation.Action)
-ShowMainAction = display_menu_base_ns.class_("ShowMainAction", automation.Action)
-
-IsActiveCondition = display_menu_base_ns.class_(
-    "IsActiveCondition", automation.Condition
-)
 
 MenuItemType = display_menu_base_ns.enum("MenuItemType")
 
@@ -294,85 +282,23 @@ MENU_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action(
-    "display_menu.up", UpAction, MENU_ACTION_SCHEMA, synchronous=True
+for _name, _call in (
+    ("display_menu.up", "up()"),
+    ("display_menu.down", "down()"),
+    ("display_menu.left", "left()"),
+    ("display_menu.right", "right()"),
+    ("display_menu.enter", "enter()"),
+    ("display_menu.show", "show()"),
+    ("display_menu.hide", "hide()"),
+    ("display_menu.show_main", "show_main()"),
+):
+    automation.register_apply_action(
+        _name, MENU_ACTION_SCHEMA, automation.ApplyCall(_call)
+    )
+
+automation.register_apply_condition(
+    "display_menu.is_active", MENU_ACTION_SCHEMA, "is_active()"
 )
-async def menu_up_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.down", DownAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_down_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.left", LeftAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_left_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.right", RightAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_right_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.enter", EnterAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_enter_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.show", ShowAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_show_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.hide", HideAction, MENU_ACTION_SCHEMA, synchronous=True
-)
-async def menu_hide_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "display_menu.show_main",
-    ShowMainAction,
-    MENU_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def menu_show_main_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_condition(
-    "display_menu.is_active",
-    IsActiveCondition,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(DisplayMenuComponent),
-        }
-    ),
-)
-async def display_menu_is_active_to_code(config, condition_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
 async def menu_item_to_code(menu, config, parent):

esphome/components/display_menu_base/automation.h

@@ -5,94 +5,6 @@
 
 namespace esphome::display_menu_base {
 
-template<typename... Ts> class UpAction final : public Action<Ts...> {
- public:
-  explicit UpAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->up(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class DownAction final : public Action<Ts...> {
- public:
-  explicit DownAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->down(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class LeftAction final : public Action<Ts...> {
- public:
-  explicit LeftAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->left(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class RightAction final : public Action<Ts...> {
- public:
-  explicit RightAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->right(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class EnterAction final : public Action<Ts...> {
- public:
-  explicit EnterAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->enter(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class ShowAction final : public Action<Ts...> {
- public:
-  explicit ShowAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->show(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class HideAction final : public Action<Ts...> {
- public:
-  explicit HideAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->hide(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
-template<typename... Ts> class ShowMainAction final : public Action<Ts...> {
- public:
-  explicit ShowMainAction(DisplayMenuComponent *menu) : menu_(menu) {}
-
-  void play(const Ts &...x) override { this->menu_->show_main(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-template<typename... Ts> class IsActiveCondition final : public Condition<Ts...> {
- public:
-  explicit IsActiveCondition(DisplayMenuComponent *menu) : menu_(menu) {}
-  bool check(const Ts &...x) override { return this->menu_->is_active(); }
-
- protected:
-  DisplayMenuComponent *menu_;
-};
-
 class DisplayMenuOnEnterTrigger final : public Trigger<const MenuItem *> {
  public:
   explicit DisplayMenuOnEnterTrigger(MenuItem *parent) : parent_(parent) {

esphome/components/ds1307/ds1307.h

@@ -55,13 +55,4 @@ class DS1307Component final : public time::RealTimeClock, public i2c::I2CDevice
   } ds1307_;
 };
 
-template<typename... Ts> class WriteAction final : public Action<Ts...>, public Parented<DS1307Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->write_time(); }
-};
-
-template<typename... Ts> class ReadAction final : public Action<Ts...>, public Parented<DS1307Component> {
- public:
-  void play(const Ts &...x) override { this->parent_->read_time(); }
-};
 }  // namespace esphome::ds1307

esphome/components/ds1307/time.py

@@ -3,16 +3,12 @@ import esphome.codegen as cg
 from esphome.components import i2c, time
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@badbadc0ffee"]
 DEPENDENCIES = ["i2c"]
 ds1307_ns = cg.esphome_ns.namespace("ds1307")
 DS1307Component = ds1307_ns.class_("DS1307Component", time.RealTimeClock, i2c.I2CDevice)
-WriteAction = ds1307_ns.class_("WriteAction", automation.Action)
-ReadAction = ds1307_ns.class_("ReadAction", automation.Action)
 
 
 CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
@@ -22,46 +18,25 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
 ).extend(i2c.i2c_device_schema(0x68))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "ds1307.write_time",
-    WriteAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(DS1307Component),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("write_time()"),
 )
-async def ds1307_write_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ds1307.read_time",
-    ReadAction,
     automation.maybe_simple_id(
         {
             cv.GenerateID(): cv.use_id(DS1307Component),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("read_time()"),
 )
-async def ds1307_read_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/duty_time/duty_time_sensor.h

@@ -2,7 +2,6 @@
 
 #include <cinttypes>
 
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/preferences.h"
 #include "esphome/components/sensor/sensor.h"
@@ -47,27 +46,4 @@ class DutyTimeSensor final : public sensor::Sensor, public PollingComponent {
   bool restore_;
 };
 
-template<typename... Ts> class BaseAction : public Action<Ts...>, public Parented<DutyTimeSensor> {};
-
-template<typename... Ts> class StartAction : public BaseAction<Ts...> {
-  void play(const Ts &...x) override { this->parent_->start(); }
-};
-
-template<typename... Ts> class StopAction : public BaseAction<Ts...> {
-  void play(const Ts &...x) override { this->parent_->stop(); }
-};
-
-template<typename... Ts> class ResetAction : public BaseAction<Ts...> {
-  void play(const Ts &...x) override { this->parent_->reset(); }
-};
-
-template<typename... Ts> class RunningCondition final : public Condition<Ts...>, public Parented<DutyTimeSensor> {
- public:
-  explicit RunningCondition(DutyTimeSensor *parent, bool state) : Parented(parent), state_(state) {}
-
- protected:
-  bool check(const Ts &...x) override { return this->parent_->is_running() == this->state_; }
-  bool state_;
-};
-
 }  // namespace esphome::duty_time_sensor

esphome/components/duty_time/sensor.py

@@ -1,10 +1,4 @@
-from esphome.automation import (
-    Action,
-    Condition,
-    maybe_simple_id,
-    register_action,
-    register_condition,
-)
+from esphome import automation
 import esphome.codegen as cg
 from esphome.components import binary_sensor, sensor
 import esphome.config_validation as cv
@@ -19,8 +13,6 @@ from esphome.const import (
     STATE_CLASS_TOTAL_INCREASING,
     UNIT_SECOND,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CONF_LAST_TIME = "last_time"
@@ -29,14 +21,6 @@ duty_time_sensor_ns = cg.esphome_ns.namespace("duty_time_sensor")
 DutyTimeSensor = duty_time_sensor_ns.class_(
     "DutyTimeSensor", sensor.Sensor, cg.PollingComponent
 )
-BaseAction = duty_time_sensor_ns.class_("BaseAction", Action, cg.Parented)
-StartAction = duty_time_sensor_ns.class_("StartAction", BaseAction)
-StopAction = duty_time_sensor_ns.class_("StopAction", BaseAction)
-ResetAction = duty_time_sensor_ns.class_("ResetAction", BaseAction)
-SetAction = duty_time_sensor_ns.class_("SetAction", BaseAction)
-RunningCondition = duty_time_sensor_ns.class_(
-    "RunningCondition", Condition, cg.Parented
-)
 
 
 CONFIG_SCHEMA = cv.All(
@@ -86,76 +70,25 @@ async def to_code(config: ConfigType) -> None:
 
 # AUTOMATIONS
 
-DUTY_TIME_ID_SCHEMA = maybe_simple_id(
+DUTY_TIME_ID_SCHEMA = automation.maybe_simple_id(
     {
         cv.Required(CONF_ID): cv.use_id(DutyTimeSensor),
     }
 )
 
 
-@register_action(
-    "sensor.duty_time.start", StartAction, DUTY_TIME_ID_SCHEMA, synchronous=True
+for _name, _call in (
+    ("sensor.duty_time.start", "start()"),
+    ("sensor.duty_time.stop", "stop()"),
+    ("sensor.duty_time.reset", "reset()"),
+):
+    automation.register_apply_action(
+        _name, DUTY_TIME_ID_SCHEMA, automation.ApplyCall(_call)
+    )
+
+automation.register_apply_condition(
+    "sensor.duty_time.is_running", DUTY_TIME_ID_SCHEMA, "is_running()"
 )
-async def sensor_runtime_start_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@register_action(
-    "sensor.duty_time.stop", StopAction, DUTY_TIME_ID_SCHEMA, synchronous=True
+automation.register_apply_condition(
+    "sensor.duty_time.is_not_running", DUTY_TIME_ID_SCHEMA, "is_running() == false"
 )
-async def sensor_runtime_stop_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@register_action(
-    "sensor.duty_time.reset", ResetAction, DUTY_TIME_ID_SCHEMA, synchronous=True
-)
-async def sensor_runtime_reset_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@register_condition(
-    "sensor.duty_time.is_running", RunningCondition, DUTY_TIME_ID_SCHEMA
-)
-async def duty_time_is_running_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(condition_id, template_arg, paren, True)
-
-
-@register_condition(
-    "sensor.duty_time.is_not_running", RunningCondition, DUTY_TIME_ID_SCHEMA
-)
-async def duty_time_is_not_running_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(condition_id, template_arg, paren, False)

esphome/components/emontx/__init__.py

@@ -11,8 +11,7 @@ from esphome.const import (
     CONF_RX_BUFFER_SIZE,
     CONF_UART_ID,
 )
-from esphome.core import CORE, ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import CORE
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -23,9 +22,6 @@ DEPENDENCIES = ["uart"]
 emontx_ns = cg.esphome_ns.namespace("emontx")
 EmonTx = emontx_ns.class_("EmonTx", cg.Component, uart.UARTDevice)
 
-# Action to send command to emonTx
-EmonTxSendCommandAction = emontx_ns.class_("EmonTxSendCommandAction", automation.Action)
-
 CONF_EMONTX_ID = "emontx_id"
 CONF_TAG_NAME = "tag_name"
 CONF_ON_JSON = "on_json"
@@ -139,20 +135,16 @@ EMONTX_SEND_COMMAND_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
+def _plain_literal(config: ConfigType, value: str) -> str:
+    return str(cg.safe_exp(value))
+
+
+automation.register_apply_action(
     "emontx.send_command",
-    EmonTxSendCommandAction,
     EMONTX_SEND_COMMAND_ACTION_SCHEMA,
-    synchronous=True,
+    # A constant is a plain literal for the const char * overload; a lambda returns a
+    # std::string and takes the inline overload.
+    automation.ApplyField(
+        CONF_COMMAND, "send_command", cg.std_string, const_fn=_plain_literal
+    ),
 )
-async def emontx_send_command_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.std_string)
-    cg.add(var.set_command(template_))
-    return var

esphome/components/emontx/emontx.cpp

@@ -94,9 +94,9 @@ void EmonTx::dump_config() {
  *
  * @param command The command string to send (LF will be appended automatically).
  */
-void EmonTx::send_command(const std::string &command) {
-  ESP_LOGD(TAG, "Sending command to emonTx: %s", command.c_str());
-  this->write_str(command.c_str());
+void EmonTx::send_command(const char *command) {
+  ESP_LOGD(TAG, "Sending command to emonTx: %s", command);
+  this->write_str(command);
   this->write_byte('\n');
 }
 

esphome/components/emontx/emontx.h

@@ -2,7 +2,6 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/string_ref.h"
 #include "esphome/components/uart/uart.h"
@@ -39,7 +38,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
   template<typename F> void add_on_data_callback(F &&callback) { this->data_callbacks_.add(std::forward<F>(callback)); }
 
   // Send command to emonTx via UART
-  void send_command(const std::string &command);
+  void send_command(const char *command);
+  void send_command(const std::string &command) { this->send_command(command.c_str()); }
 
 #ifdef USE_SENSOR
   void init_sensors(size_t count) { this->sensors_.init(count); }
@@ -58,12 +58,4 @@ class EmonTx final : public Component, public uart::UARTDevice {
   std::array<char, MAX_LINE_LENGTH + 1> buffer_{};
 };
 
-// Action to send command to emonTx
-template<typename... Ts> class EmonTxSendCommandAction final : public Action<Ts...>, public Parented<EmonTx> {
- public:
-  TEMPLATABLE_VALUE(std::string, command)
-
-  void play(const Ts &...x) override { this->parent_->send_command(this->command_.value(x...)); }
-};
-
 }  // namespace esphome::emontx

esphome/components/esp32/__init__.py

@@ -11,7 +11,10 @@ from typing import Any
 
 from esphome import yaml_util
 import esphome.codegen as cg
-from esphome.components.const import CONF_ENABLE_OTA_DOWNGRADE_PROTECTION
+from esphome.components.const import (
+    CONF_ENABLE_OTA_DOWNGRADE_PROTECTION,
+    CONF_IGNORE_NOT_FOUND,
+)
 from esphome.config_helpers import filter_source_files_from_defines
 import esphome.config_validation as cv
 from esphome.const import (
@@ -111,6 +114,7 @@ CONF_ENGINEERING_SAMPLE = "engineering_sample"
 CONF_INCLUDE_BUILTIN_IDF_COMPONENTS = "include_builtin_idf_components"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
+CONF_NVS_CACHE_IN_PSRAM = "nvs_cache_in_psram"
 CONF_FLASH_CHIP = "flash_chip"
 CONF_KEY_ID = "key_id"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
@@ -1595,6 +1599,29 @@ def final_validate(config) -> None:
                     path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
                 )
             )
+    if advanced.get(CONF_NVS_CACHE_IN_PSRAM):
+        psram_conf = full_config.get(PSRAM_DOMAIN)
+        if (
+            psram_conf is None
+            or psram_conf[CONF_DISABLED]
+            or psram_conf[CONF_IGNORE_NOT_FOUND]
+        ):
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_NVS_CACHE_IN_PSRAM}' requires PSRAM with 'ignore_not_found: false'",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_NVS_CACHE_IN_PSRAM],
+                )
+            )
+        if (
+            advanced.get(CONF_NVS_ENCRYPTION) is not None
+            or conf_fw[CONF_SDKCONFIG_OPTIONS].get("CONFIG_NVS_ENCRYPTION") == "y"
+        ):
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_NVS_CACHE_IN_PSRAM}' cannot be used with NVS encryption; the keys must stay in internal RAM",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_NVS_CACHE_IN_PSRAM],
+                )
+            )
 
     final_validate_pins(full_config)
 
@@ -2035,6 +2062,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_RINGBUF_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_HEAP_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): cv.boolean,
+                cv.Optional(CONF_NVS_CACHE_IN_PSRAM): cv.boolean,
                 cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
                     min=8192, max=32768
                 ),
@@ -2361,6 +2389,20 @@ async def _set_libc_picolibc_newlib_compat() -> None:
     )
 
 
+@coroutine_with_priority(CoroPriority.FINAL)
+async def _apply_nvs_cache_in_psram(explicit: bool) -> None:
+    """Keep the NVS cache in PSRAM unless NVS encryption is on, however it was enabled."""
+    # The encrypted partition object holds the derived keys, which must stay in internal RAM
+    if is_idf_sdkconfig_option_enabled("CONFIG_NVS_ENCRYPTION"):
+        if explicit:
+            _LOGGER.warning(
+                "%s ignored: NVS encryption keeps the NVS cache in internal RAM",
+                CONF_NVS_CACHE_IN_PSRAM,
+            )
+        return
+    set_idf_sdkconfig_default("CONFIG_NVS_ALLOCATE_CACHE_IN_SPIRAM", True)
+
+
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _reconcile_certificate_bundle_sdkconfig() -> None:
     """Enable the mbedTLS certificate bundle only when something asked for it.
@@ -2913,6 +2955,17 @@ async def to_code(config):
     if advanced[CONF_EXECUTE_FROM_PSRAM]:
         add_idf_sdkconfig_option("CONFIG_SPIRAM_XIP_FROM_PSRAM", True)
 
+    # Imported here as psram imports this module
+    from esphome.components.psram import is_guaranteed as psram_is_guaranteed
+
+    # Frees internal heap (the cache scales with the NVS partition) but slows NVS, so only
+    # where PSRAM is known to be fitted. Decided at FINAL so every way of enabling NVS
+    # encryption has been seen and a user's sdkconfig_options value wins.
+    # Unset means on; only an explicit true is worth a warning when it has to be dropped.
+    requested = advanced.get(CONF_NVS_CACHE_IN_PSRAM)
+    if requested is not False and psram_is_guaranteed():
+        CORE.add_job(_apply_nvs_cache_in_psram, requested is 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

esphome/components/esp32_ble/__init__.py

@@ -32,8 +32,7 @@ from esphome.const import (
     CONF_NAME,
     CONF_NAME_ADD_MAC_SUFFIX,
 )
-from esphome.core import CORE, ID, TimePeriod
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import CORE, TimePeriod
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -606,38 +605,27 @@ async def to_code(config: ConfigType) -> None:
         cg.add_define("USE_ESP32_BLE_UUID")
 
 
-@automation.register_condition("ble.enabled", BLEEnabledCondition, cv.Schema({}))
-async def ble_enabled_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(condition_id, template_arg)
-
-
-@automation.register_action(
-    "ble.enable", BLEEnableAction, cv.Schema({}), synchronous=True
+automation.register_bare_condition(
+    "ble.enabled",
+    BLEEnabledCondition,
+    cv.Schema({}),
 )
-async def ble_enable_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(action_id, template_arg)
 
 
-@automation.register_action(
-    "ble.disable", BLEDisableAction, cv.Schema({}), synchronous=True
+automation.register_bare_action(
+    "ble.enable",
+    BLEEnableAction,
+    cv.Schema({}),
+    synchronous=True,
+)
+
+
+automation.register_bare_action(
+    "ble.disable",
+    BLEDisableAction,
+    cv.Schema({}),
+    synchronous=True,
 )
-async def ble_disable_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(action_id, template_arg)
 
 
 # ble_advertising.cpp is fully #ifdef'd on USE_ESP32_BLE_ADVERTISING, set

esphome/components/esp8266/__init__.py

@@ -5,6 +5,7 @@ import re
 import subprocess
 from typing import Any
 
+from esphome.build_helpers.native import native_backend
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -14,6 +15,7 @@ from esphome.const import (
     CONF_FRAMEWORK,
     CONF_PLATFORM_VERSION,
     CONF_SOURCE,
+    CONF_TOOLCHAIN,
     CONF_VERSION,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
@@ -21,6 +23,7 @@ from esphome.const import (
     KEY_TARGET_PLATFORM,
     PLATFORM_ESP8266,
     ThreadModel,
+    Toolchain,
 )
 from esphome.core import (
     CORE,
@@ -43,6 +46,7 @@ from .const import (
     CONF_ENABLE_SERIAL1,
     CONF_RESTORE_FROM_FLASH,
     KEY_BOARD,
+    KEY_DECODE_TOOLS,
     KEY_ESP8266,
     KEY_PIN_INITIAL_STATES,
     KEY_SCANF_FLOAT,
@@ -105,6 +109,47 @@ def set_core_data(config: ConfigType) -> ConfigType:
     return config
 
 
+_TOOLCHAINS = (Toolchain.PLATFORMIO, Toolchain.ARDUINO)
+_validate_toolchain = cv.toolchain_enum(_TOOLCHAINS)
+_resolve_toolchain = cv.resolve_toolchain("ESP8266", _TOOLCHAINS, Toolchain.PLATFORMIO)
+
+
+def _validate_native_toolchain(config: ConfigType) -> ConfigType:
+    """Constraints of the native (non-PlatformIO) Arduino toolchain."""
+    if not CORE.using_toolchain_arduino:
+        return config
+    from esphome.arduino8266.framework import MIN_FRAMEWORK_VERSION
+
+    conf = config[CONF_FRAMEWORK]
+    version = cv.Version.parse(conf[CONF_VERSION])
+    if version < MIN_FRAMEWORK_VERSION:
+        raise cv.Invalid(
+            "'toolchain: arduino' requires framework version "
+            f"{MIN_FRAMEWORK_VERSION} or newer"
+        )
+    # platform_version is a PlatformIO concept; drop it, warning when a
+    # custom pin is discarded
+    if (
+        conf.pop(CONF_PLATFORM_VERSION, _ARDUINO_4_PLATFORM_SPEC)
+        != _ARDUINO_4_PLATFORM_SPEC
+    ):
+        _LOGGER.warning(
+            "'platform_version' is ignored by 'toolchain: arduino'; the native "
+            "toolchain downloads the framework and compiler directly"
+        )
+    if conf[CONF_SOURCE] != _format_framework_arduino_version(version):
+        raise cv.Invalid(
+            "'toolchain: arduino' does not support a custom framework source; "
+            "use 'toolchain: platformio'"
+        )
+    if config[CONF_BOARD] not in BOARDS:
+        raise cv.Invalid(
+            f"Board '{config[CONF_BOARD]}' is not supported by "
+            "'toolchain: arduino'; use 'toolchain: platformio'"
+        )
+    return config
+
+
 def get_download_types(storage_json: StorageJSON) -> list[dict[str, str]]:
     """Binary-download entries for a built ESP8266 firmware.
 
@@ -134,7 +179,7 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
     # a PIO platformio/framework-arduinoespressif8266 value
     # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
     # Same encoding the native toolchain uses for its package download, so a
-    # version bump cannot drift between the two paths.
+    # custom-source check against this value cannot drift from what it fetches.
     from esphome.arduino8266.framework import framework_package_version
 
     try:
@@ -196,7 +241,7 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
     platform_version = value.get(CONF_PLATFORM_VERSION)
     if platform_version is None:
         if version >= cv.Version(3, 1, 0):
-            platform_version = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
+            platform_version = _ARDUINO_4_PLATFORM_SPEC
         else:
             platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
     value[CONF_PLATFORM_VERSION] = platform_version
@@ -219,6 +264,10 @@ def _parse_platform_version(value: Any) -> str:
         return value
 
 
+# The platform_version derived for every core >= 3.1.0 config
+_ARDUINO_4_PLATFORM_SPEC = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
+
+
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -251,11 +300,13 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ENABLE_SERIAL1): cv.boolean,
             cv.Optional(CONF_ENABLE_FULL_PRINTF, default=False): cv.boolean,
             cv.Optional(CONF_ENABLE_SCANF_FLOAT): cv.boolean,
+            cv.Optional(
+                CONF_TOOLCHAIN, visibility=cv.Visibility.ADVANCED
+            ): _validate_toolchain,
         }
     ),
-    # Until the native toolchain lands, PlatformIO is the only backend;
-    # reject a --toolchain this platform cannot serve yet.
-    cv.require_platformio_toolchain("ESP8266"),
+    _resolve_toolchain,
+    _validate_native_toolchain,
     set_core_data,
 )
 
@@ -295,12 +346,13 @@ def _choose_ld_script(board: str) -> str:
 
 @coroutine_with_priority(CoroPriority.PLATFORM)
 async def to_code(config: ConfigType) -> None:
+    use_platformio = CORE.using_toolchain_platformio
     cg.add(esp8266_ns.setup_preferences())
 
-    cg.add_platformio_option("lib_ldf_mode", "off")
-    cg.add_platformio_option("lib_compat_mode", "strict")
-
-    cg.add_platformio_option("board", config[CONF_BOARD])
+    if use_platformio:
+        cg.add_platformio_option("lib_ldf_mode", "off")
+        cg.add_platformio_option("lib_compat_mode", "strict")
+        cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_build_flag("-DUSE_ESP8266")
     cg.set_cpp_standard("gnu++20")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -318,29 +370,30 @@ async def to_code(config: ConfigType) -> None:
 
     # The native generator reads the same decision (KEY_SCANF_FLOAT)
     CORE.data[KEY_ESP8266][KEY_SCANF_FLOAT] = bool(enable_scanf_float)
-
-    extra_scripts = [
-        "pre:ccache.py",
-        "pre:testing_mode.py",
-        "pre:exclude_updater.py",
-        "pre:exclude_waveform.py",
-        "pre:relocate_ratetable.py",
-    ]
-    if not enable_scanf_float:
-        extra_scripts.append("pre:remove_float_scanf.py")
-    extra_scripts.append("post:post_build.py")
-    cg.add_platformio_option("extra_scripts", extra_scripts)
+    if use_platformio:
+        extra_scripts = [
+            "pre:ccache.py",
+            "pre:testing_mode.py",
+            "pre:exclude_updater.py",
+            "pre:exclude_waveform.py",
+            "pre:relocate_ratetable.py",
+        ]
+        if not enable_scanf_float:
+            extra_scripts.append("pre:remove_float_scanf.py")
+        extra_scripts.append("post:post_build.py")
+        cg.add_platformio_option("extra_scripts", extra_scripts)
 
     conf = config[CONF_FRAMEWORK]
-    cg.add_platformio_option("framework", "arduino")
     cg.add_build_flag("-DUSE_ARDUINO")
     cg.add_build_flag("-DUSE_ESP8266_FRAMEWORK_ARDUINO")
     cg.add_build_flag("-Wno-nonnull-compare")
-    cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
-    cg.add_platformio_option(
-        "platform_packages",
-        [f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}"],
-    )
+    if use_platformio:
+        cg.add_platformio_option("framework", "arduino")
+        cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
+        cg.add_platformio_option(
+            "platform_packages",
+            [f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}"],
+        )
 
     # Default for platformio is LWIP2_LOW_MEMORY with:
     #  - MSS=536
@@ -369,8 +422,8 @@ async def to_code(config: ConfigType) -> None:
 
     # Force-include inline std::__throw_* overrides so GCC dead-strips the unused
     # libstdc++ error message strings (e.g. "basic_string::_M_create") from DRAM.
-    # See throw_stubs.h for details. Must be prepended before <string>, so this
-    # uses build_src_flags with -include.
+    # See throw_stubs.h. Unconditional: the native build generator reads
+    # the same option, keeping one source of truth.
     cg.add_platformio_option(
         "build_src_flags", "-include esphome/components/esp8266/throw_stubs.h"
     )
@@ -400,6 +453,8 @@ async def to_code(config: ConfigType) -> None:
     # implementation in the Arduino ESP8266 core.
     cg.add_build_flag("-Wl,--wrap=millis")
 
+    # Unconditional: the native build generator reads the same option,
+    # keeping one source of truth
     cg.add_platformio_option("board_build.flash_mode", config[CONF_BOARD_FLASH_MODE])
 
     ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
@@ -408,7 +463,7 @@ async def to_code(config: ConfigType) -> None:
         cg.RawExpression(f"VERSION_CODE({ver.major}, {ver.minor}, {ver.patch})"),
     )
 
-    if config[CONF_BOARD] in BOARDS:
+    if use_platformio and config[CONF_BOARD] in BOARDS:
         cg.add_platformio_option(
             "board_build.ldscript", _choose_ld_script(config[CONF_BOARD])
         )
@@ -449,8 +504,24 @@ async def finalize_serial_config() -> None:
         cg.add_build_flag("-DNO_GLOBAL_SERIAL1")
 
 
+# Called by __main__.compile_program; returning False falls through to the
+# PlatformIO toolchain.
+def run_compile(args, config: ConfigType) -> bool:
+    # Positive check: the native backend only runs when explicitly resolved
+    toolchain = native_backend()
+    if toolchain is None:
+        return False
+    if toolchain.run_compile(config, CORE.verbose) != 0:
+        raise EsphomeError("ESP8266 native build failed")
+    return True
+
+
 # Called by writer.py
 def copy_files() -> None:
+    # Native builds skip the PlatformIO extra scripts; the build generator
+    # carries their logic
+    if CORE.using_toolchain_arduino:
+        return
     dir = Path(__file__).parent
     for script in (
         "post_build",
@@ -507,22 +578,54 @@ ESP8266_EXCEPTION_CODES = {
 }
 
 
-def _decode_pc(config: ConfigType, addr: str) -> None:
+def _resolve_decode_tools(config: ConfigType) -> tuple[str, str] | None:
+    """``(addr2line, elf)`` for this build, or None after warning why."""
+    if (native_toolchain := native_backend()) is not None:
+        addr2line = native_toolchain.get_addr2line_path()
+        elf = native_toolchain.get_elf_path()
+        for path in (addr2line, elf):
+            if not path.is_file():
+                _LOGGER.warning("Cannot decode crash addresses: %s missing", path)
+                return None
+        return str(addr2line), str(elf)
     from esphome.platformio import toolchain
 
     idedata = toolchain.get_idedata(config)
     if not idedata.addr2line_path or not idedata.firmware_elf_path:
-        _LOGGER.debug("decode_pc no addr2line")
+        _LOGGER.warning("Cannot decode crash addresses: no addr2line or ELF in idedata")
+        return None
+    return idedata.addr2line_path, idedata.firmware_elf_path
+
+
+def _decode_tools(config: ConfigType) -> tuple[str, str] | None:
+    """Resolved once per run: the tools are a property of the build, not of
+    the address, so a stack dump cannot repeat the failure warning."""
+    data = CORE.data.setdefault(KEY_ESP8266, {})
+    if KEY_DECODE_TOOLS not in data:
+        data[KEY_DECODE_TOOLS] = _resolve_decode_tools(config)
+    return data[KEY_DECODE_TOOLS]
+
+
+def _decode_pc(config: ConfigType, addr: str, *, bulk: bool = False) -> None:
+    """Decode one crash address. ``bulk``: the caller is scanning every
+    8-hex stack word, most of which are not code addresses -- unmappable
+    ones log at debug so real frames are not buried."""
+    # Bulk stack words are ~150 per dump; only named registers warn
+    log = _LOGGER.debug if bulk else _LOGGER.warning
+    if (tools := _decode_tools(config)) is None:
+        log("Not decoded %s (no addr2line or ELF)", addr)
         return
-    command = [idedata.addr2line_path, "-pfiaC", "-e", idedata.firmware_elf_path, addr]
+    addr2line, elf = tools
+    command = [addr2line, "-pfiaC", "-e", elf, addr]
     try:
         translation = subprocess.check_output(command, close_fds=False).decode().strip()
-    except Exception:  # noqa: BLE001  # pylint: disable=broad-except
+    except Exception as err:  # noqa: BLE001  # pylint: disable=broad-except
+        log("Could not decode crash address %s (%s)", addr, err)
         _LOGGER.debug("Caught exception for command %s", command, exc_info=1)
         return
 
     if "?? ??:0" in translation:
-        # Nothing useful
+        log("Not decoded %s (address not in %s)", addr, elf)
         return
     translation = translation.replace(" at ??:?", "").replace(":?", "")
     _LOGGER.warning("Decoded %s", translation)
@@ -592,6 +695,6 @@ def process_stacktrace(config: ConfigType, line: str, backtrace_state: bool) ->
 
     if backtrace_state:
         for addr in re.finditer(STACKTRACE_ESP8266_BACKTRACE_PC_RE, line):
-            _decode_pc(config, addr.group())
+            _decode_pc(config, addr.group(), bulk=True)
 
     return backtrace_state

esphome/components/esp8266/const.py

@@ -19,6 +19,8 @@ KEY_SERIAL1_REQUIRED = "serial1_required"
 KEY_SCANF_FLOAT = "scanf_float"
 # Per-board flash-layout override consumed by board_ld_script()
 KEY_LDSCRIPT = "ldscript"
+# Crash-decode tools, resolved once per run by __init__
+KEY_DECODE_TOOLS = "decode_tools"
 
 # esp8266 namespace is already defined by arduino, manually prefix esphome
 esp8266_ns = cg.global_ns.namespace("esphome").namespace("esp8266")

esphome/components/esp_ldo/__init__.py

@@ -1,12 +1,11 @@
 from typing import Any
 
-from esphome.automation import Action, register_action
+from esphome import automation
 import esphome.codegen as cg
 from esphome.components.esp32 import VARIANT_ESP32P4, only_on_variant
 import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID, CONF_VOLTAGE
 from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.final_validate import full_config
 from esphome.types import ConfigType
 
@@ -16,7 +15,6 @@ DOMAIN = "esp_ldo"
 
 esp_ldo_ns = cg.esphome_ns.namespace("esp_ldo")
 EspLdo = esp_ldo_ns.class_("EspLdo", cg.Component)
-AdjustAction = esp_ldo_ns.class_("AdjustAction", Action)
 
 CHANNELS = (1, 2, 3, 4)
 CHANNELS_INTERNAL = (1, 2)
@@ -123,9 +121,8 @@ def adjusted_ldo_id(value: Any) -> ID:
     return value
 
 
-@register_action(
+automation.register_apply_action(
     "esp_ldo.voltage.adjust",
-    AdjustAction,
     cv.Schema(
         {
             cv.GenerateID(CONF_ID): adjusted_ldo_id,
@@ -134,16 +131,5 @@ def adjusted_ldo_id(value: Any) -> ID:
             ),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_VOLTAGE, "adjust_voltage", cg.float_),
 )
-async def ldo_voltage_adjust_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    parent = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, parent)
-    template_ = await cg.templatable(config[CONF_VOLTAGE], args, cg.float_)
-    cg.add(var.set_voltage(template_))
-    return var

esphome/components/esp_ldo/esp_ldo.h

@@ -1,7 +1,6 @@
 #pragma once
 #ifdef USE_ESP32_VARIANT_ESP32P4
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esp_ldo_regulator.h"
 
 namespace esphome::esp_ldo {
@@ -27,18 +26,6 @@ class EspLdo final : public Component {
   esp_ldo_channel_handle_t handle_{};
 };
 
-template<typename... Ts> class AdjustAction final : public Action<Ts...> {
- public:
-  explicit AdjustAction(EspLdo *ldo) : ldo_(ldo) {}
-
-  TEMPLATABLE_VALUE(float, voltage)
-
-  void play(const Ts &...x) override { this->ldo_->adjust_voltage(this->voltage_.value(x...)); }
-
- protected:
-  EspLdo *ldo_;
-};
-
 }  // namespace esphome::esp_ldo
 
 #endif  // USE_ESP32_VARIANT_ESP32P4

esphome/components/esphome/ota/__init__.py

@@ -2,7 +2,7 @@ import logging
 
 import esphome.codegen as cg
 from esphome.components.noise import (
-    encryption_schema,
+    ENCRYPTION_SCHEMA,
     new_psk_progmem,
     static_encryption_key,
 )
@@ -27,6 +27,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+from esphome.espota2 import CONF_ALLOW_PLAINTEXT_UPLOAD
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -231,15 +232,38 @@ def _resolve_encryption_key(encryption_conf: ConfigType, api_conf: ConfigType) -
         encryption_conf[CONF_KEY] = api_key
 
 
+# Uploader side options live only on the ota block; the api block keeps the
+# shared schema
+_ENCRYPTION_SCHEMA = ENCRYPTION_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ALLOW_PLAINTEXT_UPLOAD): cv.boolean,
+    }
+)
+
+
+def _encryption_schema(config: ConfigType | None) -> ConfigType:
+    # Only a bare `encryption:` block is keyless; `false` or a list must fail
+    return _ENCRYPTION_SCHEMA({} if config is None else config)
+
+
 # Also called on merged same-port configs in final validate, where schemas
 # do not run
 def _validate_no_password_with_encryption(config: ConfigType) -> ConfigType:
-    if CONF_PASSWORD in config and CONF_ENCRYPTION in config:
-        raise cv.Invalid(
-            f"'{CONF_PASSWORD}' cannot be combined with '{CONF_ENCRYPTION}'; the "
-            f"encryption key already authenticates the uploader, remove '{CONF_PASSWORD}'"
-        )
-    return config
+    if (
+        CONF_PASSWORD not in config
+        or (encryption := config.get(CONF_ENCRYPTION)) is None
+    ):
+        return config
+    # The migration install may still have to answer the old firmware's
+    # password prompt on the plaintext leg; the password is not built in
+    if encryption.get(CONF_ALLOW_PLAINTEXT_UPLOAD):
+        return config
+    raise cv.Invalid(
+        f"'{CONF_PASSWORD}' cannot be combined with '{CONF_ENCRYPTION}'; the "
+        f"encryption key already authenticates the uploader, remove '{CONF_PASSWORD}' "
+        f"(or set '{CONF_ALLOW_PLAINTEXT_UPLOAD}: true' for the one install that "
+        f"migrates a device still asking for it)"
+    )
 
 
 def _consume_ota_sockets(config: ConfigType) -> ConfigType:
@@ -269,7 +293,7 @@ CONFIG_SCHEMA = cv.All(
             ): cv.port,
             cv.Optional(CONF_ALLOW_PARTITION_ACCESS, default=False): cv.boolean,
             cv.Optional(CONF_PASSWORD): cv.sensitive(),
-            cv.Optional(CONF_ENCRYPTION): encryption_schema,
+            cv.Optional(CONF_ENCRYPTION): _encryption_schema,
             cv.Optional(CONF_NUM_ATTEMPTS): cv.invalid(
                 f"'{CONF_SAFE_MODE}' (and its related configuration variables) has moved from 'ota' to its own component. See https://esphome.io/components/safe_mode"
             ),
@@ -304,7 +328,10 @@ async def to_code(config: ConfigType) -> None:
     # An empty password opts in to the auth code path so set_auth_password() can be
     # called at runtime (e.g. to rotate the password from a lambda). When `password:`
     # is omitted entirely, the auth path is excluded to save flash on small devices.
-    if CONF_PASSWORD in config:
+    # A password is never built in next to encryption: validation only lets
+    # the two coexist for the migration install, where the password answers
+    # the running firmware and the build is authenticated by the key
+    if CONF_PASSWORD in config and CONF_ENCRYPTION not in config:
         cg.add_define("USE_OTA_PASSWORD")
         if config[CONF_PASSWORD]:
             cg.add(var.set_auth_password(config[CONF_PASSWORD]))

esphome/components/esphome/ota/ota_esphome.cpp

@@ -459,7 +459,10 @@ void ESPHomeOTAComponent::handle_data_() {
   tv.tv_usec = 0;
   this->client_->setsockopt(SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
   this->client_->setsockopt(SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
-  this->client_->setblocking(true);
+  if (this->client_->setblocking(true) != 0) {
+    this->log_socket_error_(LOG_STR("blocking"));
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+  }
 
   // Acknowledge auth OK - 1 byte
   this->data_write_byte_(ota::OTA_RESPONSE_AUTH_OK);

esphome/components/ethernet/__init__.py

@@ -53,12 +53,10 @@ from esphome.const import (
 )
 from esphome.core import (
     CORE,
-    ID,
     CoroPriority,
     TimePeriodMilliseconds,
     coroutine_with_priority,
 )
-from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -924,24 +922,15 @@ def _filter_source_files() -> list[str]:
 FILTER_SOURCE_FILES = _filter_source_files
 
 
-async def _new_pvariable_to_code(
-    config: ConfigType,
-    id_: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(id_, template_arg)
-
-
-for _name, _cls in (
-    ("ethernet.connected", EthernetConnectedCondition),
-    ("ethernet.enabled", EthernetEnabledCondition),
-):
-    automation.register_condition(_name, _cls, cv.Schema({}))(_new_pvariable_to_code)
-for _name, _cls in (
-    ("ethernet.enable", EthernetEnableAction),
-    ("ethernet.disable", EthernetDisableAction),
-):
-    automation.register_action(_name, _cls, cv.Schema({}), synchronous=True)(
-        _new_pvariable_to_code
-    )
+automation.register_bare_condition(
+    "ethernet.connected", EthernetConnectedCondition, cv.Schema({})
+)
+automation.register_bare_condition(
+    "ethernet.enabled", EthernetEnabledCondition, cv.Schema({})
+)
+automation.register_bare_action(
+    "ethernet.enable", EthernetEnableAction, cv.Schema({}), synchronous=True
+)
+automation.register_bare_action(
+    "ethernet.disable", EthernetDisableAction, cv.Schema({}), synchronous=True
+)

esphome/components/ezo_pmp/__init__.py

@@ -44,112 +44,19 @@ EZO_PMP_NO_ARGS_ACTION_SCHEMA = maybe_simple_id(
     }
 )
 
-# Actions that do not require more arguments
-
-EzoPMPFindAction = ezo_pmp_ns.class_("EzoPMPFindAction", automation.Action)
-EzoPMPClearTotalVolumeDispensedAction = ezo_pmp_ns.class_(
-    "EzoPMPClearTotalVolumeDispensedAction", automation.Action
-)
-EzoPMPClearCalibrationAction = ezo_pmp_ns.class_(
-    "EzoPMPClearCalibrationAction", automation.Action
-)
-EzoPMPPauseDosingAction = ezo_pmp_ns.class_(
-    "EzoPMPPauseDosingAction", automation.Action
-)
-EzoPMPStopDosingAction = ezo_pmp_ns.class_("EzoPMPStopDosingAction", automation.Action)
-EzoPMPDoseContinuouslyAction = ezo_pmp_ns.class_(
-    "EzoPMPDoseContinuouslyAction", automation.Action
-)
-
-# Actions that require more arguments
-EzoPMPDoseVolumeAction = ezo_pmp_ns.class_("EzoPMPDoseVolumeAction", automation.Action)
-EzoPMPDoseVolumeOverTimeAction = ezo_pmp_ns.class_(
-    "EzoPMPDoseVolumeOverTimeAction", automation.Action
-)
-EzoPMPDoseWithConstantFlowRateAction = ezo_pmp_ns.class_(
-    "EzoPMPDoseWithConstantFlowRateAction", automation.Action
-)
-EzoPMPSetCalibrationVolumeAction = ezo_pmp_ns.class_(
-    "EzoPMPSetCalibrationVolumeAction", automation.Action
-)
-EzoPMPChangeI2CAddressAction = ezo_pmp_ns.class_(
-    "EzoPMPChangeI2CAddressAction", automation.Action
-)
-EzoPMPArbitraryCommandAction = ezo_pmp_ns.class_(
-    "EzoPMPArbitraryCommandAction", automation.Action
-)
-
-
-@automation.register_action(
-    "ezo_pmp.find",
-    EzoPMPFindAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_find_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "ezo_pmp.dose_continuously",
-    EzoPMPDoseContinuouslyAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_dose_continuously_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "ezo_pmp.clear_total_volume_dosed",
-    EzoPMPClearTotalVolumeDispensedAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_clear_total_volume_dosed_to_code(
-    config, action_id, template_arg, args
+for _name, _method in (
+    ("ezo_pmp.find", "find()"),
+    ("ezo_pmp.dose_continuously", "dose_continuously()"),
+    ("ezo_pmp.clear_total_volume_dosed", "clear_total_volume_dosed()"),
+    ("ezo_pmp.clear_calibration", "clear_calibration()"),
+    ("ezo_pmp.pause_dosing", "pause_dosing()"),
+    ("ezo_pmp.stop_dosing", "stop_dosing()"),
 ):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    automation.register_apply_action(
+        _name, EZO_PMP_NO_ARGS_ACTION_SCHEMA, automation.ApplyCall(_method)
+    )
 
 
-@automation.register_action(
-    "ezo_pmp.clear_calibration",
-    EzoPMPClearCalibrationAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_clear_calibration_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "ezo_pmp.pause_dosing",
-    EzoPMPPauseDosingAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_pause_dosing_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "ezo_pmp.stop_dosing",
-    EzoPMPStopDosingAction,
-    EZO_PMP_NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def ezo_pmp_stop_dosing_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-# Actions that require Multiple Args
-
 EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA = cv.All(
     {
         cv.Required(CONF_ID): cv.use_id(EzoPMP),
@@ -159,21 +66,11 @@ EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.dose_volume",
-    EzoPMPDoseVolumeAction,
     EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_VOLUME, "dose_volume", cg.double),
 )
-async def ezo_pmp_dose_volume_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_VOLUME], args, cg.double)
-    cg.add(var.set_volume(template_))
-
-    return var
 
 
 EZO_PMP_DOSE_VOLUME_OVER_TIME_ACTION_SCHEMA = cv.All(
@@ -188,24 +85,14 @@ EZO_PMP_DOSE_VOLUME_OVER_TIME_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.dose_volume_over_time",
-    EzoPMPDoseVolumeOverTimeAction,
     EZO_PMP_DOSE_VOLUME_OVER_TIME_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyCall(
+        "dose_volume_over_time({}, {})",
+        ((CONF_VOLUME, cg.double), (CONF_DURATION, cg.int_)),
+    ),
 )
-async def ezo_pmp_dose_volume_over_time_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_VOLUME], args, cg.double)
-    cg.add(var.set_volume(template_))
-
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int_)
-    cg.add(var.set_duration(template_))
-
-    return var
 
 
 EZO_PMP_DOSE_WITH_CONSTANT_FLOW_RATE_ACTION_SCHEMA = cv.All(
@@ -220,26 +107,14 @@ EZO_PMP_DOSE_WITH_CONSTANT_FLOW_RATE_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.dose_with_constant_flow_rate",
-    EzoPMPDoseWithConstantFlowRateAction,
     EZO_PMP_DOSE_WITH_CONSTANT_FLOW_RATE_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyCall(
+        "dose_with_constant_flow_rate({}, {})",
+        ((CONF_VOLUME_PER_MINUTE, cg.double), (CONF_DURATION, cg.int_)),
+    ),
 )
-async def ezo_pmp_dose_with_constant_flow_rate_to_code(
-    config, action_id, template_arg, args
-):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_VOLUME_PER_MINUTE], args, cg.double)
-    cg.add(var.set_volume(template_))
-
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.int_)
-    cg.add(var.set_duration(template_))
-
-    return var
 
 
 EZO_PMP_SET_CALIBRATION_VOLUME_ACTION_SCHEMA = cv.All(
@@ -251,21 +126,11 @@ EZO_PMP_SET_CALIBRATION_VOLUME_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.set_calibration_volume",
-    EzoPMPSetCalibrationVolumeAction,
     EZO_PMP_SET_CALIBRATION_VOLUME_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_VOLUME, "set_calibration_volume", cg.double),
 )
-async def ezo_pmp_set_calibration_volume_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_VOLUME], args, cg.double)
-    cg.add(var.set_volume(template_))
-
-    return var
 
 
 EZO_PMP_CHANGE_I2C_ADDRESS_ACTION_SCHEMA = cv.All(
@@ -275,21 +140,11 @@ EZO_PMP_CHANGE_I2C_ADDRESS_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.change_i2c_address",
-    EzoPMPChangeI2CAddressAction,
     EZO_PMP_CHANGE_I2C_ADDRESS_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_ADDRESS, "change_i2c_address", cg.int_),
 )
-async def ezo_pmp_change_i2c_address_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_ADDRESS], args, cg.int_)
-    cg.add(var.set_address(template_))
-
-    return var
 
 
 EZO_PMP_ARBITRARY_COMMAND_ACTION_SCHEMA = cv.All(
@@ -299,18 +154,8 @@ EZO_PMP_ARBITRARY_COMMAND_ACTION_SCHEMA = cv.All(
     }
 )
 
-
-@automation.register_action(
+automation.register_apply_action(
     "ezo_pmp.arbitrary_command",
-    EzoPMPArbitraryCommandAction,
     EZO_PMP_ARBITRARY_COMMAND_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_COMMAND, "exec_arbitrary_command", cg.std_string),
 )
-async def ezo_pmp_arbitrary_command_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.std_string)
-    cg.add(var.set_command(template_))
-
-    return var

esphome/components/ezo_pmp/ezo_pmp.h

@@ -2,7 +2,6 @@
 
 #include "esphome/core/defines.h"
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/i2c/i2c.h"
 
 #ifdef USE_BINARY_SENSOR
@@ -113,137 +112,4 @@ class EzoPMP final : public PollingComponent, public i2c::I2CDevice {
 #endif
 };
 
-// Action Templates
-template<typename... Ts> class EzoPMPFindAction final : public Action<Ts...> {
- public:
-  EzoPMPFindAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->find(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPDoseContinuouslyAction final : public Action<Ts...> {
- public:
-  EzoPMPDoseContinuouslyAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->dose_continuously(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPDoseVolumeAction final : public Action<Ts...> {
- public:
-  EzoPMPDoseVolumeAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->dose_volume(this->volume_.value(x...)); }
-  TEMPLATABLE_VALUE(double, volume)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPDoseVolumeOverTimeAction final : public Action<Ts...> {
- public:
-  EzoPMPDoseVolumeOverTimeAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override {
-    this->ezopmp_->dose_volume_over_time(this->volume_.value(x...), this->duration_.value(x...));
-  }
-  TEMPLATABLE_VALUE(double, volume)
-  TEMPLATABLE_VALUE(int, duration)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPDoseWithConstantFlowRateAction final : public Action<Ts...> {
- public:
-  EzoPMPDoseWithConstantFlowRateAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override {
-    this->ezopmp_->dose_with_constant_flow_rate(this->volume_.value(x...), this->duration_.value(x...));
-  }
-  TEMPLATABLE_VALUE(double, volume)
-  TEMPLATABLE_VALUE(int, duration)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPSetCalibrationVolumeAction final : public Action<Ts...> {
- public:
-  EzoPMPSetCalibrationVolumeAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->set_calibration_volume(this->volume_.value(x...)); }
-  TEMPLATABLE_VALUE(double, volume)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPClearTotalVolumeDispensedAction final : public Action<Ts...> {
- public:
-  EzoPMPClearTotalVolumeDispensedAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->clear_total_volume_dosed(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPClearCalibrationAction final : public Action<Ts...> {
- public:
-  EzoPMPClearCalibrationAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->clear_calibration(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPPauseDosingAction final : public Action<Ts...> {
- public:
-  EzoPMPPauseDosingAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->pause_dosing(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPStopDosingAction final : public Action<Ts...> {
- public:
-  EzoPMPStopDosingAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->stop_dosing(); }
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPChangeI2CAddressAction final : public Action<Ts...> {
- public:
-  EzoPMPChangeI2CAddressAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->change_i2c_address(this->address_.value(x...)); }
-  TEMPLATABLE_VALUE(int, address)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
-template<typename... Ts> class EzoPMPArbitraryCommandAction final : public Action<Ts...> {
- public:
-  EzoPMPArbitraryCommandAction(EzoPMP *ezopmp) : ezopmp_(ezopmp) {}
-
-  void play(const Ts &...x) override { this->ezopmp_->exec_arbitrary_command(this->command_.value(x...)); }
-  TEMPLATABLE_VALUE(std::string, command)
-
- protected:
-  EzoPMP *ezopmp_;
-};
-
 }  // namespace esphome::ezo_pmp

esphome/components/fan/__init__.py

@@ -61,8 +61,6 @@ RESTORE_MODES = {
 }
 
 # Actions
-TurnOffAction = fan_ns.class_("TurnOffAction", automation.Action)
-ToggleAction = fan_ns.class_("ToggleAction", automation.Action)
 CycleSpeedAction = fan_ns.class_("CycleSpeedAction", automation.Action)
 
 FanStateTrigger = fan_ns.class_(
@@ -310,21 +308,8 @@ FAN_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action(
-    "fan.toggle", ToggleAction, FAN_ACTION_SCHEMA, synchronous=True
-)
-async def fan_toggle_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "fan.turn_off", TurnOffAction, FAN_ACTION_SCHEMA, synchronous=True
-)
-async def fan_turn_off_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
+automation.register_apply_action("fan.toggle", FAN_ACTION_SCHEMA, call="toggle")
+automation.register_apply_action("fan.turn_off", FAN_ACTION_SCHEMA, call="turn_off")
 
 automation.register_apply_action(
     "fan.turn_on",

esphome/components/fan/automation.h

@@ -6,24 +6,6 @@
 
 namespace esphome::fan {
 
-template<typename... Ts> class TurnOffAction final : public Action<Ts...> {
- public:
-  explicit TurnOffAction(Fan *state) : state_(state) {}
-
-  void play(const Ts &...x) override { this->state_->turn_off().perform(); }
-
-  Fan *state_;
-};
-
-template<typename... Ts> class ToggleAction final : public Action<Ts...> {
- public:
-  explicit ToggleAction(Fan *state) : state_(state) {}
-
-  void play(const Ts &...x) override { this->state_->toggle().perform(); }
-
-  Fan *state_;
-};
-
 template<typename... Ts> class CycleSpeedAction final : public Action<Ts...> {
  public:
   explicit CycleSpeedAction(Fan *state) : state_(state) {}

esphome/components/fingerprint_grow/__init__.py

@@ -37,16 +37,6 @@ FingerprintGrowComponent = fingerprint_grow_ns.class_(
     "FingerprintGrowComponent", cg.PollingComponent, uart.UARTDevice
 )
 
-EnrollmentAction = fingerprint_grow_ns.class_("EnrollmentAction", automation.Action)
-CancelEnrollmentAction = fingerprint_grow_ns.class_(
-    "CancelEnrollmentAction", automation.Action
-)
-DeleteAction = fingerprint_grow_ns.class_("DeleteAction", automation.Action)
-DeleteAllAction = fingerprint_grow_ns.class_("DeleteAllAction", automation.Action)
-LEDControlAction = fingerprint_grow_ns.class_("LEDControlAction", automation.Action)
-AuraLEDControlAction = fingerprint_grow_ns.class_(
-    "AuraLEDControlAction", automation.Action
-)
 
 AuraLEDState = fingerprint_grow_ns.enum("GrowAuraLEDState", True)
 AURA_LED_STATES = {
@@ -181,111 +171,68 @@ async def to_code(config):
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
-@automation.register_action(
-    "fingerprint_grow.enroll",
-    EnrollmentAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
-            cv.Required(CONF_FINGER_ID): cv.templatable(cv.uint16_t),
-            cv.Optional(CONF_NUM_SCANS): cv.templatable(cv.uint8_t),
-        },
-        key=CONF_FINGER_ID,
-    ),
-    synchronous=True,
-)
-async def fingerprint_grow_enroll_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    template_ = await cg.templatable(config[CONF_FINGER_ID], args, cg.uint16)
-    cg.add(var.set_finger_id(template_))
-    if CONF_NUM_SCANS in config:
-        template_ = await cg.templatable(config[CONF_NUM_SCANS], args, cg.uint8)
-        cg.add(var.set_num_scans(template_))
-    return var
-
-
-@automation.register_action(
-    "fingerprint_grow.cancel_enroll",
-    CancelEnrollmentAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
-        }
-    ),
-    synchronous=True,
-)
-async def fingerprint_grow_cancel_enroll_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@automation.register_action(
-    "fingerprint_grow.delete",
-    DeleteAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
-            cv.Required(CONF_FINGER_ID): cv.templatable(cv.uint16_t),
-        },
-        key=CONF_FINGER_ID,
-    ),
-    synchronous=True,
-)
-async def fingerprint_grow_delete_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    template_ = await cg.templatable(config[CONF_FINGER_ID], args, cg.uint16)
-    cg.add(var.set_finger_id(template_))
-    return var
-
-
-@automation.register_action(
-    "fingerprint_grow.delete_all",
-    DeleteAllAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
-        }
-    ),
-    synchronous=True,
-)
-async def fingerprint_grow_delete_all_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-FINGERPRINT_GROW_LED_CONTROL_ACTION_SCHEMA = cv.maybe_simple_value(
+FINGERPRINT_GROW_ID_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
-        cv.Required(CONF_STATE): cv.templatable(cv.boolean),
-    },
-    key=CONF_STATE,
+    }
 )
 
+automation.register_apply_action(
+    "fingerprint_grow.enroll",
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
+            cv.Required(CONF_FINGER_ID): cv.templatable(cv.uint16_t),
+            cv.Optional(CONF_NUM_SCANS, default=2): cv.templatable(
+                cv.int_range(min=1, max=255)
+            ),
+        },
+        key=CONF_FINGER_ID,
+    ),
+    automation.ApplyCall(
+        "enroll_fingerprint({}, {})",
+        ((CONF_FINGER_ID, cg.uint16), (CONF_NUM_SCANS, cg.uint8)),
+    ),
+)
 
-@automation.register_action(
+automation.register_apply_action(
+    "fingerprint_grow.cancel_enroll",
+    FINGERPRINT_GROW_ID_SCHEMA,
+    automation.ApplyCall("finish_enrollment(1)"),
+)
+
+automation.register_apply_action(
+    "fingerprint_grow.delete",
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
+            cv.Required(CONF_FINGER_ID): cv.templatable(cv.uint16_t),
+        },
+        key=CONF_FINGER_ID,
+    ),
+    automation.ApplyField(CONF_FINGER_ID, "delete_fingerprint", cg.uint16),
+)
+
+automation.register_apply_action(
+    "fingerprint_grow.delete_all",
+    FINGERPRINT_GROW_ID_SCHEMA,
+    automation.ApplyCall("delete_all_fingerprints()"),
+)
+
+automation.register_apply_action(
     "fingerprint_grow.led_control",
-    LEDControlAction,
-    FINGERPRINT_GROW_LED_CONTROL_ACTION_SCHEMA,
-    synchronous=True,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
+            cv.Required(CONF_STATE): cv.templatable(cv.boolean),
+        },
+        key=CONF_STATE,
+    ),
+    automation.ApplyField(CONF_STATE, "led_control", cg.bool_),
 )
-async def fingerprint_grow_led_control_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    template_ = await cg.templatable(config[CONF_STATE], args, cg.bool_)
-    cg.add(var.set_state(template_))
-    return var
-
-
-@automation.register_action(
+automation.register_apply_action(
     "fingerprint_grow.aura_led_control",
-    AuraLEDControlAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
@@ -295,15 +242,13 @@ async def fingerprint_grow_led_control_to_code(config, action_id, template_arg,
             cv.Required(CONF_COUNT): cv.templatable(cv.uint8_t),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall(
+        "aura_led_control({}, {}, {}, {})",
+        (
+            (CONF_STATE, cg.uint8),
+            (CONF_SPEED, cg.uint8),
+            (CONF_COLOR, cg.uint8),
+            (CONF_COUNT, cg.uint8),
+        ),
+    ),
 )
-async def fingerprint_grow_aura_led_control_to_code(
-    config, action_id, template_arg, args
-):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    for key in [CONF_STATE, CONF_SPEED, CONF_COLOR, CONF_COUNT]:
-        template_ = await cg.templatable(config[key], args, cg.uint8)
-        cg.add(getattr(var, f"set_{key}")(template_))
-    return var

esphome/components/fingerprint_grow/fingerprint_grow.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/components/uart/uart.h"
@@ -209,71 +208,4 @@ class FingerprintGrowComponent final : public PollingComponent, public uart::UAR
   CallbackManager<void(uint16_t)> enrollment_failed_callback_;
 };
 
-template<typename... Ts>
-class EnrollmentAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, finger_id)
-  TEMPLATABLE_VALUE(uint8_t, num_scans)
-
-  void play(const Ts &...x) override {
-    auto finger_id = this->finger_id_.value(x...);
-    auto num_scans = this->num_scans_.value(x...);
-    if (num_scans) {
-      this->parent_->enroll_fingerprint(finger_id, num_scans);
-    } else {
-      this->parent_->enroll_fingerprint(finger_id, 2);
-    }
-  }
-};
-
-template<typename... Ts>
-class CancelEnrollmentAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  void play(const Ts &...x) override { this->parent_->finish_enrollment(1); }
-};
-
-template<typename... Ts> class DeleteAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, finger_id)
-
-  void play(const Ts &...x) override {
-    auto finger_id = this->finger_id_.value(x...);
-    this->parent_->delete_fingerprint(finger_id);
-  }
-};
-
-template<typename... Ts> class DeleteAllAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  void play(const Ts &...x) override { this->parent_->delete_all_fingerprints(); }
-};
-
-template<typename... Ts>
-class LEDControlAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  TEMPLATABLE_VALUE(bool, state)
-
-  void play(const Ts &...x) override {
-    auto state = this->state_.value(x...);
-    this->parent_->led_control(state);
-  }
-};
-
-template<typename... Ts>
-class AuraLEDControlAction final : public Action<Ts...>, public Parented<FingerprintGrowComponent> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, state)
-  TEMPLATABLE_VALUE(uint8_t, speed)
-  TEMPLATABLE_VALUE(uint8_t, color)
-  TEMPLATABLE_VALUE(uint8_t, count)
-
-  void play(const Ts &...x) override {
-    auto state = this->state_.value(x...);
-    auto speed = this->speed_.value(x...);
-    auto color = this->color_.value(x...);
-    auto count = this->count_.value(x...);
-
-    this->parent_->aura_led_control(state, speed, color, count);
-  }
-};
-
 }  // namespace esphome::fingerprint_grow

esphome/components/gree/gree.cpp

@@ -226,7 +226,7 @@ uint8_t GreeClimate::vertical_swing_() {
 }
 
 uint8_t GreeClimate::temperature_() {
-  return (uint8_t) roundf(clamp<float>(this->target_temperature, GREE_TEMP_MIN, GREE_TEMP_MAX));
+  return (uint8_t) roundf(clamp<float>(this->target_temperature, GREE_TEMP_MIN, GREE_TEMP_MAX)) - GREE_TEMP_MIN;
 }
 
 uint8_t GreeClimate::preset_() {

esphome/components/grove_tb6612fng/__init__.py

@@ -20,28 +20,9 @@ grove_tb6612fng_ns = cg.esphome_ns.namespace("grove_tb6612fng")
 GROVE_TB6612FNG = grove_tb6612fng_ns.class_(
     "GroveMotorDriveTB6612FNG", cg.Component, i2c.I2CDevice
 )
-GROVETB6612FNGMotorRunAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorRunAction", automation.Action
-)
-GROVETB6612FNGMotorBrakeAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorBrakeAction", automation.Action
-)
-GROVETB6612FNGMotorStopAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorStopAction", automation.Action
-)
-GROVETB6612FNGMotorStandbyAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorStandbyAction", automation.Action
-)
-GROVETB6612FNGMotorNoStandbyAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorNoStandbyAction", automation.Action
-)
-GROVETB6612FNGMotorChangeAddressAction = grove_tb6612fng_ns.class_(
-    "GROVETB6612FNGMotorChangeAddressAction", automation.Action
-)
-
 DIRECTION_TYPE = {
     "FORWARD": 1,
-    "BACKWARD": 2,
+    "BACKWARD": -1,
 }
 
 CONFIG_SCHEMA = (
@@ -61,9 +42,8 @@ async def to_code(config):
     await i2c.register_i2c_device(var, config)
 
 
-@automation.register_action(
+automation.register_apply_action(
     "grove_tb6612fng.run",
-    GROVETB6612FNGMotorRunAction,
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
@@ -72,109 +52,52 @@ async def to_code(config):
             cv.Required(CONF_DIRECTION): cv.enum(DIRECTION_TYPE, upper=True),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall(
+        "dc_motor_run({}, {} * {})",
+        ((CONF_CHANNEL, cg.uint8), (CONF_DIRECTION, cg.int16), (CONF_SPEED, cg.uint16)),
+    ),
 )
-async def grove_tb6612fng_run_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
-    template_speed = await cg.templatable(config[CONF_SPEED], args, cg.uint16)
-    cg.add(var.set_channel(template_channel))
-    cg.add(var.set_speed(template_speed))
-    cg.add(var.set_direction(config[CONF_DIRECTION] == "FORWARD"))
-    return var
+CHANNEL_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
+        cv.Required(CONF_CHANNEL): cv.templatable(cv.int_range(min=0, max=1)),
+    }
+)
 
-
-@automation.register_action(
+automation.register_apply_action(
     "grove_tb6612fng.break",
-    GROVETB6612FNGMotorBrakeAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
-            cv.Required(CONF_CHANNEL): cv.templatable(cv.int_range(min=0, max=1)),
-        }
-    ),
-    synchronous=True,
+    CHANNEL_SCHEMA,
+    automation.ApplyField(CONF_CHANNEL, "dc_motor_brake", cg.uint8),
 )
-async def grove_tb6612fng_break_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
-    cg.add(var.set_channel(template_channel))
-    return var
-
-
-@automation.register_action(
+automation.register_apply_action(
     "grove_tb6612fng.stop",
-    GROVETB6612FNGMotorStopAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
-            cv.Required(CONF_CHANNEL): cv.templatable(cv.int_range(min=0, max=1)),
-        }
-    ),
-    synchronous=True,
+    CHANNEL_SCHEMA,
+    automation.ApplyField(CONF_CHANNEL, "dc_motor_stop", cg.uint8),
 )
-async def grove_tb6612fng_stop_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    template_channel = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
-    cg.add(var.set_channel(template_channel))
-    return var
-
-
-@automation.register_action(
-    "grove_tb6612fng.standby",
-    GROVETB6612FNGMotorStandbyAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
-        }
-    ),
-    synchronous=True,
+PARENT_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
+    }
 )
-async def grove_tb6612fng_standby_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    return var
-
-
-@automation.register_action(
-    "grove_tb6612fng.no_standby",
-    GROVETB6612FNGMotorNoStandbyAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
-        }
-    ),
-    synchronous=True,
+automation.register_apply_action(
+    "grove_tb6612fng.standby", PARENT_SCHEMA, automation.ApplyCall("standby()")
 )
-async def grove_tb6612fng_no_standby_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
 
-    return var
+automation.register_apply_action(
+    "grove_tb6612fng.no_standby", PARENT_SCHEMA, automation.ApplyCall("not_standby()")
+)
 
-
-@automation.register_action(
+automation.register_apply_action(
     "grove_tb6612fng.change_address",
-    GROVETB6612FNGMotorChangeAddressAction,
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
             cv.Required(CONF_ADDRESS): cv.i2c_address,
         }
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_ADDRESS, "set_i2c_addr", cg.uint8),
 )
-async def grove_tb6612fng_change_address_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    template_channel = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
-    cg.add(var.set_address(template_channel))
-    return var

esphome/components/grove_tb6612fng/grove_tb6612fng.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 // #include "esphome/core/helpers.h"
@@ -161,61 +160,4 @@ class GroveMotorDriveTB6612FNG final : public Component, public i2c::I2CDevice {
   uint8_t buffer_[16];
 };
 
-template<typename... Ts>
-class GROVETB6612FNGMotorRunAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, channel)
-  TEMPLATABLE_VALUE(uint16_t, speed)
-
-  void set_direction(bool forward) { this->forward_ = forward; }
-
-  void play(const Ts &...x) override {
-    auto channel = this->channel_.value(x...);
-    int16_t speed = this->speed_.value(x...);
-    if (!this->forward_) {
-      speed = -speed;
-    }
-    this->parent_->dc_motor_run(channel, speed);
-  }
-
- protected:
-  bool forward_{true};
-};
-
-template<typename... Ts>
-class GROVETB6612FNGMotorBrakeAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, channel)
-
-  void play(const Ts &...x) override { this->parent_->dc_motor_brake(this->channel_.value(x...)); }
-};
-
-template<typename... Ts>
-class GROVETB6612FNGMotorStopAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, channel)
-
-  void play(const Ts &...x) override { this->parent_->dc_motor_stop(this->channel_.value(x...)); }
-};
-
-template<typename... Ts>
-class GROVETB6612FNGMotorStandbyAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  void play(const Ts &...x) override { this->parent_->standby(); }
-};
-
-template<typename... Ts>
-class GROVETB6612FNGMotorNoStandbyAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  void play(const Ts &...x) override { this->parent_->not_standby(); }
-};
-
-template<typename... Ts>
-class GROVETB6612FNGMotorChangeAddressAction final : public Action<Ts...>, public Parented<GroveMotorDriveTB6612FNG> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, address)
-
-  void play(const Ts &...x) override { this->parent_->set_i2c_addr(this->address_.value(x...)); }
-};
-
 }  // namespace esphome::grove_tb6612fng

esphome/components/haier/automation.h

@@ -1,128 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "haier_base.h"
-#include "hon_climate.h"
-
-namespace esphome::haier {
-
-template<typename... Ts> class DisplayOnAction final : public Action<Ts...> {
- public:
-  DisplayOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_display_state(true); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class DisplayOffAction final : public Action<Ts...> {
- public:
-  DisplayOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_display_state(false); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class BeeperOnAction final : public Action<Ts...> {
- public:
-  BeeperOnAction(HonClimate *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_beeper_state(true); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class BeeperOffAction final : public Action<Ts...> {
- public:
-  BeeperOffAction(HonClimate *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_beeper_state(false); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class VerticalAirflowAction final : public Action<Ts...> {
- public:
-  VerticalAirflowAction(HonClimate *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(hon_protocol::VerticalSwingMode, direction)
-  void play(const Ts &...x) { this->parent_->set_vertical_airflow(this->direction_.value(x...)); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class HorizontalAirflowAction final : public Action<Ts...> {
- public:
-  HorizontalAirflowAction(HonClimate *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(hon_protocol::HorizontalSwingMode, direction)
-  void play(const Ts &...x) { this->parent_->set_horizontal_airflow(this->direction_.value(x...)); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class HealthOnAction final : public Action<Ts...> {
- public:
-  HealthOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_health_mode(true); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class HealthOffAction final : public Action<Ts...> {
- public:
-  HealthOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->set_health_mode(false); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class StartSelfCleaningAction final : public Action<Ts...> {
- public:
-  StartSelfCleaningAction(HonClimate *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->start_self_cleaning(); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class StartSteriCleaningAction final : public Action<Ts...> {
- public:
-  StartSteriCleaningAction(HonClimate *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->start_steri_cleaning(); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class PowerOnAction final : public Action<Ts...> {
- public:
-  PowerOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->send_power_on_command(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class PowerOffAction final : public Action<Ts...> {
- public:
-  PowerOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->send_power_off_command(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class PowerToggleAction final : public Action<Ts...> {
- public:
-  PowerToggleAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(const Ts &...x) { this->parent_->toggle_power(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-}  // namespace esphome::haier

esphome/components/haier/climate.py

@@ -9,7 +9,6 @@ from esphome.const import (
     CONF_BEEPER,
     CONF_CURRENT_TEMPERATURE,
     CONF_DISPLAY,
-    CONF_ID,
     CONF_LEVEL,
     CONF_LOGGER,
     CONF_LOGS,
@@ -254,23 +253,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-# Actions
-DisplayOnAction = haier_ns.class_("DisplayOnAction", automation.Action)
-DisplayOffAction = haier_ns.class_("DisplayOffAction", automation.Action)
-BeeperOnAction = haier_ns.class_("BeeperOnAction", automation.Action)
-BeeperOffAction = haier_ns.class_("BeeperOffAction", automation.Action)
-StartSelfCleaningAction = haier_ns.class_("StartSelfCleaningAction", automation.Action)
-StartSteriCleaningAction = haier_ns.class_(
-    "StartSteriCleaningAction", automation.Action
-)
-VerticalAirflowAction = haier_ns.class_("VerticalAirflowAction", automation.Action)
-HorizontalAirflowAction = haier_ns.class_("HorizontalAirflowAction", automation.Action)
-HealthOnAction = haier_ns.class_("HealthOnAction", automation.Action)
-HealthOffAction = haier_ns.class_("HealthOffAction", automation.Action)
-PowerOnAction = haier_ns.class_("PowerOnAction", automation.Action)
-PowerOffAction = haier_ns.class_("PowerOffAction", automation.Action)
-PowerToggleAction = haier_ns.class_("PowerToggleAction", automation.Action)
-
 HAIER_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
     {
         cv.GenerateID(): cv.use_id(HaierClimateBase),
@@ -284,62 +266,35 @@ HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 
 
-@automation.register_action(
-    "climate.haier.display_on",
-    DisplayOnAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.display_off",
-    DisplayOffAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def display_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+for _name, _schema, _call in (
+    ("climate.haier.display_on", HAIER_BASE_ACTION_SCHEMA, "set_display_state(true)"),
+    ("climate.haier.display_off", HAIER_BASE_ACTION_SCHEMA, "set_display_state(false)"),
+    ("climate.haier.beeper_on", HAIER_HON_BASE_ACTION_SCHEMA, "set_beeper_state(true)"),
+    (
+        "climate.haier.beeper_off",
+        HAIER_HON_BASE_ACTION_SCHEMA,
+        "set_beeper_state(false)",
+    ),
+    (
+        "climate.haier.start_self_cleaning",
+        HAIER_HON_BASE_ACTION_SCHEMA,
+        "start_self_cleaning()",
+    ),
+    (
+        "climate.haier.start_steri_cleaning",
+        HAIER_HON_BASE_ACTION_SCHEMA,
+        "start_steri_cleaning()",
+    ),
+    ("climate.haier.health_on", HAIER_BASE_ACTION_SCHEMA, "set_health_mode(true)"),
+    ("climate.haier.health_off", HAIER_BASE_ACTION_SCHEMA, "set_health_mode(false)"),
+    ("climate.haier.power_on", HAIER_BASE_ACTION_SCHEMA, "send_power_on_command()"),
+    ("climate.haier.power_off", HAIER_BASE_ACTION_SCHEMA, "send_power_off_command()"),
+    ("climate.haier.power_toggle", HAIER_BASE_ACTION_SCHEMA, "toggle_power()"),
+):
+    automation.register_apply_action(_name, _schema, automation.ApplyCall(_call))
 
-
-@automation.register_action(
-    "climate.haier.beeper_on",
-    BeeperOnAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.beeper_off",
-    BeeperOffAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def beeper_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-# Start self cleaning or steri-cleaning action action
-@automation.register_action(
-    "climate.haier.start_self_cleaning",
-    StartSelfCleaningAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.start_steri_cleaning",
-    StartSteriCleaningAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def start_cleaning_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-# Set vertical airflow direction action
-@automation.register_action(
+automation.register_apply_action(
     "climate.haier.set_vertical_airflow",
-    VerticalAirflowAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(HonClimate),
@@ -348,22 +303,13 @@ async def start_cleaning_to_code(config, action_id, template_arg, args):
             ),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(
+        CONF_VERTICAL_AIRFLOW, "set_vertical_airflow", AirflowVerticalDirection
+    ),
 )
-async def haier_set_vertical_airflow_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(
-        config[CONF_VERTICAL_AIRFLOW], args, AirflowVerticalDirection
-    )
-    cg.add(var.set_direction(template_))
-    return var
 
-
-# Set horizontal airflow direction action
-@automation.register_action(
+automation.register_apply_action(
     "climate.haier.set_horizontal_airflow",
-    HorizontalAirflowAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(HonClimate),
@@ -372,56 +318,10 @@ async def haier_set_vertical_airflow_to_code(config, action_id, template_arg, ar
             ),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(
+        CONF_HORIZONTAL_AIRFLOW, "set_horizontal_airflow", AirflowHorizontalDirection
+    ),
 )
-async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(
-        config[CONF_HORIZONTAL_AIRFLOW], args, AirflowHorizontalDirection
-    )
-    cg.add(var.set_direction(template_))
-    return var
-
-
-@automation.register_action(
-    "climate.haier.health_on",
-    HealthOnAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.health_off",
-    HealthOffAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def health_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-@automation.register_action(
-    "climate.haier.power_on",
-    PowerOnAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.power_off",
-    PowerOffAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-@automation.register_action(
-    "climate.haier.power_toggle",
-    PowerToggleAction,
-    HAIER_BASE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def power_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 def _final_validate(config) -> None:

esphome/components/hbridge/fan/__init__.py

@@ -7,14 +7,11 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_DECAY_MODE,
     CONF_ENABLE_PIN,
-    CONF_ID,
     CONF_PIN_A,
     CONF_PIN_B,
     CONF_PRESET_MODES,
     CONF_SPEED_COUNT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 from .. import hbridge_ns
@@ -30,9 +27,6 @@ DECAY_MODE_OPTIONS = {
     "FAST": DecayMode.DECAY_MODE_FAST,
 }
 
-# Actions
-BrakeAction = hbridge_ns.class_("BrakeAction", automation.Action)
-
 CONFIG_SCHEMA = (
     fan.fan_schema(HBridgeFan)
     .extend(
@@ -51,20 +45,11 @@ CONFIG_SCHEMA = (
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "fan.hbridge.brake",
-    BrakeAction,
     maybe_simple_id({cv.GenerateID(): cv.use_id(HBridgeFan)}),
-    synchronous=True,
+    automation.ApplyCall("brake()"),
 )
-async def fan_hbridge_brake_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/hbridge/fan/hbridge_fan.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "esphome/core/automation.h"
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/output/float_output.h"
 #include "esphome/components/fan/fan.h"
@@ -46,13 +45,4 @@ class HBridgeFan final : public Component, public fan::Fan {
   void set_hbridge_levels_(float a_level, float b_level, float enable);
 };
 
-template<typename... Ts> class BrakeAction final : public Action<Ts...> {
- public:
-  explicit BrakeAction(HBridgeFan *parent) : parent_(parent) {}
-
-  void play(const Ts &...x) override { this->parent_->brake(); }
-
-  HBridgeFan *parent_;
-};
-
 }  // namespace esphome::hbridge

esphome/components/hc8/hc8.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -26,11 +25,4 @@ class HC8Component final : public PollingComponent, public uart::UARTDevice {
   bool warmup_complete_{false};
 };
 
-template<typename... Ts> class HC8CalibrateAction final : public Action<Ts...>, public Parented<HC8Component> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, baseline)
-
-  void play(const Ts &...x) override { this->parent_->calibrate(this->baseline_.value(x...)); }
-};
-
 }  // namespace esphome::hc8

esphome/components/hc8/sensor.py

@@ -12,15 +12,12 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     UNIT_PARTS_PER_MILLION,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["uart"]
 
 hc8_ns = cg.esphome_ns.namespace("hc8")
 HC8Component = hc8_ns.class_("HC8Component", cg.PollingComponent, uart.UARTDevice)
-HC8CalibrateAction = hc8_ns.class_("HC8CalibrateAction", automation.Action)
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -73,20 +70,8 @@ CALIBRATION_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "hc8.calibrate",
-    HC8CalibrateAction,
     CALIBRATION_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyField(CONF_BASELINE, "calibrate", cg.uint16),
 )
-async def hc8_calibration_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_BASELINE], args, cg.uint16)
-    cg.add(var.set_baseline(template_))
-    return var

esphome/components/hdc302x/hdc302x.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
 
@@ -48,21 +47,4 @@ class HDC302XComponent final : public PollingComponent, public i2c::I2CDevice {
   uint32_t conversion_delay_ms_();
 };
 
-template<typename... Ts> class HeaterOnAction final : public Action<Ts...>, public Parented<HDC302XComponent> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, power)
-  TEMPLATABLE_VALUE(uint32_t, duration)
-
-  void play(const Ts &...x) override {
-    auto power_val = this->power_.value(x...);
-    auto duration_val = this->duration_.value(x...);
-    this->parent_->start_heater(power_val, duration_val);
-  }
-};
-
-template<typename... Ts> class HeaterOffAction final : public Action<Ts...>, public Parented<HDC302XComponent> {
- public:
-  void play(const Ts &...x) override { this->parent_->stop_heater(); }
-};
-
 }  // namespace esphome::hdc302x

esphome/components/hdc302x/sensor.py

@@ -18,8 +18,6 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PERCENT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["i2c"]
@@ -37,10 +35,6 @@ POWER_MODE_OPTIONS = {
     "ULTRA_LOW_POWER": HDC302XPowerMode.ULTRA_LOW_POWER,
 }
 
-# Actions
-HeaterOnAction = hdc302x_ns.class_("HeaterOnAction", automation.Action)
-HeaterOffAction = hdc302x_ns.class_("HeaterOffAction", automation.Action)
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -118,39 +112,14 @@ HDC302X_HEATER_ON_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action(
+automation.register_apply_action(
     "hdc302x.heater_on",
-    HeaterOnAction,
     HDC302X_HEATER_ON_ACTION_SCHEMA,
-    synchronous=True,
+    automation.ApplyCall(
+        "start_heater({}, {})", ((CONF_POWER, cg.uint16), (CONF_DURATION, cg.uint32))
+    ),
 )
-async def hdc302x_heater_on_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_POWER], args, cg.uint16)
-    cg.add(var.set_power(template_))
-    template_ = await cg.templatable(config[CONF_DURATION], args, cg.uint32)
-    cg.add(var.set_duration(template_))
-    return var
 
-
-@automation.register_action(
-    "hdc302x.heater_off",
-    HeaterOffAction,
-    HDC302X_ACTION_SCHEMA,
-    synchronous=True,
+automation.register_apply_action(
+    "hdc302x.heater_off", HDC302X_ACTION_SCHEMA, automation.ApplyCall("stop_heater()")
 )
-async def hdc302x_heater_off_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var

esphome/components/htu21d/htu21d.h

@@ -3,7 +3,6 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/automation.h"
 
 namespace esphome::htu21d {
 
@@ -34,26 +33,4 @@ class HTU21DComponent final : public PollingComponent, public i2c::I2CDevice {
   HTU21DSensorModels sensor_model_{HTU21D_SENSOR_MODEL_HTU21D};
 };
 
-template<typename... Ts> class SetHeaterLevelAction final : public Action<Ts...>, public Parented<HTU21DComponent> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, level)
-
-  void play(const Ts &...x) override {
-    auto level = this->level_.value(x...);
-
-    this->parent_->set_heater_level(level);
-  }
-};
-
-template<typename... Ts> class SetHeaterAction final : public Action<Ts...>, public Parented<HTU21DComponent> {
- public:
-  TEMPLATABLE_VALUE(bool, status)
-
-  void play(const Ts &...x) override {
-    auto status = this->status_.value(x...);
-
-    this->parent_->set_heater(status);
-  }
-};
-
 }  // namespace esphome::htu21d

esphome/components/htu21d/sensor.py

@@ -17,8 +17,6 @@ from esphome.const import (
     UNIT_EMPTY,
     UNIT_PERCENT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["i2c"]
@@ -27,8 +25,6 @@ htu21d_ns = cg.esphome_ns.namespace("htu21d")
 HTU21DComponent = htu21d_ns.class_(
     "HTU21DComponent", cg.PollingComponent, i2c.I2CDevice
 )
-SetHeaterLevelAction = htu21d_ns.class_("SetHeaterLevelAction", automation.Action)
-SetHeaterAction = htu21d_ns.class_("SetHeaterAction", automation.Action)
 HTU21DSensorModels = htu21d_ns.enum("HTU21DSensorModels")
 
 MODELS = {
@@ -86,9 +82,8 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_sensor_model(config[CONF_MODEL]))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "htu21d.set_heater_level",
-    SetHeaterLevelAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(HTU21DComponent),
@@ -96,24 +91,11 @@ async def to_code(config: ConfigType) -> None:
         },
         key=CONF_LEVEL,
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_LEVEL, "set_heater_level", cg.uint8),
 )
-async def set_heater_level_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    level_ = await cg.templatable(config[CONF_LEVEL], args, cg.uint8)
-    cg.add(var.set_level(level_))
-    return var
 
-
-@automation.register_action(
+automation.register_apply_action(
     "htu21d.set_heater",
-    SetHeaterAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(HTU21DComponent),
@@ -121,16 +103,5 @@ async def set_heater_level_to_code(
         },
         key=CONF_STATUS,
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_STATUS, "set_heater", cg.bool_),
 )
-async def set_heater_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    status_ = await cg.templatable(config[CONF_STATUS], args, cg.bool_)
-    cg.add(var.set_status(status_))
-    return var

esphome/components/hub75/display.py

@@ -18,8 +18,7 @@ from esphome.const import (
     CONF_ROTATION,
     CONF_UPDATE_INTERVAL,
 )
-from esphome.core import ID, EnumValue
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import EnumValue
 import esphome.final_validate as fv
 from esphome.helpers import add_class_to_obj
 from esphome.types import ConfigType
@@ -167,7 +166,6 @@ ROTATIONS = {
 HUB75Display = hub75_ns.class_("HUB75Display", cg.PollingComponent, display.Display)
 Hub75Config = cg.global_ns.struct("Hub75Config")
 Hub75Pins = cg.global_ns.struct("Hub75Pins")
-SetBrightnessAction = hub75_ns.class_("SetBrightnessAction", automation.Action)
 
 
 def _merge_board_pins(config: ConfigType) -> ConfigType:
@@ -619,9 +617,8 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_writer(lambda_))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "hub75.set_brightness",
-    SetBrightnessAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(HUB75Display),
@@ -629,16 +626,5 @@ async def to_code(config: ConfigType) -> None:
         },
         key=CONF_BRIGHTNESS,
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_BRIGHTNESS, "set_brightness", cg.uint8),
 )
-async def hub75_set_brightness_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_BRIGHTNESS], args, cg.uint8)
-    cg.add(var.set_brightness(template_))
-    return var

esphome/components/hub75/hub75_component.h

@@ -5,7 +5,6 @@
 #include <utility>
 
 #include "esphome/components/display/display_buffer.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -51,13 +50,6 @@ class HUB75Display final : public display::Display {
   bool enabled_{false};
 };
 
-template<typename... Ts> class SetBrightnessAction final : public Action<Ts...>, public Parented<HUB75Display> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, brightness)
-
-  void play(const Ts &...x) override { this->parent_->set_brightness(this->brightness_.value(x...)); }
-};
-
 }  // namespace esphome::hub75
 
 #endif

esphome/components/integration/integration_sensor.h

@@ -71,16 +71,4 @@ class IntegrationSensor final : public sensor::Sensor, public Component {
   float last_value_{0.0f};
 };
 
-template<typename... Ts> class ResetAction final : public Action<Ts...>, public Parented<IntegrationSensor> {
- public:
-  void play(const Ts &...x) override { this->parent_->reset(); }
-};
-
-template<typename... Ts> class SetValueAction final : public Action<Ts...>, public Parented<IntegrationSensor> {
- public:
-  TEMPLATABLE_VALUE(float, value)
-
-  void play(const Ts &...x) override { this->parent_->set_value(this->value_.value(x...)); }
-};
-
 }  // namespace esphome::integration

esphome/components/integration/sensor.py

@@ -11,17 +11,13 @@ from esphome.const import (
     CONF_UNIT_OF_MEASUREMENT,
     CONF_VALUE,
 )
-from esphome.core import ID
 from esphome.core.entity_helpers import inherit_property_from
-from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 integration_ns = cg.esphome_ns.namespace("integration")
 IntegrationSensor = integration_ns.class_(
     "IntegrationSensor", sensor.Sensor, cg.Component
 )
-ResetAction = integration_ns.class_("ResetAction", automation.Action)
-SetValueAction = integration_ns.class_("SetValueAction", automation.Action)
 
 IntegrationSensorTime = integration_ns.enum("IntegrationSensorTime")
 INTEGRATION_TIMES = {
@@ -106,46 +102,23 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_restore(config[CONF_RESTORE]))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "sensor.integration.reset",
-    ResetAction,
     automation.maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
         }
     ),
-    synchronous=True,
+    automation.ApplyCall("reset()"),
 )
-async def sensor_integration_reset_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
 
-
-@automation.register_action(
+automation.register_apply_action(
     "sensor.integration.set_value",
-    SetValueAction,
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
             cv.Required(CONF_VALUE): cv.templatable(cv.float_),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_VALUE, "set_value", cg.float_),
 )
-async def sensor_integration_set_value_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_VALUE], args, cg.float_)
-    cg.add(var.set_value(template_))
-    return var

esphome/components/it8951/display.py

@@ -36,8 +36,7 @@ from esphome.const import (
     CONF_UPDATE_INTERVAL,
     CONF_WIDTH,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, RawExpression, TemplateArgsType
+from esphome.cpp_generator import RawExpression
 from esphome.final_validate import full_config
 from esphome.types import ConfigType
 
@@ -61,7 +60,6 @@ VCOM_REGISTER_OPTIONS = (VCOM_REGISTER_DEFAULT, VCOM_REGISTER_ALT)
 
 it8951_ns = cg.esphome_ns.namespace("it8951")
 IT8951Display = it8951_ns.class_("IT8951Display", display.Display, spi.SPIDevice)
-IT8951UpdateAction = it8951_ns.class_("IT8951UpdateAction", automation.Action)
 
 # Hardware waveform modes exposed to YAML. Strings are mapped to the C++
 # UpdateMode enum so the runtime can store the mode as a uint16_t rather
@@ -80,6 +78,7 @@ UPDATE_MODE_OPTIONS = {
     "A2": UpdateMode.UPDATE_MODE_A2,
     "FAST": UpdateMode.UPDATE_MODE_DU,
     "FULL": UpdateMode.UPDATE_MODE_GC16,
+    "DEFAULT": UpdateMode.UPDATE_MODE_NONE,
 }
 # Maps the YAML mode string directly to the C++ UpdateMode enum value, so the
 # config option and the it8951.update action share one validator.
@@ -419,26 +418,13 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_transform(RawExpression(str(transform_value))))
 
 
-@automation.register_action(
+automation.register_apply_action(
     "it8951.update",
-    IT8951UpdateAction,
     automation.maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(IT8951Display),
-            cv.Optional(CONF_MODE): cv.templatable(update_mode),
+            cv.Optional(CONF_MODE, default="DEFAULT"): cv.templatable(update_mode),
         }
     ),
-    synchronous=True,
+    automation.ApplyField(CONF_MODE, "update_mode", UpdateMode),
 )
-async def it8951_update_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    display_var = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, display_var)
-    if mode := config.get(CONF_MODE):
-        mode = await cg.templatable(mode, args, UpdateMode)
-        cg.add(var.set_mode(mode))
-    return var

esphome/components/it8951/it8951.cpp

@@ -777,12 +777,12 @@ void IT8951Display::update() {
 }
 
 void IT8951Display::update_mode(UpdateMode mode) {
-  if (!this->is_ready())
-    return;
   if (mode == UPDATE_MODE_NONE) {
-    ESP_LOGW(TAG, "Unknown update mode");
+    this->update();
     return;
   }
+  if (!this->is_ready())
+    return;
   this->start_update_(mode);
 }
 

esphome/components/it8951/it8951.h

@@ -6,7 +6,6 @@
 
 #include "esphome/components/display/display.h"
 #include "esphome/components/spi/spi.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
@@ -350,24 +349,4 @@ class IT8951Display : public Display,
   uint8_t dev_info_attempts_{0};
 };
 
-// --- Automation action ---
-template<typename... Ts> class IT8951UpdateAction : public Action<Ts...> {
- public:
-  explicit IT8951UpdateAction(IT8951Display *display) : display_(display) {}
-  TEMPLATABLE_VALUE(UpdateMode, mode)
-
- protected:
-  void play(const Ts &...x) override {
-    if (!this->display_->is_ready())
-      return;
-    if (this->mode_.has_value()) {
-      this->display_->update_mode(this->mode_.value(x...));
-    } else {
-      this->display_->update();
-    }
-  }
-
-  IT8951Display *display_;
-};
-
 }  // namespace esphome::it8951

esphome/components/key_collector/__init__.py

@@ -15,7 +15,6 @@ from esphome.const import (
     CONF_TIMEOUT,
     CONF_TRIGGER_ID,
 )
-from esphome.core import ID
 from esphome.cpp_generator import MockObj, literal
 from esphome.types import ConfigType, TemplateArgsType
 
@@ -36,8 +35,6 @@ CONF_ON_RESULT = "on_result"
 
 key_collector_ns = cg.esphome_ns.namespace("key_collector")
 KeyCollector = key_collector_ns.class_("KeyCollector", cg.Component)
-EnableAction = key_collector_ns.class_("EnableAction", automation.Action)
-DisableAction = key_collector_ns.class_("DisableAction", automation.Action)
 
 X_TYPE = cg.std_string_ref.operator("const")
 
@@ -135,43 +132,19 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_enabled(config[CONF_ENABLE_ON_BOOT]))
 
 
-@automation.register_action(
+KEY_COLLECTOR_ACTION_SCHEMA = automation.maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(KeyCollector),
+    }
+)
+
+automation.register_apply_action(
     "key_collector.enable",
-    EnableAction,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(KeyCollector),
-        }
-    ),
-    synchronous=True,
+    KEY_COLLECTOR_ACTION_SCHEMA,
+    automation.ApplyCall("set_enabled(true)"),
 )
-async def enable_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@automation.register_action(
+automation.register_apply_action(
     "key_collector.disable",
-    DisableAction,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(KeyCollector),
-        }
-    ),
-    synchronous=True,
+    KEY_COLLECTOR_ACTION_SCHEMA,
+    automation.ApplyCall("set_enabled(false)"),
 )
-async def disable_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var