Merge remote-tracking branch 'upstream/dev' into pi05

# Conflicts:
#	esphome/components/packet_interface/__init__.py
#	esphome/core/defines.h

CODEOWNERS

@@ -196,6 +196,7 @@ esphome/components/ens160_base/* @latonita @vincentscode
 esphome/components/ens160_i2c/* @latonita
 esphome/components/ens160_spi/* @latonita
 esphome/components/ens210/* @itn3rd77
+esphome/components/entity_transport/* @clydebarrow
 esphome/components/epaper_spi/* @esphome/core
 esphome/components/es7210/* @kahrendt
 esphome/components/es7243/* @Chorty

esphome/components/copy/sensor/__init__.py

@@ -13,10 +13,19 @@ from esphome.const import (
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.types import ConfigType
 
-CONFIG_SCHEMA = sensor.sensor_schema(sensor.Sensor).extend(
-    {
-        cv.Required(CONF_SOURCE_ID): cv.use_id(sensor.Sensor),
-    }
+from .. import copy_ns
+
+CopySensor = copy_ns.class_("CopySensor", sensor.Sensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(CopySensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(sensor.Sensor),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
 FINAL_VALIDATE_SCHEMA = cv.All(
@@ -31,4 +40,6 @@ FINAL_VALIDATE_SCHEMA = cv.All(
 
 async def to_code(config: ConfigType) -> None:
     var = await sensor.new_sensor(config)
-    sensor.follow_sensor(var, await cg.get_variable(config[CONF_SOURCE_ID]))
+    await cg.register_component(var, config)
+
+    await cg.add_variable(var.set_source, config[CONF_SOURCE_ID])

esphome/components/copy/sensor/copy_sensor.cpp

@@ -0,0 +1,16 @@
+#include "copy_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::copy {
+
+ESPHOME_LOG_TAG(TAG, "copy.sensor");
+
+void CopySensor::setup() {
+  source_->add_on_state_callback([this](float value) { this->publish_state(value); });
+  if (source_->has_state())
+    this->publish_state(source_->state);
+}
+
+void CopySensor::dump_config() { LOG_SENSOR("", "Copy Sensor", this); }
+
+}  // namespace esphome::copy

esphome/components/copy/sensor/copy_sensor.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome::copy {
+
+class CopySensor final : public sensor::Sensor, public Component {
+ public:
+  void set_source(sensor::Sensor *source) { source_ = source; }
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  sensor::Sensor *source_;
+};
+
+}  // namespace esphome::copy

esphome/components/copy/text_sensor/__init__.py

@@ -5,10 +5,19 @@ from esphome.const import CONF_ENTITY_CATEGORY, CONF_ICON, CONF_SOURCE_ID
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.types import ConfigType
 
-CONFIG_SCHEMA = text_sensor.text_sensor_schema(text_sensor.TextSensor).extend(
-    {
-        cv.Required(CONF_SOURCE_ID): cv.use_id(text_sensor.TextSensor),
-    }
+from .. import copy_ns
+
+CopyTextSensor = copy_ns.class_("CopyTextSensor", text_sensor.TextSensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    text_sensor.text_sensor_schema(CopyTextSensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(text_sensor.TextSensor),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
 FINAL_VALIDATE_SCHEMA = cv.All(
@@ -19,4 +28,6 @@ FINAL_VALIDATE_SCHEMA = cv.All(
 
 async def to_code(config: ConfigType) -> None:
     var = await text_sensor.new_text_sensor(config)
-    text_sensor.follow_text_sensor(var, await cg.get_variable(config[CONF_SOURCE_ID]))
+    await cg.register_component(var, config)
+
+    await cg.add_variable(var.set_source, config[CONF_SOURCE_ID])

esphome/components/copy/text_sensor/copy_text_sensor.cpp

@@ -0,0 +1,16 @@
+#include "copy_text_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::copy {
+
+ESPHOME_LOG_TAG(TAG, "copy.text_sensor");
+
+void CopyTextSensor::setup() {
+  source_->add_on_state_callback([this](const std::string &value) { this->publish_state(value); });
+  if (source_->has_state())
+    this->publish_state(source_->state);
+}
+
+void CopyTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Copy Sensor", this); }
+
+}  // namespace esphome::copy

esphome/components/copy/text_sensor/copy_text_sensor.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+
+namespace esphome::copy {
+
+class CopyTextSensor final : public text_sensor::TextSensor, public Component {
+ public:
+  void set_source(text_sensor::TextSensor *source) { source_ = source; }
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  text_sensor::TextSensor *source_;
+};
+
+}  // namespace esphome::copy

esphome/components/display/__init__.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass
-from typing import Any, Protocol
 
-from esphome import automation, core, pins
+from esphome import automation, core
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 from esphome.components.const import (
@@ -14,7 +13,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_AUTO_CLEAR_ENABLED,
     CONF_DIMENSIONS,
-    CONF_ENABLE_PIN,
     CONF_FROM,
     CONF_HEIGHT,
     CONF_ID,
@@ -56,33 +54,6 @@ DISPLAY_ROTATIONS = {
 }
 
 
-class DisplayModel(Protocol):
-    """The parts of a display model used by enable_pin_schema()."""
-
-    def get_default(self, key: str, fallback: Any = ...) -> Any: ...
-
-
-def enable_pin_schema(
-    model: DisplayModel, config: ConfigType
-) -> dict[cv.Optional, Any]:
-    """
-    Get the schema entry for a display's enable pins.
-    Pins given in the user config are used as they are. Otherwise the model's default enable
-    pins are used, except any that is also used elsewhere in the config, so a user can take
-    control of that pin, e.g. with a switch.
-    :param config: The display config as given by the user
-    """
-    schema = cv.ensure_list(pins.gpio_output_pin_schema)
-    default = model.get_default(CONF_ENABLE_PIN, None)
-    if default is None or CONF_ENABLE_PIN in config:
-        return {cv.Optional(CONF_ENABLE_PIN): schema}
-    return {
-        cv.Optional(
-            CONF_ENABLE_PIN, default=default
-        ): pins.PIN_SCHEMA_REGISTRY.optional(schema)
-    }
-
-
 def validate_rotation(value):
     value = cv.string(value)
     value = value.removesuffix("°")

esphome/components/entity_transport/__init__.py

@@ -0,0 +1,169 @@
+"""Send sensor and binary sensor states to other devices over a packet interface."""
+
+from collections.abc import Callable
+from typing import Any
+
+import esphome.codegen as cg
+from esphome.components import packet_interface
+from esphome.components.binary_sensor import BinarySensor
+from esphome.components.const import CONF_PROVIDER, CONF_REMOTE_ID
+from esphome.components.packet_interface import CONF_PACKET_INTERFACE, interface_layers
+from esphome.components.packet_interface.layers import CONF_SESSION
+from esphome.components.sensor import Sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BINARY_SENSORS,
+    CONF_ID,
+    CONF_SENSORS,
+    CONF_TIMEOUT,
+    CONF_UPDATE_INTERVAL,
+)
+from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@clydebarrow"]
+DEPENDENCIES = ["packet_interface"]
+DOMAIN = "entity_transport"
+MULTI_CONF = True
+
+CONF_BROADCAST_ID = "broadcast_id"
+CONF_ENTITY_TRANSPORT_ID = "entity_transport_id"
+
+entity_transport_ns = cg.esphome_ns.namespace("entity_transport")
+EntityTransport = entity_transport_ns.class_("EntityTransport", cg.Component)
+
+_request_remote_sensor_slot = cg.slot_counter("ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT")
+_request_remote_binary_sensor_slot = cg.slot_counter(
+    "ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT"
+)
+
+
+def _advertised_id(conf: ConfigType) -> str:
+    return conf.get(CONF_BROADCAST_ID, conf[CONF_ID].id)
+
+
+def _unique_advertised_ids(entities: list[ConfigType]) -> list[ConfigType]:
+    """A receiver tells entities of one type apart by their advertised ids, so each must be different."""
+    seen: set[str] = set()
+    for index, conf in enumerate(entities):
+        if (advertised := _advertised_id(conf)) in seen:
+            raise cv.Invalid(
+                f"The id '{advertised}' is sent for two entities", path=[index]
+            )
+        seen.add(advertised)
+    return entities
+
+
+def _local_entity(cls: MockObjClass) -> Callable[[Any], Any]:
+    return cv.maybe_simple_value(
+        cv.Schema(
+            {
+                cv.Required(CONF_ID): cv.use_id(cls),
+                cv.Optional(CONF_BROADCAST_ID): cv.All(
+                    cv.validate_id_name, cv.Length(max=255)
+                ),
+            }
+        ),
+        key=CONF_ID,
+    )
+
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(EntityTransport),
+        cv.Required(CONF_PACKET_INTERFACE): cv.use_id(packet_interface.PacketInterface),
+        # Defaults to a periodic resend unless the interface has session and reliability layers
+        cv.Optional(CONF_UPDATE_INTERVAL): cv.All(
+            cv.update_interval, cv.Range(min=cv.TimePeriod(seconds=1))
+        ),
+        # Remote entities lose their state when none arrives for this long
+        cv.Optional(CONF_TIMEOUT): cv.All(
+            cv.positive_time_period_milliseconds,
+            cv.Range(min=cv.TimePeriod(seconds=1)),
+        ),
+        # Entities are numbered with one byte
+        cv.Optional(CONF_SENSORS): cv.All(
+            cv.ensure_list(_local_entity(Sensor)),
+            cv.Length(max=255),
+            _unique_advertised_ids,
+        ),
+        cv.Optional(CONF_BINARY_SENSORS): cv.All(
+            cv.ensure_list(_local_entity(BinarySensor)),
+            cv.Length(max=255),
+            _unique_advertised_ids,
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    """With a session layer, which clears the states when the peer is lost, nothing would refresh an unchanged state."""
+    layers = interface_layers(config[CONF_PACKET_INTERFACE])
+    if CONF_TIMEOUT in config and layers is not None and CONF_SESSION in layers:
+        raise cv.Invalid(
+            f"Not allowed with a '{CONF_SESSION}' layer, which already clears the states when the other device "
+            "cannot be reached; unchanged states may never be sent again, so they would time out on a working link",
+            path=[CONF_TIMEOUT],
+        )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+def _validate_remote_id(config: ConfigType) -> ConfigType:
+    if CONF_REMOTE_ID not in config and not config[CONF_ID].is_manual:
+        raise cv.Invalid(f"'{CONF_REMOTE_ID}' is required unless '{CONF_ID}' is given")
+    return config
+
+
+def remote_entity_schema(base_schema: cv.Schema) -> cv.Schema:
+    """Schema for an entity whose state comes from another device."""
+    return cv.All(
+        base_schema.extend(
+            {
+                cv.GenerateID(CONF_ENTITY_TRANSPORT_ID): cv.use_id(EntityTransport),
+                cv.Required(CONF_PROVIDER): cv.valid_name,
+                cv.Optional(CONF_REMOTE_ID): cv.All(
+                    cv.string_strict, cv.Length(min=1, max=255)
+                ),
+            }
+        ),
+        _validate_remote_id,
+    )
+
+
+def _remote_id(config: ConfigType) -> str:
+    return config.get(CONF_REMOTE_ID) or config[CONF_ID].id
+
+
+async def register_remote_sensor(config: ConfigType, var: MockObj) -> None:
+    hub = await cg.get_variable(config[CONF_ENTITY_TRANSPORT_ID])
+    _request_remote_sensor_slot(str(hub))
+    cg.add(hub.add_remote_sensor(config[CONF_PROVIDER], _remote_id(config), var))
+
+
+async def register_remote_binary_sensor(config: ConfigType, var: MockObj) -> None:
+    hub = await cg.get_variable(config[CONF_ENTITY_TRANSPORT_ID])
+    _request_remote_binary_sensor_slot(str(hub))
+    cg.add(hub.add_remote_binary_sensor(config[CONF_PROVIDER], _remote_id(config), var))
+
+
+async def to_code(config: ConfigType) -> None:
+    interface = await cg.get_variable(config[CONF_PACKET_INTERFACE])
+    var = cg.new_Pvariable(config[CONF_ID], interface)
+    await cg.register_component(var, config)
+    if (interval := config.get(CONF_UPDATE_INTERVAL)) is not None:
+        cg.add(var.set_update_interval(interval))
+    if (timeout := config.get(CONF_TIMEOUT)) is not None:
+        cg.add(var.set_remote_timeout(timeout))
+    sensors = config.get(CONF_SENSORS, [])
+    binary_sensors = config.get(CONF_BINARY_SENSORS, [])
+    if count := len(sensors) + len(binary_sensors):
+        cg.add(var.set_entity_count(count))
+    for conf in sensors:
+        sensor = await cg.get_variable(conf[CONF_ID])
+        cg.add(var.add_sensor(_advertised_id(conf), sensor))
+    for conf in binary_sensors:
+        sensor = await cg.get_variable(conf[CONF_ID])
+        cg.add(var.add_binary_sensor(_advertised_id(conf), sensor))

esphome/components/entity_transport/binary_sensor.py

@@ -0,0 +1,11 @@
+from esphome.components import binary_sensor
+from esphome.types import ConfigType
+
+from . import register_remote_binary_sensor, remote_entity_schema
+
+CONFIG_SCHEMA = remote_entity_schema(binary_sensor.binary_sensor_schema())
+
+
+async def to_code(config: ConfigType) -> None:
+    var = await binary_sensor.new_binary_sensor(config)
+    await register_remote_binary_sensor(config, var)

esphome/components/entity_transport/entity_transport.cpp

@@ -0,0 +1,683 @@
+#include "entity_transport.h"
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+
+namespace esphome::entity_transport {
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+
+ESPHOME_LOG_TAG(TAG, "entity_transport");
+
+// The packet type byte holds the format version in its high nibble
+static constexpr uint8_t FORMAT_VERSION = 1;
+static constexpr uint8_t PACKET_DICTIONARY = 0x11;
+static constexpr uint8_t PACKET_DATA = 0x12;
+static constexpr uint8_t PACKET_REQUEST = 0x13;
+// Entity types, in dictionary sections and data records; 0 is not used
+static constexpr uint8_t TYPE_SENSOR = 1;
+static constexpr uint8_t TYPE_BINARY_SENSOR = 2;
+static constexpr uint8_t MAX_TYPE = 31;
+// Packet type and dictionary id
+static constexpr size_t HEADER_SIZE = 5;
+// A dictionary packet's part byte follows the header: the part's index in bits 0-6, and on the last part, bit 7
+static constexpr uint8_t PART_INDEX_MASK = 0x7F;
+static constexpr uint8_t PART_LAST = 0x80;
+static constexpr uint8_t PART_NONE = 0xFF;  // no dictionary is being received in order
+// A data record starts with a 16-bit tag: the entity's number in bits 0-7, its type in bits 8-12, the payload form in
+// bits 13-14, and with PAYLOAD_NONE, the state in bit 15. Any record can be skipped without knowing its type.
+static constexpr size_t TAG_SIZE = 2;
+static constexpr uint8_t TAG_TYPE_SHIFT = 8;
+static constexpr uint8_t TAG_PAYLOAD_SHIFT = 13;
+static constexpr uint16_t TAG_VALUE_BIT = 0x8000;
+static constexpr uint8_t PAYLOAD_NONE = 0;      // the state is in the tag's value bit
+static constexpr uint8_t PAYLOAD_WORD = 1;      // 4 bytes follow
+static constexpr uint8_t PAYLOAD_LENGTH = 2;    // a length byte follows, then that many bytes
+static constexpr uint8_t PAYLOAD_NO_STATE = 3;  // the entity has no state
+static constexpr size_t WORD_SIZE = 4;
+static constexpr size_t MAX_RECORD_SIZE = TAG_SIZE + WORD_SIZE;
+// A dictionary section starts with the entity type, first number and count
+static constexpr size_t SECTION_HEADER_SIZE = 3;
+static constexpr size_t MAX_STRING_LENGTH = 255;
+static constexpr uint32_t DEFAULT_UPDATE_INTERVAL_MS = 15000;
+static constexpr uint32_t REQUEST_INTERVAL_MS = 5000;
+static constexpr uint32_t RETRY_DELAY_MS = 1000;
+static constexpr uint32_t RETRY_TIMER_ID = 0;
+static constexpr uint32_t TIMEOUT_CHECK_INTERVAL_MS = 1000;
+static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
+// How long the interface may refuse every packet before it is reported
+static constexpr uint32_t REFUSED_WARNING_MS = 60000;
+
+static void put_uint32(uint8_t *buf, uint32_t value) {
+  for (size_t i = 0; i != 4; i++)
+    buf[i] = value >> (i * 8);
+}
+
+// True if the NUL terminated str is the same as the len bytes at data
+static bool matches(const char *str, const char *data, size_t len) {
+  return strlen(str) == len && memcmp(str, data, len) == 0;
+}
+
+struct Record {
+  uint8_t number;
+  uint8_t type;
+  uint8_t payload;
+  bool value;
+  const uint8_t *data;  // what follows the tag
+};
+
+static Record parse_record(std::span<const uint8_t> packet, size_t pos) {
+  uint16_t tag = encode_uint16(packet[pos + 1], packet[pos]);
+  return {static_cast<uint8_t>(tag), static_cast<uint8_t>((tag >> TAG_TYPE_SHIFT) & MAX_TYPE),
+          static_cast<uint8_t>((tag >> TAG_PAYLOAD_SHIFT) & 3), (tag & TAG_VALUE_BIT) != 0,
+          packet.data() + pos + TAG_SIZE};
+}
+
+// The size of the data record at pos, or 0 if it does not fit in the packet
+static size_t record_size(std::span<const uint8_t> packet, size_t pos) {
+  if (pos + TAG_SIZE > packet.size())
+    return 0;
+  size_t size = TAG_SIZE;
+  uint8_t payload = parse_record(packet, pos).payload;
+  if (payload == PAYLOAD_WORD) {
+    size += WORD_SIZE;
+  } else if (payload == PAYLOAD_LENGTH) {
+    if (pos + TAG_SIZE == packet.size())
+      return 0;
+    size += 1 + packet[pos + TAG_SIZE];
+  }
+  return pos + size <= packet.size() ? size : 0;
+}
+
+// Checks every record of a data packet, so that a damaged or forged packet changes no state at all
+static bool data_well_formed(std::span<const uint8_t> packet) {
+  for (size_t pos = HEADER_SIZE; pos != packet.size();) {
+    size_t size = record_size(packet, pos);
+    if (size == 0)
+      return false;
+    Record record = parse_record(packet, pos);
+    if (record.type == 0 || (record.value && record.payload != PAYLOAD_NONE))
+      return false;
+    // Types this device knows must use their own payload form; others are skipped
+    if (record.type == TYPE_SENSOR && record.payload != PAYLOAD_WORD && record.payload != PAYLOAD_NO_STATE)
+      return false;
+    if (record.type == TYPE_BINARY_SENSOR && record.payload != PAYLOAD_NONE && record.payload != PAYLOAD_NO_STATE)
+      return false;
+    pos += size;
+  }
+  return true;
+}
+
+// Checks the device name and every section of a dictionary packet before anything is learnt from it
+static bool dictionary_well_formed(std::span<const uint8_t> packet) {
+  size_t pos = HEADER_SIZE + 1;
+  if (pos >= packet.size())
+    return false;
+  pos += 1 + packet[pos];
+  if (pos > packet.size())
+    return false;
+  while (pos != packet.size()) {
+    if (pos + SECTION_HEADER_SIZE > packet.size())
+      return false;
+    uint8_t type = packet[pos];
+    size_t first = packet[pos + 1];
+    size_t count = packet[pos + 2];
+    pos += SECTION_HEADER_SIZE;
+    // Numbers are one byte, and a data record can name types up to MAX_TYPE only
+    if (type == 0 || type > MAX_TYPE || count == 0 || first + count > 256)
+      return false;
+    for (size_t i = 0; i != count; i++) {
+      if (pos == packet.size())
+        return false;
+      pos += 1 + packet[pos];
+      if (pos > packet.size())
+        return false;
+    }
+  }
+  return true;
+}
+
+void EntityTransport::setup() {
+  this->interface_ = this->interface_->top();
+  this->max_packet_size_ = this->interface_->get_max_packet_size();
+  const auto &name = App.get_name();
+  size_t longest_id = 0;
+  for (const auto &entity : this->entities_)
+    longest_id = std::max(longest_id, strlen(entity.id));
+  // A dictionary packet must hold the device name and any one id, which also leaves room for a data record
+  if (name.size() > MAX_STRING_LENGTH || longest_id > MAX_STRING_LENGTH ||
+      HEADER_SIZE + 2 + name.size() + SECTION_HEADER_SIZE + 1 + longest_id > this->max_packet_size_) {
+    this->mark_failed(LOG_STR("max_packet_size too small for the device name and entity ids"));
+    return;
+  }
+  RAMAllocator<uint8_t> allocator;
+  this->buffer_ = allocator.allocate(this->max_packet_size_);
+  if (this->buffer_ == nullptr) {
+    this->mark_failed(LOG_STR("Not enough memory for the packet buffer"));
+    return;
+  }
+  // The dictionary id changes when the device name or any entity changes
+  uint32_t hash = fnv1a_hash(name.c_str());
+  for (const auto &entity : this->entities_) {
+    hash = fnv1a_hash_extend(hash, entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR);
+    hash = fnv1a_hash_extend(hash, entity.id);
+  }
+  this->dictionary_id_ = hash;
+
+  // [&entity] is safe: FixedVector never reallocates, and the parent pointer keeps the capture to one pointer
+  for (auto &entity : this->entities_) {
+#ifdef USE_SENSOR
+    if (entity.is_sensor) {
+      static_cast<sensor::Sensor *>(entity.entity)->add_on_state_callback([&entity](float) {
+        entity.parent->mark_updated_(entity);
+      });
+    }
+#endif
+#ifdef USE_BINARY_SENSOR
+    if (!entity.is_sensor) {
+      // The full state callback also fires for the first state
+      static_cast<binary_sensor::BinarySensor *>(entity.entity)
+          ->add_full_state_callback(
+              [&entity](optional<bool>, optional<bool>) { entity.parent->mark_updated_(entity); });
+    }
+#endif
+  }
+  this->interface_->add_packet_interface_listener(
+      [this](const PacketBuffer &data, const PacketMetaData &) { this->receive_(data); });
+
+  bool session = this->interface_->has_capability(packet_interface::CAPABILITY_SESSION);
+  if (session)
+    this->interface_->add_on_session_state_callback([this](bool connected) { this->on_session_(connected); });
+  // Without a session and reliable delivery, a lost dictionary or state is only replaced by a periodic resend
+  if (this->update_interval_ms_ == 0) {
+    this->update_interval_ms_ = session && this->interface_->has_capability(packet_interface::CAPABILITY_RELIABILITY)
+                                    ? SCHEDULER_DONT_RUN
+                                    : DEFAULT_UPDATE_INTERVAL_MS;
+  }
+  if (this->update_interval_ms_ != SCHEDULER_DONT_RUN)
+    this->set_interval(this->update_interval_ms_, [this] { this->send_all_(); });
+  if (this->remote_timeout_ms_ != 0)
+    this->set_interval(TIMEOUT_CHECK_INTERVAL_MS, [this] { this->clear_remote_states_(true); });
+  this->send_all_();
+}
+
+void EntityTransport::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Entity Transport:\n"
+                "  Packet Interface: %s\n"
+                "  Max Packet Size: %zu\n"
+                "  Encryption: %s\n"
+                "  Reliability: %s\n"
+                "  Session: %s\n"
+                "  Dictionary ID: %08" PRIX32,
+                this->interface_->get_name(), this->max_packet_size_,
+                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_ENCRYPTION)),
+                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_RELIABILITY)),
+                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_SESSION)), this->dictionary_id_);
+  if (this->update_interval_ms_ == SCHEDULER_DONT_RUN) {
+    ESP_LOGCONFIG(TAG, "  Update Interval: never");
+  } else {
+    ESP_LOGCONFIG(TAG, "  Update Interval: %" PRIu32 "ms", this->update_interval_ms_);
+  }
+  if (this->remote_timeout_ms_ != 0) {
+    ESP_LOGCONFIG(TAG, "  Remote Timeout: %" PRIu32 "ms", this->remote_timeout_ms_);
+  }
+  for (const auto &entity : this->entities_) {
+    ESP_LOGCONFIG(TAG, "  %s %u: %s", entity.is_sensor ? LOG_STR_LITERAL("Sensor") : LOG_STR_LITERAL("Binary Sensor"),
+                  entity.number, entity.id);
+  }
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  for (const auto &remote : this->remote_sensors_) {
+    ESP_LOGCONFIG(TAG, "  Remote Sensor: %s from %s", remote.remote_id, remote.provider);
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  for (const auto &remote : this->remote_binary_sensors_) {
+    ESP_LOGCONFIG(TAG, "  Remote Binary Sensor: %s from %s", remote.remote_id, remote.provider);
+  }
+#endif
+}
+
+void EntityTransport::send_all_() {
+  this->dictionary_pending_ = true;
+  this->dictionary_next_ = 0;
+  this->dictionary_part_ = 0;
+  for (auto &entity : this->entities_)
+    entity.updated = true;
+  this->enable_loop();
+}
+
+void EntityTransport::mark_updated_(LocalEntity &entity) {
+  entity.updated = true;
+  this->enable_loop();
+}
+
+void EntityTransport::loop() {
+  this->disable_loop();
+  // States are only sent once the dictionary that names them has been accepted
+  if ((this->dictionary_pending_ && !this->send_dictionary_()) || !this->send_updated_()) {
+    this->sending_refused_();
+    this->set_timeout(RETRY_TIMER_ID, RETRY_DELAY_MS, [this] { this->enable_loop(); });
+    return;
+  }
+  this->refusing_ = false;
+  if (this->status_has_warning()) {
+    ESP_LOGI(TAG, "Packets are accepted again");
+    this->status_clear_warning();
+  }
+}
+
+// A link that is down or full refuses packets for a while; one that refuses them for long sends nothing at all
+void EntityTransport::sending_refused_() {
+  uint32_t now = App.get_loop_component_start_time();
+  if (!this->refusing_) {
+    this->refusing_ = true;
+    this->refused_since_ms_ = now;
+    return;
+  }
+  if (!this->status_has_warning() && now - this->refused_since_ms_ >= REFUSED_WARNING_MS) {
+    ESP_LOGW(TAG, "The packet interface has accepted no packets for %" PRIu32 "s, so no states are sent",
+             (now - this->refused_since_ms_) / 1000);
+    this->status_set_warning();
+  }
+}
+
+size_t EntityTransport::write_header_(uint8_t type) const {
+  this->buffer_[0] = type;
+  put_uint32(this->buffer_ + 1, this->dictionary_id_);
+  return HEADER_SIZE;
+}
+
+bool EntityTransport::send_dictionary_() {
+  uint8_t *buf = this->buffer_;
+  const auto &name = App.get_name();
+  size_t header = this->write_header_(PACKET_DICTIONARY);
+  size_t part_offset = header++;
+  buf[header++] = name.size();
+  memcpy(buf + header, name.c_str(), name.size());
+  header += name.size();
+  size_t length = header;
+  size_t count_offset = 0;
+  uint8_t section_type = 0;  // none
+  // A dictionary in several packets resumes after the last packet accepted, so a refused one does not resend the rest
+  for (size_t i = this->dictionary_next_; i != this->entities_.size(); i++) {
+    const auto &entity = this->entities_[i];
+    uint8_t type = entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR;
+    size_t id_length = strlen(entity.id);
+    bool new_section = type != section_type;
+    if (length + (new_section ? SECTION_HEADER_SIZE : 0) + 1 + id_length > this->max_packet_size_) {
+      buf[part_offset] = this->dictionary_part_ & PART_INDEX_MASK;
+      if (!this->interface_->send_to_interface(PacketBuffer(buf, length), {})) {
+        ESP_LOGV(TAG, "Dictionary packet of %zu bytes not accepted, will retry", length);
+        return false;
+      }
+      this->dictionary_next_ = i;
+      this->dictionary_part_++;
+      length = header;
+      new_section = true;
+    }
+    if (new_section) {
+      buf[length++] = type;
+      buf[length++] = entity.number;
+      count_offset = length;
+      buf[length++] = 0;
+      section_type = type;
+    }
+    buf[count_offset]++;
+    buf[length++] = id_length;
+    memcpy(buf + length, entity.id, id_length);
+    length += id_length;
+  }
+  if (length != header) {
+    buf[part_offset] = (this->dictionary_part_ & PART_INDEX_MASK) | PART_LAST;
+    if (!this->interface_->send_to_interface(PacketBuffer(buf, length), {})) {
+      ESP_LOGV(TAG, "Dictionary packet of %zu bytes not accepted, will retry", length);
+      return false;
+    }
+  }
+  this->dictionary_pending_ = false;
+  this->dictionary_next_ = 0;
+  this->dictionary_part_ = 0;
+  return true;
+}
+
+// Writes the entity's data record, and returns its size
+size_t EntityTransport::write_record_(const LocalEntity &entity, uint8_t *record) const {
+  uint8_t type = entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR;
+  uint8_t payload = PAYLOAD_NO_STATE;
+  bool value = false;
+  size_t size = TAG_SIZE;
+#ifdef USE_SENSOR
+  if (entity.is_sensor) {
+    float state = static_cast<sensor::Sensor *>(entity.entity)->get_state();
+    if (!std::isnan(state)) {
+      payload = PAYLOAD_WORD;
+      uint32_t bits;
+      memcpy(&bits, &state, sizeof(bits));
+      put_uint32(record + TAG_SIZE, bits);
+      size += WORD_SIZE;
+    }
+  }
+#endif
+#ifdef USE_BINARY_SENSOR
+  if (!entity.is_sensor) {
+    auto *sensor = static_cast<binary_sensor::BinarySensor *>(entity.entity);
+    if (sensor->has_state()) {
+      payload = PAYLOAD_NONE;
+      value = sensor->state;
+    }
+  }
+#endif
+  uint16_t tag =
+      entity.number | (type << TAG_TYPE_SHIFT) | (payload << TAG_PAYLOAD_SHIFT) | (value ? TAG_VALUE_BIT : 0);
+  record[0] = tag;
+  record[1] = tag >> 8;
+  return size;
+}
+
+// Sends every updated entity, in as few packets as fit; returns false if a packet was refused
+bool EntityTransport::send_updated_() {
+  size_t length = this->write_header_(PACKET_DATA);
+  size_t first = 0;
+  for (size_t i = 0; i != this->entities_.size(); i++) {
+    auto &entity = this->entities_[i];
+    if (!entity.updated)
+      continue;
+    uint8_t record[MAX_RECORD_SIZE];
+    size_t size = this->write_record_(entity, record);
+    if (length + size > this->max_packet_size_) {
+      if (!this->flush_(length, first, i))
+        return false;
+      length = HEADER_SIZE;
+      first = i;
+    }
+    memcpy(this->buffer_ + length, record, size);
+    length += size;
+  }
+  return this->flush_(length, first, this->entities_.size());
+}
+
+// Sends the packet holding the updated entities from first up to last, and clears their flags if it was accepted
+bool EntityTransport::flush_(size_t length, size_t first, size_t last) {
+  if (length == HEADER_SIZE)
+    return true;
+  if (!this->interface_->send_to_interface(PacketBuffer(this->buffer_, length), {})) {
+    ESP_LOGV(TAG, "Packet of %zu bytes not accepted, will retry", length);
+    return false;
+  }
+  for (size_t i = first; i != last; i++)
+    this->entities_[i].updated = false;
+  return true;
+}
+
+void EntityTransport::receive_(const PacketBuffer &data) {
+  // Packet interface layers deliver packets in one piece
+  if (!data.is_contiguous()) {
+    ESP_LOGW(TAG, "Packet split across buffers is not supported");
+    return;
+  }
+  auto packet = data.as_span();
+  if (packet.size() < HEADER_SIZE) {
+    if (this->warning_due_()) {
+      ESP_LOGW(TAG, "Packet of %zu bytes is too short", packet.size());
+    }
+    return;
+  }
+  if (packet[0] >> 4 != FORMAT_VERSION) {
+    if (this->warning_due_()) {
+      ESP_LOGW(TAG, "Packet format version %u not supported; the sender may run another ESPHome version",
+               packet[0] >> 4);
+    }
+    return;
+  }
+  uint32_t dictionary_id = encode_uint32(packet[4], packet[3], packet[2], packet[1]);
+  if (dictionary_id == this->dictionary_id_) {
+    // Either a request for our dictionary, or our own packet heard on a broadcast channel
+    if (packet[0] == PACKET_REQUEST && packet.size() == HEADER_SIZE) {
+      ESP_LOGD(TAG, "Dictionary requested");
+      this->send_all_();
+    }
+    return;
+  }
+  if (packet[0] == PACKET_DICTIONARY) {
+    this->receive_dictionary_(packet, dictionary_id);
+  } else if (packet[0] == PACKET_DATA) {
+    this->receive_data_(packet, dictionary_id);
+  } else if (packet[0] != PACKET_REQUEST) {
+    ESP_LOGV(TAG, "Unknown packet type 0x%02X", packet[0]);
+  }
+}
+
+void EntityTransport::receive_dictionary_(std::span<const uint8_t> packet, uint32_t dictionary_id) {
+  if (!dictionary_well_formed(packet)) {
+    if (this->warning_due_()) {
+      ESP_LOGW(TAG, "Dictionary packet of %zu bytes is malformed", packet.size());
+    }
+    return;
+  }
+  size_t pos = HEADER_SIZE;
+  uint8_t part = packet[pos++];
+  uint8_t index = part & PART_INDEX_MASK;
+  // The dictionary is complete, and need not be asked for again, once its last part follows all the others in order
+  bool in_order = index == 0 || (this->rx_dictionary_id_ == dictionary_id && index == this->rx_next_part_);
+  this->rx_dictionary_id_ = dictionary_id;
+  this->rx_next_part_ = in_order ? (index + 1) & PART_INDEX_MASK : PART_NONE;
+  bool completed = in_order && (part & PART_LAST) != 0;
+  bool first_time = completed && !this->dictionary_seen_(dictionary_id);
+  if (first_time) {
+    this->seen_dictionaries_[this->seen_next_] = dictionary_id;
+    this->seen_next_ = (this->seen_next_ + 1) % this->seen_dictionaries_.size();
+  }
+  size_t provider_length = packet[pos++];
+  const auto *provider = reinterpret_cast<const char *>(packet.data() + pos);
+  pos += provider_length;
+  while (pos != packet.size()) {
+    uint8_t type = packet[pos];
+    uint8_t number = packet[pos + 1];
+    uint8_t count = packet[pos + 2];
+    pos += SECTION_HEADER_SIZE;
+    for (uint8_t i = 0; i != count; i++) {
+      size_t id_length = packet[pos++];
+      this->learn_(provider, provider_length, type, number + i, reinterpret_cast<const char *>(packet.data() + pos),
+                   id_length, dictionary_id);
+      pos += id_length;
+    }
+  }
+  // A provider may go back to a dictionary already seen, so every complete one is checked
+  if (completed)
+    this->forget_unnamed_(provider, provider_length, dictionary_id, first_time);
+}
+
+void EntityTransport::forget_unnamed_(const char *provider, size_t provider_length, uint32_t dictionary_id,
+                                      bool first_time) {
+  // A remote entity that its provider's whole dictionary does not name would otherwise keep no or a stale state
+  // silently
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  for (auto &remote : this->remote_sensors_) {
+    if (!matches(remote.provider, provider, provider_length) || (remote.known && remote.dictionary_id == dictionary_id))
+      continue;
+    if (remote.known || first_time) {
+      ESP_LOGW(TAG, "'%s' does not send '%s'", remote.provider, remote.remote_id);
+    }
+    remote.known = false;
+    if (remote.has_state) {
+      remote.has_state = false;
+      remote.entity->publish_state(NAN);
+    }
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  for (auto &remote : this->remote_binary_sensors_) {
+    if (!matches(remote.provider, provider, provider_length) || (remote.known && remote.dictionary_id == dictionary_id))
+      continue;
+    if (remote.known || first_time) {
+      ESP_LOGW(TAG, "'%s' does not send '%s'", remote.provider, remote.remote_id);
+    }
+    remote.known = false;
+    if (remote.has_state) {
+      remote.has_state = false;
+      remote.entity->invalidate_state();
+    }
+  }
+#endif
+}
+
+void EntityTransport::learn_(const char *provider, size_t provider_length, uint8_t type, uint8_t number, const char *id,
+                             size_t id_length, uint32_t dictionary_id) {
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  if (type == TYPE_SENSOR) {
+    for (auto &remote : this->remote_sensors_) {
+      if (matches(remote.provider, provider, provider_length) && matches(remote.remote_id, id, id_length)) {
+        remote.dictionary_id = dictionary_id;
+        remote.number = number;
+        remote.known = true;
+      }
+    }
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  if (type == TYPE_BINARY_SENSOR) {
+    for (auto &remote : this->remote_binary_sensors_) {
+      if (matches(remote.provider, provider, provider_length) && matches(remote.remote_id, id, id_length)) {
+        remote.dictionary_id = dictionary_id;
+        remote.number = number;
+        remote.known = true;
+      }
+    }
+  }
+#endif
+}
+
+bool EntityTransport::dictionary_seen_(uint32_t dictionary_id) const {
+  return std::find(this->seen_dictionaries_.begin(), this->seen_dictionaries_.end(), dictionary_id) !=
+         this->seen_dictionaries_.end();
+}
+
+void EntityTransport::receive_data_(std::span<const uint8_t> packet, uint32_t dictionary_id) {
+  bool known = false;
+  bool has_remotes = false;
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  for (const auto &remote : this->remote_sensors_) {
+    known |= remote.known && remote.dictionary_id == dictionary_id;
+    has_remotes = true;
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  for (const auto &remote : this->remote_binary_sensors_) {
+    known |= remote.known && remote.dictionary_id == dictionary_id;
+    has_remotes = true;
+  }
+#endif
+  if (!has_remotes)
+    return;
+  // Checked first, so a damaged packet does not make the provider resend everything
+  if (!data_well_formed(packet)) {
+    if (this->warning_due_()) {
+      ESP_LOGW(TAG, "Data packet of %zu bytes is malformed", packet.size());
+    }
+    return;
+  }
+  // A dictionary not yet received in full may name our entities, or be a provider's new one; one received in full
+  // named all of them it could, so asking again would only make that provider resend everything
+  if (!this->dictionary_seen_(dictionary_id))
+    this->request_dictionary_(dictionary_id);
+  if (!known)
+    return;
+  [[maybe_unused]] uint32_t now = App.get_loop_component_start_time();
+  for (size_t pos = HEADER_SIZE; pos != packet.size(); pos += record_size(packet, pos)) {
+    [[maybe_unused]] Record record = parse_record(packet, pos);
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+    if (record.type == TYPE_SENSOR) {
+      float value = NAN;
+      if (record.payload == PAYLOAD_WORD) {
+        uint32_t bits = encode_uint32(record.data[3], record.data[2], record.data[1], record.data[0]);
+        memcpy(&value, &bits, sizeof(value));
+      }
+      for (auto &remote : this->remote_sensors_) {
+        if (remote.known && remote.dictionary_id == dictionary_id && remote.number == record.number) {
+          remote.last_state_ms = now;
+          remote.has_state = true;
+          remote.entity->publish_state(value);
+        }
+      }
+    }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+    if (record.type == TYPE_BINARY_SENSOR) {
+      for (auto &remote : this->remote_binary_sensors_) {
+        if (!remote.known || remote.dictionary_id != dictionary_id || remote.number != record.number)
+          continue;
+        remote.last_state_ms = now;
+        remote.has_state = true;
+        if (record.payload == PAYLOAD_NO_STATE) {
+          remote.entity->invalidate_state();
+        } else {
+          remote.entity->publish_state(record.value);
+        }
+      }
+    }
+#endif
+  }
+}
+
+void EntityTransport::request_dictionary_(uint32_t dictionary_id) {
+  uint32_t now = App.get_loop_component_start_time();
+  if (this->request_sent_ && now - this->last_request_ms_ < REQUEST_INTERVAL_MS)
+    return;
+  uint8_t packet[HEADER_SIZE] = {PACKET_REQUEST};
+  put_uint32(packet + 1, dictionary_id);
+  // A refused request is tried again with the next data packet under that dictionary id
+  if (!this->interface_->send_to_interface(PacketBuffer(packet, sizeof(packet)), {})) {
+    ESP_LOGV(TAG, "Request for dictionary %08" PRIX32 " not accepted", dictionary_id);
+    return;
+  }
+  this->request_sent_ = true;
+  this->last_request_ms_ = now;
+  ESP_LOGD(TAG, "Requested dictionary %08" PRIX32, dictionary_id);
+}
+
+// Dropped packets point to a device with other firmware or a fault, and may arrive steadily, so warn only now and then
+bool EntityTransport::warning_due_() {
+  uint32_t now = App.get_loop_component_start_time();
+  if (this->warned_ && now - this->last_warning_ms_ < WARNING_INTERVAL_MS)
+    return false;
+  this->warned_ = true;
+  this->last_warning_ms_ = now;
+  return true;
+}
+
+// A newly connected or restarted peer needs the dictionary and every state; while it is lost, its entities have no
+// state
+void EntityTransport::on_session_(bool connected) {
+  if (connected) {
+    this->send_all_();
+    return;
+  }
+  this->clear_remote_states_(false);
+}
+
+// Clears the state of every remote entity, or with timed_out_only, of those whose state is older than the timeout
+void EntityTransport::clear_remote_states_(bool timed_out_only) {
+  [[maybe_unused]] uint32_t now = App.get_loop_component_start_time();
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  for (auto &remote : this->remote_sensors_) {
+    if (timed_out_only && (!remote.has_state || now - remote.last_state_ms <= this->remote_timeout_ms_))
+      continue;
+    remote.has_state = false;
+    remote.entity->publish_state(NAN);
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  for (auto &remote : this->remote_binary_sensors_) {
+    if (timed_out_only && (!remote.has_state || now - remote.last_state_ms <= this->remote_timeout_ms_))
+      continue;
+    remote.has_state = false;
+    remote.entity->invalidate_state();
+  }
+#endif
+}
+
+}  // namespace esphome::entity_transport

esphome/components/entity_transport/entity_transport.h

@@ -0,0 +1,171 @@
+#pragma once
+
+#include <array>
+#include <span>
+
+#include "esphome/components/packet_interface/packet_interface.h"
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+#ifdef USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+#ifdef USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
+
+namespace esphome::entity_transport {
+
+/**
+ * Sends the states of local sensors and binary sensors over a packet interface, and publishes the states received
+ * from other devices to remote entities.
+ *
+ * Each device numbers its sensors and its binary sensors from 0, and sends a dictionary that gives the id for each
+ * number. Data packets then refer to an entity by its number. Every packet carries the sender's dictionary id, a hash
+ * of its device name and dictionary, so that a receiver knows which device sent it and which dictionary applies.
+ * All values are little endian.
+ *
+ * Dictionary packet:
+ * - type: 1 byte, PACKET_DICTIONARY;
+ * - dictionary id: 4 bytes;
+ * - part: 1 byte, the packet's index in the dictionary in bits 0-6, counting from 0 and wrapping, and bit 7 set on
+ *   the last packet;
+ * - sender's device name: length (1 byte), then the name;
+ * - one or more sections, each: entity type (1 byte), first number (1 byte), count (1 byte), then for each entity
+ *   its id: length (1 byte), then the id.
+ *
+ * Data packet:
+ * - type: 1 byte, PACKET_DATA;
+ * - dictionary id: 4 bytes;
+ * - records, to the end, each a 16-bit tag, then its payload. The tag holds the entity's number in bits 0-7, its type
+ *   in bits 8-12, and the payload form in bits 13-14: none, with the state in bit 15 (binary sensors); 4 bytes (a
+ *   sensor's float); a length byte, then that many bytes; or no state, with no payload. The form gives the record's
+ *   size, so a receiver skips records of types it does not know.
+ *
+ * Every packet is checked in full before anything in it is used, so a damaged or forged packet changes no state.
+ *
+ * Dictionary request packet, sent by a device that receives data with a dictionary id it has not received in full,
+ * with every part in order:
+ * - type: 1 byte, PACKET_REQUEST;
+ * - the dictionary id wanted: 4 bytes.
+ *
+ * Changed states are sent from loop(). The dictionary and all states are sent at boot, when a session layer reports
+ * the peer connected, when the dictionary is requested, and every update interval. Unless the interface has both a
+ * session and a reliability layer, the update interval defaults to DEFAULT_UPDATE_INTERVAL_MS. When the interface
+ * refuses a packet, sending is tried again after a delay, and a warning is set once it has refused every packet for a
+ * minute. With a remote timeout, a remote entity loses its state when
+ * none arrives for it within the timeout.
+ */
+class EntityTransport : public Component {
+ public:
+  explicit EntityTransport(packet_interface::PacketInterface *interface) : interface_(interface) {}
+
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+
+  /// 0 chooses the default for the interface's layers; SCHEDULER_DONT_RUN never resends.
+  void set_update_interval(uint32_t interval_ms) { this->update_interval_ms_ = interval_ms; }
+  /// Remote entities lose their state when none arrives for this long; 0 keeps the last state.
+  void set_remote_timeout(uint32_t timeout_ms) { this->remote_timeout_ms_ = timeout_ms; }
+  void set_entity_count(size_t count) { this->entities_.init(count); }
+  // Sensors must be added before binary sensors, so that data packets hold sensor records first
+#ifdef USE_SENSOR
+  void add_sensor(const char *id, sensor::Sensor *sensor) {
+    this->entities_.push_back({sensor, id, this, this->sensor_count_++, true, true});
+  }
+#endif
+#ifdef USE_BINARY_SENSOR
+  void add_binary_sensor(const char *id, binary_sensor::BinarySensor *sensor) {
+    this->entities_.push_back({sensor, id, this, this->binary_sensor_count_++, false, true});
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  void add_remote_sensor(const char *provider, const char *remote_id, sensor::Sensor *sensor) {
+    this->remote_sensors_.push_back({provider, remote_id, sensor});
+  }
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  void add_remote_binary_sensor(const char *provider, const char *remote_id, binary_sensor::BinarySensor *sensor) {
+    this->remote_binary_sensors_.push_back({provider, remote_id, sensor});
+  }
+#endif
+
+ protected:
+  struct LocalEntity {
+    EntityBase *entity;  // a sensor::Sensor or a binary_sensor::BinarySensor, as is_sensor says
+    const char *id;
+    EntityTransport *parent;
+    uint8_t number;
+    bool is_sensor;
+    bool updated;
+  };
+  template<typename T> struct RemoteEntity {
+    const char *provider;
+    const char *remote_id;
+    T *entity;
+    uint32_t dictionary_id{0};  // learnt from the provider's dictionary
+    uint32_t last_state_ms{0};
+    uint8_t number{0};
+    bool known{false};
+    bool has_state{false};  // a state arrived, and has not yet timed out
+  };
+
+  void send_all_();
+  void mark_updated_(LocalEntity &entity);
+  bool send_dictionary_();
+  bool send_updated_();
+  size_t write_record_(const LocalEntity &entity, uint8_t *record) const;
+  bool flush_(size_t length, size_t first, size_t last);
+  size_t write_header_(uint8_t type) const;
+  void receive_(const packet_interface::PacketBuffer &data);
+  void receive_dictionary_(std::span<const uint8_t> packet, uint32_t dictionary_id);
+  void receive_data_(std::span<const uint8_t> packet, uint32_t dictionary_id);
+  void learn_(const char *provider, size_t provider_length, uint8_t type, uint8_t number, const char *id,
+              size_t id_length, uint32_t dictionary_id);
+  void request_dictionary_(uint32_t dictionary_id);
+  bool dictionary_seen_(uint32_t dictionary_id) const;
+  /// Clears each remote entity of \p provider that its complete dictionary does not name, warning if the entity was
+  /// known or the dictionary is \p first_time seen, so a resent dictionary does not repeat the warning.
+  void forget_unnamed_(const char *provider, size_t provider_length, uint32_t dictionary_id, bool first_time);
+  bool warning_due_();
+  void sending_refused_();
+  void on_session_(bool connected);
+  void clear_remote_states_(bool timed_out_only);
+
+  packet_interface::PacketInterface *interface_;
+  FixedVector<LocalEntity> entities_;
+#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
+  StaticVector<RemoteEntity<sensor::Sensor>, ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT> remote_sensors_;
+#endif
+#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
+  StaticVector<RemoteEntity<binary_sensor::BinarySensor>, ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT>
+      remote_binary_sensors_;
+#endif
+  // Packets are built here, allocated in setup()
+  uint8_t *buffer_{nullptr};
+  size_t max_packet_size_{0};
+  uint32_t update_interval_ms_{0};
+  uint32_t remote_timeout_ms_{0};
+  uint32_t dictionary_id_{0};
+  uint32_t last_request_ms_{0};
+  uint32_t last_warning_ms_{0};
+  uint32_t refused_since_ms_{0};  // when the interface began refusing every packet
+  uint32_t rx_dictionary_id_{0};  // the dictionary whose parts are arriving
+  // The last dictionary ids received in full, so a provider whose dictionary names none of our entities is not asked
+  // again
+  std::array<uint32_t, 8> seen_dictionaries_{};
+  uint8_t seen_next_{0};
+  uint8_t rx_next_part_{0};     // the index of its next part, or PART_NONE if one was missed
+  uint8_t dictionary_part_{0};  // the index of the next dictionary packet to send
+  uint8_t sensor_count_{0};
+  uint8_t binary_sensor_count_{0};
+  size_t dictionary_next_{0};  // the first entity of the next dictionary packet to send
+  bool dictionary_pending_{true};
+  bool request_sent_{false};
+  bool warned_{false};
+  bool refusing_{false};
+};
+
+}  // namespace esphome::entity_transport

esphome/components/entity_transport/sensor.py

@@ -0,0 +1,11 @@
+from esphome.components import sensor
+from esphome.types import ConfigType
+
+from . import register_remote_sensor, remote_entity_schema
+
+CONFIG_SCHEMA = remote_entity_schema(sensor.sensor_schema())
+
+
+async def to_code(config: ConfigType) -> None:
+    var = await sensor.new_sensor(config)
+    await register_remote_sensor(config, var)

esphome/components/epaper_spi/display.py

@@ -146,7 +146,7 @@ def model_schema(config):
             cv.GenerateID(): cv.declare_id(class_name),
             cv.GenerateID(CONF_INIT_SEQUENCE_ID): cv.declare_id(cg.uint8),
             cv_dimensions(CONF_DIMENSIONS): dimension_schema(model),
-            **display.enable_pin_schema(model, config),
+            model.option(CONF_ENABLE_PIN): cv.ensure_list(pins.gpio_output_pin_schema),
             model.option(CONF_INIT_SEQUENCE, cv.UNDEFINED): cv.ensure_list(
                 map_sequence
             ),

esphome/components/epaper_spi/models/__init__.py

@@ -1,8 +1,8 @@
 from typing import Any, Self
 
-from esphome.components.mipi import check_model_requirements
 import esphome.config_validation as cv
 from esphome.const import CONF_DIMENSIONS, CONF_HEIGHT, CONF_OFFSET_HEIGHT, CONF_WIDTH
+from esphome.core import CORE
 from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType
 
@@ -128,5 +128,24 @@ class EpaperModel:
         return model
 
     def check_requirements(self) -> None:
-        """Check that the components this model needs are configured, see check_model_requirements()."""
-        check_model_requirements(self.name, self.defaults)
+        """
+        Raise a friendly error if any component this model requires is not configured.
+
+        This runs during schema validation (before ID references are resolved) so that a
+        model whose default pins live on a pin expander reports the missing expander clearly
+        instead of a cryptic "Couldn't find ID" from the unresolved pin reference.
+        """
+        if requirements := self.get_default("requires", set()):
+            # ``raw_config`` is populated before any component schema runs during a real
+            # validation, so presence of a required component is simply a top-level key.
+            # When it is absent (e.g. a unit test that invokes the schema directly) there
+            # is no config to check against, so skip.
+            global_config = CORE.raw_config
+            if global_config is None:
+                return
+            missing = {x for x in requirements if x not in global_config}
+            if missing:
+                reqstr = ", ".join(f"'{x}'" for x in sorted(missing))
+                raise cv.Invalid(
+                    f"{self.name} requires component{'s' if len(missing) > 1 else ''} {reqstr} to be configured"
+                )

esphome/components/it8951/display.py

@@ -274,7 +274,9 @@ def _model_schema(config: ConfigType) -> cv.Schema:
             cv.Optional(CONF_UPDATE_MODE): update_mode,
             # One or more GPIOs driven high during setup to power on the panel
             # (e.g. board power-enable rails), before reset and init.
-            **display.enable_pin_schema(model, config),
+            cv.Optional(
+                CONF_ENABLE_PIN, default=model.get_default(CONF_ENABLE_PIN, [])
+            ): cv.ensure_list(pins.gpio_output_pin_schema),
             cv.Optional(CONF_RESET_DURATION): cv.All(
                 cv.positive_time_period_milliseconds,
                 cv.Range(max=core.TimePeriod(milliseconds=500)),

esphome/components/lightwaverf/__init__.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import automation, pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -17,8 +15,6 @@ from esphome.core import CORE
 from esphome.cpp_helpers import gpio_pin_expression
 from esphome.types import ConfigType
 
-_LOGGER = logging.getLogger(__name__)
-
 CODEOWNERS = ["@max246"]
 DOMAIN = "lightwaverf"
 
@@ -39,20 +35,10 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.polling_component_schema("1s"))
 
 
-def _drop_unused_name(config: ConfigType) -> ConfigType:
-    # Remove before 2027.5.0
-    if config.pop(CONF_NAME, None) is not None:
-        _LOGGER.warning(
-            "[lightwaverf] 'name' on lightwaverf.send_raw has no effect; remove it. "
-            "Removed in 2027.5.0"
-        )
-    return config
-
-
 LIGHTWAVE_SEND_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.use_id(LIGHTWAVERFComponent),
-        cv.Optional(CONF_NAME): cv.string,
+        cv.Required(CONF_NAME): cv.string,
         cv.Required(CONF_CODE): cv.All(
             [cv.Any(cv.hex_uint8_t)],
             cv.Length(min=10),
@@ -61,7 +47,7 @@ LIGHTWAVE_SEND_SCHEMA = cv.Schema(
         cv.Optional(CONF_INVERTED, default=False): cv.boolean,
         cv.Optional(CONF_PULSE_LENGTH, default=330): cv.int_,
     }
-).add_extra(_drop_unused_name)
+)
 
 
 automation.register_apply_action(

esphome/components/lvgl/widgets/canvas.py

@@ -28,7 +28,6 @@ from esphome.const import (
     CONF_X,
     CONF_Y,
 )
-from esphome.cpp_generator import MockObj
 from esphome.cpp_types import FixedVector
 
 from ..automation import action_to_code
@@ -42,7 +41,6 @@ from ..defines import (
     CONF_RADIUS,
     CONF_SRC,
     CONF_START_ANGLE,
-    LValidator,
     addr,
     literal,
 )
@@ -59,7 +57,7 @@ from ..lv_validation import (
 )
 from ..lvcode import LocalVariable, lv, lv_assign, lv_expr
 from ..schemas import STYLE_PROPS, TEXT_SCHEMA, point_schema, remap_property
-from ..types import LvType, ObjUpdateAction, lv_gradient_t, lv_point_precise_t
+from ..types import LvType, ObjUpdateAction, lv_point_precise_t
 from . import Widget, WidgetType, get_widgets
 from .img import CONF_IMAGE
 
@@ -223,6 +221,7 @@ RECT_PROPS = {
         "radius",
         "bg_opa",
         "bg_color",
+        "bg_grad",
         "border_color",
         "border_width",
         "border_opa",
@@ -240,30 +239,6 @@ RECT_PROPS = {
         "shadow_opa",
     )
 }
-RECT_PROPS.update(
-    bg_grad=LValidator(
-        cv.use_id(lv_gradient_t), lv_gradient_t, retmapper=lambda v: MockObj(f"*{v}")
-    )
-)
-RECT_SCHEMA = {
-    **{cv.Optional(prop): validator for prop, validator in RECT_PROPS.items()},
-    cv.Optional(CONF_OPA): cv.invalid(
-        "Rectangles have no single opacity; use bg_opa, border_opa, outline_opa or shadow_opa"
-    ),
-}
-POLYGON_PROPS = {
-    p: RECT_PROPS[p] for p in ("border_color", "border_width", "border_opa")
-}
-POLYGON_SCHEMA = {
-    **{cv.Optional(prop): validator for prop, validator in POLYGON_PROPS.items()},
-    **{
-        cv.Optional(prop): cv.invalid(
-            "Polygons are drawn as an outline; use border_color, border_width and border_opa"
-        )
-        for prop in (*RECT_PROPS, CONF_OPA)
-        if prop not in POLYGON_PROPS
-    },
-}
 
 
 def _draw_line(layer, dsc, points):
@@ -289,10 +264,10 @@ def _draw_line(layer, dsc, points):
     ObjUpdateAction,
     cv.Schema(
         {
-            **DRAW_SCHEMA,
+            **DRAW_OPA_SCHEMA,
             cv.Required(CONF_WIDTH): cv.templatable(cv.int_),
             cv.Required(CONF_HEIGHT): cv.templatable(cv.int_),
-            **RECT_SCHEMA,
+            **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
         }
     ),
     synchronous=True,
@@ -448,8 +423,8 @@ async def canvas_draw_image(config, action_id, template_arg, args):
 LINE_PROPS = {
     "width": STYLE_PROPS["line_width"],
     "color": STYLE_PROPS["line_color"],
-    "dash_width": STYLE_PROPS["line_dash_width"],
-    "dash_gap": STYLE_PROPS["line_dash_gap"],
+    "dash-width": STYLE_PROPS["line_dash_width"],
+    "dash-gap": STYLE_PROPS["line_dash_gap"],
     "round_start": lv_bool,
     "round_end": lv_bool,
 }
@@ -499,7 +474,7 @@ async def canvas_draw_line(config, action_id, template_arg, args):
         {
             cv.GenerateID(CONF_ID): cv.use_id(lv_canvas_t),
             cv.Required(CONF_POINTS): cv.ensure_list(point_schema),
-            **POLYGON_SCHEMA,
+            **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
         },
     ).add_extra(_validate_points),
     synchronous=True,
@@ -528,7 +503,7 @@ async def canvas_draw_polygon(config, action_id, template_arg, args):
             _draw_line(layer, line_dsc, points)
 
     return await draw_to_code(
-        config, "rect", POLYGON_PROPS, do_draw_polygon, action_id, template_arg, args
+        config, "rect", RECT_PROPS, do_draw_polygon, action_id, template_arg, args
     )
 
 

esphome/components/lvgl/widgets/meter.py

@@ -17,7 +17,6 @@ from esphome.const import (
     CONF_WIDTH,
     CONF_X,
 )
-from esphome.core import ID
 from esphome.cpp_generator import MockObj
 from esphome.cpp_types import nullptr
 
@@ -65,7 +64,7 @@ from ..lv_validation import (
 )
 from ..lvcode import LambdaContext, LocalVariable, lv, lv_add, lv_expr, lv_obj
 from ..schemas import STATE_SCHEMA
-from ..styles import LVStyle, create_style
+from ..styles import LVStyle
 from ..types import (
     LV_EVENT,
     LvCompound,
@@ -101,12 +100,6 @@ CONF_SCALES = "scales"
 CONF_STRIDE = "stride"
 CONF_TICK_STYLE = "tick_style"
 
-
-def _arc_style_name(indicator_id: str) -> str:
-    """Name of the style variable generated for an arc indicator."""
-    return f"meter_arc_{indicator_id}_style"
-
-
 # LVGL 9.4 Migration: Use scale widget instead of removed meter widget
 #
 # The lv_meter widget was removed in LVGL 9.4 and replaced with the more
@@ -430,9 +423,11 @@ class MeterType(WidgetType):
                         get_warnings().add(
                             "The 'r_mod' indicator property is not supported in LVGL 9.x and will be ignored."
                         )
-                    style_var = await create_style(_arc_style_name(iid.id), props)
+                    arc_style = LVStyle(f"meter_arc_{iid.id}", props)
                     tvar = cg.Pvariable(iid, lv_expr.scale_add_section(scale_var))
-                    lv.scale_section_set_style(tvar, LV_PART.MAIN, style_var)
+                    lv.scale_section_set_style(
+                        tvar, LV_PART.MAIN, await arc_style.get_var()
+                    )
                     lw = Widget.create(iid, tvar, arc_indicator_type)
                     lw.parent = scale_var
                     await set_indicator_values(scale_var, lw, v)
@@ -615,15 +610,6 @@ async def indicator_update_to_code(config, action_id, template_arg, args):
 
     async def set_value(w: Widget):
         await set_indicator_values(w.parent, w, config)
-        if (opa := config.get(CONF_OPA)) is None:
-            return
-        opa = await opacity.process(opa)
-        if w.type is arc_indicator_type:
-            style = await cg.get_variable(ID(_arc_style_name(str(w.var))))
-            lv.style_set_arc_opa(style, opa)
-            lv_obj.invalidate(w.parent)
-        else:
-            lv_obj.set_style_opa(w.obj, opa, LV_PART.MAIN)
 
     return await action_to_code(widget, set_value, action_id, template_arg, args)
 

esphome/components/mipi/__init__.py

@@ -4,12 +4,10 @@
 
 from collections.abc import Callable
 import functools
-import importlib.util
 from typing import Any, Self
 
 import voluptuous as vol
 
-from esphome import pins
 from esphome.components.const import CONF_COLOR_DEPTH
 from esphome.components.display import CONF_SHOW_TEST_CARD, display_ns
 import esphome.config_validation as cv
@@ -25,7 +23,6 @@ from esphome.const import (
     CONF_MIRROR_X,
     CONF_MIRROR_Y,
     CONF_MODEL,
-    CONF_NUMBER,
     CONF_OFFSET_HEIGHT,
     CONF_OFFSET_WIDTH,
     CONF_PAGES,
@@ -309,57 +306,6 @@ def model_schema_extractor(
     return decorate
 
 
-def _is_pin_expander(key: str) -> bool:
-    """Check if a pin config key names a component that provides pins, e.g. an I/O expander."""
-    from esphome import loader
-
-    if key not in pins.PIN_SCHEMA_REGISTRY:
-        if importlib.util.find_spec(f"esphome.components.{key}") is None:
-            return False
-        # Loading the component registers its pin schema. If it fails to load (the
-        # loader logs why), still require it rather than quietly dropping it.
-        if loader.get_component(key) is None:
-            return True
-    return key in pins.PIN_SCHEMA_REGISTRY
-
-
-def _pin_expanders(value: Any) -> set[str]:
-    """Find the pin expander components used by any pin configs in a model's defaults."""
-    if isinstance(value, (list, tuple)):
-        return set().union(*(_pin_expanders(v) for v in value))
-    if not isinstance(value, dict):
-        return set()
-    found = set().union(*(_pin_expanders(v) for v in value.values()))
-    if CONF_NUMBER in value:
-        found.update(k for k in value if k != CONF_NUMBER and _is_pin_expander(k))
-    return found
-
-
-def check_model_requirements(name: str, defaults: dict[str, Any]) -> None:
-    """
-    Raise a friendly error if any component a display model requires is not configured.
-    These are the components in its ``requires`` default plus any pin expander used by its
-    default pins, which is needed even if the user config overrides those pins.
-
-    This runs during schema validation (before ID references are resolved) so that a
-    model whose default pins live on a pin expander reports the missing expander clearly
-    instead of a cryptic "Couldn't find ID" from the unresolved pin reference.
-    """
-    # ``raw_config`` is populated before any component schema runs during a real
-    # validation, so presence of a required component is simply a top-level key.
-    # When it is absent (e.g. a unit test that invokes the schema directly) there
-    # is no config to check against, so skip.
-    global_config = CORE.raw_config
-    if global_config is None:
-        return
-    requirements = set(defaults.get("requires", ())) | _pin_expanders(defaults)
-    if missing := {x for x in requirements if x not in global_config}:
-        reqstr = ", ".join(f"'{x}'" for x in sorted(missing))
-        raise cv.Invalid(
-            f"{name} requires component{'s' if len(missing) > 1 else ''} {reqstr} to be configured"
-        )
-
-
 class DriverChip:
     """
     A class representing a MIPI DBI driver chip model.
@@ -725,14 +671,32 @@ class DriverChip:
 
     def check_requirements(self) -> None:
         """
-        Check that the components this model needs are configured, see check_model_requirements().
+        Raise a friendly error if any component this model requires is not configured.
+
+        This runs during schema validation (before ID references are resolved) so that a
+        model whose default pins live on a pin expander reports the missing expander clearly
+        instead of a cryptic "Couldn't find ID" from the unresolved pin reference.
+
         Also logs a warning if the model is deprecated.
         """
         if deprecation_reason := self.get_default("deprecation_reason"):
             LOGGER.warning(
                 "Display model %s is deprecated: %s", self.name, deprecation_reason
             )
-        check_model_requirements(self.name, self.defaults)
+        if requirements := self.get_default("requires", set()):
+            # ``raw_config`` is populated before any component schema runs during a real
+            # validation, so presence of a required component is simply a top-level key.
+            # When it is absent (e.g. a unit test that invokes the schema directly) there
+            # is no config to check against, so skip.
+            global_config = CORE.raw_config
+            if global_config is None:
+                return
+            missing = {x for x in requirements if x not in global_config}
+            if missing:
+                reqstr = ", ".join(f"'{x}'" for x in sorted(missing))
+                raise cv.Invalid(
+                    f"{self.name} requires component{'s' if len(missing) > 1 else ''} {reqstr} to be configured"
+                )
 
 
 def requires_buffer(config) -> bool:

esphome/components/mipi_dsi/display.py

@@ -85,7 +85,7 @@ COLOR_DEPTHS = {
 }
 
 
-def model_schema(config: ConfigType) -> cv.Schema:
+def model_schema(config: ConfigType) -> cv.All:
     model = MODELS[config[CONF_MODEL].upper()]
     transform = model.transform_schema()
     # CUSTOM model will need to provide a custom init sequence
@@ -97,14 +97,16 @@ def model_schema(config: ConfigType) -> cv.Schema:
     # Dimensions are optional if the model has a default width
     cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
     pixel_modes = (PIXEL_MODE_16BIT, PIXEL_MODE_24BIT, "16", "24")
-    return display.FULL_DISPLAY_SCHEMA.extend(
+    schema = display.FULL_DISPLAY_SCHEMA.extend(
         {
             model.option(CONF_RESET_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
             cv.GenerateID(): cv.declare_id(MipiDsi),
             cv_dimensions(CONF_DIMENSIONS): dimension_schema(
                 model.get_default(CONF_DRAW_ROUNDING, 1)
             ),
-            **display.enable_pin_schema(model, config),
+            model.option(CONF_ENABLE_PIN, cv.UNDEFINED): cv.ensure_list(
+                pins.gpio_output_pin_schema
+            ),
             model.option(CONF_COLOR_ORDER, MODE_BGR): cv.enum(COLOR_ORDERS, upper=True),
             model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
             model.option(CONF_PIXEL_MODE, PIXEL_MODE_16BIT): cv.one_of(
@@ -138,6 +140,11 @@ def model_schema(config: ConfigType) -> cv.Schema:
             model.option(CONF_VSYNC_FRONT_PORCH): cv.int_,
         }
     )
+    return cv.All(
+        schema,
+        cv.only_on_esp32,
+        only_on_variant(supported=[VARIANT_ESP32P4]),
+    )
 
 
 @model_schema_extractor(MODELS, model_schema)
@@ -148,13 +155,9 @@ def _config_schema(config: ConfigType) -> ConfigType:
         },
         extra=cv.ALLOW_EXTRA,
     )(config)
-    config = cv.All(cv.only_on_esp32, only_on_variant(supported=[VARIANT_ESP32P4]))(
-        config
-    )
-    # Check before the schema, which would fail on default pins of a missing expander
+    config = model_schema(config)(config)
     model = MODELS[config[CONF_MODEL].upper()]
     model.check_requirements()
-    config = model_schema(config)(config)
     width, height, _offset_width, _offset_height, _pad_width, _pad_height = (
         model.get_dimensions(config)
     )

esphome/components/mipi_dsi/models/m5stack.py

@@ -14,7 +14,7 @@ DsiDriverChip(
     pclk_frequency="60MHz",
     lane_bit_rate="730Mbps",
     color_order="RGB",
-    requires={"psram"},
+    requires={"psram", "pi4ioe5v6408"},
     reset_pin={"pi4ioe5v6408": {"address": 0x43}, "number": 4},
     initsequence=[
         (0xFF, 0x98, 0x81, 0x01),  # Select Page 1
@@ -69,7 +69,7 @@ TAB5_ST7123 = DsiDriverChip(
     pclk_frequency="80MHz",
     lane_bit_rate="960Mbps",
     color_order="RGB",
-    requires={"psram"},
+    requires={"psram", "pi4ioe5v6408"},
     reset_pin={"pi4ioe5v6408": {"address": 0x43}, "number": 4},
     initsequence=[
         (0x01,),
@@ -122,7 +122,7 @@ DsiDriverChip(
     pclk_frequency="70MHz",
     lane_bit_rate="965Mbps",
     color_order="RGB",
-    requires={"psram"},
+    requires={"psram", "pi4ioe5v6408"},
     reset_pin={"pi4ioe5v6408": {"address": 0x43}, "number": 4},
     initsequence=[
         (0x01,),

esphome/components/mipi_dsi/models/seeed.py

@@ -17,7 +17,7 @@ DsiDriverChip(
     color_order="RGB",
     enable_pin=[{"xl9535": None, "number": 0}, {"xl9535": None, "number": 7}],
     reset_pin={"xl9535": None, "number": 2},
-    requires={"psram"},
+    requires={"psram", "xl9535"},
     initsequence=(
         (0xE0, 0x00),
         (0xE1, 0x93),

esphome/components/mipi_rgb/display.py

@@ -154,7 +154,9 @@ def model_schema(config: ConfigType) -> cv.Schema:
             cv_dimensions(CONF_DIMENSIONS): dimension_schema(
                 model.get_default(CONF_DRAW_ROUNDING, 1)
             ),
-            **display.enable_pin_schema(model, config),
+            model.option(CONF_ENABLE_PIN, cv.UNDEFINED): cv.ensure_list(
+                pins.gpio_output_pin_schema
+            ),
             model.option(CONF_COLOR_ORDER, MODE_RGB): cv.enum(COLOR_ORDERS, upper=True),
             model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
             model.option(CONF_PIXEL_MODE, PIXEL_MODE_16BIT): cv.one_of(
@@ -224,14 +226,14 @@ def _config_schema(config: ConfigType) -> ConfigType:
         },
         extra=cv.ALLOW_EXTRA,
     )(config)
+    schema = model_schema(config)
     config = cv.All(
+        schema,
         cv.only_on_esp32,
         only_on_variant(supported=[VARIANT_ESP32S3, VARIANT_ESP32P4, VARIANT_ESP32S31]),
     )(config)
-    # Check before the schema, which would fail on default pins of a missing expander
     model = MODELS[config[CONF_MODEL].upper()]
     model.check_requirements()
-    config = model_schema(config)(config)
     width, height, _offset_width, _offset_height, _pad_width, _pad_height = (
         model.get_dimensions(config)
     )

esphome/components/mipi_rgb/models/lilygo.py

@@ -9,7 +9,7 @@ ST7701S(
     spi_mode="MODE3",
     cs_pin={"xl9535": None, "number": 17},
     reset_pin={"xl9535": None, "number": 5},
-    requires={"psram"},
+    requires={"psram", "xl9535"},
     hsync_pin=39,
     vsync_pin=40,
     pclk_pin=41,
@@ -57,7 +57,7 @@ t_rgb = ST7701S(
     invert_colors=False,
     spi_mode="MODE3",
     cs_pin={"xl9535": None, "number": 3},
-    requires={"psram"},
+    requires={"psram", "xl9535"},
     de_pin=45,
     hsync_pin=47,
     vsync_pin=41,

esphome/components/mipi_rgb/models/st7701s.py

@@ -115,7 +115,7 @@ st7701s.extend(
     vsync_pulse_width=8,
     vsync_back_porch=20,
     cs_pin={"pca9554": None, "number": 4},
-    requires={"psram"},
+    requires={"psram", "pca9554"},
     de_pin=18,
     hsync_pin=16,
     vsync_pin=17,

esphome/components/mipi_rgb/models/waveshare.py

@@ -12,7 +12,7 @@ wave_4_3 = RgbDriverChip(
     pclk_frequency="16MHz",
     reset_pin={"ch422g": None, "number": 3},
     enable_pin={"ch422g": None, "number": 2},
-    requires={"psram"},
+    requires={"psram", "ch422g"},
     de_pin=5,
     hsync_pin={"number": 46, "ignore_strapping_warning": True},
     vsync_pin={"number": 3, "ignore_strapping_warning": True},

esphome/components/mipi_spi/display.py

@@ -197,7 +197,9 @@ def model_schema(config: ConfigType) -> cv.All | cv.Schema:
             {
                 cv.GenerateID(): cv.declare_id(MipiSpi),
                 cv_dimensions(CONF_DIMENSIONS): dimension_schema(1),
-                **display.enable_pin_schema(model, config),
+                model.option(CONF_ENABLE_PIN, cv.UNDEFINED): cv.ensure_list(
+                    pins.gpio_output_pin_schema
+                ),
                 model.option(CONF_COLOR_ORDER, MODE_BGR): cv.enum(
                     COLOR_ORDERS, upper=True
                 ),

esphome/components/mipi_spi/models/spd2010.py

@@ -22,6 +22,7 @@ DriverChip(
     transforms={CONF_MIRROR_X, CONF_MIRROR_Y},
     use_axis_flips=True,
     reset_delay=20,
+    requires={"pca9554"},
     initsequence=(
         delay(100),
         (0xFF, 0x20, 0x10, 0x10),

esphome/components/packet_interface/__init__.py

@@ -6,7 +6,9 @@ import esphome.codegen as cg
 from esphome.components.const import CONF_MAX_PACKET_SIZE
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
+from esphome.core import ID
 from esphome.cpp_generator import MockObj, MockObjClass
+import esphome.final_validate as fv
 from esphome.types import ConfigType
 
 from . import layers
@@ -34,6 +36,7 @@ LINK_LAYER_SCHEMAS = stack_schema()
 __all__ = [
     "CONF_MAX_PACKET_SIZE",
     "CONF_PACKET_INTERFACE",
+    "interface_layers",
     "PacketInterface",
     "new_packet_interface",
     "packet_interface_ns",
@@ -59,6 +62,14 @@ def _validate_layers(config: ConfigType) -> ConfigType:
     return config
 
 
+def interface_layers(interface_id: ID) -> ConfigType | None:
+    """During final validation, the configuration holding the layers of the packet interface with this id."""
+    for interface in fv.full_config.get().get(DOMAIN, []):
+        if interface[CONF_ID].id == interface_id.id:
+            return interface
+    return None
+
+
 def packet_interface_schema(
     class_: MockObjClass,
     default_max_packet_size: int,

esphome/components/sensor/__init__.py

@@ -124,7 +124,6 @@ from esphome.core import (
 )
 from esphome.core.config import UNIT_OF_MEASUREMENT_MAX_LENGTH
 from esphome.core.entity_helpers import (
-    FollowEntity,
     SubEntities,
     entity_duplicate_validator,
     lazy_load_validator,
@@ -1110,10 +1109,6 @@ def sub_sensors(
     return SubEntities(new_sensor, config, parent)
 
 
-# Makes a plain sensor follow another sensor: follow_sensor(entity, source)
-follow_sensor = FollowEntity("add_on_state_callback", ((cg.float_, "x"),), "x")
-
-
 SENSOR_IN_RANGE_CONDITION_SCHEMA = cv.All(
     {
         cv.Required(CONF_ID): cv.use_id(Sensor),

esphome/components/text_sensor/__init__.py

@@ -22,7 +22,6 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
-    FollowEntity,
     SubEntities,
     entity_duplicate_validator,
     queue_entity_register,
@@ -239,12 +238,6 @@ def sub_text_sensors(
     return SubEntities(new_text_sensor, config, parent)
 
 
-# Makes a plain text sensor follow another text sensor: follow_text_sensor(entity, source)
-follow_text_sensor = FollowEntity(
-    "add_on_state_callback", ((cg.std_string_ref.operator("const"), "x"),), "x"
-)
-
-
 @coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(text_sensor_ns.using)

esphome/config.py

@@ -1264,18 +1264,6 @@ class CoreFinalValidateStep(ConfigValidationStep):
         fv.full_config.reset(token)
 
 
-class OptionalPinValidationStep(ConfigValidationStep):
-    """Remove optional pins that are also used elsewhere"""
-
-    # After the ID pass, and before component final validations which may inspect pin use
-    priority = -15.0
-
-    def run(self, result: Config) -> None:
-        if result.errors:
-            return
-        pins.PIN_SCHEMA_REGISTRY.remove_optional_conflicts(result)
-
-
 class PinUseValidationCheck(ConfigValidationStep):
     """Check for pin reuse"""
 
@@ -1449,7 +1437,6 @@ def validate_config(
     result.add_validation_step(PrefetchRemoteFilesValidationStep())
     result.add_validation_step(IDPassValidationStep())
     result.add_validation_step(CoreFinalValidateStep())
-    result.add_validation_step(OptionalPinValidationStep())
     result.add_validation_step(PinUseValidationCheck())
 
     result.add_validation_step(RemoveReferenceValidationStep())

esphome/core/application.cpp

@@ -416,13 +416,10 @@ void Application::teardown_components(uint32_t timeout_ms) {
   }
 }
 
-void Application::add_looping_components_by_state_(bool inactive) {
+void Application::add_looping_components_by_state_(bool match_loop_done) {
   for (auto *obj : this->components_) {
-    if (!obj->has_overridden_loop()) {
-      continue;
-    }
-    const uint8_t state = obj->get_component_state() & COMPONENT_STATE_MASK;
-    if ((state == COMPONENT_STATE_LOOP_DONE || state == COMPONENT_STATE_FAILED) == inactive) {
+    if (obj->has_overridden_loop() &&
+        ((obj->get_component_state() & COMPONENT_STATE_MASK) == COMPONENT_STATE_LOOP_DONE) == match_loop_done) {
       this->looping_components_.push_back(obj);
     }
   }

esphome/core/application.h

@@ -433,15 +433,16 @@ class Application {
     // FixedVector capacity was pre-initialized by codegen with the exact count
     // of components that override loop(), computed at C++ compile time.
 
-    // Add all components with loop override that aren't already LOOP_DONE or FAILED
-    // Some components (like logger) may call disable_loop() during initialization,
-    // and some call mark_failed() from their constructor, before setup runs
+    // Add all components with loop override that aren't already LOOP_DONE
+    // Some components (like logger) may call disable_loop() during initialization
+    // before setup runs, so we need to respect their LOOP_DONE state
     this->add_looping_components_by_state_(false);
     this->looping_components_active_end_ = this->looping_components_.size();
-    // Then add any components that are already LOOP_DONE or FAILED to the inactive section
+    // Then add any components that are already LOOP_DONE to the inactive section
+    // This handles components that called disable_loop() during initialization
     this->add_looping_components_by_state_(true);
   }
-  void add_looping_components_by_state_(bool inactive);
+  void add_looping_components_by_state_(bool match_loop_done);
 
   // These methods are called by Component::disable_loop() and Component::enable_loop()
   // Components should not call these directly - use this->disable_loop() or this->enable_loop()

esphome/core/color.h

@@ -169,7 +169,7 @@ struct Color {
     uint8_t r = rand >> 16;
     uint8_t g = rand >> 8;
     uint8_t b = rand >> 0;
-    const uint16_t max_rgb = std::max({r, g, b, uint8_t(1)});
+    const uint16_t max_rgb = std::max({r, g, b});
     return Color(uint8_t((uint16_t(r) * 255U / max_rgb)), uint8_t((uint16_t(g) * 255U / max_rgb)),
                  uint8_t((uint16_t(b) * 255U / max_rgb)), w);
   }

esphome/core/defines.h

@@ -76,6 +76,8 @@
 #define USE_DISPLAY
 #define DISPLAY_PAGE_CHANGE_CALLBACK_COUNT 1
 #define DUCO_DEVICE_COUNT 4
+#define ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT 1
+#define ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT 1
 #define USE_EMONTX_VERSION
 #define USE_EMONTX_VERSION_TEXT_SENSOR
 #define USE_ENTITY_DEVICE_CLASS

esphome/core/entity_helpers.py

@@ -45,7 +45,6 @@ from esphome.core.config import (
     UNIT_OF_MEASUREMENT_MAX_LENGTH,
 )
 from esphome.cpp_generator import (
-    LambdaExpression,
     MockObj,
     MockObjClass,
     RawExpression,
@@ -520,23 +519,6 @@ class ApplyEntity:
 _APPLY_DOMAIN = "entity_apply"
 
 
-@dataclass(frozen=True, slots=True)
-class FollowEntity:
-    """A state callback, its parameters and the value an entity republishes from it."""
-
-    callback: str
-    params: tuple[tuple[SafeExpType, str], ...]
-    value: str
-
-    def __call__(self, entity: MockObj, source: MockObj, *args: SafeExpType) -> None:
-        """Make ``entity`` publish every state of ``source``; ``args`` precede the callback."""
-        publish = f"{parent_ref(entity).publish_state(RawExpression(self.value))};"
-        callback = LambdaExpression(
-            [publish], list(self.params), capture="", return_type=cg.void
-        )
-        add(getattr(source, self.callback)(*args, callback))
-
-
 @dataclass(frozen=True, slots=True)
 class SubEntities:
     """Create the child entity configured under key, set parent (if bound) and pass it to setter.

esphome/cpp_generator.py

@@ -331,8 +331,6 @@ class FloatLiteral(Literal):
     def __str__(self):
         if math.isnan(self.f):
             return "NAN"
-        if math.isinf(self.f):
-            return "INFINITY" if self.f > 0 else "-INFINITY"
         return f"{self.f}f"
 
 

esphome/espota2.py

@@ -466,15 +466,9 @@ def receive_exactly(
 
     while len(data) < amount:
         try:
-            chunk = recv_decode(sock, amount - len(data), decode=decode)
+            data += recv_decode(sock, amount - len(data), decode=decode)  # type: ignore[operator]
         except OSError as err:
             raise OTANetworkError(f"receiving {msg}: {err}") from err
-        if not chunk:
-            raise OTANetworkError(
-                f"receiving {msg}: device closed connection after "
-                f"{len(data)} of {amount} bytes"
-            )
-        data += chunk  # type: ignore[operator]
     return data
 
 

esphome/pins.py

@@ -1,10 +1,8 @@
 from collections.abc import Callable, Hashable
-from contextvars import ContextVar
 from functools import reduce
-import logging
 from logging import Logger
 import operator
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import esphome.config_validation as cv
 from esphome.const import (
@@ -23,64 +21,17 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID
 from esphome.cpp_generator import MockObj, MockObjClass
-from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
+from esphome.schema_extractors import schema_extractor
 from esphome.types import ConfigType, SafeExpType
 
-if TYPE_CHECKING:
-    from esphome.config import Config
-
-_LOGGER = logging.getLogger(__name__)
-
-# A use of a pin: the path of the component using it, the pin provider's id and the pin config
-PinUse = tuple[list, Any, ConfigType]
-
-# Set while validating pins that should give way to any other use of the same pin
-_validating_optional = ContextVar("validating_optional_pins", default=False)
-
-
-def _remove_value(conf: Any, target: Any) -> bool:
-    """Remove the object ``target`` from wherever it is nested in ``conf``."""
-    items = conf.items() if isinstance(conf, dict) else enumerate(conf)
-    for key, value in items:
-        if value is target:
-            del conf[key]
-            return True
-        if isinstance(value, (dict, list)) and _remove_value(value, target):
-            return True
-    return False
-
 
 class PinRegistry(dict):
     def __init__(self):
         super().__init__()
         self.pins_used = {}
-        # Entries of pins_used that give way to other uses, keyed by id()
-        self.optional_pins = {}
 
     def reset(self):
         self.pins_used = {}
-        self.optional_pins = {}
-
-    def optional(self, validator: Callable[[Any], Any]) -> Callable[[Any], Any]:
-        """
-        Wrap a pin validator so the pins it validates give way to any other use of the
-        same pin. Instead of the pin being reported as used in multiple places,
-        remove_optional_conflicts() removes it from the config, unless every other use
-        sets allow_other_uses, in which case the pin is shared. Use this for pins a
-        component supplies as defaults that a user may want to take over.
-        """
-
-        @schema_extractor("schema")
-        def wrapper(value: Any) -> Any:
-            if value == SCHEMA_EXTRACT:
-                return validator
-            token = _validating_optional.set(True)
-            try:
-                return validator(value)
-            finally:
-                _validating_optional.reset(token)
-
-        return wrapper
 
     def get_count(self, key, id, number):
         """
@@ -135,10 +86,7 @@ class PinRegistry(dict):
                 self.pins_used[pin_key] = []
             # client_id identifies the instance of the providing component
             client_id = result.get(key)
-            entry = (path_context.get(), client_id, result)
-            self.pins_used[pin_key].append(entry)
-            if _validating_optional.get():
-                self.optional_pins[id(entry)] = entry
+            self.pins_used[pin_key].append((path_context.get(), client_id, result))
         # return the validated pin config
         return result
 
@@ -162,69 +110,23 @@ class PinRegistry(dict):
         key = self.get_key(key) if isinstance(key, dict) else key
         return self[key][0]
 
-    def _grouped(self) -> dict[tuple, list[PinUse]]:
-        """Group pin uses by (schema key, resolved provider id, pin number)."""
-        # Regroup by (schema key, resolved provider id, pin number) rather than
-        # the validate()-time bucket, so the same physical pin reached via an
-        # explicit id and via {address: ...} (or an omitted id) is recognized as
-        # one reuse group regardless of which syntax was used to reference the hub.
-        grouped: dict[tuple, list[PinUse]] = {}
-        for (key, _, number), pin_list in self.pins_used.items():
-            for entry in pin_list:
-                client_id = entry[1]
-                provider_id = client_id.id if isinstance(client_id, ID) else client_id
-                grouped.setdefault((key, provider_id, number), []).append(entry)
-        return grouped
-
-    def remove_optional_conflicts(self, fconf: "Config") -> None:
-        """
-        Remove optional pins that are also used elsewhere from the config, or mark them
-        as shared if every other use sets allow_other_uses. This runs once ids are resolved and before the components' final validation,
-        so those only see the pins that will be used.
-        :param fconf: The full config
-        """
-        if not self.optional_pins:
-            return
-        for (key, provider_id, _), pin_list in self._grouped().items():
-            optional = [e for e in pin_list if id(e) in self.optional_pins]
-            others = [e for e in pin_list if id(e) not in self.optional_pins]
-            if not optional or not others:
-                continue
-            if all(e[2].get(CONF_ALLOW_OTHER_USES, False) for e in others):
-                # The other uses ask to share the pin, so share it with the optional ones too
-                for _, _, pin_config in optional:
-                    pin_config[CONF_ALLOW_OTHER_USES] = True
-                continue
-            for entry in optional:
-                self._remove_optional(fconf, key, provider_id, entry)
-
-    def _remove_optional(
-        self, fconf: "Config", key: str, provider_id: str | None, entry: PinUse
-    ) -> None:
-        """
-        Remove an optional pin from the config and from the pins used. If it cannot be
-        found in the config it is kept, so final_validate() reports the conflict.
-        """
-        pin_path, _, pin_config = entry
-        if not _remove_value(fconf.get_config_for_path(pin_path), pin_config):
-            return
-        for pin_list in self.pins_used.values():
-            pin_list[:] = [e for e in pin_list if e is not entry]
-        del self.optional_pins[id(entry)]
-        pin = f"{key} {provider_id} pin" if provider_id is not None else "Pin"
-        _LOGGER.info(
-            "%s %s is used elsewhere, so is not applied as a default for %s",
-            pin,
-            pin_config[CONF_NUMBER],
-            "->".join(str(p) for p in pin_path),
-        )
-
     def final_validate(self, fconf):
         """
         Run the final validation for all pins, and check for reuse
         :param fconf: The full config
         """
-        for (key, _, _), pin_list in self._grouped().items():
+        # Regroup by (schema key, resolved provider id, pin number) rather than
+        # the validate()-time bucket, so the same physical pin reached via an
+        # explicit id and via {address: ...} (or an omitted id) is recognized as
+        # one reuse group regardless of which syntax was used to reference the hub.
+        grouped: dict[tuple, list] = {}
+        for (key, _, number), pin_list in self.pins_used.items():
+            for entry in pin_list:
+                client_id = entry[1]
+                provider_id = client_id.id if isinstance(client_id, ID) else client_id
+                grouped.setdefault((key, provider_id, number), []).append(entry)
+
+        for (key, _, _), pin_list in grouped.items():
             count = len(pin_list)  # number of places same pin used.
             final_val_fun = self[key][2]  # final validation function
             for pin_path, client_id, pin_config in pin_list:

tests/component_tests/epaper_spi/config/enable_pin_default.yaml

@@ -1,17 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32-s3-devkitc-1
-
-psram:
-  mode: octal
-
-spi:
-  clk_pin: GPIO7
-  mosi_pin: GPIO9
-
-display:
-  - platform: epaper_spi
-    id: epaper_display
-    model: seeed-reterminal-sticky

tests/component_tests/epaper_spi/config/enable_pin_used_elsewhere.yaml

@@ -1,23 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32-s3-devkitc-1
-
-psram:
-  mode: octal
-
-spi:
-  clk_pin: GPIO7
-  mosi_pin: GPIO9
-
-# Takes over the model's default enable pin
-switch:
-  - platform: gpio
-    id: panel_power
-    pin: GPIO47
-
-display:
-  - platform: epaper_spi
-    id: epaper_display
-    model: seeed-reterminal-sticky

tests/component_tests/epaper_spi/test_enable_pins.py

@@ -1,46 +0,0 @@
-"""Tests for applying the default enable pins of epaper_spi models."""
-
-from collections.abc import Callable
-from pathlib import Path
-import re
-
-
-def _enable_pin_numbers(main_cpp: str) -> list[int]:
-    """Get the GPIO numbers passed to set_enable_pins() in the generated code."""
-    match = re.search(r"epaper_display->set_enable_pins\(\{(.*)\}\);", main_cpp)
-    if match is None:
-        return []
-    numbers = []
-    for pin_id in match.group(1).split(", "):
-        pin = re.search(rf"{pin_id}->set_pin\(::GPIO_NUM_(\d+)\);", main_cpp)
-        assert pin is not None
-        numbers.append(int(pin.group(1)))
-    return numbers
-
-
-def test_default_enable_pin(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    """The model's enable pin is applied when it is not used elsewhere."""
-    main_cpp = generate_main(component_config_path("enable_pin_default.yaml"))
-    assert _enable_pin_numbers(main_cpp) == [47]
-
-
-def test_default_enable_pin_used_elsewhere(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    """A default enable pin used by a switch is left out instead of failing validation."""
-    main_cpp = generate_main(component_config_path("enable_pin_used_elsewhere.yaml"))
-    assert _enable_pin_numbers(main_cpp) == []
-    assert "panel_power->set_pin(" in main_cpp
-
-
-def test_user_enable_pins(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    """Enable pins given in the config are applied as given."""
-    main_cpp = generate_main(component_config_path("enable_pin_test.yaml"))
-    assert _enable_pin_numbers(main_cpp) == [25, 26]

tests/component_tests/it8951/fixtures/enable_pins.yaml

@@ -1,26 +0,0 @@
-esphome:
-  name: it8951-enable-pins
-
-esp32:
-  board: esp32-s3-devkitc-1
-  framework:
-    type: esp-idf
-
-psram:
-  mode: octal
-
-spi:
-  clk_pin: 7
-  mosi_pin: 9
-  miso_pin: 8
-
-# Takes over the model's default 1.8V logic supply enable pin
-switch:
-  - platform: gpio
-    id: logic_supply
-    pin: GPIO21
-
-display:
-  - platform: it8951
-    id: epaper_display
-    model: seeed-reterminal-e1003

tests/component_tests/it8951/test_init.py

@@ -1,8 +1,6 @@
 """Tests for it8951 configuration validation."""
 
 from collections.abc import Callable
-from pathlib import Path
-import re
 from typing import Any
 
 from esphome.components.const import CONF_HOLD_STATE
@@ -28,18 +26,3 @@ def test_reterminal_e1003_enable_pins_hold_state(
     enable_pins = config[CONF_ENABLE_PIN]
     assert [pin[CONF_NUMBER] for pin in enable_pins] == [21, 11]
     assert all(pin[CONF_HOLD_STATE] for pin in enable_pins)
-
-
-def test_reterminal_e1003_enable_pin_used_elsewhere(
-    generate_main: Callable[[str | Path], str],
-    component_fixture_path: Callable[[str], Path],
-) -> None:
-    """A default enable pin used by a switch is left out, and the other is still applied."""
-    main_cpp = generate_main(component_fixture_path("enable_pins.yaml"))
-
-    match = re.search(r"epaper_display->set_enable_pins\(\{(.*)\}\);", main_cpp)
-    assert match is not None
-    pin_ids = match.group(1).split(", ")
-    assert len(pin_ids) == 1
-    assert f"{pin_ids[0]}->set_pin(::GPIO_NUM_11);" in main_cpp
-    assert "logic_supply->set_pin(" in main_cpp

tests/component_tests/lightwaverf/test_send_raw.py

@@ -1,24 +0,0 @@
-"""lightwaverf.send_raw never used name; it is dropped with a warning until 2027.5.0."""
-
-import pytest
-
-from esphome.automation import ACTION_REGISTRY
-import esphome.components.lightwaverf  # noqa: F401
-from esphome.const import CONF_NAME, CONF_REPEAT
-
-CODE = [0x04, 0x00, 0x00, 0x00, 0x0F, 0x03, 0x0D, 0x09, 0x08, 0x08]
-
-
-def test_name_is_dropped_with_a_warning(caplog: pytest.LogCaptureFixture) -> None:
-    config = ACTION_REGISTRY["lightwaverf.send_raw"].schema(
-        {"code": CODE, CONF_NAME: "Sofa"}
-    )
-    assert CONF_NAME not in config
-    assert "'name' on lightwaverf.send_raw has no effect" in caplog.text
-    assert "2027.5.0" in caplog.text
-
-
-def test_name_is_no_longer_required(caplog: pytest.LogCaptureFixture) -> None:
-    config = ACTION_REGISTRY["lightwaverf.send_raw"].schema({"code": CODE})
-    assert config[CONF_REPEAT] == 10
-    assert "lightwaverf" not in caplog.text

tests/component_tests/lvgl/config/canvas_draw_options_test.yaml

@@ -1,50 +0,0 @@
-esphome:
-  name: test-canvas-draw-options
-  on_boot:
-    - lvgl.canvas.draw_rectangle:
-        id: test_canvas
-        x: 0
-        y: 0
-        width: 20
-        height: 10
-        bg_grad: test_grad
-    - lvgl.canvas.draw_line:
-        id: test_canvas
-        dash_width: 4
-        dash_gap: 2
-        points:
-          - 0,0
-          - 10,10
-
-esp32:
-  board: lolin_c3_mini
-
-spi:
-  mosi_pin:
-    number: GPIO2
-    ignore_strapping_warning: true
-  clk_pin: GPIO1
-
-display:
-  - platform: mipi_spi
-    data_rate: 20MHz
-    model: st7735
-    cs_pin:
-      number: GPIO8
-      ignore_strapping_warning: true
-    dc_pin: GPIO3
-
-lvgl:
-  gradients:
-    - id: test_grad
-      direction: hor
-      stops:
-        - color: 0xFF0000
-          position: 0
-        - color: 0x0000FF
-          position: 255
-  widgets:
-    - canvas:
-        id: test_canvas
-        width: 32
-        height: 32

tests/component_tests/lvgl/config/indicator_update_opa_test.yaml

@@ -1,58 +0,0 @@
-esphome:
-  name: test-indicator-update-opa
-  on_boot:
-    - lvgl.indicator.update:
-        id: test_arc
-        opa: 50%
-    - lvgl.indicator.update:
-        id: test_needle
-        value: 5
-        opa: 25%
-    - lvgl.indicator.update:
-        id: test_image
-        opa: 75%
-
-esp32:
-  board: lolin_c3_mini
-
-spi:
-  mosi_pin:
-    number: GPIO2
-    ignore_strapping_warning: true
-  clk_pin: GPIO1
-
-display:
-  - platform: mipi_spi
-    data_rate: 20MHz
-    model: st7735
-    cs_pin:
-      number: GPIO8
-      ignore_strapping_warning: true
-    dc_pin: GPIO3
-
-image:
-  - platform: file
-    file: image.png
-    id: meter_image
-    resize: 8x8
-    type: binary
-
-lvgl:
-  widgets:
-    - meter:
-        height: 100px
-        width: 100px
-        scales:
-          - id: test_scale
-            range_from: 0
-            range_to: 10
-            indicators:
-              - arc:
-                  id: test_arc
-                  start_value: 0
-                  end_value: 5
-              - line:
-                  id: test_needle
-              - image:
-                  id: test_image
-                  src: meter_image

tests/component_tests/lvgl/test_canvas_draw_options.py

@@ -1,69 +0,0 @@
-"""Canvas draw options must map onto the LVGL 9 draw descriptor fields."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from esphome import config_validation as cv
-from esphome.__main__ import generate_cpp_contents
-from esphome.automation import ACTION_REGISTRY
-import esphome.components.lvgl.widgets.canvas  # noqa: F401 - registers the actions
-from esphome.config import read_config
-from esphome.core import CORE
-
-
-@pytest.fixture(scope="module")
-def main_cpp(request: pytest.FixtureRequest) -> str:
-    config_path = (
-        Path(request.fspath).parent / "config" / "canvas_draw_options_test.yaml"
-    )
-    original_path = CORE.config_path
-    try:
-        CORE.config_path = config_path
-        CORE.config = read_config({})
-        generate_cpp_contents(CORE.config)
-        return CORE.cpp_main_section
-    finally:
-        CORE.config_path = original_path
-        CORE.reset()
-
-
-def test_rect_gradient_is_copied_by_value(main_cpp: str) -> None:
-    assert ".bg_grad = *test_grad;" in main_cpp
-
-
-def test_line_dash_fields(main_cpp: str) -> None:
-    assert ".dash_width = 4;" in main_cpp
-    assert ".dash_gap = 2;" in main_cpp
-
-
-def test_rect_opa_names_the_per_part_keys() -> None:
-    with pytest.raises(cv.Invalid, match="bg_opa"):
-        ACTION_REGISTRY["lvgl.canvas.draw_rectangle"].schema(
-            {"id": "cv", "x": 0, "y": 0, "width": 10, "height": 10, "opa": "50%"}
-        )
-
-
-@pytest.mark.parametrize(
-    "key", ["opa", "bg_color", "bg_grad", "radius", "shadow_width"]
-)
-def test_polygon_rejects_non_border_keys(key: str) -> None:
-    with pytest.raises(cv.Invalid, match="drawn as an outline"):
-        ACTION_REGISTRY["lvgl.canvas.draw_polygon"].schema(
-            {"id": "cv", "points": [{"x": 0, "y": 0}], key: 1}
-        )
-
-
-def test_polygon_accepts_border_keys() -> None:
-    config = ACTION_REGISTRY["lvgl.canvas.draw_polygon"].schema(
-        {
-            "id": "cv",
-            "points": [{"x": 0, "y": 0}],
-            "border_color": 0xFF0000,
-            "border_width": 2,
-            "border_opa": "50%",
-        }
-    )
-    assert config["border_width"] == 2

tests/component_tests/lvgl/test_indicator_update_opa.py

@@ -1,49 +0,0 @@
-"""lvgl.indicator.update must apply opa to arc, needle and image indicators."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from esphome.__main__ import generate_cpp_contents
-from esphome.config import read_config
-from esphome.core import CORE
-
-
-@pytest.fixture(scope="module")
-def main_cpp(request: pytest.FixtureRequest) -> str:
-    config_path = (
-        Path(request.fspath).parent / "config" / "indicator_update_opa_test.yaml"
-    )
-    original_path = CORE.config_path
-    try:
-        CORE.config_path = config_path
-        CORE.config = read_config({})
-        generate_cpp_contents(CORE.config)
-        return CORE.cpp_main_section
-    finally:
-        CORE.config_path = original_path
-        CORE.reset()
-
-
-def test_arc_section_opa_is_applied(main_cpp: str) -> None:
-    assert (
-        "lv_style_set_arc_opa(meter_arc_test_arc_style, static_cast<uint8_t>(127.5f));"
-        in main_cpp
-    )
-    assert "lv_obj_invalidate(test_scale);" in main_cpp
-
-
-def test_needle_opa_is_applied(main_cpp: str) -> None:
-    assert (
-        "lv_obj_set_style_opa(test_needle->obj, static_cast<uint8_t>(63.75f), LV_PART_MAIN);"
-        in main_cpp
-    )
-
-
-def test_image_opa_is_applied(main_cpp: str) -> None:
-    assert (
-        "lv_obj_set_style_opa(test_image, static_cast<uint8_t>(191.25f), LV_PART_MAIN);"
-        in main_cpp
-    )

tests/component_tests/mipi_dsi/fixtures/enable_pins_address.yaml

@@ -1,38 +0,0 @@
-esphome:
-  name: enable-pins-address
-
-esp32:
-  board: esp32-p4-evboard
-  framework:
-    type: esp-idf
-
-psram:
-  speed: 200MHz
-
-esp_ldo:
-  - channel: 3
-    voltage: 2.5V
-
-i2c:
-  sda: GPIO7
-  scl: GPIO8
-
-pi4ioe5v6408:
-  - id: pi4ioe1
-    address: 0x43
-  - id: pi4ioe2
-    address: 0x44
-
-# Takes over the default enable pin on the hub at 0x44, given by address
-switch:
-  - platform: gpio
-    id: takeover
-    pin:
-      pi4ioe5v6408:
-        address: 0x44
-      number: 1
-
-display:
-  - platform: mipi_dsi
-    id: default_pins
-    model: TEST-ENABLE-BY-ADDRESS

tests/component_tests/mipi_dsi/test_enable_pins.py

@@ -1,40 +0,0 @@
-"""Tests for applying the default enable pins of mipi_dsi models."""
-
-from collections.abc import Callable
-from pathlib import Path
-import re
-
-import pytest
-
-from esphome.components.mipi import DriverChip
-
-
-def test_default_enable_pins_by_address(
-    generate_main: Callable[[str | Path], str],
-    component_fixture_path: Callable[[str], Path],
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Default enable pins naming a hub by address resolve to that hub, and only
-    the pin used elsewhere is left out, not the same pin number on the other hub."""
-    from esphome.components.mipi_dsi.display import MODELS
-
-    models = set(DriverChip.models)
-    model = MODELS["M5STACK-TAB5"].extend(
-        "TEST-ENABLE-BY-ADDRESS",
-        enable_pin=[
-            {"pi4ioe5v6408": {"address": 0x43}, "number": 1},
-            {"pi4ioe5v6408": {"address": 0x44}, "number": 1},
-        ],
-    )
-    for name in set(DriverChip.models) - models:
-        monkeypatch.delitem(DriverChip.models, name)
-    monkeypatch.setitem(MODELS, model.name, model)
-
-    main_cpp = generate_main(component_fixture_path("enable_pins_address.yaml"))
-
-    match = re.search(r"default_pins->set_enable_pins\(\{(.*)\}\);", main_cpp)
-    assert match is not None
-    pin_ids = match.group(1).split(", ")
-    assert len(pin_ids) == 1
-    assert f"{pin_ids[0]}->set_parent(pi4ioe1);" in main_cpp
-    assert f"{pin_ids[0]}->set_pin(1);" in main_cpp

tests/component_tests/mipi_dsi/test_mipi_dsi_config.py

@@ -8,7 +8,7 @@ import re
 import pytest
 
 from esphome import config_validation as cv
-from esphome.components.esp32 import KEY_BOARD, VARIANT_ESP32P4, VARIANT_ESP32S3
+from esphome.components.esp32 import KEY_BOARD, VARIANT_ESP32P4
 
 # Importing the I/O expanders registers their pin schemas with
 # pins.PIN_SCHEMA_REGISTRY so that models whose defaults reference expander-backed
@@ -215,20 +215,3 @@ def test_code_generation(
     assert "p4_86->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);" not in main_cpp
     assert "custom_id->set_rotation(display::DISPLAY_ROTATION_180_DEGREES);" in main_cpp
     # assert "backlight_id = new light::LightState(mipi_dsi_dsibacklight_id);" in main_cpp
-
-
-def test_unsupported_variant_reported_before_requirements(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    """On an unsupported chip the variant error is shown, not the missing components."""
-    from esphome.components.mipi_dsi.display import CONFIG_SCHEMA
-    from esphome.core import CORE
-
-    set_core_config(
-        PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
-    )
-    CORE.raw_config = {}
-
-    with pytest.raises(cv.Invalid, match=r"This feature is only available on ESP32P4"):
-        CONFIG_SCHEMA({"model": "SEEED-RETERMINAL-D1001"})

tests/component_tests/mipi_rgb/fixtures/enable_pins.yaml

@@ -1,32 +0,0 @@
-esphome:
-  name: enable-pins-test
-
-esp32:
-  board: esp32-s3-devkitc-1
-  framework:
-    type: esp-idf
-
-psram:
-  mode: octal
-  speed: 80MHz
-
-i2c:
-  sda: 8
-  scl: 9
-
-ch422g:
-  - id: ch422g_hub
-
-# Takes over the model's default backlight enable pin
-switch:
-  - platform: gpio
-    id: backlight
-    pin:
-      ch422g: ch422g_hub
-      number: 2
-
-display:
-  - platform: mipi_rgb
-    id: default_pins
-    model: ESP32-S3-TOUCH-LCD-7-800X480
-    update_interval: never

tests/component_tests/mipi_rgb/fixtures/enable_pins_default.yaml

@@ -1,24 +0,0 @@
-esphome:
-  name: enable-pins-test
-
-esp32:
-  board: esp32-s3-devkitc-1
-  framework:
-    type: esp-idf
-
-psram:
-  mode: octal
-  speed: 80MHz
-
-i2c:
-  sda: 8
-  scl: 9
-
-ch422g:
-  - id: ch422g_hub
-
-display:
-  - platform: mipi_rgb
-    id: default_pins
-    model: ESP32-S3-TOUCH-LCD-7-800X480
-    update_interval: never

tests/component_tests/mipi_rgb/test_enable_pins.py

@@ -1,36 +0,0 @@
-"""Tests for applying the default enable pins of mipi_rgb models."""
-
-from collections.abc import Callable
-from pathlib import Path
-import re
-
-
-def _enable_pin_numbers(main_cpp: str) -> list[int]:
-    """Get the expander pin numbers passed to set_enable_pins() in the generated code."""
-    match = re.search(r"default_pins->set_enable_pins\(\{(.*)\}\);", main_cpp)
-    assert match is not None
-    numbers = []
-    for pin_id in match.group(1).split(", "):
-        pin = re.search(rf"{pin_id}->set_pin\((\d+)\);", main_cpp)
-        assert pin is not None
-        numbers.append(int(pin.group(1)))
-    return numbers
-
-
-def test_default_enable_pins(
-    generate_main: Callable[[str | Path], str],
-    component_fixture_path: Callable[[str], Path],
-) -> None:
-    """All of the model's enable pins are applied when none are used elsewhere."""
-    main_cpp = generate_main(component_fixture_path("enable_pins_default.yaml"))
-    assert _enable_pin_numbers(main_cpp) == [2, 6]
-
-
-def test_default_enable_pin_used_elsewhere(
-    generate_main: Callable[[str | Path], str],
-    component_fixture_path: Callable[[str], Path],
-) -> None:
-    """A default enable pin used by a switch is left out instead of failing validation."""
-    main_cpp = generate_main(component_fixture_path("enable_pins.yaml"))
-    assert _enable_pin_numbers(main_cpp) == [6]
-    assert "backlight->set_pin(" in main_cpp

tests/component_tests/mipi_rgb/test_init.py

@@ -8,12 +8,7 @@ from typing import Any
 import pytest
 
 from esphome import config_validation as cv
-from esphome.components.esp32 import (
-    KEY_BOARD,
-    KEY_VARIANT,
-    VARIANT_ESP32C3,
-    VARIANT_ESP32S3,
-)
+from esphome.components.esp32 import KEY_BOARD, KEY_VARIANT, VARIANT_ESP32S3
 from esphome.components.mipi_rgb.display import CONFIG_SCHEMA, FINAL_VALIDATE_SCHEMA
 
 # Importing pca9554 registers its pin schema with pins.PIN_SCHEMA_REGISTRY so that
@@ -92,78 +87,3 @@ def test_model_requires_psram_and_expander(
                 "spi_id": "spi_bus",
             }
         )
-
-
-def test_model_requires_expander_when_pins_overridden(
-    set_core_config: SetCoreConfigCallable,
-    set_component_config: Any,
-) -> None:
-    """A model with default pins on an expander requires it even when the user config
-    overrides all of those pins, and without the expander being listed in ``requires``."""
-    set_core_config(
-        PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
-    )
-    set_component_config("psram", True)
-    CORE.raw_config = {"psram": True}
-
-    with pytest.raises(
-        cv.Invalid,
-        match=r"ESP32-S3-TOUCH-LCD-7-800X480 requires component 'ch422g' to be configured",
-    ):
-        _validated(
-            {
-                "model": "ESP32-S3-TOUCH-LCD-7-800X480",
-                "reset_pin": 10,
-                "enable_pin": [11, 12],
-            }
-        )
-
-
-def test_model_requires_expander_with_default_pins(
-    set_core_config: SetCoreConfigCallable,
-    set_component_config: Any,
-) -> None:
-    """The missing expander is reported before the model's default pins on it are validated."""
-    set_core_config(
-        PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
-    )
-    set_component_config("psram", True)
-    CORE.raw_config = {"psram": True}
-
-    with pytest.raises(
-        cv.Invalid,
-        match=r"ESP32-S3-TOUCH-LCD-7-800X480 requires component 'ch422g' to be configured",
-    ):
-        _validated({"model": "ESP32-S3-TOUCH-LCD-7-800X480"})
-
-
-def test_unsupported_variant_reported_before_requirements(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    """On an unsupported chip the variant error is shown, not the missing components."""
-    set_core_config(
-        PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32-c3-devkitm-1", KEY_VARIANT: VARIANT_ESP32C3},
-    )
-    CORE.raw_config = {}
-
-    with pytest.raises(
-        cv.Invalid,
-        match=r"This feature is only available on ESP32S3, ESP32P4, ESP32S31",
-    ):
-        _validated({"model": "ESP32-S3-TOUCH-LCD-7-800X480"})
-
-
-def test_expander_that_fails_to_load_is_still_required(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """An expander component that exists but fails to load is still counted as required."""
-    from esphome import loader, pins
-    from esphome.components import mipi
-
-    monkeypatch.setattr(pins, "PIN_SCHEMA_REGISTRY", pins.PinRegistry())
-    monkeypatch.setattr(loader, "get_component", lambda key: None)
-    defaults = {"enable_pin": {"xl9535": "hub", "number": 1, "mode": "output"}}
-    assert mipi._pin_expanders(defaults) == {"xl9535"}

tests/components/api/common-base.yaml

@@ -36,30 +36,6 @@ esphome:
           service: notify.html5
           data:
             message: Button was pressed
-      - homeassistant.service:
-          service: !lambda 'return std::string("notify.html5");'
-          data:
-            title: Title
-          data_template:
-            message: The value is {{ my_value }}
-          variables:
-            my_value: !lambda 'return std::string("42");'
-          capture_response: true
-          response_template: !lambda 'return std::string("{{ response.value }}");'
-          on_success:
-            - logger.log: "service succeeded"
-          on_error:
-            - logger.log:
-                format: "service failed: %s"
-                args: [error.c_str()]
-      - homeassistant.action:
-          action: weather.get_forecasts
-          data:
-            entity_id: weather.forecast_home
-          capture_response: true
-          response_template: !lambda 'return std::string("{{ response }}");'
-          on_success:
-            - logger.log: "forecast received"
       - homeassistant.tag_scanned: pulse
       - homeassistant.action:
           action: weather.get_forecasts
@@ -331,13 +307,6 @@ api:
             success: false
             error_message: !lambda 'return error_msg;'
 
-    - action: test_respond_lambda_success
-      variables:
-        ok: bool
-      then:
-        - api.respond:
-            success: !lambda 'return ok;'
-
     # ==========================================================================
     # supports_response: optional (auto-detected - api.respond with data)
     # Has call_id and return_response - client decides if it wants response

tests/components/at581x/common.yaml

@@ -21,14 +21,6 @@ esphome:
           id: waveradar
           frequency: 5800MHz
           power_consumption: 91uA
-      - at581x.settings:
-          id: waveradar
-          hw_frontend_reset: !lambda return true;
-          sensing_distance: !lambda return 300;
-          protect_time: !lambda return 1500;
-          trigger_base: !lambda return 600;
-          trigger_keep: !lambda return 12000;
-          stage_gain: !lambda return 4;
       - at581x.reset:
           id: waveradar
 

tests/components/bk72xx_ble_tracker/validate-automations.bk72xx-ard.yaml

@@ -7,8 +7,6 @@ esphome:
       - bk72xx_ble_tracker.start_scan
       - bk72xx_ble_tracker.start_scan:
           continuous: true
-      - bk72xx_ble_tracker.start_scan:
-          continuous: !lambda return false;
       - bk72xx_ble_tracker.stop_scan
       - bk72xx_ble_tracker.stop_scan: ble_tracker
 

tests/components/bmi270/common.yaml

@@ -109,10 +109,3 @@ button:
             - logger.log: Level calibration failed
       - motion.calibrate_heading:
           id: bmi270_motion
-      - motion.calibrate_heading:
-          id: bmi270_motion
-          save: true
-          on_success:
-            - logger.log: Heading calibrated
-          on_error:
-            - logger.log: Heading calibration failed

tests/components/bq25186/common.yaml

@@ -9,49 +9,6 @@ esphome:
           id: bq25186_charger
           battery_regulation_voltage: 4.1V
           fast_charge_current: 200mA
-      - bq25186.apply_configuration:
-          id: bq25186_charger
-          charge_enabled: false
-          flash_charging_mode: true
-          precharge_is_iterm: true
-          termination_percent: 5%
-          vindpm_mode: 4.7v
-          thermal_regulation: 80c
-          battery_ocp_limit: 1500ma
-          battery_uvlo: 3.0v
-          mask_charge_status_interrupt: false
-          mask_ilim_interrupt: false
-          mask_vindpm_interrupt: true
-          ts_auto_function: false
-          vlowv: 2.8v
-          recharge_threshold: 200mv
-          double_timer_during_dpm: true
-          safety_timer: 12h
-          watchdog: 160s_hardware_reset
-          long_press_duration: 15s
-          hw_reset_requires_vin: true
-          autowake: 2s
-          input_current_limit: 200ma
-      - bq25186.apply_configuration:
-          id: bq25186_charger
-          push_button_long_press_action: shutdown_mode
-          wake1_timer: 1s
-          wake2_timer: 3s
-          enable_push_button: false
-          system_regulation: 4.6v
-          sys_mode: battery_only
-          watchdog_15s_enable: false
-          disable_vdppm: true
-          ts_hot: 65c
-          ts_cold: 3c
-          ts_warm_disable: true
-          ts_cool_disable: true
-          ts_ichg: 0.2x
-          ts_vrcg: -200mv
-          mask_ts_interrupt: true
-          mask_treg_interrupt: false
-          mask_bat_interrupt: true
-          mask_pg_interrupt: true
 
 bq25186:
   - id: bq25186_charger

tests/components/bq76972/common.yaml

@@ -14,9 +14,6 @@ button:
           id: bms
           address: 0x09
       - bq76972.program_i2c_address: !lambda "return 0x08;"
-      - bq76972.program_i2c_address:
-          id: bms
-          address: !lambda return 0x0A;
 
 sensor:
   - platform: bq76972

tests/components/canbus/common.yaml

@@ -69,7 +69,3 @@ button:
       - canbus.send: !lambda |-
           uint8_t val = (uint8_t)id(canbus_test_number).state;
           return std::vector<uint8_t>{0xAA, val, 0xBB};
-      - canbus.send:
-          can_id: 0x123
-          remote_transmission_request: true
-          data: []

tests/components/counter/common.yaml

@@ -5,9 +5,6 @@ esphome:
           id: counter_sensor
           value: 100
       - counter.increment: counter_sensor
-      - counter.set_value:
-          id: counter_sensor
-          value: !lambda return 42LL;
       - counter.increment:
           id: counter_sensor
           value: -5

tests/components/deep_sleep/common.yaml

@@ -14,8 +14,6 @@ esphome:
           then:
             - deep_sleep.enter:
                 sleep_duration: 60min
-            - deep_sleep.enter:
-                sleep_duration: !lambda return 60000;
       - if:
           condition:
             lambda: 'return deep_sleep::woke_from_deep_sleep();'

tests/components/deep_sleep/test-ota-rollback.esp32-idf.yaml

@@ -2,8 +2,7 @@
 # (the default on ESP-IDF). Entering deep sleep runs the safe shutdown hooks,
 # where safe_mode confirms the running app image so the bootloader does not
 # roll back a fresh OTA update when the device goes to sleep before
-# boot_is_good_after has elapsed. The network this needs also serves the
-# deep_sleep.enter until/time_id case, which requires a time source.
+# boot_is_good_after has elapsed.
 substitutions:
   wakeup_pin: GPIO4
 
@@ -18,16 +17,3 @@ wifi:
 ota:
   - platform: esphome
     password: "superlongpasswordthatnoonewillknow"
-
-time:
-  - platform: sntp
-    id: sntp_time
-
-button:
-  - platform: template
-    name: Sleep until
-    on_press:
-      - deep_sleep.enter:
-          id: deep_sleep_1
-          until: "06:30:00"
-          time_id: sntp_time

tests/components/dfplayer/common.yaml

@@ -27,12 +27,6 @@ esphome:
       - dfplayer.set_volume: !lambda "return id(dfplayer_test).is_playing() ? 10 : 5;"
       - dfplayer.set_eq: ROCK
       - dfplayer.set_eq: !lambda "return id(dfplayer_test).is_playing() ? dfplayer::JAZZ : dfplayer::BASS;"
-      - dfplayer.play_mp3:
-          file: 7
-      - dfplayer.set_volume:
-          volume: 12
-      - dfplayer.set_eq:
-          eq_preset: CLASSIC
       - dfplayer.play_next
       - dfplayer.play_previous
       - dfplayer.reset

tests/components/dfrobot_sen0395/common.yaml

@@ -12,10 +12,6 @@ esphome:
             delay_after_detect: 0s
             delay_after_disappear: 0s
           sensitivity: 6
-      - dfrobot_sen0395.settings:
-          id: mmwave
-          factory_reset: !lambda return false;
-          sensitivity: !lambda return 7;
       - dfrobot_sen0395.reset
 
 dfrobot_sen0395:

tests/components/ds3231/common.yaml

@@ -52,36 +52,6 @@ button:
           minute: !lambda return 45;
       - ds3231.set_alarm_2:
           mode: every_minute
-      - ds3231.set_alarm_1:
-          mode: weekly
-          day_of_week: 3
-          hour: !lambda return 8;
-          second: !lambda return 30;
-          enabled: !lambda return true;
-      - ds3231.set_alarm_1:
-          mode: monthly
-          day_of_month: !lambda return 20;
-          minute: !lambda return 10;
-      - ds3231.set_alarm_2:
-          mode: monthly
-          day_of_month: 10
-          enabled: false
-      - ds3231.set_alarm_2:
-          mode: weekly
-          day_of_week: !lambda return 5;
-          hour: !lambda return 18;
-      - ds3231.enable_alarm:
-          alarm: !lambda return 2;
-      - ds3231.disable_alarm:
-          alarm: !lambda return 1;
-      - if:
-          condition:
-            ds3231.is_alarm_triggered:
-              alarm: !lambda return 1;
-          then:
-            - logger.log: alarm 1 triggered
-      - ds3231.set_32khz_output:
-          state: !lambda return false;
       - ds3231.enable_alarm:
           alarm: 1
       - ds3231.disable_alarm:

tests/components/entity_transport/__init__.py

@@ -0,0 +1,19 @@
+import esphome.codegen as cg
+from esphome.core import CORE
+from esphome.types import ConfigType
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    async def to_code_testing(config: ConfigType) -> None:
+        cg.add_define("ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT", 2)
+        cg.add_define("ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT", 2)
+        cg.add_define("USE_PACKET_INTERFACE_BASIC_SESSION")
+        # No entity platforms are configured, so count the test's own entities to emit USE_SENSOR and friends
+        CORE.platform_counts["sensor"] += 2
+        CORE.platform_counts["binary_sensor"] += 2
+
+    manifest.to_code = to_code_testing
+    # A multi_conf component gets an empty list in the test build, so to_code would not run
+    manifest.multi_conf = False
+    manifest.dependencies = manifest.dependencies + ["sensor", "binary_sensor"]

tests/components/entity_transport/common.yaml

@@ -0,0 +1,33 @@
+packet_interface:
+  - platform: uart
+    id: entity_transport_link
+    reliability:
+
+sensor:
+  - platform: template
+    id: entity_transport_sensor
+    lambda: return 1.0;
+  - platform: entity_transport
+    provider: remote-device
+    remote_id: entity_transport_sensor
+    name: Remote sensor
+
+binary_sensor:
+  - platform: template
+    id: entity_transport_binary_sensor
+    lambda: return true;
+  - platform: entity_transport
+    id: remote_binary_sensor
+    provider: remote-device
+    remote_id: door
+    name: Remote binary sensor
+
+entity_transport:
+  - packet_interface: entity_transport_link
+    update_interval: 60s
+    timeout: 3min
+    sensors:
+      - entity_transport_sensor
+    binary_sensors:
+      - id: entity_transport_binary_sensor
+        broadcast_id: door

tests/components/entity_transport/entity_transport.cpp

@@ -0,0 +1,552 @@
+#include <gtest/gtest.h>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <memory>
+#include <vector>
+#include "esphome/components/entity_transport/entity_transport.h"
+#include "esphome/core/application.h"
+
+namespace esphome::entity_transport::testing {
+
+// Copies a packet into a vector, for comparing in tests
+static std::vector<uint8_t> to_vector(const esphome::packet_interface::PacketBuffer &data) {
+  std::vector<uint8_t> result(data.size());
+  data.copy_to(result.data(), result.size());
+  return result;
+}
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+using Packet = std::vector<uint8_t>;
+
+static constexpr const char *DEVICE_NAME = "this-device";
+static constexpr uint8_t PACKET_DICTIONARY = 0x11;
+static constexpr uint8_t PACKET_DATA = 0x12;
+static constexpr uint8_t PACKET_REQUEST = 0x13;
+
+// A packet interface that records what is sent, can refuse to send, and can act as a session layer
+class MockInterface : public packet_interface::PacketInterface {
+ public:
+  explicit MockInterface(size_t max_packet_size = 64) : packet_interface::PacketInterface(max_packet_size) {}
+  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &) override {
+    if (!this->accept || this->budget == 0)
+      return false;
+    this->budget--;
+    this->sent.push_back(to_vector(data));
+    return true;
+  }
+  void inject(const Packet &packet) { this->on_receive_from_interface_(PacketBuffer(packet), {}); }
+  void set_capabilities(uint8_t capabilities) { this->capabilities_ = capabilities; }
+  void report_session(bool connected) { this->session_callback_.call(connected); }
+  // Deliver everything sent so far to another interface
+  void deliver_to(MockInterface &other) {
+    auto packets = std::move(this->sent);
+    this->sent.clear();
+    for (auto &packet : packets)
+      other.inject(packet);
+  }
+
+  std::vector<Packet> sent;
+  bool accept{true};
+  size_t budget{SIZE_MAX};  // packets accepted before refusing, like a full queue
+};
+
+class TestTransport : public EntityTransport {
+ public:
+  using EntityTransport::EntityTransport;
+  uint32_t get_dictionary_id() const { return this->dictionary_id_; }
+  uint32_t get_update_interval() const { return this->update_interval_ms_; }
+  using EntityTransport::clear_remote_states_;
+};
+
+static Packet header(uint8_t packet_type, uint32_t id) {
+  return {packet_type, static_cast<uint8_t>(id), static_cast<uint8_t>(id >> 8), static_cast<uint8_t>(id >> 16),
+          static_cast<uint8_t>(id >> 24)};
+}
+
+// The start of a dictionary packet from this device's name: the header, the part byte, then the name
+static Packet dictionary_start(uint32_t id, uint8_t part = 0x80) {
+  Packet packet = header(PACKET_DICTIONARY, id);
+  packet.push_back(part);
+  packet.push_back(strlen(DEVICE_NAME));
+  packet.insert(packet.end(), DEVICE_NAME, DEVICE_NAME + strlen(DEVICE_NAME));
+  return packet;
+}
+
+class EntityTransportTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    App.~Application();
+    new (&App) Application();
+    static char name[] = "this-device";
+    static char friendly_name[] = "";
+    App.pre_setup(name, sizeof(name) - 1, friendly_name, 0);
+  }
+  void TearDown() override {
+    App.~Application();
+    new (&App) Application();  // later tests and the test listener use App
+  }
+
+  // The sender, with a sensor and a binary sensor
+  std::unique_ptr<TestTransport> make_sender_(MockInterface *link = nullptr) {
+    auto transport = std::make_unique<TestTransport>(link != nullptr ? link : &this->link_a_);
+    transport->set_entity_count(2);
+    transport->add_sensor("temp", &this->temp_);
+    transport->add_binary_sensor("door", &this->door_);
+    transport->setup();
+    return transport;
+  }
+  // The receiver, showing the sender's entities; both run on this device, so they share its name
+  std::unique_ptr<TestTransport> make_receiver_(const char *provider = DEVICE_NAME, uint32_t timeout_ms = 0) {
+    auto transport = std::make_unique<TestTransport>(&this->link_b_);
+    transport->set_remote_timeout(timeout_ms);
+    transport->add_remote_sensor(provider, "temp", &this->remote_temp_);
+    transport->add_remote_binary_sensor(provider, "door", &this->remote_door_);
+    transport->setup();
+    return transport;
+  }
+
+  MockInterface link_a_, link_b_;
+  sensor::Sensor temp_, remote_temp_;
+  binary_sensor::BinarySensor door_, remote_door_;
+};
+
+TEST_F(EntityTransportTest, SendsDictionaryThenStates) {
+  this->temp_.publish_state(21.5f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_();
+  sender->loop();
+  uint32_t id = sender->get_dictionary_id();
+  Packet dictionary = dictionary_start(id);
+  dictionary.insert(dictionary.end(), {1, 0, 1, 4, 't', 'e', 'm', 'p', 2, 0, 1, 4, 'd', 'o', 'o', 'r'});
+  Packet data = header(PACKET_DATA, id);
+  // Tags: sensor 0 with a 4 byte state, then binary sensor 0 with its state in the top bit
+  data.insert(data.end(), {0x00, 0x21, 0x00, 0x00, 0xAC, 0x41, 0x00, 0x82});
+  ASSERT_EQ(this->link_a_.sent.size(), 2);
+  EXPECT_EQ(this->link_a_.sent[0], dictionary);
+  EXPECT_EQ(this->link_a_.sent[1], data);
+}
+
+TEST_F(EntityTransportTest, SendsOnlyChangedStates) {
+  auto sender = this->make_sender_();
+  sender->loop();
+  this->link_a_.sent.clear();
+  this->temp_.publish_state(3.0f);
+  sender->loop();
+  Packet data = header(PACKET_DATA, sender->get_dictionary_id());
+  data.insert(data.end(), {0x00, 0x21, 0x00, 0x00, 0x40, 0x40});
+  ASSERT_EQ(this->link_a_.sent.size(), 1);
+  EXPECT_EQ(this->link_a_.sent[0], data);
+}
+
+TEST_F(EntityTransportTest, StatesReachRemoteEntities) {
+  this->temp_.publish_state(12.25f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 12.25f);
+  EXPECT_TRUE(this->remote_door_.state);
+  this->door_.invalidate_state();
+  this->temp_.publish_state(NAN);
+  sender->loop();
+  ASSERT_EQ(this->link_a_.sent.size(), 1);
+  // Both records have no state, and so no payload
+  EXPECT_EQ(Packet(this->link_a_.sent[0].begin() + 5, this->link_a_.sent[0].end()), (Packet{0x00, 0x61, 0x00, 0x62}));
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_FALSE(this->remote_door_.has_state());
+  EXPECT_TRUE(std::isnan(this->remote_temp_.get_state()));
+}
+
+TEST_F(EntityTransportTest, SplitsAcrossPackets) {
+  MockInterface link(5 + 2 + strlen(DEVICE_NAME) + 3 + 5);
+  this->temp_.publish_state(1.0f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_(&link);
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  EXPECT_EQ(link.sent.size(), 3);  // one dictionary packet for each entity, then one data packet
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 1.0f);
+  EXPECT_TRUE(this->remote_door_.state);
+}
+
+TEST_F(EntityTransportTest, RefusedPacketSentAgain) {
+  this->link_a_.accept = false;
+  auto sender = this->make_sender_();
+  sender->loop();
+  EXPECT_TRUE(this->link_a_.sent.empty());
+  this->link_a_.accept = true;
+  sender->loop();
+  EXPECT_EQ(this->link_a_.sent.size(), 2);
+}
+
+TEST_F(EntityTransportTest, LongRefusalWarns) {
+  this->link_a_.accept = false;
+  auto sender = this->make_sender_();
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 1000};
+  }
+  sender->loop();
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 60999};
+  }
+  sender->loop();
+  EXPECT_FALSE(sender->status_has_warning());
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 61000};
+  }
+  sender->loop();
+  EXPECT_TRUE(sender->status_has_warning());
+  this->link_a_.accept = true;
+  sender->loop();
+  EXPECT_FALSE(sender->status_has_warning());
+  EXPECT_EQ(this->link_a_.sent.size(), 2);
+}
+
+TEST_F(EntityTransportTest, UnknownDictionaryRequested) {
+  this->temp_.publish_state(5.0f);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  this->link_a_.sent.erase(this->link_a_.sent.begin());  // the dictionary is lost
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_FALSE(this->remote_temp_.has_state());
+  ASSERT_EQ(this->link_b_.sent.size(), 1);
+  EXPECT_EQ(this->link_b_.sent[0], header(PACKET_REQUEST, sender->get_dictionary_id()));
+  this->link_b_.deliver_to(this->link_a_);
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 5.0f);
+}
+
+TEST_F(EntityTransportTest, ChangedDictionaryRequested) {
+  this->temp_.publish_state(5.0f);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 5.0f);
+  // The provider restarts with other entities, and its new dictionary is lost
+  sensor::Sensor temp;
+  MockInterface link;
+  TestTransport changed(&link);
+  changed.set_entity_count(1);
+  changed.add_sensor("temp", &temp);
+  changed.setup();
+  temp.publish_state(6.0f);
+  changed.loop();
+  link.sent.erase(link.sent.begin());
+  link.deliver_to(this->link_b_);
+  ASSERT_EQ(this->link_b_.sent.size(), 1);
+  EXPECT_EQ(this->link_b_.sent[0], header(PACKET_REQUEST, changed.get_dictionary_id()));
+  this->link_b_.deliver_to(link);
+  changed.loop();
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 6.0f);
+}
+
+TEST_F(EntityTransportTest, MalformedDataNotRequested) {
+  auto receiver = this->make_receiver_();
+  // A data packet under an unknown dictionary, cut off inside its first record
+  Packet data = header(PACKET_DATA, 0x12345678);
+  data.insert(data.end(), {0x00, 0x21, 0x00});
+  this->link_b_.inject(data);
+  EXPECT_TRUE(this->link_b_.sent.empty());
+}
+
+TEST_F(EntityTransportTest, EntityLeftOutOfNewDictionaryCleared) {
+  this->temp_.publish_state(5.0f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_TRUE(this->remote_door_.state);
+  // The provider restarts without the door
+  sensor::Sensor temp;
+  MockInterface link;
+  TestTransport changed(&link);
+  changed.set_entity_count(1);
+  changed.add_sensor("temp", &temp);
+  changed.setup();
+  temp.publish_state(6.0f);
+  changed.loop();
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 6.0f);
+  EXPECT_FALSE(this->remote_door_.has_state());
+}
+
+TEST_F(EntityTransportTest, EntityLeftOutOfSeenDictionaryCleared) {
+  // The provider names only the sensor, then both entities, then goes back to naming only the sensor
+  sensor::Sensor temp;
+  MockInterface link;
+  auto make_temp_only = [&] {
+    auto transport = std::make_unique<TestTransport>(&link);
+    transport->set_entity_count(1);
+    transport->add_sensor("temp", &temp);
+    transport->setup();
+    return transport;
+  };
+  temp.publish_state(4.0f);
+  auto receiver = this->make_receiver_();
+  make_temp_only()->loop();
+  link.deliver_to(this->link_b_);
+  this->door_.publish_state(true);
+  this->make_sender_()->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_TRUE(this->remote_door_.state);
+  make_temp_only()->loop();
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 4.0f);
+  EXPECT_FALSE(this->remote_door_.has_state());
+}
+
+TEST_F(EntityTransportTest, LostDictionaryPartRequested) {
+  // One entity in each dictionary packet
+  MockInterface link(5 + 2 + strlen(DEVICE_NAME) + 3 + 5);
+  this->temp_.publish_state(2.0f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_(&link);
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  ASSERT_EQ(link.sent.size(), 3);
+  EXPECT_EQ(link.sent[0][5], 0x00);
+  EXPECT_EQ(link.sent[1][5], 0x81);
+  link.sent.erase(link.sent.begin() + 1);  // the part naming the binary sensor is lost
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 2.0f);
+  EXPECT_FALSE(this->remote_door_.has_state());
+  // The sensor is known, but the dictionary is not complete, so it is asked for
+  ASSERT_EQ(this->link_b_.sent.size(), 1);
+  EXPECT_EQ(this->link_b_.sent[0], header(PACKET_REQUEST, sender->get_dictionary_id()));
+  this->link_b_.deliver_to(link);
+  sender->loop();
+  link.deliver_to(this->link_b_);
+  EXPECT_TRUE(this->remote_door_.state);
+  // Now complete, it is not asked for again
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 10000};
+  }
+  this->door_.publish_state(false);
+  sender->loop();
+  link.deliver_to(this->link_b_);
+  EXPECT_FALSE(this->remote_door_.state);
+  EXPECT_TRUE(this->link_b_.sent.empty());
+}
+
+TEST_F(EntityTransportTest, RefusedRequestSentAgain) {
+  auto receiver = this->make_receiver_();
+  Packet data = header(PACKET_DATA, 0x12345678);
+  this->link_b_.accept = false;
+  this->link_b_.inject(data);
+  this->link_b_.accept = true;
+  this->link_b_.inject(data);
+  ASSERT_EQ(this->link_b_.sent.size(), 1);
+  EXPECT_EQ(this->link_b_.sent[0], header(PACKET_REQUEST, 0x12345678));
+}
+
+TEST_F(EntityTransportTest, RequestsLimited) {
+  auto receiver = this->make_receiver_();
+  Packet data = header(PACKET_DATA, 0x12345678);
+  data.insert(data.end(), {0x00, 0x61});  // sensor 0 with no state
+  this->link_b_.inject(data);
+  this->link_b_.inject(data);
+  EXPECT_EQ(this->link_b_.sent.size(), 1);
+}
+
+TEST_F(EntityTransportTest, OtherProviderAndOwnPacketsIgnored) {
+  this->temp_.publish_state(5.0f);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_("other-device");
+  sender->loop();
+  auto packets = this->link_a_.sent;
+  this->link_a_.deliver_to(this->link_b_);
+  EXPECT_FALSE(this->remote_temp_.has_state());
+  // The dictionary named none of the receiver's entities, so it is not asked for again
+  EXPECT_TRUE(this->link_b_.sent.empty());
+  for (auto &packet : packets)
+    this->link_a_.inject(packet);
+  this->link_a_.inject(header(PACKET_REQUEST, 0x12345678));
+  sender->loop();
+  EXPECT_TRUE(this->link_a_.sent.empty());
+}
+
+TEST_F(EntityTransportTest, MalformedPacketsIgnored) {
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  Packet dictionary = this->link_a_.sent[0];
+  Packet data = this->link_a_.sent[1];
+  this->link_b_.inject(Packet(dictionary.begin(), dictionary.end() - 1));
+  this->link_b_.inject(dictionary);
+  this->link_b_.inject(Packet(data.begin(), data.end() - 1));
+  this->link_b_.inject({PACKET_DATA, 1, 2});
+  this->link_b_.inject({0x21, 0, 0, 0, 0});
+  EXPECT_FALSE(this->remote_temp_.has_state());
+}
+
+// Data packets from the sender's dictionary, holding the given records
+class EntityTransportRecordTest : public EntityTransportTest {
+ protected:
+  void SetUp() override {
+    EntityTransportTest::SetUp();
+    this->sender_ = this->make_sender_();
+    this->receiver_ = this->make_receiver_();
+    this->sender_->loop();
+    this->link_a_.sent.resize(1);  // the dictionary only
+    this->link_a_.deliver_to(this->link_b_);
+  }
+  void inject_data_(std::initializer_list<uint8_t> records) {
+    Packet data = header(PACKET_DATA, this->sender_->get_dictionary_id());
+    data.insert(data.end(), records);
+    this->link_b_.inject(data);
+  }
+
+  std::unique_ptr<TestTransport> sender_, receiver_;
+};
+
+TEST_F(EntityTransportRecordTest, WholePacketCheckedBeforeUse) {
+  // A good record for each entity, then a record cut short
+  this->inject_data_({0x00, 0x21, 0x00, 0x00, 0x10, 0x41, 0x00, 0x82, 0x00, 0x21, 0x00});
+  // A good record, then a sensor record without its state, then a binary sensor record with a payload
+  this->inject_data_({0x00, 0x21, 0x00, 0x00, 0x10, 0x41, 0x00, 0x01});
+  this->inject_data_({0x00, 0x82, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00});
+  // The value bit is only for records without a payload, and type 0 is not used
+  this->inject_data_({0x00, 0xA1, 0x00, 0x00, 0x10, 0x41});
+  this->inject_data_({0x00, 0x82, 0x00, 0x00});
+  // A length byte past the end
+  this->inject_data_({0x00, 0x82, 0x00, 0x45, 0x03, 0x01});
+  EXPECT_FALSE(this->remote_temp_.has_state());
+  EXPECT_FALSE(this->remote_door_.has_state());
+  this->inject_data_({0x00, 0x21, 0x00, 0x00, 0x10, 0x41, 0x00, 0x82});
+  EXPECT_EQ(this->remote_temp_.get_state(), 9.0f);
+  EXPECT_TRUE(this->remote_door_.state);
+}
+
+TEST_F(EntityTransportRecordTest, UnknownTypesSkipped) {
+  // Type 5 with 3 bytes after a length byte, type 6 with a 4 byte payload, type 7 without a state, then the sensor
+  this->inject_data_({0x00, 0x45, 0x03, 0x01, 0x02, 0x03, 0x01, 0x26, 0x00, 0x00,
+                      0x00, 0x00, 0x02, 0x67, 0x00, 0x21, 0x00, 0x00, 0x10, 0x41});
+  EXPECT_EQ(this->remote_temp_.get_state(), 9.0f);
+}
+
+TEST_F(EntityTransportTest, PartlyValidDictionaryNotLearnt) {
+  auto receiver = this->make_receiver_();
+  static constexpr uint32_t OTHER_ID = 0x0BADF00D;
+  Packet dictionary = dictionary_start(OTHER_ID);
+  // A good section naming the sensor, then sections cut short, of type 0, and of more than 255 numbers
+  dictionary.insert(dictionary.end(), {1, 0, 1, 4, 't', 'e', 'm', 'p'});
+  for (Packet bad : {Packet{2, 0, 2, 4, 'd', 'o', 'o', 'r'}, Packet{0, 0, 1, 1, 'x'}, Packet{2, 255, 2, 1, 'a', 1, 'b'},
+                     Packet{2, 0, 1}}) {
+    Packet packet = dictionary;
+    packet.insert(packet.end(), bad.begin(), bad.end());
+    this->link_b_.inject(packet);
+  }
+  Packet data = header(PACKET_DATA, OTHER_ID);
+  data.insert(data.end(), {0x00, 0x21, 0x00, 0x00, 0x80, 0x3F});
+  this->link_b_.inject(data);
+  EXPECT_FALSE(this->remote_temp_.has_state());
+  this->link_b_.inject(dictionary);
+  this->link_b_.inject(data);
+  EXPECT_EQ(this->remote_temp_.get_state(), 1.0f);
+}
+
+TEST_F(EntityTransportTest, UpdateIntervalFollowsCapabilities) {
+  EXPECT_EQ(this->make_sender_()->get_update_interval(), 15000);
+  this->link_a_.set_capabilities(packet_interface::CAPABILITY_SESSION);
+  EXPECT_EQ(this->make_sender_()->get_update_interval(), 15000);
+  this->link_a_.set_capabilities(packet_interface::CAPABILITY_SESSION | packet_interface::CAPABILITY_RELIABILITY);
+  EXPECT_EQ(this->make_sender_()->get_update_interval(), SCHEDULER_DONT_RUN);
+  auto transport = std::make_unique<TestTransport>(&this->link_a_);
+  transport->set_update_interval(5000);
+  transport->setup();
+  EXPECT_EQ(transport->get_update_interval(), 5000);
+}
+
+TEST_F(EntityTransportTest, SessionConnectSendsAllAndLossClearsRemote) {
+  this->link_a_.set_capabilities(packet_interface::CAPABILITY_SESSION);
+  this->link_b_.set_capabilities(packet_interface::CAPABILITY_SESSION);
+  this->temp_.publish_state(7.0f);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_();
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  this->link_a_.report_session(true);
+  sender->loop();
+  EXPECT_EQ(this->link_a_.sent.size(), 2);
+  this->link_b_.report_session(false);
+  EXPECT_TRUE(std::isnan(this->remote_temp_.get_state()));
+  EXPECT_FALSE(this->remote_door_.has_state());
+}
+
+TEST_F(EntityTransportTest, RefusedDictionaryPartResumes) {
+  // One entity in each dictionary packet
+  MockInterface link(5 + 2 + strlen(DEVICE_NAME) + 3 + 5);
+  this->temp_.publish_state(4.0f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_(&link);
+  auto receiver = this->make_receiver_();
+  link.budget = 1;
+  sender->loop();
+  ASSERT_EQ(link.sent.size(), 1);
+  link.budget = SIZE_MAX;
+  sender->loop();
+  int dictionaries = 0;
+  for (auto &packet : link.sent)
+    dictionaries += packet[0] == PACKET_DICTIONARY;
+  EXPECT_EQ(dictionaries, 2);  // the first part was not sent again
+  link.deliver_to(this->link_b_);
+  EXPECT_EQ(this->remote_temp_.get_state(), 4.0f);
+  EXPECT_TRUE(this->remote_door_.state);
+}
+
+TEST_F(EntityTransportTest, RemoteStatesTimeOut) {
+  this->temp_.publish_state(6.0f);
+  this->door_.publish_state(true);
+  auto sender = this->make_sender_();
+  auto receiver = this->make_receiver_(DEVICE_NAME, 5000);
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 1000};
+  }
+  sender->loop();
+  this->link_a_.deliver_to(this->link_b_);
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 6000};
+  }
+  receiver->clear_remote_states_(true);
+  EXPECT_EQ(this->remote_temp_.get_state(), 6.0f);
+  EXPECT_TRUE(this->remote_door_.has_state());
+  {
+    LoopBlockingGuard guard{nullptr, nullptr, 6001};
+  }
+  receiver->clear_remote_states_(true);
+  EXPECT_TRUE(std::isnan(this->remote_temp_.get_state()));
+  EXPECT_FALSE(this->remote_door_.has_state());
+}
+
+TEST_F(EntityTransportTest, IdMatchingOnlyUpToNulNotLearnt) {
+  auto receiver = this->make_receiver_();
+  static constexpr uint32_t OTHER_ID = 0x0BADF00D;
+  Packet dictionary = dictionary_start(OTHER_ID);
+  // The id "temp" followed by a NUL and more bytes, nine in all
+  dictionary.insert(dictionary.end(), {1, 0, 1, 9, 't', 'e', 'm', 'p', 0, 'a', 'b', 'c', 'd'});
+  this->link_b_.inject(dictionary);
+  Packet data = header(PACKET_DATA, OTHER_ID);
+  data.insert(data.end(), {0x00, 0x21, 0x00, 0x00, 0x80, 0x3F});
+  this->link_b_.inject(data);
+  EXPECT_FALSE(this->remote_temp_.has_state());
+}
+
+TEST_F(EntityTransportTest, PacketTooSmallForIdsFailsSetup) {
+  // One byte short of a dictionary packet holding the device name and a four character id
+  MockInterface small_link(5 + 2 + strlen(DEVICE_NAME) + 3 + 1 + 4 - 1);
+  auto sender = this->make_sender_(&small_link);
+  EXPECT_TRUE(sender->is_failed());
+  EXPECT_FALSE(this->make_sender_()->is_failed());
+}
+
+}  // namespace esphome::entity_transport::testing

tests/components/entity_transport/test.esp32-idf.yaml

@@ -0,0 +1,3 @@
+packages:
+  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
+  entity_transport: !include common.yaml

tests/components/es7210/common.yaml

@@ -3,8 +3,6 @@ esphome:
     then:
       - audio_adc.set_mic_gain: 0db
       - audio_adc.set_mic_gain: !lambda 'return 4;'
-      - audio_adc.set_mic_gain:
-          mic_gain: 6db
 
 audio_adc:
   - platform: es7210

tests/components/espnow/common.yaml

@@ -35,18 +35,6 @@ espnow:
         data: [0x01, 0x02, 0x03, 0x04, 0x05]
     - espnow.broadcast:
         data: !lambda 'return {0x01, 0x02, 0x03, 0x04, 0x05};'
-    - espnow.broadcast:
-        address: FF:FF:FF:FF:FF:FF
-        data: "options"
-        wait_for_sent: true
-        continue_on_error: false
-        on_sent:
-          - logger.log: "broadcast sent"
-        on_error:
-          - logger.log: "broadcast failed"
-    - espnow.send:
-        address: !lambda 'return {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};'
-        data: "lambda address"
     - espnow.send:
         address: 11:22:33:44:55:66
         data: !lambda 'return std::vector<uint8_t>(data, data + size);'

tests/components/ezo_pmp/common.yaml

@@ -46,13 +46,6 @@ text_sensor:
         - ezo_pmp.set_calibration_volume:
             id: hcl_pump
             volume: 10
-        - ezo_pmp.dose_with_constant_flow_rate:
-            id: hcl_pump
-            volume_per_minute: !lambda return 5.5f;
-            duration: !lambda return 3;
-        - ezo_pmp.set_calibration_volume:
-            id: hcl_pump
-            volume: !lambda return 12.5f;
         - ezo_pmp.find: hcl_pump
         - ezo_pmp.dose_continuously: hcl_pump
         - ezo_pmp.clear_total_volume_dosed: hcl_pump

tests/components/fingerprint_grow/common-actions.yaml

@@ -14,10 +14,3 @@ button:
           speed: 200
           color: BLUE
           count: 2
-      - fingerprint_grow.aura_led_control:
-          state: !lambda return fingerprint_grow::FLASHING;
-          speed: !lambda return 100;
-          color: !lambda return fingerprint_grow::RED;
-          count: !lambda return 3;
-      - fingerprint_grow.delete:
-          finger_id: !lambda return 2;

tests/components/hdmi_cec/common.yaml

@@ -9,9 +9,6 @@ hdmi_cec:
         - hdmi_cec.send:
             destination: !lambda return source;
             data: [0x90, 0x01]  # Report Power Status: standby
-        - hdmi_cec.send:
-            destination: 0x0
-            data: !lambda return {0x90, 0x01};
     - opcode: 0x8C  # Give Device Vendor ID
       then:
         - lambda: |-

tests/components/hlk_fm22x/common.yaml

@@ -5,8 +5,6 @@ esphome:
           name: "Test"
           direction: 1
       - hlk_fm22x.delete: 5
-      - hlk_fm22x.delete:
-          face_id: 7
       - hlk_fm22x.delete_all:
       - hlk_fm22x.reset:
       - hlk_fm22x.scan:

tests/components/http_request/http_request.yaml

@@ -35,59 +35,6 @@ esphome:
       - http_request.get:
           url: https://esphome.io
           timeout: !lambda "return 10000;"
-      - http_request.get:
-          url: !lambda 'return std::string("https://esphome.io/get");'
-          method: GET
-          collect_headers:
-            - Content-Type
-            - X-Request-Id
-          max_response_buffer_size: 2kB
-          capture_response: true
-          on_response:
-            then:
-              - logger.log:
-                  format: "Content-Type %s, body %zu bytes"
-                  args:
-                    - response->get_response_header("content-type").c_str()
-                    - body.size()
-      - http_request.post:
-          url: !lambda 'return std::string("https://esphome.io/post");'
-          method: POST
-          body: !lambda 'return std::string("{\"key\": \"value\"}");'
-          timeout: 5s
-          collect_headers:
-            - Location
-          max_response_buffer_size: 512
-          on_error:
-            - logger.log: "POST failed"
-      - http_request.post:
-          url: https://esphome.io
-          body: "plain body"
-          timeout: !lambda "return 2500;"
-      - http_request.send:
-          method: PATCH
-          url: !lambda 'return std::string("https://esphome.io/send");'
-          json:
-            key: value
-            dynamic: !lambda 'return std::string("x");'
-          collect_headers:
-            - ETag
-          max_response_buffer_size: 4kB
-          capture_response: true
-          timeout: !lambda "return 3000;"
-          on_response:
-            then:
-              - logger.log:
-                  format: "Send status %d, body %s"
-                  args:
-                    - response->status_code
-                    - body.c_str()
-          on_error:
-            - logger.log: "Send failed"
-      - http_request.send:
-          method: DELETE
-          url: https://esphome.io/item
-          body: !lambda 'return std::string("id=1");'
       - http_request.post:
           url: https://esphome.io
           request_headers:

tests/components/htu21d/common.yaml

@@ -21,9 +21,3 @@ button:
       - htu21d.set_heater_level:
           id: htu21d_sensor
           level: 5
-      - htu21d.set_heater:
-          id: htu21d_sensor
-          status: !lambda return false;
-      - htu21d.set_heater_level:
-          id: htu21d_sensor
-          level: !lambda return 3;

tests/components/hub75/common.yaml

@@ -10,6 +10,3 @@ esphome:
     - hub75.set_brightness:
         id: my_hub75
         brightness: 50
-    - hub75.set_brightness:
-        id: my_hub75
-        brightness: !lambda return 150;

tests/components/it8951/test.esp32-s3-idf.yaml

@@ -108,6 +108,3 @@ interval:
           id: m5epd_display
           mode: A2
       - it8951.update: m5epd_display
-      - it8951.update:
-          id: m5epd_display
-          mode: !lambda return it8951::UPDATE_MODE_GL16;

tests/components/light/common.yaml

@@ -155,33 +155,6 @@ esphome:
       - light.turn_off:
           id: test_rgb_light
           transition_length: 300ms
-      - light.turn_off:
-          id: test_rgb_light
-          state: false
-          transition_length: !lambda return 200;
-      - light.turn_on:
-          id: test_rgb_light
-          red: !lambda return 0.2f;
-          green: !lambda return 0.4f;
-          blue: !lambda return 0.6f;
-          transition_length: !lambda return 350;
-      - light.turn_on:
-          id: test_cwww_light
-          color_temperature: 300 mireds
-      - light.turn_on:
-          id: test_cwww_light
-          color_temperature: !lambda return 250.0f;
-      - light.control:
-          id: test_rgbww_light
-          cold_white: !lambda return 0.6f;
-          warm_white: !lambda return 0.2f;
-      - light.control:
-          id: test_monochromatic_light
-          effect: !lambda return "My Flicker";
-      - light.dim_relative:
-          id: test_monochromatic_light
-          relative_brightness: !lambda return 0.1f;
-          transition_length: !lambda return 150;
       # Test static effect name resolution at codegen time
       - light.turn_on:
           id: test_monochromatic_light

tests/components/lightwaverf/common.yaml

@@ -9,12 +9,5 @@ button:
     on_press:
       lightwaverf.send_raw:
         code: [0x04, 0x00, 0x00, 0x00, 0x0f, 0x03, 0x0d, 0x09, 0x08, 0x08]
+        name: "Sofa"
         repeat: 1
-  - platform: template
-    name: "Turn off sofa inverted"
-    on_press:
-      lightwaverf.send_raw:
-        code: [0x04, 0x00, 0x00, 0x00, 0x0f, 0x03, 0x0d, 0x09, 0x08, 0x08]
-        name: "Sofa inverted"
-        inverted: true
-        pulse_length: 300

tests/components/logger/common-default_uart.yaml

@@ -5,10 +5,6 @@ esphome:
           level: warn
           format: "Warning: Logger level is %d"
           args: [id(logger_id).get_log_level()]
-      - logger.log:
-          tag: custom.tag
-          level: info
-          format: "Tagged log entry"
       - logger.set_level: WARN
       - logger.set_level:
           level: ERROR

tests/components/lvgl/lvgl-package.yaml

@@ -41,10 +41,6 @@ script:
           id: test_list_id
           label:
             text: row
-      - lvgl.list.add:
-          id: test_list_id
-          checkbox:
-            text: list checkbox
 
 esphome:
   on_boot:
@@ -111,28 +107,12 @@ lvgl:
         id: meter_arc_indicator
         start_value: 0
         end_value: 180
-    - lvgl.indicator.update:
-        id: meter_arc_indicator
-        value: 90
-        opa: 50%
-    - lvgl.indicator.update:
-        id: minute_hand
-        value: 30
-        opa: !lambda return 128;
     - lvgl.animation.start:
         id:
           - anim_slide
           - anim_color
         duration: 3s
         loop: true
-    - lvgl.animation.start:
-        id: anim_slide
-        start_delay: 250ms
-    - lvgl.update:
-        disp_bg_color: 0x101010
-        disp_bg_opa: 80%
-    - lvgl.update:
-        disp_bg_image: cat_image
   on_invalidate_area:
     logger.log: Invalidate area
   on_resolution_change:
@@ -704,11 +684,8 @@ lvgl:
             on_long_press:
               lvgl.matrix.button.update:
                 id: [button_a, button_e, button_c]
-                width: 2
-                selected: true
                 control:
                   disabled: true
-                  checkable: true
             on_click:
               logger.log:
                 format: "matrix button clicked: %d, is button_a = %u"
@@ -1087,13 +1064,6 @@ lvgl:
                   outline_width: 4
                   outline_pad: 4
                   outline_opa: cover
-              - lvgl.canvas.draw_rectangle:
-                  x: 10
-                  y: 10
-                  width: !lambda return 120;
-                  height: !lambda return 80;
-                  shadow_ofs_x: 3
-                  shadow_ofs_y: 3
               - lvgl.canvas.set_pixels:
                   color: red
                   points:
@@ -1127,12 +1097,6 @@ lvgl:
                   text: Canvas Text
                   align: center
                   max_width: 150
-              - lvgl.canvas.draw_text:
-                  x: 20
-                  y: 150
-                  font: montserrat_18
-                  text: Lambda Width
-                  max_width: !lambda return 120;
               - lvgl.canvas.draw_image:
                   src: cat_image
                   x: 100
@@ -1144,35 +1108,6 @@ lvgl:
                   skew_y: 5
                   pivot_x: 25
                   pivot_y: 25
-              - lvgl.canvas.draw_image:
-                  src: cat_image
-                  x: 50
-                  y: 50
-                  angle: 45
-                  scale: 1.5
-                  opa: 70%
-                  recolor: red
-                  recolor_opa: 30%
-              - lvgl.canvas.draw_image:
-                  src: cat_image
-                  x: 60
-                  y: 60
-                  zoom: 2.0
-              - lvgl.canvas.draw_rectangle:
-                  x: 10
-                  y: 10
-                  width: 120
-                  height: 80
-                  bg_grad: color_bar
-              - lvgl.canvas.draw_line:
-                  color: green
-                  width: 2
-                  opa: 60%
-                  dash_width: 6
-                  dash_gap: 3
-                  points:
-                    - 10,10
-                    - 90,90
               - lvgl.canvas.draw_line:
                   color: blue
                   width: 4
@@ -1185,6 +1120,7 @@ lvgl:
                     - 200, 50
                     - 50,50
               - lvgl.canvas.draw_polygon:
+                  bg_color: teal
                   border_color: white
                   border_width: 2
                   border_opa: cover
@@ -1396,12 +1332,6 @@ lvgl:
                     column: 1
                     text: !lambda return str_sprintf("%.1f", (float) rand() / RAND_MAX * 100);
                     merge_right: false
-                - lvgl.table.cell.update:
-                    id: table_id
-                    row: 0
-                    column: 1
-                    text: cropped
-                    text_crop: true
                 - lvgl.table.update:
                     id: table_id
                     selected_row: !lambda return (int) ((float) rand() / RAND_MAX * 2);
@@ -1433,9 +1363,6 @@ lvgl:
                     - 180, 60
                     - 240, 10
               - lvgl.page.next:
-              - lvgl.page.next:
-                  animation: move_left
-                  time: 200ms
         - switch:
             align: right_mid
         - checkbox:

tests/components/lvgl/test.esp32-idf.yaml

@@ -75,8 +75,6 @@ lvgl:
   on_draw_end:
     - logger.log: draw ended
     - lvgl.pause:
-    - lvgl.pause:
-        show_snow: true
     - component.update: tft_display
     - delay: 60s
     - lvgl.resume:

tests/components/max7219digit/common.yaml

@@ -20,6 +20,3 @@ esphome:
         - max7219digit.reverse_on:
         - max7219digit.reverse_off:
         - max7219digit.intensity: 10
-        - max7219digit.intensity:
-            intensity: 7
-        - max7219digit.intensity: !lambda return 3;

tests/components/media_player/common.yaml

@@ -53,60 +53,6 @@ media_player:
       - media_player.unshuffle: test_media_player
       - media_player.group_join: test_media_player
       - media_player.clear_playlist: test_media_player
-      - media_player.play:
-          id: test_media_player
-          announcement: true
-      - media_player.pause:
-          id: test_media_player
-          announcement: true
-      - media_player.toggle:
-          id: test_media_player
-          announcement: true
-      - media_player.turn_on:
-          id: test_media_player
-          announcement: true
-      - media_player.turn_off:
-          id: test_media_player
-          announcement: true
-      - media_player.next:
-          id: test_media_player
-          announcement: true
-      - media_player.previous:
-          id: test_media_player
-          announcement: true
-      - media_player.mute:
-          id: test_media_player
-          announcement: true
-      - media_player.unmute:
-          id: test_media_player
-          announcement: true
-      - media_player.repeat_off:
-          id: test_media_player
-          announcement: true
-      - media_player.repeat_one:
-          id: test_media_player
-          announcement: true
-      - media_player.repeat_all:
-          id: test_media_player
-          announcement: true
-      - media_player.shuffle:
-          id: test_media_player
-          announcement: true
-      - media_player.unshuffle:
-          id: test_media_player
-          announcement: true
-      - media_player.group_join:
-          id: test_media_player
-          announcement: true
-      - media_player.clear_playlist:
-          id: test_media_player
-          announcement: true
-      - media_player.volume_up:
-          id: test_media_player
-          announcement: true
-      - media_player.volume_down:
-          id: test_media_player
-          announcement: true
       - wait_until:
           media_player.is_idle: test_media_player
       - wait_until:
@@ -140,7 +86,3 @@ media_player:
           id: test_media_player
           media_url: http://localhost/media.mp3
           announcement: true
-      - media_player.enqueue:
-          id: test_media_player
-          media_url: http://localhost/media.mp3
-          announcement: !lambda return true;

tests/components/midea/common-actions.yaml

@@ -10,10 +10,6 @@ button:
           id: midea_unit
           temperature: !lambda return id(midea_unit).target_temperature + 1.0f;
           use_fahrenheit: !lambda return false;
-      - midea_ac.follow_me:
-          id: midea_unit
-          temperature: 24.0
-          beeper: !lambda return true;
       - midea_ac.display_toggle:
           id: midea_unit
       - midea_ac.swing_step:

tests/components/mitsubishi_cn105/common.yaml

@@ -30,9 +30,6 @@ esphome:
           temperature: 22.0
       - mitsubishi_cn105.clear_remote_temperature:
           id: ac
-      - mitsubishi_cn105.set_remote_temperature:
-          id: ac
-          temperature: !lambda return 21.5f;
       - mitsubishi_cn105.vane.control:
           id: ac
           vertical:

tests/components/modbus_client/common.yaml

@@ -186,215 +186,6 @@ button:
           read_address: 0x0420
           read_count: 1
 
-  - platform: template
-    name: "Typed Handlers"
-    on_press:
-      - modbus_client.read_coils:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x03;"
-          count: !lambda "return 8;"
-          continuous: !lambda "return false;"
-          allow_broadcast_read: !lambda "return false;"
-          on_sent:
-            then:
-              - logger.log: "coils sent"
-          on_not_sent:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "coils not sent fc 0x%X", request.empty() ? 0 : request[0]);'
-          on_no_response:
-            then:
-              - logger.log: "coils timeout"
-            retry: !lambda "return false;"
-          on_custom_response:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "coils custom reply %u bytes", (unsigned) response.size());'
-      - modbus_client.read_coils:
-          address: 0
-          start_address: 0x03
-          allow_broadcast_read: true
-          on_response:
-            then:
-              - lambda: 'ESP_LOGI("modbus_client.test", "broadcast coil0=%d", bits[0]);'
-      - modbus_client.read_discrete_inputs:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x00;"
-          count: 4
-          continuous: !lambda "return true;"
-          on_sent:
-            then:
-              - logger.log: "inputs sent"
-          on_not_sent:
-            then:
-              - logger.log: "inputs not sent"
-          on_no_response: !lambda "return false;"
-          on_response:
-            then:
-              - lambda: 'ESP_LOGI("modbus_client.test", "input0=%d n=%u", bits[0], (unsigned) bits.size());'
-          on_custom_response:
-            then:
-              - logger.log: "inputs custom reply"
-      - modbus_client.read_discrete_inputs:
-          address: 0
-          start_address: 0x00
-          allow_broadcast_read: true
-      - modbus_client.read_holding_registers:
-          address: 0x01
-          start_address: !lambda "return 0x10;"
-          continuous: !lambda "return true;"
-          on_sent:
-            then:
-              - logger.log: "holding sent"
-          on_custom_response:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "holding custom reply fc 0x%X", response.empty() ? 0 : response[0]);'
-      - modbus_client.read_input_registers:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x20;"
-          count: 3
-          on_sent:
-            then:
-              - logger.log: "inputs regs sent"
-          on_not_sent:
-            then:
-              - logger.log: "input regs not sent"
-          on_error:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "input regs exception %d", (int) exception_code);'
-          on_no_response:
-            then:
-              - logger.log: "input regs timeout"
-          on_response:
-            then:
-              - lambda: 'ESP_LOGI("modbus_client.test", "input reg0=%u n=%u", values[0], (unsigned) values.size());'
-      - modbus_client.read_input_registers:
-          address: 0
-          start_address: 0x20
-          allow_broadcast_read: true
-      - modbus_client.read_write_multiple_registers:
-          address: !lambda "return 1;"
-          write_address: !lambda "return 0x0300;"
-          values: [1, 2]
-          read_address: !lambda "return 0x0400;"
-          read_count: !lambda "return 2;"
-          allow_broadcast_read: !lambda "return false;"
-          on_sent:
-            then:
-              - logger.log: "rw sent"
-          on_not_sent:
-            then:
-              - logger.log: "rw not sent"
-          on_error:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "rw exception %d", (int) exception_code);'
-          on_no_response:
-            then:
-              - logger.log: "rw timeout"
-          on_custom_response:
-            then:
-              - logger.log: "rw custom reply"
-      - modbus_client.send:
-          address: 0
-          pdu: [0x03, 0x00, 0x10, 0x00, 0x01]
-          allow_broadcast_read: true
-      - modbus_client.send:
-          address: !lambda "return 1;"
-          pdu: [0x06, 0x01, 0x02, 0x00, 0x2A]
-          continuous: !lambda "return false;"
-          expect_broadcast_write_response: !lambda "return false;"
-      - modbus_client.write_multiple_coils:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x0010;"
-          values: [true, false]
-          expect_broadcast_write_response: !lambda "return false;"
-          on_sent:
-            then:
-              - logger.log: "coils write sent"
-          on_not_sent:
-            then:
-              - logger.log: "coils write not sent"
-          on_no_response:
-            then:
-              - logger.log: "coils write timeout"
-          on_response:
-            then:
-              - logger.log: "coils write acked"
-          on_custom_response:
-            then:
-              - logger.log: "coils write custom reply"
-      - modbus_client.write_multiple_coils:
-          address: 0
-          start_address: 0x0010
-          values: [true]
-          expect_broadcast_write_response: true
-      - modbus_client.write_multiple_registers:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x0200;"
-          values: [1, 2]
-          on_sent:
-            then:
-              - logger.log: "regs write sent"
-          on_not_sent:
-            then:
-              - logger.log: "regs write not sent"
-          on_error:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "regs write exception %d", (int) exception_code);'
-          on_no_response:
-            then:
-              - logger.log: "regs write timeout"
-          on_custom_response:
-            then:
-              - logger.log: "regs write custom reply"
-      - modbus_client.write_multiple_registers:
-          address: 0
-          start_address: 0x0200
-          values: [7]
-          expect_broadcast_write_response: true
-      - modbus_client.write_single_coil:
-          address: !lambda "return 1;"
-          start_address: !lambda "return 0x01;"
-          value: !lambda "return false;"
-          expect_broadcast_write_response: !lambda "return false;"
-          on_sent:
-            then:
-              - logger.log: "coil sent"
-          on_not_sent:
-            then:
-              - logger.log: "coil not sent"
-          on_error:
-            then:
-              - lambda: 'ESP_LOGW("modbus_client.test", "coil exception %d", (int) exception_code);'
-          on_no_response:
-            then:
-              - logger.log: "coil timeout"
-          on_response:
-            then:
-              - logger.log: "coil acked"
-          on_custom_response:
-            then:
-              - logger.log: "coil custom reply"
-      - modbus_client.write_single_coil:
-          address: 0
-          start_address: 0x01
-          value: true
-          expect_broadcast_write_response: true
-      - modbus_client.write_single_register:
-          address: 0x01
-          start_address: !lambda "return 0x0102;"
-          value: 42
-          expect_broadcast_write_response: !lambda "return false;"
-          on_sent:
-            then:
-              - logger.log: "register sent"
-          on_not_sent:
-            then:
-              - logger.log: "register not sent"
-          on_no_response:
-            then:
-              - logger.log: "register timeout"
-          on_custom_response:
-            then:
-              - logger.log: "register custom reply"
 number:
   - platform: template
     name: "Modbus Client Write Value"

tests/components/modem/common.yaml

@@ -8,9 +8,7 @@ esphome:
           condition:
             modem.enabled:
           then:
-            - modem.send_at: "AT+CGSN"
-            - modem.send_at:
-                command: !lambda 'return std::string("AT+CSQ");'
+            modem.send_at: "AT+CGSN"
           else:
             modem.enable:
       - if:

tests/components/mqtt/common.yaml

@@ -109,18 +109,6 @@ button:
             return payload;
           qos: !lambda return 1;
           retain: !lambda return false;
-      - mqtt.publish_json:
-          topic: some/topic/json
-          payload: |-
-            root["key"] = "value";
-          qos: 1
-          retain: true
-      - mqtt.publish_json:
-          topic: !lambda return "some/topic/json/lambda";
-          payload: |-
-            root["key"] = 1;
-          qos: !lambda return 2;
-          retain: !lambda return false;
 
 climate:
   - platform: thermostat

tests/components/number/common.yaml

@@ -42,19 +42,6 @@ button:
           cycle: false
       - number.to_min: number_test_number
       - number.to_max: number_test_number
-      - number.increment:
-          id: number_test_number
-          mode: INCREMENT
-          cycle: true
-      - number.decrement:
-          id: number_test_number
-          mode: DECREMENT
-      - number.to_min:
-          id: number_test_number
-          mode: TO_MIN
-      - number.to_max:
-          id: number_test_number
-          mode: TO_MAX
       - number.operation:
           id: number_test_number
           operation: increment

tests/components/openthread/test-tlv.esp32-c6-idf.yaml

@@ -18,5 +18,3 @@ switch:
     turn_off_action:
       then:
         - openthread.set_poll_period: 5s
-        - openthread.set_poll_period:
-            poll_period: !lambda return 10000;