esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/udp/__init__.py

@@ -1,164 +1,162 @@
-import hashlib
-
+from esphome import automation
+from esphome.automation import Trigger
 import esphome.codegen as cg
-from esphome.components.api import CONF_ENCRYPTION
-from esphome.components.binary_sensor import BinarySensor
-from esphome.components.sensor import Sensor
-import esphome.config_validation as cv
-from esphome.const import (
+from esphome.components.packet_transport import (
     CONF_BINARY_SENSORS,
-    CONF_ID,
-    CONF_INTERNAL,
-    CONF_KEY,
-    CONF_NAME,
-    CONF_PORT,
+    CONF_ENCRYPTION,
+    CONF_PING_PONG_ENABLE,
+    CONF_PROVIDERS,
+    CONF_ROLLING_CODE_ENABLE,
     CONF_SENSORS,
 )
-from esphome.cpp_generator import MockObjClass
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
+from esphome.core import Lambda
+from esphome.cpp_generator import ExpressionStatement, MockObj
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
-AUTO_LOAD = ["socket", "xxtea"]
-MULTI_CONF = True
+AUTO_LOAD = ["socket"]
 
+MULTI_CONF = True
 udp_ns = cg.esphome_ns.namespace("udp")
-UDPComponent = udp_ns.class_("UDPComponent", cg.PollingComponent)
+UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
+UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
+trigger_args = cg.std_vector.template(cg.uint8)
 
-CONF_BROADCAST = "broadcast"
-CONF_BROADCAST_ID = "broadcast_id"
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
-CONF_PROVIDER = "provider"
-CONF_PROVIDERS = "providers"
-CONF_REMOTE_ID = "remote_id"
 CONF_UDP_ID = "udp_id"
-CONF_PING_PONG_ENABLE = "ping_pong_enable"
-CONF_PING_PONG_RECYCLE_TIME = "ping_pong_recycle_time"
-CONF_ROLLING_CODE_ENABLE = "rolling_code_enable"
-
-
-def sensor_validation(cls: MockObjClass):
-    return cv.maybe_simple_value(
-        cv.Schema(
-            {
-                cv.Required(CONF_ID): cv.use_id(cls),
-                cv.Optional(CONF_BROADCAST_ID): cv.validate_id_name,
-            }
-        ),
-        key=CONF_ID,
-    )
-
+CONF_ON_RECEIVE = "on_receive"
+CONF_LISTEN_PORT = "listen_port"
+CONF_BROADCAST_PORT = "broadcast_port"
 
-ENCRYPTION_SCHEMA = {
-    cv.Optional(CONF_ENCRYPTION): cv.maybe_simple_value(
-        cv.Schema(
-            {
-                cv.Required(CONF_KEY): cv.string,
-            }
-        ),
-        key=CONF_KEY,
-    )
-}
-
-PROVIDER_SCHEMA = cv.Schema(
+UDP_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_NAME): cv.valid_name,
+        cv.GenerateID(CONF_UDP_ID): cv.use_id(UDPComponent),
     }
-).extend(ENCRYPTION_SCHEMA)
+)
 
 
-def validate_(config):
-    if CONF_ENCRYPTION in config:
-        if CONF_SENSORS not in config and CONF_BINARY_SENSORS not in config:
-            raise cv.Invalid("No sensors or binary sensors to encrypt")
-    elif config[CONF_ROLLING_CODE_ENABLE]:
-        raise cv.Invalid("Rolling code requires an encryption key")
-    if config[CONF_PING_PONG_ENABLE]:
-        if not any(CONF_ENCRYPTION in p for p in config.get(CONF_PROVIDERS) or ()):
-            raise cv.Invalid("Ping-pong requires at least one encrypted provider")
-    return config
+def is_relocated(option):
+    def validator(value):
+        raise cv.Invalid(
+            f"The '{option}' option should now be configured in the 'packet_transport' component"
+        )
 
+    return validator
 
-CONFIG_SCHEMA = cv.All(
-    cv.polling_component_schema("15s")
-    .extend(
-        {
-            cv.GenerateID(): cv.declare_id(UDPComponent),
-            cv.Optional(CONF_PORT, default=18511): cv.port,
-            cv.Optional(
-                CONF_LISTEN_ADDRESS, default="255.255.255.255"
-            ): cv.ipv4address_multi_broadcast,
-            cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
-                cv.ipv4address,
-            ),
-            cv.Optional(CONF_ROLLING_CODE_ENABLE, default=False): cv.boolean,
-            cv.Optional(CONF_PING_PONG_ENABLE, default=False): cv.boolean,
-            cv.Optional(
-                CONF_PING_PONG_RECYCLE_TIME, default="600s"
-            ): cv.positive_time_period_seconds,
-            cv.Optional(CONF_SENSORS): cv.ensure_list(sensor_validation(Sensor)),
-            cv.Optional(CONF_BINARY_SENSORS): cv.ensure_list(
-                sensor_validation(BinarySensor)
-            ),
-            cv.Optional(CONF_PROVIDERS): cv.ensure_list(PROVIDER_SCHEMA),
-        },
+
+RELOCATED = {
+    cv.Optional(x): is_relocated(x)
+    for x in (
+        CONF_PROVIDERS,
+        CONF_ENCRYPTION,
+        CONF_PING_PONG_ENABLE,
+        CONF_ROLLING_CODE_ENABLE,
+        CONF_SENSORS,
+        CONF_BINARY_SENSORS,
     )
-    .extend(ENCRYPTION_SCHEMA),
-    validate_,
-)
+}
 
-SENSOR_SCHEMA = cv.Schema(
+CONFIG_SCHEMA = cv.COMPONENT_SCHEMA.extend(
     {
-        cv.Optional(CONF_REMOTE_ID): cv.string_strict,
-        cv.Required(CONF_PROVIDER): cv.valid_name,
-        cv.GenerateID(CONF_UDP_ID): cv.use_id(UDPComponent),
+        cv.GenerateID(): cv.declare_id(UDPComponent),
+        cv.Optional(CONF_PORT, default=18511): cv.Any(
+            cv.port,
+            cv.Schema(
+                {
+                    cv.Required(CONF_LISTEN_PORT): cv.port,
+                    cv.Required(CONF_BROADCAST_PORT): cv.port,
+                }
+            ),
+        ),
+        cv.Optional(
+            CONF_LISTEN_ADDRESS, default="255.255.255.255"
+        ): cv.ipv4address_multi_broadcast,
+        cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
+            cv.ipv4address,
+        ),
+        cv.Optional(CONF_ON_RECEIVE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    Trigger.template(trigger_args)
+                ),
+            }
+        ),
     }
-)
-
+).extend(RELOCATED)
 
-def require_internal_with_name(config):
-    if CONF_NAME in config and CONF_INTERNAL not in config:
-        raise cv.Invalid("Must provide internal: config when using name:")
-    return config
 
-
-def hash_encryption_key(config: dict):
-    return list(hashlib.sha256(config[CONF_KEY].encode()).digest())
+async def register_udp_client(var, config):
+    udp_var = await cg.get_variable(config[CONF_UDP_ID])
+    cg.add(var.set_parent(udp_var))
+    return udp_var
 
 
 async def to_code(config):
     cg.add_define("USE_UDP")
     cg.add_global(udp_ns.using)
     var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    cg.add(var.set_port(config[CONF_PORT]))
-    cg.add(var.set_rolling_code_enable(config[CONF_ROLLING_CODE_ENABLE]))
-    cg.add(var.set_ping_pong_enable(config[CONF_PING_PONG_ENABLE]))
-    cg.add(
-        var.set_ping_pong_recycle_time(
-            config[CONF_PING_PONG_RECYCLE_TIME].total_seconds
-        )
-    )
-    for sens_conf in config.get(CONF_SENSORS, ()):
-        sens_id = sens_conf[CONF_ID]
-        sensor = await cg.get_variable(sens_id)
-        bcst_id = sens_conf.get(CONF_BROADCAST_ID, sens_id.id)
-        cg.add(var.add_sensor(bcst_id, sensor))
-    for sens_conf in config.get(CONF_BINARY_SENSORS, ()):
-        sens_id = sens_conf[CONF_ID]
-        sensor = await cg.get_variable(sens_id)
-        bcst_id = sens_conf.get(CONF_BROADCAST_ID, sens_id.id)
-        cg.add(var.add_binary_sensor(bcst_id, sensor))
+    var = await cg.register_component(var, config)
+    conf_port = config[CONF_PORT]
+    if isinstance(conf_port, int):
+        cg.add(var.set_listen_port(conf_port))
+        cg.add(var.set_broadcast_port(conf_port))
+    else:
+        cg.add(var.set_listen_port(conf_port[CONF_LISTEN_PORT]))
+        cg.add(var.set_broadcast_port(conf_port[CONF_BROADCAST_PORT]))
+    if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
+        cg.add(var.set_listen_address(listen_address))
     for address in config[CONF_ADDRESSES]:
         cg.add(var.add_address(str(address)))
+    if on_receive := config.get(CONF_ON_RECEIVE):
+        on_receive = on_receive[0]
+        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger = await automation.build_automation(
+            trigger, [(trigger_args, "data")], on_receive
+        )
+        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())
+
+
+def validate_raw_data(value):
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise cv.Invalid(
+        "data must either be a string wrapped in quotes or a list of bytes"
+    )
 
-    if encryption := config.get(CONF_ENCRYPTION):
-        cg.add(var.set_encryption_key(hash_encryption_key(encryption)))
 
-    for provider in config.get(CONF_PROVIDERS, ()):
-        name = provider[CONF_NAME]
-        cg.add(var.add_provider(name))
-        if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
-            cg.add(var.set_listen_address(listen_address))
-        if encryption := provider.get(CONF_ENCRYPTION):
-            cg.add(var.set_provider_encryption(name, hash_encryption_key(encryption)))
+@automation.register_action(
+    "udp.write",
+    UDPWriteAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(UDPComponent),
+            cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+        },
+        key=CONF_DATA,
+    ),
+)
+async def udp_write_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    udp_var = await cg.get_variable(config[CONF_ID])
+    await cg.register_parented(var, udp_var)
+    cg.add(udp_var.set_should_broadcast())
+    data = config[CONF_DATA]
+    if isinstance(data, bytes):
+        data = list(data)
+
+    if cg.is_template(data):
+        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
+        cg.add(var.set_data_template(templ))
+    else:
+        cg.add(var.set_data_static(data))
+    return var

esphome/components/udp/automation.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "udp_component.h"
+#ifdef USE_NETWORK
+#include "esphome/core/automation.h"
+
+#include <vector>
+
+namespace esphome {
+namespace udp {
+
+template<typename... Ts> class UDPWriteAction : public Action<Ts...>, public Parented<UDPComponent> {
+ public:
+  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    this->static_ = false;
+  }
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = data;
+    this->static_ = true;
+  }
+
+  void play(Ts... x) override {
+    if (this->static_) {
+      this->parent_->send_packet(this->data_static_);
+    } else {
+      auto val = this->data_func_(x...);
+      this->parent_->send_packet(val);
+    }
+  }
+
+ protected:
+  bool static_{false};
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
+};
+
+}  // namespace udp
+}  // namespace esphome
+#endif

esphome/components/udp/binary_sensor.py

@@ -1,27 +1,5 @@
-import esphome.codegen as cg
-from esphome.components import binary_sensor
-from esphome.config_validation import All, has_at_least_one_key
-from esphome.const import CONF_ID
+import esphome.config_validation as cv
 
-from . import (
-    CONF_PROVIDER,
-    CONF_REMOTE_ID,
-    CONF_UDP_ID,
-    SENSOR_SCHEMA,
-    require_internal_with_name,
+CONFIG_SCHEMA = cv.invalid(
+    "The 'udp.binary_sensor' component has been migrated to the 'packet_transport.binary_sensor' component."
 )
-
-DEPENDENCIES = ["udp"]
-
-CONFIG_SCHEMA = All(
-    binary_sensor.binary_sensor_schema().extend(SENSOR_SCHEMA),
-    has_at_least_one_key(CONF_ID, CONF_REMOTE_ID),
-    require_internal_with_name,
-)
-
-
-async def to_code(config):
-    var = await binary_sensor.new_binary_sensor(config)
-    comp = await cg.get_variable(config[CONF_UDP_ID])
-    remote_id = str(config.get(CONF_REMOTE_ID) or config.get(CONF_ID))
-    cg.add(comp.add_remote_binary_sensor(config[CONF_PROVIDER], remote_id, var))

esphome/components/udp/packet_transport/__init__.py

@@ -0,0 +1,29 @@
+import esphome.codegen as cg
+from esphome.components.api import CONF_ENCRYPTION
+from esphome.components.packet_transport import (
+    CONF_PING_PONG_ENABLE,
+    PacketTransport,
+    new_packet_transport,
+    transport_schema,
+)
+from esphome.const import CONF_BINARY_SENSORS, CONF_SENSORS
+from esphome.cpp_types import PollingComponent
+
+from .. import UDP_SCHEMA, register_udp_client, udp_ns
+
+UDPTransport = udp_ns.class_("UDPTransport", PacketTransport, PollingComponent)
+
+CONFIG_SCHEMA = transport_schema(UDPTransport).extend(UDP_SCHEMA)
+
+
+async def to_code(config):
+    var, providers = await new_packet_transport(config)
+    udp_var = await register_udp_client(var, config)
+    if CONF_ENCRYPTION in config or providers:
+        cg.add(udp_var.set_should_listen())
+    if (
+        config[CONF_PING_PONG_ENABLE]
+        or config.get(CONF_SENSORS, ())
+        or config.get(CONF_BINARY_SENSORS, ())
+    ):
+        cg.add(udp_var.set_should_broadcast())

esphome/components/udp/packet_transport/udp_transport.cpp

@@ -0,0 +1,36 @@
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/components/network/util.h"
+#include "udp_transport.h"
+
+namespace esphome {
+namespace udp {
+
+static const char *const TAG = "udp_transport";
+
+bool UDPTransport::should_send() { return this->should_broadcast_ && network::is_connected(); }
+void UDPTransport::setup() {
+  PacketTransport::setup();
+  this->should_broadcast_ = this->ping_pong_enable_;
+#ifdef USE_SENSOR
+  this->should_broadcast_ |= !this->sensors_.empty();
+#endif
+#ifdef USE_BINARY_SENSOR
+  this->should_broadcast_ |= !this->binary_sensors_.empty();
+#endif
+  if (this->should_broadcast_)
+    this->parent_->set_should_broadcast();
+  if (!this->providers_.empty() || this->is_encrypted_()) {
+    this->parent_->add_listener([this](std::vector<uint8_t> &buf) { this->process_(buf); });
+  }
+}
+
+void UDPTransport::update() {
+  PacketTransport::update();
+  this->updated_ = true;
+  this->resend_data_ = this->should_broadcast_;
+}
+
+void UDPTransport::send_packet(const std::vector<uint8_t> &buf) const { this->parent_->send_packet(buf); }
+}  // namespace udp
+}  // namespace esphome

esphome/components/udp/packet_transport/udp_transport.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../udp_component.h"
+#ifdef USE_NETWORK
+#include "esphome/core/component.h"
+#include "esphome/components/packet_transport/packet_transport.h"
+#include <vector>
+
+namespace esphome {
+namespace udp {
+
+class UDPTransport : public packet_transport::PacketTransport, public Parented<UDPComponent> {
+ public:
+  void setup() override;
+  void update() override;
+
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+ protected:
+  void send_packet(const std::vector<uint8_t> &buf) const override;
+  bool should_send() override;
+  bool should_broadcast_{false};
+  size_t get_max_packet_size() override { return MAX_PACKET_SIZE; }
+};
+
+}  // namespace udp
+}  // namespace esphome
+#endif

esphome/components/udp/sensor.py

@@ -1,27 +1,5 @@
-import esphome.codegen as cg
-from esphome.components.sensor import new_sensor, sensor_schema
-from esphome.config_validation import All, has_at_least_one_key
-from esphome.const import CONF_ID
+import esphome.config_validation as cv
 
-from . import (
-    CONF_PROVIDER,
-    CONF_REMOTE_ID,
-    CONF_UDP_ID,
-    SENSOR_SCHEMA,
-    require_internal_with_name,
+CONFIG_SCHEMA = cv.invalid(
+    "The 'udp.sensor' component has been migrated to the 'packet_transport.sensor' component."
 )
-
-DEPENDENCIES = ["udp"]
-
-CONFIG_SCHEMA = All(
-    sensor_schema().extend(SENSOR_SCHEMA),
-    has_at_least_one_key(CONF_ID, CONF_REMOTE_ID),
-    require_internal_with_name,
-)
-
-
-async def to_code(config):
-    var = await new_sensor(config)
-    comp = await cg.get_variable(config[CONF_UDP_ID])
-    remote_id = str(config.get(CONF_REMOTE_ID) or config.get(CONF_ID))
-    cg.add(comp.add_remote_sensor(config[CONF_PROVIDER], remote_id, var))