[api] Align water_heater_command with standard entity command pattern

esphome/components/api/api.proto

@@ -45,6 +45,7 @@ service APIConnection {
   rpc time_command (TimeCommandRequest) returns (void) {}
   rpc update_command (UpdateCommandRequest) returns (void) {}
   rpc valve_command (ValveCommandRequest) returns (void) {}
+  rpc water_heater_command (WaterHeaterCommandRequest) returns (void) {}
 
   rpc subscribe_bluetooth_le_advertisements(SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
   rpc bluetooth_device_request(BluetoothDeviceRequest) returns (void) {}

esphome/components/api/api_connection.cpp

@@ -1385,7 +1385,7 @@ uint16_t APIConnection::try_send_water_heater_info(EntityBase *entity, APIConnec
                                      is_single);
 }
 
-void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+void APIConnection::water_heater_command(const WaterHeaterCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(water_heater::WaterHeater, water_heater, water_heater)
   if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_MODE)
     call.set_mode(static_cast<water_heater::WaterHeaterMode>(msg.mode));

esphome/components/api/api_connection.h

@@ -170,7 +170,7 @@ class APIConnection final : public APIServerConnection {
 
 #ifdef USE_WATER_HEATER
   bool send_water_heater_state(water_heater::WaterHeater *water_heater);
-  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+  void water_heater_command(const WaterHeaterCommandRequest &msg) override;
 #endif
 
 #ifdef USE_IR_RF

esphome/components/api/api_pb2_service.cpp

@@ -746,6 +746,11 @@ void APIServerConnection::on_update_command_request(const UpdateCommandRequest &
 #ifdef USE_VALVE
 void APIServerConnection::on_valve_command_request(const ValveCommandRequest &msg) { this->valve_command(msg); }
 #endif
+#ifdef USE_WATER_HEATER
+void APIServerConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+  this->water_heater_command(msg);
+}
+#endif
 #ifdef USE_BLUETOOTH_PROXY
 void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
     const SubscribeBluetoothLEAdvertisementsRequest &msg) {

esphome/components/api/api_pb2_service.h

@@ -303,6 +303,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_VALVE
   virtual void valve_command(const ValveCommandRequest &msg) = 0;
 #endif
+#ifdef USE_WATER_HEATER
+  virtual void water_heater_command(const WaterHeaterCommandRequest &msg) = 0;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
 #endif
@@ -432,6 +435,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_VALVE
   void on_valve_command_request(const ValveCommandRequest &msg) override;
 #endif
+#ifdef USE_WATER_HEATER
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
 #endif

esphome/components/esp32/__init__.py

@@ -124,14 +124,10 @@ COMPILER_OPTIMIZATIONS = {
 # - "sdmmc": driver -> esp_driver_sdmmc -> sdmmc dependency chain
 DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
-    "driver",  # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers
     "esp_adc",  # ADC driver - only needed by adc component
-    "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
     "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
-    "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
     "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
-    "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
     "esp_eth",  # Ethernet driver - only needed by ethernet component
     "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
     "esp_http_client",  # HTTP client - only needed by http_request component
@@ -142,11 +138,9 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "espcoredump",  # Core dump support - ESPHome has its own debug component
     "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
     "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
-    "openthread",  # Thread protocol - only needed by openthread component
     "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
     "protocomm",  # Protocol communication for provisioning - unused by ESPHome
     "spiffs",  # SPIFFS filesystem - ESPHome doesn't use filesystem storage (IDF only)
-    "ulp",  # ULP coprocessor - not currently used by any ESPHome component
     "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
     "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
     "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation

esphome/components/esp32_can/canbus.py

@@ -15,7 +15,6 @@ from esphome.components.esp32 import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
     get_esp32_variant,
-    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -122,10 +121,6 @@ def get_default_tx_enqueue_timeout(bit_rate):
 
 
 async def to_code(config):
-    # Legacy driver component provides driver/twai.h header
-    include_builtin_idf_component("driver")
-    # Also enable esp_driver_twai for future migration to new API
-    include_builtin_idf_component("esp_driver_twai")
     var = cg.new_Pvariable(config[CONF_ID])
     await canbus.register_canbus(var, config)
 

esphome/components/esp32_dac/output.py

@@ -1,12 +1,7 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import output
-from esphome.components.esp32 import (
-    VARIANT_ESP32,
-    VARIANT_ESP32S2,
-    get_esp32_variant,
-    include_builtin_idf_component,
-)
+from esphome.components.esp32 import VARIANT_ESP32, VARIANT_ESP32S2, get_esp32_variant
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_NUMBER, CONF_PIN
 
@@ -43,7 +38,6 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
 
 
 async def to_code(config):
-    include_builtin_idf_component("esp_driver_dac")
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await output.register_output(var, config)

esphome/components/esp32_touch/__init__.py

@@ -269,8 +269,6 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     # Re-enable ESP-IDF's touch sensor driver (excluded by default to save compile time)
     include_builtin_idf_component("esp_driver_touch_sens")
-    # Legacy driver component provides driver/touch_sensor.h header
-    include_builtin_idf_component("driver")
 
     touch = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(touch, config)

esphome/components/openthread/__init__.py

@@ -4,7 +4,6 @@ from esphome.components.esp32 import (
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
     add_idf_sdkconfig_option,
-    include_builtin_idf_component,
     only_on_variant,
     require_vfs_select,
 )
@@ -173,9 +172,6 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
-    # Re-enable openthread IDF component (excluded by default)
-    include_builtin_idf_component("openthread")
-
     cg.add_define("USE_OPENTHREAD")
 
     # OpenThread SRP needs access to mDNS services after setup

esphome/components/udp/__init__.py

@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID
-from esphome.cpp_generator import literal
+from esphome.core import ID, Lambda
+from esphome.cpp_generator import ExpressionStatement, MockObj
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,8 +24,6 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
-trigger_argname = "data"
-trigger_argtype = [(trigger_args, trigger_argname)]
 
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -113,14 +111,13 @@ async def to_code(config):
     cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
-        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
         trigger = await automation.build_automation(
-            trigger_id, trigger_argtype, on_receive
+            trigger, [(trigger_args, "data")], on_receive
         )
-        trigger_lambda = await cg.process_lambda(
-            trigger.trigger(literal(trigger_argname)), trigger_argtype
-        )
-        cg.add(var.add_listener(trigger_lambda))
+        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
+        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
+        cg.add(var.add_listener(trigger))
         cg.add(var.set_should_listen())
 
 

esphome/core/__init__.py

@@ -278,13 +278,9 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")
 
 class Lambda:
     def __init__(self, value):
-        from esphome.cpp_generator import Expression, statement
-
         # pylint: disable=protected-access
         if isinstance(value, Lambda):
             self._value = value._value
-        elif isinstance(value, Expression):
-            self._value = str(statement(value))
         else:
             self._value = value
         self._parts = None

esphome/cpp_generator.py

@@ -462,16 +462,6 @@ def statement(expression: Expression | Statement) -> Statement:
     return ExpressionStatement(expression)
 
 
-def literal(name: str) -> "MockObj":
-    """Create a literal name that will appear in the generated code
-    not surrounded by quotes.
-
-    :param name: The name of the literal.
-    :return: The literal as a MockObj.
-    """
-    return MockObj(name, "")
-
-
 def variable(
     id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -675,7 +665,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 
 async def process_lambda(
-    value: Lambda | Expression,
+    value: Lambda,
     parameters: TemplateArgsType,
     capture: str = "",
     return_type: SafeExpType = None,
@@ -699,14 +689,6 @@ async def process_lambda(
 
     if value is None:
         return None
-    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
-    # "Generating C++ source..." stage, so check here to save the developer's hair.
-    assert isinstance(parameters, list) and all(
-        isinstance(p, tuple) and len(p) == 2 for p in parameters
-    )
-    if isinstance(value, Expression):
-        value = Lambda(value)
-
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
         full_id, var = await get_variable_with_full_id(id)

tests/unit_tests/test_cpp_generator.py

@@ -347,280 +347,3 @@ class TestMockObj:
         assert isinstance(actual, cg.MockObj)
         assert actual.base == "foo.eek"
         assert actual.op == "."
-
-
-class TestStatementFunction:
-    """Tests for the statement() function."""
-
-    def test_statement__expression_converted_to_statement(self):
-        """Test that expressions are converted to ExpressionStatement."""
-        expr = cg.RawExpression("foo()")
-        result = cg.statement(expr)
-
-        assert isinstance(result, cg.ExpressionStatement)
-        assert str(result) == "foo();"
-
-    def test_statement__statement_unchanged(self):
-        """Test that statements are returned unchanged."""
-        stmt = cg.RawStatement("foo()")
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "foo()"
-
-    def test_statement__expression_statement_unchanged(self):
-        """Test that ExpressionStatement is returned unchanged."""
-        stmt = cg.ExpressionStatement(42)
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "42;"
-
-    def test_statement__line_comment_unchanged(self):
-        """Test that LineComment is returned unchanged."""
-        stmt = cg.LineComment("This is a comment")
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "// This is a comment"
-
-
-class TestLiteralFunction:
-    """Tests for the literal() function."""
-
-    def test_literal__creates_mockobj(self):
-        """Test that literal() creates a MockObj."""
-        result = cg.literal("MY_CONSTANT")
-
-        assert isinstance(result, cg.MockObj)
-        assert result.base == "MY_CONSTANT"
-        assert result.op == ""
-
-    def test_literal__string_representation(self):
-        """Test that literal names appear unquoted in generated code."""
-        result = cg.literal("nullptr")
-
-        assert str(result) == "nullptr"
-
-    def test_literal__can_be_used_in_expressions(self):
-        """Test that literals can be used as part of larger expressions."""
-        null_lit = cg.literal("nullptr")
-        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
-
-        assert str(expr) == "my_func(nullptr)"
-
-    def test_literal__common_cpp_literals(self):
-        """Test common C++ literal values."""
-        test_cases = [
-            ("nullptr", "nullptr"),
-            ("true", "true"),
-            ("false", "false"),
-            ("NULL", "NULL"),
-            ("NAN", "NAN"),
-        ]
-
-        for name, expected in test_cases:
-            result = cg.literal(name)
-            assert str(result) == expected
-
-
-class TestLambdaConstructor:
-    """Tests for the Lambda class constructor in core/__init__.py."""
-
-    def test_lambda__from_string(self):
-        """Test Lambda constructor with string argument."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-
-        assert lambda_obj.value == "return x + 1;"
-        assert str(lambda_obj) == "return x + 1;"
-
-    def test_lambda__from_expression(self):
-        """Test Lambda constructor with Expression argument."""
-        from esphome.core import Lambda
-
-        expr = cg.RawExpression("x + 1")
-        lambda_obj = Lambda(expr)
-
-        # Expression should be converted to statement (with semicolon)
-        assert lambda_obj.value == "x + 1;"
-
-    def test_lambda__from_lambda(self):
-        """Test Lambda constructor with another Lambda argument."""
-        from esphome.core import Lambda
-
-        original = Lambda("return x + 1;")
-        copy = Lambda(original)
-
-        assert copy.value == original.value
-        assert copy.value == "return x + 1;"
-
-    def test_lambda__parts_parsing(self):
-        """Test that Lambda correctly parses parts with id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return id(my_sensor).state;")
-        parts = lambda_obj.parts
-
-        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
-        assert len(parts) == 4
-        assert parts[0] == "return "
-        assert parts[1] == "my_sensor"
-        assert parts[2] == "."
-        assert parts[3] == "state;"
-
-    def test_lambda__requires_ids(self):
-        """Test that Lambda correctly extracts required IDs."""
-        from esphome.core import ID, Lambda
-
-        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
-        ids = lambda_obj.requires_ids
-
-        assert len(ids) == 2
-        assert all(isinstance(id_obj, ID) for id_obj in ids)
-        assert ids[0].id == "sensor1"
-        assert ids[1].id == "sensor2"
-
-    def test_lambda__no_ids(self):
-        """Test Lambda with no id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return 42;")
-        ids = lambda_obj.requires_ids
-
-        assert len(ids) == 0
-
-    def test_lambda__comment_removal(self):
-        """Test that comments are removed when parsing parts."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
-        parts = lambda_obj.parts
-
-        # Comment should be replaced with space, not affect parsing
-        assert "my_sensor" not in str(parts)
-
-    def test_lambda__multiline_string(self):
-        """Test Lambda with multiline string."""
-        from esphome.core import Lambda
-
-        code = """if (id(sensor).state > 0) {
-  return true;
-}
-return false;"""
-        lambda_obj = Lambda(code)
-
-        assert lambda_obj.value == code
-        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
-
-
-@pytest.mark.asyncio
-class TestProcessLambda:
-    """Tests for the process_lambda() async function."""
-
-    async def test_process_lambda__none_value(self):
-        """Test that None returns None."""
-        result = await cg.process_lambda(None, [])
-
-        assert result is None
-
-    async def test_process_lambda__with_expression(self):
-        """Test process_lambda with Expression argument."""
-
-        expr = cg.RawExpression("return x + 1")
-        result = await cg.process_lambda(expr, [(int, "x")])
-
-        assert isinstance(result, cg.LambdaExpression)
-        assert "x + 1" in str(result)
-
-    async def test_process_lambda__simple_lambda_no_ids(self):
-        """Test process_lambda with simple Lambda without id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")])
-
-        assert isinstance(result, cg.LambdaExpression)
-        # Should have parameter
-        lambda_str = str(result)
-        assert "int32_t x" in lambda_str
-        assert "return x + 1;" in lambda_str
-
-    async def test_process_lambda__with_return_type(self):
-        """Test process_lambda with return type specified."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x > 0;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "-> bool" in lambda_str
-
-    async def test_process_lambda__with_capture(self):
-        """Test process_lambda with capture specified."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return captured + x;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "[captured]" in lambda_str
-
-    async def test_process_lambda__empty_capture(self):
-        """Test process_lambda with empty capture (stateless lambda)."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "[]" in lambda_str
-
-    async def test_process_lambda__no_parameters(self):
-        """Test process_lambda with no parameters."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return 42;")
-        result = await cg.process_lambda(lambda_obj, [])
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        # Should have empty parameter list
-        assert "()" in lambda_str
-
-    async def test_process_lambda__multiple_parameters(self):
-        """Test process_lambda with multiple parameters."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + y + z;")
-        result = await cg.process_lambda(
-            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
-        )
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "int32_t x" in lambda_str
-        assert "float y" in lambda_str
-        assert "bool z" in lambda_str
-
-    async def test_process_lambda__parameter_validation(self):
-        """Test that malformed parameters raise assertion error."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x;")
-
-        # Test invalid parameter format (not list of tuples)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, "invalid")
-
-        # Test invalid tuple format (not 2-element tuples)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
-
-        # Test invalid tuple format (single element)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, [(int,)])