esphome 2025.8.3__py3-none-any.whl → 2025.9.0__py3-none-any.whl

esphome/components/inkplate6/display.py

@@ -1,214 +1,5 @@
-from esphome import pins
-import esphome.codegen as cg
-from esphome.components import display, i2c
-from esphome.components.esp32 import CONF_CPU_FREQUENCY
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_FULL_UPDATE_EVERY,
-    CONF_ID,
-    CONF_LAMBDA,
-    CONF_MIRROR_X,
-    CONF_MIRROR_Y,
-    CONF_MODEL,
-    CONF_OE_PIN,
-    CONF_PAGES,
-    CONF_TRANSFORM,
-    CONF_WAKEUP_PIN,
-    PLATFORM_ESP32,
-)
-import esphome.final_validate as fv
-
-DEPENDENCIES = ["i2c", "esp32"]
-AUTO_LOAD = ["psram"]
-
-CONF_DISPLAY_DATA_0_PIN = "display_data_0_pin"
-CONF_DISPLAY_DATA_1_PIN = "display_data_1_pin"
-CONF_DISPLAY_DATA_2_PIN = "display_data_2_pin"
-CONF_DISPLAY_DATA_3_PIN = "display_data_3_pin"
-CONF_DISPLAY_DATA_4_PIN = "display_data_4_pin"
-CONF_DISPLAY_DATA_5_PIN = "display_data_5_pin"
-CONF_DISPLAY_DATA_6_PIN = "display_data_6_pin"
-CONF_DISPLAY_DATA_7_PIN = "display_data_7_pin"
-
-CONF_CL_PIN = "cl_pin"
-CONF_CKV_PIN = "ckv_pin"
-CONF_GREYSCALE = "greyscale"
-CONF_GMOD_PIN = "gmod_pin"
-CONF_GPIO0_ENABLE_PIN = "gpio0_enable_pin"
-CONF_LE_PIN = "le_pin"
-CONF_PARTIAL_UPDATING = "partial_updating"
-CONF_POWERUP_PIN = "powerup_pin"
-CONF_SPH_PIN = "sph_pin"
-CONF_SPV_PIN = "spv_pin"
-CONF_VCOM_PIN = "vcom_pin"
-
-inkplate6_ns = cg.esphome_ns.namespace("inkplate6")
-Inkplate6 = inkplate6_ns.class_(
-    "Inkplate6",
-    cg.PollingComponent,
-    i2c.I2CDevice,
-    display.Display,
-    display.DisplayBuffer,
-)
-
-InkplateModel = inkplate6_ns.enum("InkplateModel")
-
-MODELS = {
-    "inkplate_6": InkplateModel.INKPLATE_6,
-    "inkplate_10": InkplateModel.INKPLATE_10,
-    "inkplate_6_plus": InkplateModel.INKPLATE_6_PLUS,
-    "inkplate_6_v2": InkplateModel.INKPLATE_6_V2,
-    "inkplate_5": InkplateModel.INKPLATE_5,
-    "inkplate_5_v2": InkplateModel.INKPLATE_5_V2,
-}
 
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
-        {
-            cv.GenerateID(): cv.declare_id(Inkplate6),
-            cv.Optional(CONF_GREYSCALE, default=False): cv.boolean,
-            cv.Optional(CONF_TRANSFORM): cv.Schema(
-                {
-                    cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
-                    cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
-                }
-            ),
-            cv.Optional(CONF_PARTIAL_UPDATING, default=True): cv.boolean,
-            cv.Optional(CONF_FULL_UPDATE_EVERY, default=10): cv.uint32_t,
-            cv.Optional(CONF_MODEL, default="inkplate_6"): cv.enum(
-                MODELS, lower=True, space="_"
-            ),
-            # Control pins
-            cv.Required(CONF_CKV_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_GMOD_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_GPIO0_ENABLE_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_OE_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_POWERUP_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_SPH_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_SPV_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_VCOM_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_WAKEUP_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_CL_PIN, default=0): pins.internal_gpio_output_pin_schema,
-            cv.Optional(CONF_LE_PIN, default=2): pins.internal_gpio_output_pin_schema,
-            # Data pins
-            cv.Optional(
-                CONF_DISPLAY_DATA_0_PIN, default=4
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_1_PIN, default=5
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_2_PIN, default=18
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_3_PIN, default=19
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_4_PIN, default=23
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_5_PIN, default=25
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_6_PIN, default=26
-            ): pins.internal_gpio_output_pin_schema,
-            cv.Optional(
-                CONF_DISPLAY_DATA_7_PIN, default=27
-            ): pins.internal_gpio_output_pin_schema,
-        }
-    )
-    .extend(cv.polling_component_schema("5s"))
-    .extend(i2c.i2c_device_schema(0x48)),
-    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
+CONFIG_SCHEMA = cv.invalid(
+    "The inkplate6 display component has been renamed to inkplate."
 )
-
-
-def _validate_cpu_frequency(config):
-    esp32_config = fv.full_config.get()[PLATFORM_ESP32]
-    if esp32_config[CONF_CPU_FREQUENCY] != "240MHZ":
-        raise cv.Invalid(
-            "Inkplate requires 240MHz CPU frequency (set in esp32 component)"
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _validate_cpu_frequency
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-
-    await display.register_display(var, config)
-    await i2c.register_i2c_device(var, config)
-
-    if CONF_LAMBDA in config:
-        lambda_ = await cg.process_lambda(
-            config[CONF_LAMBDA], [(display.DisplayRef, "it")], return_type=cg.void
-        )
-        cg.add(var.set_writer(lambda_))
-
-    cg.add(var.set_greyscale(config[CONF_GREYSCALE]))
-    if transform := config.get(CONF_TRANSFORM):
-        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
-        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
-    cg.add(var.set_partial_updating(config[CONF_PARTIAL_UPDATING]))
-    cg.add(var.set_full_update_every(config[CONF_FULL_UPDATE_EVERY]))
-
-    cg.add(var.set_model(config[CONF_MODEL]))
-
-    ckv = await cg.gpio_pin_expression(config[CONF_CKV_PIN])
-    cg.add(var.set_ckv_pin(ckv))
-
-    gmod = await cg.gpio_pin_expression(config[CONF_GMOD_PIN])
-    cg.add(var.set_gmod_pin(gmod))
-
-    gpio0_enable = await cg.gpio_pin_expression(config[CONF_GPIO0_ENABLE_PIN])
-    cg.add(var.set_gpio0_enable_pin(gpio0_enable))
-
-    oe = await cg.gpio_pin_expression(config[CONF_OE_PIN])
-    cg.add(var.set_oe_pin(oe))
-
-    powerup = await cg.gpio_pin_expression(config[CONF_POWERUP_PIN])
-    cg.add(var.set_powerup_pin(powerup))
-
-    sph = await cg.gpio_pin_expression(config[CONF_SPH_PIN])
-    cg.add(var.set_sph_pin(sph))
-
-    spv = await cg.gpio_pin_expression(config[CONF_SPV_PIN])
-    cg.add(var.set_spv_pin(spv))
-
-    vcom = await cg.gpio_pin_expression(config[CONF_VCOM_PIN])
-    cg.add(var.set_vcom_pin(vcom))
-
-    wakeup = await cg.gpio_pin_expression(config[CONF_WAKEUP_PIN])
-    cg.add(var.set_wakeup_pin(wakeup))
-
-    cl = await cg.gpio_pin_expression(config[CONF_CL_PIN])
-    cg.add(var.set_cl_pin(cl))
-
-    le = await cg.gpio_pin_expression(config[CONF_LE_PIN])
-    cg.add(var.set_le_pin(le))
-
-    display_data_0 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_0_PIN])
-    cg.add(var.set_display_data_0_pin(display_data_0))
-
-    display_data_1 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_1_PIN])
-    cg.add(var.set_display_data_1_pin(display_data_1))
-
-    display_data_2 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_2_PIN])
-    cg.add(var.set_display_data_2_pin(display_data_2))
-
-    display_data_3 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_3_PIN])
-    cg.add(var.set_display_data_3_pin(display_data_3))
-
-    display_data_4 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_4_PIN])
-    cg.add(var.set_display_data_4_pin(display_data_4))
-
-    display_data_5 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_5_PIN])
-    cg.add(var.set_display_data_5_pin(display_data_5))
-
-    display_data_6 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_6_PIN])
-    cg.add(var.set_display_data_6_pin(display_data_6))
-
-    display_data_7 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_7_PIN])
-    cg.add(var.set_display_data_7_pin(display_data_7))

esphome/components/integration/integration_sensor.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "integration";
 
 void IntegrationSensor::setup() {
   if (this->restore_) {
-    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     float preference_value = 0;
     this->pref_.load(&preference_value);
     this->result_ = preference_value;

esphome/components/json/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.core import coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 json_ns = cg.esphome_ns.namespace("json")
@@ -10,7 +10,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(1.0)
+@coroutine_with_priority(CoroPriority.BUS)
 async def to_code(config):
     cg.add_library("bblanchon/ArduinoJson", "7.4.2")
     cg.add_define("USE_JSON")

esphome/components/kmeteriso/kmeteriso.cpp

@@ -33,7 +33,7 @@ void KMeterISOComponent::setup() {
   }
 
   uint8_t read_buf[4] = {1};
-  if (!this->read_register(KMETER_ERROR_STATUS_REG, read_buf, 1)) {
+  if (!this->read_bytes(KMETER_ERROR_STATUS_REG, read_buf, 1)) {
     ESP_LOGCONFIG(TAG, "Could not read from the device.");
     this->error_code_ = COMMUNICATION_FAILED;
     this->mark_failed();

esphome/components/lc709203f/lc709203f.cpp

@@ -1,5 +1,6 @@
-#include "esphome/core/log.h"
 #include "lc709203f.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace lc709203f {
@@ -189,7 +190,7 @@ uint8_t Lc709203f::get_register_(uint8_t register_to_read, uint16_t *register_va
       // Error on the i2c bus
       this->status_set_warning(
           str_sprintf("Error code %d when reading from register 0x%02X", return_code, register_to_read).c_str());
-    } else if (this->crc8_(read_buffer, 5) != read_buffer[5]) {
+    } else if (crc8(read_buffer, 5, 0x00, 0x07, true) != read_buffer[5]) {
       // I2C indicated OK, but the CRC of the data does not matcth.
       this->status_set_warning(str_sprintf("CRC error reading from register 0x%02X", register_to_read).c_str());
     } else {
@@ -220,7 +221,7 @@ uint8_t Lc709203f::set_register_(uint8_t register_to_set, uint16_t value_to_set)
   write_buffer[1] = register_to_set;
   write_buffer[2] = value_to_set & 0xFF;         // Low byte
   write_buffer[3] = (value_to_set >> 8) & 0xFF;  // High byte
-  write_buffer[4] = this->crc8_(write_buffer, 4);
+  write_buffer[4] = crc8(write_buffer, 4, 0x00, 0x07, true);
 
   for (uint8_t i = 0; i <= LC709203F_I2C_RETRY_COUNT; i++) {
     // Note: we don't write the first byte of the write buffer to the device.
@@ -239,20 +240,6 @@ uint8_t Lc709203f::set_register_(uint8_t register_to_set, uint16_t value_to_set)
   return return_code;
 }
 
-uint8_t Lc709203f::crc8_(uint8_t *byte_buffer, uint8_t length_of_crc) {
-  uint8_t crc = 0x00;
-  const uint8_t polynomial(0x07);
-
-  for (uint8_t j = length_of_crc; j; --j) {
-    crc ^= *byte_buffer++;
-
-    for (uint8_t i = 8; i; --i) {
-      crc = (crc & 0x80) ? (crc << 1) ^ polynomial : (crc << 1);
-    }
-  }
-  return crc;
-}
-
 void Lc709203f::set_pack_size(uint16_t pack_size) {
   static const uint16_t PACK_SIZE_ARRAY[6] = {100, 200, 500, 1000, 2000, 3000};
   static const uint16_t APA_ARRAY[6] = {0x08, 0x0B, 0x10, 0x19, 0x2D, 0x36};

esphome/components/lc709203f/lc709203f.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
 
 namespace esphome {
 namespace lc709203f {
@@ -38,7 +38,6 @@ class Lc709203f : public sensor::Sensor, public PollingComponent, public i2c::I2
  private:
   uint8_t get_register_(uint8_t register_to_read, uint16_t *register_value);
   uint8_t set_register_(uint8_t register_to_set, uint16_t value_to_set);
-  uint8_t crc8_(uint8_t *byte_buffer, uint8_t length_of_crc);
 
  protected:
   sensor::Sensor *voltage_sensor_{nullptr};

esphome/components/ld2420/text_sensor/{text_sensor.cpp → ld2420_text_sensor.cpp}

@@ -1,4 +1,4 @@
-#include "text_sensor.h"
+#include "ld2420_text_sensor.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 

esphome/components/ld2450/ld2450.cpp

@@ -184,7 +184,7 @@ static inline bool validate_header_footer(const uint8_t *header_footer, const ui
 void LD2450Component::setup() {
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
-    this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_preference_hash());
     this->set_presence_timeout();
   }
 #endif

esphome/components/libretiny/preferences.cpp

@@ -5,7 +5,7 @@
 #include "esphome/core/preferences.h"
 #include <flashdb.h>
 #include <cstring>
-#include <vector>
+#include <memory>
 #include <string>
 
 namespace esphome {
@@ -139,21 +139,29 @@ class LibreTinyPreferences : public ESPPreferences {
   }
 
   bool is_changed(const fdb_kvdb_t db, const NVSData &to_save) {
-    NVSData stored_data{};
     struct fdb_kv kv;
     fdb_kv_t kvp = fdb_kv_get_obj(db, to_save.key.c_str(), &kv);
     if (kvp == nullptr) {
       ESP_LOGV(TAG, "fdb_kv_get_obj('%s'): nullptr - the key might not be set yet", to_save.key.c_str());
       return true;
     }
-    stored_data.data.resize(kv.value_len);
-    fdb_blob_make(&blob, stored_data.data.data(), kv.value_len);
+
+    // Check size first - if different, data has changed
+    if (kv.value_len != to_save.data.size()) {
+      return true;
+    }
+
+    // Allocate buffer on heap to avoid stack allocation for large data
+    auto stored_data = std::make_unique<uint8_t[]>(kv.value_len);
+    fdb_blob_make(&blob, stored_data.get(), kv.value_len);
     size_t actual_len = fdb_kv_get_blob(db, to_save.key.c_str(), &blob);
     if (actual_len != kv.value_len) {
       ESP_LOGV(TAG, "fdb_kv_get_blob('%s') len mismatch: %u != %u", to_save.key.c_str(), actual_len, kv.value_len);
       return true;
     }
-    return to_save.data != stored_data.data;
+
+    // Compare the actual data
+    return memcmp(to_save.data.data(), stored_data.get(), kv.value_len) != 0;
   }
 
   bool reset() override {

esphome/components/light/__init__.py

@@ -37,7 +37,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
     CONF_WHITE,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -283,6 +283,6 @@ async def new_light(config, *args):
     return output_var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(light_ns.using)

esphome/components/light/addressable_light_effect.h

@@ -44,6 +44,13 @@ class AddressableLightEffect : public LightEffect {
     this->apply(*this->get_addressable_(), current_color);
   }
 
+  /// Get effect index specifically for addressable effects.
+  /// Can be used by effects to modify behavior based on their position in the list.
+  uint32_t get_effect_index() const { return this->get_index(); }
+
+  /// Check if this is the currently running addressable effect.
+  bool is_current_effect() const { return this->is_active() && this->get_addressable_()->is_effect_active(); }
+
  protected:
   AddressableLight *get_addressable_() const { return (AddressableLight *) this->state_->get_output(); }
 };

esphome/components/light/base_light_effects.h

@@ -125,6 +125,10 @@ class LambdaLightEffect : public LightEffect {
     }
   }
 
+  /// Get the current effect index for use in lambda functions.
+  /// This can be useful for lambda effects that need to know their own index.
+  uint32_t get_current_index() const { return this->get_index(); }
+
  protected:
   std::function<void(bool initial_run)> f_;
   uint32_t update_interval_;
@@ -143,6 +147,10 @@ class AutomationLightEffect : public LightEffect {
   }
   Trigger<> *get_trig() const { return trig_; }
 
+  /// Get the current effect index for use in automations.
+  /// Useful for automations that need to know which effect is running.
+  uint32_t get_current_index() const { return this->get_index(); }
+
  protected:
   Trigger<> *trig_{new Trigger<>};
 };

esphome/components/light/light_call.cpp

@@ -11,19 +11,21 @@ static const char *const TAG = "light";
 
 // Helper functions to reduce code size for logging
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
-static void log_validation_warning(const char *name, const char *param_name, float val, float min, float max) {
-  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, param_name, val, min, max);
+static void log_validation_warning(const char *name, const LogString *param_name, float val, float min, float max) {
+  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), val, min, max);
 }
 
-static void log_feature_not_supported(const char *name, const char *feature) {
-  ESP_LOGW(TAG, "'%s': %s not supported", name, feature);
+static void log_feature_not_supported(const char *name, const LogString *feature) {
+  ESP_LOGW(TAG, "'%s': %s not supported", name, LOG_STR_ARG(feature));
 }
 
-static void log_color_mode_not_supported(const char *name, const char *feature) {
-  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, feature);
+static void log_color_mode_not_supported(const char *name, const LogString *feature) {
+  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, LOG_STR_ARG(feature));
 }
 
-static void log_invalid_parameter(const char *name, const char *message) { ESP_LOGW(TAG, "'%s': %s", name, message); }
+static void log_invalid_parameter(const char *name, const LogString *message) {
+  ESP_LOGW(TAG, "'%s': %s", name, LOG_STR_ARG(message));
+}
 #else
 #define log_validation_warning(name, param_name, val, min, max)
 #define log_feature_not_supported(name, feature)
@@ -201,19 +203,19 @@ LightColorValues LightCall::validate_() {
 
   // Brightness exists check
   if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, "brightness");
+    log_feature_not_supported(name, LOG_STR("brightness"));
     this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
   }
 
   // Transition length possible check
   if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, "transitions");
+    log_feature_not_supported(name, LOG_STR("transitions"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
   // Color brightness exists check
   if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
-    log_color_mode_not_supported(name, "RGB brightness");
+    log_color_mode_not_supported(name, LOG_STR("RGB brightness"));
     this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
   }
 
@@ -221,7 +223,7 @@ LightColorValues LightCall::validate_() {
   if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
       (this->has_blue() && this->blue_ > 0.0f)) {
     if (!(color_mode & ColorCapability::RGB)) {
-      log_color_mode_not_supported(name, "RGB color");
+      log_color_mode_not_supported(name, LOG_STR("RGB color"));
       this->set_flag_(FLAG_HAS_RED, false);
       this->set_flag_(FLAG_HAS_GREEN, false);
       this->set_flag_(FLAG_HAS_BLUE, false);
@@ -231,21 +233,21 @@ LightColorValues LightCall::validate_() {
   // White value exists check
   if (this->has_white() && this->white_ > 0.0f &&
       !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, "white value");
+    log_color_mode_not_supported(name, LOG_STR("white value"));
     this->set_flag_(FLAG_HAS_WHITE, false);
   }
 
   // Color temperature exists check
   if (this->has_color_temperature() &&
       !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, "color temperature");
+    log_color_mode_not_supported(name, LOG_STR("color temperature"));
     this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
   }
 
   // Cold/warm white value exists check
   if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
     if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
-      log_color_mode_not_supported(name, "cold/warm white value");
+      log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
       this->set_flag_(FLAG_HAS_COLD_WHITE, false);
       this->set_flag_(FLAG_HAS_WARM_WHITE, false);
     }
@@ -255,7 +257,7 @@ LightColorValues LightCall::validate_() {
   if (this->has_##name_()) { \
     auto val = this->name_##_; \
     if (val < (min) || val > (max)) { \
-      log_validation_warning(name, LOG_STR_LITERAL(upper_name), val, (min), (max)); \
+      log_validation_warning(name, LOG_STR(upper_name), val, (min), (max)); \
       this->name_##_ = clamp(val, (min), (max)); \
     } \
   }
@@ -319,7 +321,7 @@ LightColorValues LightCall::validate_() {
 
   // Flash length check
   if (this->has_flash_() && this->flash_length_ == 0) {
-    log_invalid_parameter(name, "flash length must be greater than zero");
+    log_invalid_parameter(name, LOG_STR("flash length must be greater than zero"));
     this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
@@ -338,13 +340,13 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
-    log_invalid_parameter(name, "effect cannot be used with transition/flash");
+    log_invalid_parameter(name, LOG_STR("effect cannot be used with transition/flash"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
     this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
   if (this->has_flash_() && this->has_transition_()) {
-    log_invalid_parameter(name, "flash cannot be used with transition");
+    log_invalid_parameter(name, LOG_STR("flash cannot be used with transition"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -361,7 +363,7 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_transition_() && !supports_transition) {
-    log_feature_not_supported(name, "transitions");
+    log_feature_not_supported(name, LOG_STR("transitions"));
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -371,7 +373,7 @@ LightColorValues LightCall::validate_() {
   bool target_state = this->has_state() ? this->state_ : v.is_on();
   if (!this->has_flash_() && !target_state) {
     if (this->has_effect_()) {
-      log_invalid_parameter(name, "cannot start effect when turning off");
+      log_invalid_parameter(name, LOG_STR("cannot start effect when turning off"));
       this->set_flag_(FLAG_HAS_EFFECT, false);
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect

esphome/components/light/light_effect.cpp

@@ -0,0 +1,36 @@
+#include "light_effect.h"
+#include "light_state.h"
+
+namespace esphome {
+namespace light {
+
+uint32_t LightEffect::get_index() const {
+  if (this->state_ == nullptr) {
+    return 0;
+  }
+  return this->get_index_in_parent_();
+}
+
+bool LightEffect::is_active() const {
+  if (this->state_ == nullptr) {
+    return false;
+  }
+  return this->get_index() != 0 && this->state_->get_current_effect_index() == this->get_index();
+}
+
+uint32_t LightEffect::get_index_in_parent_() const {
+  if (this->state_ == nullptr) {
+    return 0;
+  }
+
+  const auto &effects = this->state_->get_effects();
+  for (size_t i = 0; i < effects.size(); i++) {
+    if (effects[i] == this) {
+      return i + 1;  // Effects are 1-indexed in the API
+    }
+  }
+  return 0;  // Not found
+}
+
+}  // namespace light
+}  // namespace esphome

esphome/components/light/light_effect.h

@@ -34,9 +34,23 @@ class LightEffect {
     this->init();
   }
 
+  /// Get the index of this effect in the parent light's effect list.
+  /// Returns 0 if not found or not initialized.
+  uint32_t get_index() const;
+
+  /// Check if this effect is currently active.
+  bool is_active() const;
+
+  /// Get a reference to the parent light state.
+  /// Returns nullptr if not initialized.
+  LightState *get_light_state() const { return this->state_; }
+
  protected:
   LightState *state_{nullptr};
   std::string name_;
+
+  /// Internal method to find this effect's index in the parent light's effect list.
+  uint32_t get_index_in_parent_() const;
 };
 
 }  // namespace light

esphome/components/light/light_json_schema.cpp

@@ -36,8 +36,11 @@ static constexpr const char *get_color_mode_json_str(ColorMode mode) {
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  if (state.supports_effects())
+  if (state.supports_effects()) {
     root["effect"] = state.get_effect_name();
+    root["effect_index"] = state.get_current_effect_index();
+    root["effect_count"] = state.get_effect_count();
+  }
 
   auto values = state.remote_values;
   auto traits = state.get_output()->get_traits();
@@ -160,6 +163,11 @@ void LightJSONSchema::parse_json(LightState &state, LightCall &call, JsonObject
     const char *effect = root["effect"];
     call.set_effect(effect);
   }
+
+  if (root["effect_index"].is<uint32_t>()) {
+    uint32_t effect_index = root["effect_index"];
+    call.set_effect(effect_index);
+  }
 }
 
 }  // namespace light