esphome 2025.7.5__py3-none-any.whl → 2025.8.0b2__py3-none-any.whl

esphome/components/ld2450/ld2450.h

@@ -1,12 +1,7 @@
 #pragma once
 
-#include "esphome/components/uart/uart.h"
-#include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/preferences.h"
-#include <limits>
-#include <cmath>
+#include "esphome/core/component.h"
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
@@ -29,18 +24,23 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
 
-#ifndef M_PI
-#define M_PI 3.14
-#endif
+#include "esphome/components/ld24xx/ld24xx.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"
+
+#include <array>
 
 namespace esphome {
 namespace ld2450 {
 
+using namespace ld24xx;
+
 // Constants
-static const uint8_t DEFAULT_PRESENCE_TIMEOUT = 5;  // Timeout to reset presense status 5 sec.
-static const uint8_t MAX_LINE_LENGTH = 41;          // Max characters for serial buffer
-static const uint8_t MAX_TARGETS = 3;               // Max 3 Targets in LD2450
-static const uint8_t MAX_ZONES = 3;                 // Max 3 Zones in LD2450
+static constexpr uint8_t DEFAULT_PRESENCE_TIMEOUT = 5;  // Timeout to reset presense status 5 sec.
+static constexpr uint8_t MAX_LINE_LENGTH = 41;          // Max characters for serial buffer
+static constexpr uint8_t MAX_TARGETS = 3;               // Max 3 Targets in LD2450
+static constexpr uint8_t MAX_ZONES = 3;                 // Max 3 Zones in LD2450
 
 enum Direction : uint8_t {
   DIRECTION_APPROACHING = 0,
@@ -81,9 +81,9 @@ class LD2450Component : public Component, public uart::UARTDevice {
   SUB_BINARY_SENSOR(target)
 #endif
 #ifdef USE_SENSOR
-  SUB_SENSOR(moving_target_count)
-  SUB_SENSOR(still_target_count)
-  SUB_SENSOR(target_count)
+  SUB_SENSOR_WITH_DEDUP(moving_target_count, uint8_t)
+  SUB_SENSOR_WITH_DEDUP(still_target_count, uint8_t)
+  SUB_SENSOR_WITH_DEDUP(target_count, uint8_t)
 #endif
 #ifdef USE_TEXT_SENSOR
   SUB_TEXT_SENSOR(mac)
@@ -110,7 +110,6 @@ class LD2450Component : public Component, public uart::UARTDevice {
   void dump_config() override;
   void loop() override;
   void set_presence_timeout();
-  void set_throttle(uint16_t value) { this->throttle_ = value; }
   void read_all_info();
   void query_zone_info();
   void restart_and_read_all_info();
@@ -161,11 +160,9 @@ class LD2450Component : public Component, public uart::UARTDevice {
   bool get_timeout_status_(uint32_t check_millis);
   uint8_t count_targets_in_zone_(const Zone &zone, bool is_moving);
 
-  uint32_t last_periodic_millis_ = 0;
   uint32_t presence_millis_ = 0;
   uint32_t still_presence_millis_ = 0;
   uint32_t moving_presence_millis_ = 0;
-  uint16_t throttle_ = 0;
   uint16_t timeout_ = 5;
   uint8_t buffer_data_[MAX_LINE_LENGTH];
   uint8_t mac_address_[6] = {0, 0, 0, 0, 0, 0};
@@ -176,48 +173,23 @@ class LD2450Component : public Component, public uart::UARTDevice {
   Target target_info_[MAX_TARGETS];
   Zone zone_config_[MAX_ZONES];
 
-  // Change detection - cache previous values to avoid redundant publishes
-  // All values are initialized to sentinel values that are outside the valid sensor ranges
-  // to ensure the first real measurement is always published
-  struct CachedTargetData {
-    int16_t x = std::numeric_limits<int16_t>::min();             // -32768, outside range of -4860 to 4860
-    int16_t y = std::numeric_limits<int16_t>::min();             // -32768, outside range of 0 to 7560
-    int16_t speed = std::numeric_limits<int16_t>::min();         // -32768, outside practical sensor range
-    uint16_t resolution = std::numeric_limits<uint16_t>::max();  // 65535, unlikely resolution value
-    uint16_t distance = std::numeric_limits<uint16_t>::max();    // 65535, outside range of 0 to ~8990
-    Direction direction = DIRECTION_UNDEFINED;                   // Undefined, will differ from any real direction
-    float angle = NAN;                                           // NAN, safe sentinel for floats
-  } cached_target_data_[MAX_TARGETS];
-
-  struct CachedZoneData {
-    uint8_t still_count = std::numeric_limits<uint8_t>::max();   // 255, unlikely zone count
-    uint8_t moving_count = std::numeric_limits<uint8_t>::max();  // 255, unlikely zone count
-    uint8_t total_count = std::numeric_limits<uint8_t>::max();   // 255, unlikely zone count
-  } cached_zone_data_[MAX_ZONES];
-
-  struct CachedGlobalData {
-    uint8_t target_count = std::numeric_limits<uint8_t>::max();  // 255, max 3 targets possible
-    uint8_t still_count = std::numeric_limits<uint8_t>::max();   // 255, max 3 targets possible
-    uint8_t moving_count = std::numeric_limits<uint8_t>::max();  // 255, max 3 targets possible
-  } cached_global_data_;
-
 #ifdef USE_NUMBER
   ESPPreferenceObject pref_;  // only used when numbers are in use
   ZoneOfNumbers zone_numbers_[MAX_ZONES];
 #endif
 #ifdef USE_SENSOR
-  std::vector<sensor::Sensor *> move_x_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> move_y_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> move_speed_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> move_angle_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> move_distance_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> move_resolution_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
-  std::vector<sensor::Sensor *> zone_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
-  std::vector<sensor::Sensor *> zone_still_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
-  std::vector<sensor::Sensor *> zone_moving_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_x_sensors_{};
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_y_sensors_{};
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_speed_sensors_{};
+  std::array<SensorWithDedup<float> *, MAX_TARGETS> move_angle_sensors_{};
+  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_distance_sensors_{};
+  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_resolution_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_still_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_moving_target_count_sensors_{};
 #endif
 #ifdef USE_TEXT_SENSOR
-  std::vector<text_sensor::TextSensor *> direction_text_sensors_ = std::vector<text_sensor::TextSensor *>(3);
+  std::array<text_sensor::TextSensor *, 3> direction_text_sensors_{};
 #endif
 };
 

esphome/components/ld2450/sensor.py

@@ -42,12 +42,42 @@ CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
         cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_ACCOUNT_GROUP,
         ),
         cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_HUMAN_GREETING_PROXIMITY,
         ),
         cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_ACCOUNT_SWITCH,
         ),
     }
@@ -59,32 +89,86 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
             {
                 cv.Optional(CONF_X): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_DISTANCE,
-                    unit_of_measurement=UNIT_MILLIMETER,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_ALPHA_X_BOX_OUTLINE,
+                    unit_of_measurement=UNIT_MILLIMETER,
                 ),
                 cv.Optional(CONF_Y): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_DISTANCE,
-                    unit_of_measurement=UNIT_MILLIMETER,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_ALPHA_Y_BOX_OUTLINE,
+                    unit_of_measurement=UNIT_MILLIMETER,
                 ),
                 cv.Optional(CONF_SPEED): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_SPEED,
-                    unit_of_measurement=UNIT_MILLIMETER_PER_SECOND,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_SPEEDOMETER_SLOW,
+                    unit_of_measurement=UNIT_MILLIMETER_PER_SECOND,
                 ),
                 cv.Optional(CONF_ANGLE): sensor.sensor_schema(
-                    unit_of_measurement=UNIT_DEGREES,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_FORMAT_TEXT_ROTATION_ANGLE_UP,
+                    unit_of_measurement=UNIT_DEGREES,
                 ),
                 cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_DISTANCE,
-                    unit_of_measurement=UNIT_MILLIMETER,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_MAP_MARKER_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
                 ),
                 cv.Optional(CONF_RESOLUTION): sensor.sensor_schema(
                     device_class=DEVICE_CLASS_DISTANCE,
-                    unit_of_measurement=UNIT_MILLIMETER,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_RELATION_ZERO_OR_ONE_TO_ZERO_OR_ONE,
+                    unit_of_measurement=UNIT_MILLIMETER,
                 ),
             }
         )
@@ -94,12 +178,42 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
         cv.Optional(f"zone_{n + 1}"): cv.Schema(
             {
                 cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+                    accuracy_decimals=0,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_MAP_MARKER_ACCOUNT,
                 ),
                 cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+                    accuracy_decimals=0,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_MAP_MARKER_ACCOUNT,
                 ),
                 cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+                    accuracy_decimals=0,
+                    filters=[
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                    ],
                     icon=ICON_MAP_MARKER_ACCOUNT,
                 ),
             }

esphome/components/ld2450/text_sensor.py

@@ -56,7 +56,8 @@ async def to_code(config):
         sens = await text_sensor.new_text_sensor(mac_address_config)
         cg.add(ld2450_component.set_mac_text_sensor(sens))
     for n in range(MAX_TARGETS):
-        if direction_conf := config.get(f"target_{n + 1}"):
-            if direction_config := direction_conf.get(CONF_DIRECTION):
-                sens = await text_sensor.new_text_sensor(direction_config)
-                cg.add(ld2450_component.set_direction_text_sensor(n, sens))
+        if (direction_conf := config.get(f"target_{n + 1}")) and (
+            direction_config := direction_conf.get(CONF_DIRECTION)
+        ):
+            sens = await text_sensor.new_text_sensor(direction_config)
+            cg.add(ld2450_component.set_direction_text_sensor(n, sens))

esphome/components/ld24xx/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@kbx81"]

esphome/components/ld24xx/ld24xx.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#include <memory>
+
+#ifdef USE_SENSOR
+#include "esphome/core/helpers.h"
+#include "esphome/components/sensor/sensor.h"
+
+#define SUB_SENSOR_WITH_DEDUP(name, dedup_type) \
+ protected: \
+  ld24xx::SensorWithDedup<dedup_type> *name##_sensor_{nullptr}; \
+\
+ public: \
+  void set_##name##_sensor(sensor::Sensor *sensor) { \
+    this->name##_sensor_ = new ld24xx::SensorWithDedup<dedup_type>(sensor); \
+  }
+#endif
+
+#define LOG_SENSOR_WITH_DEDUP_SAFE(tag, name, sensor) \
+  if ((sensor) != nullptr) { \
+    LOG_SENSOR(tag, name, (sensor)->sens); \
+  }
+
+#define SAFE_PUBLISH_SENSOR(sensor, value) \
+  if ((sensor) != nullptr) { \
+    (sensor)->publish_state_if_not_dup(value); \
+  }
+
+#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) \
+  if ((sensor) != nullptr) { \
+    (sensor)->publish_state_unknown(); \
+  }
+
+#define highbyte(val) (uint8_t)((val) >> 8)
+#define lowbyte(val) (uint8_t)((val) &0xff)
+
+namespace esphome {
+namespace ld24xx {
+
+#ifdef USE_SENSOR
+// Helper class to store a sensor with a deduplicator & publish state only when the value changes
+template<typename T> class SensorWithDedup {
+ public:
+  SensorWithDedup(sensor::Sensor *sens) : sens(sens) {}
+
+  void publish_state_if_not_dup(T state) {
+    if (this->publish_dedup.next(state)) {
+      this->sens->publish_state(static_cast<float>(state));
+    }
+  }
+
+  void publish_state_unknown() {
+    if (this->publish_dedup.next_unknown()) {
+      this->sens->publish_state(NAN);
+    }
+  }
+
+  sensor::Sensor *sens;
+  Deduplicator<T> publish_dedup;
+};
+#endif
+}  // namespace ld24xx
+}  // namespace esphome

esphome/components/ledc/ledc_output.cpp

@@ -116,7 +116,6 @@ void LEDCOutput::write_state(float state) {
 }
 
 void LEDCOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   auto speed_mode = get_speed_mode(this->channel_);
   auto timer_num = static_cast<ledc_timer_t>((this->channel_ % 8) / 2);
   auto chan_num = static_cast<ledc_channel_t>(this->channel_ % 8);

esphome/components/libretiny/__init__.py

@@ -20,6 +20,7 @@ from esphome.const import (
     KEY_FRAMEWORK_VERSION,
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
+    ThreadModel,
     __version__,
 )
 from esphome.core import CORE
@@ -260,6 +261,7 @@ async def component_to_code(config):
     cg.add_build_flag(f"-DUSE_LIBRETINY_VARIANT_{config[CONF_FAMILY]}")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", FAMILY_FRIENDLY[config[CONF_FAMILY]])
+    cg.add_define(ThreadModel.MULTI_NO_ATOMICS)
 
     # force using arduino framework
     cg.add_platformio_option("framework", "arduino")

esphome/components/light/__init__.py

@@ -285,5 +285,4 @@ async def new_light(config, *args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_LIGHT")
     cg.add_global(light_ns.using)

esphome/components/light/effects.py

@@ -29,6 +29,7 @@ from esphome.const import (
     CONF_WHITE,
     CONF_WIDTH,
 )
+from esphome.cpp_generator import MockObjClass
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.util import Registry
 
@@ -88,8 +89,15 @@ ADDRESSABLE_EFFECTS = []
 EFFECTS_REGISTRY = Registry()
 
 
-def register_effect(name, effect_type, default_name, schema, *extra_validators):
-    schema = cv.Schema(schema).extend(
+def register_effect(
+    name: str,
+    effect_type: MockObjClass,
+    default_name: str,
+    schema: cv.Schema | dict,
+    *extra_validators,
+):
+    schema = schema if isinstance(schema, cv.Schema) else cv.Schema(schema)
+    schema = schema.extend(
         {
             cv.Optional(CONF_NAME, default=default_name): cv.string_strict,
         }
@@ -98,7 +106,13 @@ def register_effect(name, effect_type, default_name, schema, *extra_validators):
     return EFFECTS_REGISTRY.register(name, effect_type, validator)
 
 
-def register_binary_effect(name, effect_type, default_name, schema, *extra_validators):
+def register_binary_effect(
+    name: str,
+    effect_type: MockObjClass,
+    default_name: str,
+    schema: cv.Schema | dict,
+    *extra_validators,
+):
     # binary effect can be used for all lights
     BINARY_EFFECTS.append(name)
     MONOCHROMATIC_EFFECTS.append(name)
@@ -109,7 +123,11 @@ def register_binary_effect(name, effect_type, default_name, schema, *extra_valid
 
 
 def register_monochromatic_effect(
-    name, effect_type, default_name, schema, *extra_validators
+    name: str,
+    effect_type: MockObjClass,
+    default_name: str,
+    schema: cv.Schema | dict,
+    *extra_validators,
 ):
     # monochromatic effect can be used for all lights expect binary
     MONOCHROMATIC_EFFECTS.append(name)
@@ -119,7 +137,13 @@ def register_monochromatic_effect(
     return register_effect(name, effect_type, default_name, schema, *extra_validators)
 
 
-def register_rgb_effect(name, effect_type, default_name, schema, *extra_validators):
+def register_rgb_effect(
+    name: str,
+    effect_type: MockObjClass,
+    default_name: str,
+    schema: cv.Schema | dict,
+    *extra_validators,
+):
     # RGB effect can be used for RGB and addressable lights
     RGB_EFFECTS.append(name)
     ADDRESSABLE_EFFECTS.append(name)
@@ -128,7 +152,11 @@ def register_rgb_effect(name, effect_type, default_name, schema, *extra_validato
 
 
 def register_addressable_effect(
-    name, effect_type, default_name, schema, *extra_validators
+    name: str,
+    effect_type: MockObjClass,
+    default_name: str,
+    schema: cv.Schema | dict,
+    *extra_validators,
 ):
     # addressable effect can be used only in addressable
     ADDRESSABLE_EFFECTS.append(name)
@@ -291,31 +319,30 @@ async def random_effect_to_code(config, effect_id):
 )
 async def strobe_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
-    colors = []
-    for color in config.get(CONF_COLORS, []):
-        colors.append(
-            cg.StructInitializer(
-                StrobeLightEffectColor,
-                (
-                    "color",
-                    LightColorValues(
-                        color.get(CONF_COLOR_MODE, ColorMode.UNKNOWN),
-                        color[CONF_STATE],
-                        color[CONF_BRIGHTNESS],
-                        color[CONF_COLOR_BRIGHTNESS],
-                        color[CONF_RED],
-                        color[CONF_GREEN],
-                        color[CONF_BLUE],
-                        color[CONF_WHITE],
-                        color.get(CONF_COLOR_TEMPERATURE, 0.0),
-                        color[CONF_COLD_WHITE],
-                        color[CONF_WARM_WHITE],
-                    ),
+    colors = [
+        cg.StructInitializer(
+            StrobeLightEffectColor,
+            (
+                "color",
+                LightColorValues(
+                    color.get(CONF_COLOR_MODE, ColorMode.UNKNOWN),
+                    color[CONF_STATE],
+                    color[CONF_BRIGHTNESS],
+                    color[CONF_COLOR_BRIGHTNESS],
+                    color[CONF_RED],
+                    color[CONF_GREEN],
+                    color[CONF_BLUE],
+                    color[CONF_WHITE],
+                    color.get(CONF_COLOR_TEMPERATURE, 0.0),
+                    color[CONF_COLD_WHITE],
+                    color[CONF_WARM_WHITE],
                 ),
-                ("duration", color[CONF_DURATION]),
-                ("transition_length", color[CONF_TRANSITION_LENGTH]),
-            )
+            ),
+            ("duration", color[CONF_DURATION]),
+            ("transition_length", color[CONF_TRANSITION_LENGTH]),
         )
+        for color in config.get(CONF_COLORS, [])
+    ]
     cg.add(var.set_colors(colors))
     return var
 
@@ -354,10 +381,9 @@ async def addressable_lambda_effect_to_code(config, effect_id):
         (bool, "initial_run"),
     ]
     lambda_ = await cg.process_lambda(config[CONF_LAMBDA], args, return_type=cg.void)
-    var = cg.new_Pvariable(
+    return cg.new_Pvariable(
         effect_id, config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL]
     )
-    return var
 
 
 @register_addressable_effect(
@@ -404,20 +430,19 @@ async def addressable_color_wipe_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
     cg.add(var.set_reverse(config[CONF_REVERSE]))
-    colors = []
-    for color in config.get(CONF_COLORS, []):
-        colors.append(
-            cg.StructInitializer(
-                AddressableColorWipeEffectColor,
-                ("r", int(round(color[CONF_RED] * 255))),
-                ("g", int(round(color[CONF_GREEN] * 255))),
-                ("b", int(round(color[CONF_BLUE] * 255))),
-                ("w", int(round(color[CONF_WHITE] * 255))),
-                ("random", color[CONF_RANDOM]),
-                ("num_leds", color[CONF_NUM_LEDS]),
-                ("gradient", color[CONF_GRADIENT]),
-            )
+    colors = [
+        cg.StructInitializer(
+            AddressableColorWipeEffectColor,
+            ("r", int(round(color[CONF_RED] * 255))),
+            ("g", int(round(color[CONF_GREEN] * 255))),
+            ("b", int(round(color[CONF_BLUE] * 255))),
+            ("w", int(round(color[CONF_WHITE] * 255))),
+            ("random", color[CONF_RANDOM]),
+            ("num_leds", color[CONF_NUM_LEDS]),
+            ("gradient", color[CONF_GRADIENT]),
         )
+        for color in config.get(CONF_COLORS, [])
+    ]
     cg.add(var.set_colors(colors))
     return var
 
@@ -526,7 +551,7 @@ def validate_effects(allowed_effects):
         errors = []
         names = set()
         for i, x in enumerate(value):
-            key = next(it for it in x.keys())
+            key = next(it for it in x)
             if key not in allowed_effects:
                 errors.append(
                     cv.Invalid(