esphome 2024.9.2__py3-none-any.whl → 2024.10.0b1__py3-none-any.whl

esphome/components/haier/switch/__init__.py

@@ -0,0 +1,91 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+import esphome.final_validate as fv
+from esphome.components import switch
+from esphome.const import (
+    CONF_BEEPER,
+    CONF_DISPLAY,
+    ENTITY_CATEGORY_CONFIG,
+)
+from ..climate import (
+    CONF_HAIER_ID,
+    CONF_PROTOCOL,
+    HaierClimateBase,
+    haier_ns,
+    PROTOCOL_HON,
+)
+
+CODEOWNERS = ["@paveldn"]
+BeeperSwitch = haier_ns.class_("BeeperSwitch", switch.Switch)
+HealthModeSwitch = haier_ns.class_("HealthModeSwitch", switch.Switch)
+DisplaySwitch = haier_ns.class_("DisplaySwitch", switch.Switch)
+QuietModeSwitch = haier_ns.class_("QuietModeSwitch", switch.Switch)
+
+# Haier switches
+CONF_HEALTH_MODE = "health_mode"
+CONF_QUIET_MODE = "quiet_mode"
+
+# Additional icons
+ICON_LEAF = "mdi:leaf"
+ICON_LED_ON = "mdi:led-on"
+ICON_VOLUME_HIGH = "mdi:volume-high"
+ICON_VOLUME_OFF = "mdi:volume-off"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_HAIER_ID): cv.use_id(HaierClimateBase),
+        cv.Optional(CONF_DISPLAY): switch.switch_schema(
+            DisplaySwitch,
+            icon=ICON_LED_ON,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            default_restore_mode="DISABLED",
+        ),
+        cv.Optional(CONF_HEALTH_MODE): switch.switch_schema(
+            HealthModeSwitch,
+            icon=ICON_LEAF,
+            default_restore_mode="DISABLED",
+        ),
+        # Beeper switch is only supported for HonClimate
+        cv.Optional(CONF_BEEPER): switch.switch_schema(
+            BeeperSwitch,
+            icon=ICON_VOLUME_HIGH,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            default_restore_mode="DISABLED",
+        ),
+        # Quiet mode is only supported for HonClimate
+        cv.Optional(CONF_QUIET_MODE): switch.switch_schema(
+            QuietModeSwitch,
+            icon=ICON_VOLUME_OFF,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            default_restore_mode="DISABLED",
+        ),
+    }
+)
+
+
+def _final_validate(config):
+    full_config = fv.full_config.get()
+    for switch_type in [CONF_BEEPER, CONF_QUIET_MODE]:
+        # Check switches that are only supported for HonClimate
+        if config.get(switch_type):
+            climate_path = full_config.get_path_for_id(config[CONF_HAIER_ID])[:-1]
+            climate_conf = full_config.get_config_for_path(climate_path)
+            protocol_type = climate_conf.get(CONF_PROTOCOL)
+            if protocol_type.casefold() != PROTOCOL_HON.casefold():
+                raise cv.Invalid(
+                    f"{switch_type} switch is only supported for hon climate"
+                )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    parent = await cg.get_variable(config[CONF_HAIER_ID])
+
+    for switch_type in [CONF_DISPLAY, CONF_HEALTH_MODE, CONF_BEEPER, CONF_QUIET_MODE]:
+        if conf := config.get(switch_type):
+            sw_var = await switch.new_switch(conf)
+            await cg.register_parented(sw_var, parent)
+            cg.add(getattr(parent, f"set_{switch_type}_switch")(sw_var))

esphome/components/haier/switch/beeper.cpp

@@ -0,0 +1,14 @@
+#include "beeper.h"
+
+namespace esphome {
+namespace haier {
+
+void BeeperSwitch::write_state(bool state) {
+  if (this->parent_->get_beeper_state() != state) {
+    this->parent_->set_beeper_state(state);
+  }
+  this->publish_state(state);
+}
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/beeper.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../hon_climate.h"
+
+namespace esphome {
+namespace haier {
+
+class BeeperSwitch : public switch_::Switch, public Parented<HonClimate> {
+ public:
+  BeeperSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/display.cpp

@@ -0,0 +1,14 @@
+#include "display.h"
+
+namespace esphome {
+namespace haier {
+
+void DisplaySwitch::write_state(bool state) {
+  if (this->parent_->get_display_state() != state) {
+    this->parent_->set_display_state(state);
+  }
+  this->publish_state(state);
+}
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/display.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../haier_base.h"
+
+namespace esphome {
+namespace haier {
+
+class DisplaySwitch : public switch_::Switch, public Parented<HaierClimateBase> {
+ public:
+  DisplaySwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/health_mode.cpp

@@ -0,0 +1,14 @@
+#include "health_mode.h"
+
+namespace esphome {
+namespace haier {
+
+void HealthModeSwitch::write_state(bool state) {
+  if (this->parent_->get_health_mode() != state) {
+    this->parent_->set_health_mode(state);
+  }
+  this->publish_state(state);
+}
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/health_mode.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../haier_base.h"
+
+namespace esphome {
+namespace haier {
+
+class HealthModeSwitch : public switch_::Switch, public Parented<HaierClimateBase> {
+ public:
+  HealthModeSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/quiet_mode.cpp

@@ -0,0 +1,14 @@
+#include "quiet_mode.h"
+
+namespace esphome {
+namespace haier {
+
+void QuietModeSwitch::write_state(bool state) {
+  if (this->parent_->get_quiet_mode_state() != state) {
+    this->parent_->set_quiet_mode_state(state);
+  }
+  this->publish_state(state);
+}
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/switch/quiet_mode.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../hon_climate.h"
+
+namespace esphome {
+namespace haier {
+
+class QuietModeSwitch : public switch_::Switch, public Parented<HonClimate> {
+ public:
+  QuietModeSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/hmac_md5/hmac_md5.cpp

@@ -1,6 +1,7 @@
 #include <cstdio>
 #include <cstring>
 #include "hmac_md5.h"
+#ifdef USE_MD5
 #include "esphome/core/helpers.h"
 
 namespace esphome {
@@ -54,3 +55,4 @@ bool HmacMD5::equals_hex(const char *expected) { return this->ohash_.equals_hex(
 
 }  // namespace hmac_md5
 }  // namespace esphome
+#endif

esphome/components/hmac_md5/hmac_md5.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "esphome/core/defines.h"
+#ifdef USE_MD5
 #include "esphome/components/md5/md5.h"
-
 #include <string>
 
 namespace esphome {
@@ -46,3 +46,4 @@ class HmacMD5 {
 
 }  // namespace hmac_md5
 }  // namespace esphome
+#endif

esphome/components/i2s_audio/speaker/__init__.py

@@ -25,6 +25,7 @@ I2SAudioSpeaker = i2s_audio_ns.class_(
 
 
 CONF_DAC_TYPE = "dac_type"
+CONF_I2S_COMM_FMT = "i2s_comm_fmt"
 
 i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
 INTERNAL_DAC_OPTIONS = {
@@ -33,6 +34,20 @@ INTERNAL_DAC_OPTIONS = {
     CONF_STEREO: i2s_dac_mode_t.I2S_DAC_CHANNEL_BOTH_EN,
 }
 
+i2s_comm_format_t = cg.global_ns.enum("i2s_comm_format_t")
+I2C_COMM_FMT_OPTIONS = {
+    "stand_i2s": i2s_comm_format_t.I2S_COMM_FORMAT_STAND_I2S,
+    "stand_msb": i2s_comm_format_t.I2S_COMM_FORMAT_STAND_MSB,
+    "stand_pcm_short": i2s_comm_format_t.I2S_COMM_FORMAT_STAND_PCM_SHORT,
+    "stand_pcm_long": i2s_comm_format_t.I2S_COMM_FORMAT_STAND_PCM_LONG,
+    "stand_max": i2s_comm_format_t.I2S_COMM_FORMAT_STAND_MAX,
+    "i2s_msb": i2s_comm_format_t.I2S_COMM_FORMAT_I2S_MSB,
+    "i2s_lsb": i2s_comm_format_t.I2S_COMM_FORMAT_I2S_LSB,
+    "pcm": i2s_comm_format_t.I2S_COMM_FORMAT_PCM,
+    "pcm_short": i2s_comm_format_t.I2S_COMM_FORMAT_PCM_SHORT,
+    "pcm_long": i2s_comm_format_t.I2S_COMM_FORMAT_PCM_LONG,
+}
+
 NO_INTERNAL_DAC_VARIANTS = [esp32.const.VARIANT_ESP32S2]
 
 
@@ -77,6 +92,9 @@ CONFIG_SCHEMA = cv.All(
                     cv.Required(
                         CONF_I2S_DOUT_PIN
                     ): pins.internal_gpio_output_pin_number,
+                    cv.Optional(CONF_I2S_COMM_FMT, default="stand_i2s"): cv.enum(
+                        I2C_COMM_FMT_OPTIONS, lower=True
+                    ),
                 }
             ),
         },
@@ -96,4 +114,5 @@ async def to_code(config):
         cg.add(var.set_internal_dac_mode(config[CONF_CHANNEL]))
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
+        cg.add(var.set_i2s_comm_fmt(config[CONF_I2S_COMM_FMT]))
     cg.add(var.set_timeout(config[CONF_TIMEOUT]))

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -83,7 +83,7 @@ void I2SAudioSpeaker::player_task(void *params) {
       .sample_rate = this_speaker->sample_rate_,
       .bits_per_sample = this_speaker->bits_per_sample_,
       .channel_format = this_speaker->channel_,
-      .communication_format = I2S_COMM_FORMAT_STAND_I2S,
+      .communication_format = this_speaker->i2s_comm_fmt_,
       .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
       .dma_buf_count = 8,
       .dma_buf_len = 256,

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -49,6 +49,7 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
 #if SOC_I2S_SUPPORTS_DAC
   void set_internal_dac_mode(i2s_dac_mode_t mode) { this->internal_dac_mode_ = mode; }
 #endif
+  void set_i2s_comm_fmt(i2s_comm_format_t mode) { this->i2s_comm_fmt_ = mode; }
 
   void start() override;
   void stop() override;
@@ -76,6 +77,7 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
 #if SOC_I2S_SUPPORTS_DAC
   i2s_dac_mode_t internal_dac_mode_{I2S_DAC_CHANNEL_DISABLE};
 #endif
+  i2s_comm_format_t i2s_comm_fmt_;
 };
 
 }  // namespace i2s_audio

esphome/components/ili9xxx/ili9xxx_display.h

@@ -89,6 +89,7 @@ class ILI9XXXDisplay : public display::DisplayBuffer,
 
   void dump_config() override;
   void setup() override;
+  void on_shutdown() override { this->command(ILI9XXX_SLPIN); }
 
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,

esphome/components/image/__init__.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
 
-import logging
-
 import hashlib
 import io
+import logging
 from pathlib import Path
 import re
-from magic import Magic
 
-from esphome import core
+import puremagic
+
+from esphome import core, external_files
+import esphome.codegen as cg
 from esphome.components import font
-from esphome import external_files
 import esphome.config_validation as cv
-import esphome.codegen as cg
 from esphome.const import (
     CONF_DITHER,
     CONF_FILE,
@@ -238,13 +237,12 @@ CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, IMAGE_SCHEMA)
 
 
 def load_svg_image(file: bytes, resize: tuple[int, int]):
-    # Local import only to allow "validate_pillow_installed" to run *before* importing it
-    from PIL import Image
-
-    # This import is only needed in case of SVG images; adding it
+    # Local imports only to allow "validate_pillow_installed" to run *before* importing it
+    # cairosvg is only needed in case of SVG images; adding it
     # to the top would force configurations not using SVG to also have it
     # installed for no reason.
     from cairosvg import svg2png
+    from PIL import Image
 
     if resize:
         req_width, req_height = resize
@@ -274,14 +272,16 @@ async def to_code(config):
     elif conf_file[CONF_SOURCE] == SOURCE_WEB:
         path = compute_local_image_path(conf_file).as_posix()
 
+    else:
+        raise core.EsphomeError(f"Unknown image source: {conf_file[CONF_SOURCE]}")
+
     try:
         with open(path, "rb") as f:
             file_contents = f.read()
     except Exception as e:
         raise core.EsphomeError(f"Could not load image file {path}: {e}")
 
-    mime = Magic(mime=True)
-    file_type = mime.from_buffer(file_contents)
+    file_type = puremagic.from_string(file_contents, mime=True)
 
     resize = config.get(CONF_RESIZE)
     if "svg" in file_type:

esphome/components/image/image.cpp

@@ -79,6 +79,50 @@ Color Image::get_pixel(int x, int y, Color color_on, Color color_off) const {
       return color_off;
   }
 }
+#ifdef USE_LVGL
+lv_img_dsc_t *Image::get_lv_img_dsc() {
+  // lazily construct lvgl image_dsc.
+  if (this->dsc_.data != this->data_start_) {
+    this->dsc_.data = this->data_start_;
+    this->dsc_.header.always_zero = 0;
+    this->dsc_.header.reserved = 0;
+    this->dsc_.header.w = this->width_;
+    this->dsc_.header.h = this->height_;
+    this->dsc_.data_size = image_type_to_width_stride(this->dsc_.header.w * this->dsc_.header.h, this->get_type());
+    switch (this->get_type()) {
+      case IMAGE_TYPE_BINARY:
+        this->dsc_.header.cf = LV_IMG_CF_ALPHA_1BIT;
+        break;
+
+      case IMAGE_TYPE_GRAYSCALE:
+        this->dsc_.header.cf = LV_IMG_CF_ALPHA_8BIT;
+        break;
+
+      case IMAGE_TYPE_RGB24:
+        this->dsc_.header.cf = LV_IMG_CF_RGB888;
+        break;
+
+      case IMAGE_TYPE_RGB565:
+#if LV_COLOR_DEPTH == 16
+        this->dsc_.header.cf = this->has_transparency() ? LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED : LV_IMG_CF_TRUE_COLOR;
+#else
+        this->dsc_.header.cf = LV_IMG_CF_RGB565;
+#endif
+        break;
+
+      case image::IMAGE_TYPE_RGBA:
+#if LV_COLOR_DEPTH == 32
+        this->dsc_.header.cf = LV_IMG_CF_TRUE_COLOR;
+#else
+        this->dsc_.header.cf = LV_IMG_CF_RGBA8888;
+#endif
+        break;
+    }
+  }
+  return &this->dsc_;
+}
+#endif  // USE_LVGL
+
 bool Image::get_binary_pixel_(int x, int y) const {
   const uint32_t width_8 = ((this->width_ + 7u) / 8u) * 8u;
   const uint32_t pos = x + y * width_8;

esphome/components/image/image.h

@@ -1,6 +1,15 @@
 #pragma once
 #include "esphome/core/color.h"
-#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/display/display.h"
+
+#ifdef USE_LVGL
+// required for clang-tidy
+#ifndef LV_CONF_H
+#define LV_CONF_SKIP 1  // NOLINT
+#endif                  // LV_CONF_H
+
+#include <lvgl.h>
+#endif  // USE_LVGL
 
 namespace esphome {
 namespace image {
@@ -37,7 +46,7 @@ class Image : public display::BaseImage {
   Color get_pixel(int x, int y, Color color_on = display::COLOR_ON, Color color_off = display::COLOR_OFF) const;
   int get_width() const override;
   int get_height() const override;
-  const uint8_t *get_data_start() { return this->data_start_; }
+  const uint8_t *get_data_start() const { return this->data_start_; }
   ImageType get_type() const;
 
   void draw(int x, int y, display::Display *display, Color color_on, Color color_off) override;
@@ -45,6 +54,9 @@ class Image : public display::BaseImage {
   void set_transparency(bool transparent) { transparent_ = transparent; }
   bool has_transparency() const { return transparent_; }
 
+#ifdef USE_LVGL
+  lv_img_dsc_t *get_lv_img_dsc();
+#endif
  protected:
   bool get_binary_pixel_(int x, int y) const;
   Color get_rgb24_pixel_(int x, int y) const;
@@ -57,6 +69,9 @@ class Image : public display::BaseImage {
   ImageType type_;
   const uint8_t *data_start_;
   bool transparent_;
+#ifdef USE_LVGL
+  lv_img_dsc_t dsc_{};
+#endif
 };
 
 }  // namespace image

esphome/components/inkplate6/display.py

@@ -53,6 +53,8 @@ MODELS = {
     "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(

esphome/components/inkplate6/inkplate.h

@@ -15,6 +15,8 @@ enum InkplateModel : uint8_t {
   INKPLATE_10 = 1,
   INKPLATE_6_PLUS = 2,
   INKPLATE_6_V2 = 3,
+  INKPLATE_5 = 4,
+  INKPLATE_5_V2 = 5,
 };
 
 class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
@@ -29,7 +31,7 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
   const uint8_t pixelMaskLUT[8] = {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
   const uint8_t pixelMaskGLUT[2] = {0x0F, 0xF0};
 
-  const uint8_t waveform3BitAll[4][8][9] = {// INKPLATE_6
+  const uint8_t waveform3BitAll[6][8][9] = {// INKPLATE_6
                                             {{0, 1, 1, 0, 0, 1, 1, 0, 0},
                                              {0, 1, 2, 1, 1, 2, 1, 0, 0},
                                              {1, 1, 1, 2, 2, 1, 0, 0, 0},
@@ -64,7 +66,25 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
                                              {1, 1, 1, 1, 2, 2, 1, 0, 0},
                                              {0, 1, 1, 1, 2, 2, 1, 0, 0},
                                              {0, 0, 0, 0, 1, 1, 2, 0, 0},
-                                             {0, 0, 0, 0, 0, 1, 2, 0, 0}}};
+                                             {0, 0, 0, 0, 0, 1, 2, 0, 0}},
+                                            // INKPLATE_5
+                                            {{0, 0, 1, 1, 0, 1, 1, 1, 0},
+                                             {0, 1, 1, 1, 1, 2, 0, 1, 0},
+                                             {1, 2, 2, 0, 2, 1, 1, 1, 0},
+                                             {1, 1, 1, 2, 0, 1, 1, 2, 0},
+                                             {0, 1, 1, 1, 2, 0, 1, 2, 0},
+                                             {0, 0, 0, 1, 1, 2, 1, 2, 0},
+                                             {1, 1, 1, 2, 0, 2, 1, 2, 0},
+                                             {0, 0, 0, 0, 0, 0, 0, 0, 0}},
+                                            // INKPLATE_5_V2
+                                            {{0, 0, 1, 1, 2, 1, 1, 1, 0},
+                                             {1, 1, 2, 2, 1, 2, 1, 1, 0},
+                                             {0, 1, 2, 2, 1, 1, 2, 1, 0},
+                                             {0, 0, 1, 1, 1, 1, 1, 2, 0},
+                                             {1, 2, 1, 2, 1, 1, 1, 2, 0},
+                                             {0, 1, 1, 1, 2, 0, 1, 2, 0},
+                                             {1, 1, 1, 2, 2, 2, 1, 2, 0},
+                                             {0, 0, 0, 0, 0, 0, 0, 0, 0}}};
 
   void set_greyscale(bool greyscale) {
     this->greyscale_ = greyscale;
@@ -146,6 +166,10 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
       return 800;
     } else if (this->model_ == INKPLATE_10) {
       return 1200;
+    } else if (this->model_ == INKPLATE_5) {
+      return 960;
+    } else if (this->model_ == INKPLATE_5_V2) {
+      return 1280;
     } else if (this->model_ == INKPLATE_6_PLUS) {
       return 1024;
     }
@@ -155,6 +179,10 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
   int get_height_internal() override {
     if (this->model_ == INKPLATE_6 || this->model_ == INKPLATE_6_V2) {
       return 600;
+    } else if (this->model_ == INKPLATE_5) {
+      return 540;
+    } else if (this->model_ == INKPLATE_5_V2) {
+      return 720;
     } else if (this->model_ == INKPLATE_10) {
       return 825;
     } else if (this->model_ == INKPLATE_6_PLUS) {

esphome/components/light/__init__.py

@@ -18,7 +18,7 @@ from esphome.const import (
     CONF_RESTORE_MODE,
     CONF_TRIGGER_ID,
     CONF_WARM_WHITE_COLOR_TEMPERATURE,
-    CONF_WEB_SERVER_ID,
+    CONF_WEB_SERVER,
 )
 from esphome.core import coroutine_with_priority
 from esphome.cpp_helpers import setup_entity
@@ -181,9 +181,8 @@ async def setup_light_core_(light_var, output_var, config):
         mqtt_ = cg.new_Pvariable(mqtt_id, light_var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-    if (webserver_id := config.get(CONF_WEB_SERVER_ID)) is not None:
-        web_server_ = await cg.get_variable(webserver_id)
-        web_server.add_entity_to_sorting_list(web_server_, light_var, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(light_var, web_server_config)
 
 
 async def register_light(output_var, config):

esphome/components/lock/__init__.py

@@ -9,7 +9,7 @@ from esphome.const import (
     CONF_ON_LOCK,
     CONF_ON_UNLOCK,
     CONF_TRIGGER_ID,
-    CONF_WEB_SERVER_ID,
+    CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.cpp_helpers import setup_entity
@@ -66,9 +66,8 @@ async def setup_lock_core_(var, config):
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-    if (webserver_id := config.get(CONF_WEB_SERVER_ID)) is not None:
-        web_server_ = await cg.get_variable(webserver_id)
-        web_server.add_entity_to_sorting_list(web_server_, var, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
 
 
 async def register_lock(var, config):