esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/logger/logger.h

@@ -61,7 +61,7 @@ static const char *const LOG_LEVEL_LETTERS[] = {
  *
  * Advanced configuration (pin selection, etc) is not supported.
  */
-enum UARTSelection {
+enum UARTSelection : uint8_t {
 #ifdef USE_LIBRETINY
   UART_SELECTION_DEFAULT = 0,
   UART_SELECTION_UART0,
@@ -129,10 +129,10 @@ class Logger : public Component {
 #endif
 
   /// Set the default log level for this logger.
-  void set_log_level(int level);
+  void set_log_level(uint8_t level);
   /// Set the log level of the specified tag.
-  void set_log_level(const std::string &tag, int log_level);
-  int get_log_level() { return this->current_level_; }
+  void set_log_level(const std::string &tag, uint8_t log_level);
+  uint8_t get_log_level() { return this->current_level_; }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
@@ -140,19 +140,20 @@ class Logger : public Component {
   void pre_setup();
   void dump_config() override;
 
-  inline int level_for(const char *tag);
+  inline uint8_t level_for(const char *tag);
 
   /// Register a callback that will be called for every log message sent
-  void add_on_log_callback(std::function<void(int, const char *, const char *)> &&callback);
+  void add_on_log_callback(std::function<void(uint8_t, const char *, const char *, size_t)> &&callback);
 
   // add a listener for log level changes
-  void add_listener(std::function<void(int)> &&callback) { this->level_callback_.add(std::move(callback)); }
+  void add_listener(std::function<void(uint8_t)> &&callback) { this->level_callback_.add(std::move(callback)); }
 
   float get_setup_priority() const override;
 
-  void log_vprintf_(int level, const char *tag, int line, const char *format, va_list args);  // NOLINT
+  void log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args);  // NOLINT
 #ifdef USE_STORE_LOG_STR_IN_FLASH
-  void log_vprintf_(int level, const char *tag, int line, const __FlashStringHelper *format, va_list args);  // NOLINT
+  void log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format,
+                    va_list args);  // NOLINT
 #endif
 
  protected:
@@ -160,8 +161,9 @@ class Logger : public Component {
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
   // It's the caller's responsibility to initialize buffer_at (typically to 0)
-  inline void HOT format_log_to_buffer_with_terminator_(int level, const char *tag, int line, const char *format,
-                                                        va_list args, char *buffer, int *buffer_at, int buffer_size) {
+  inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
+                                                        va_list args, char *buffer, uint16_t *buffer_at,
+                                                        uint16_t buffer_size) {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
     this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(), buffer, buffer_at, buffer_size);
 #else
@@ -180,7 +182,7 @@ class Logger : public Component {
   }
 
   // Helper to format and send a log message to both console and callbacks
-  inline void HOT log_message_to_buffer_and_send_(int level, const char *tag, int line, const char *format,
+  inline void HOT log_message_to_buffer_and_send_(uint8_t level, const char *tag, int line, const char *format,
                                                   va_list args) {
     // Format to tx_buffer and prepare for output
     this->tx_buffer_at_ = 0;  // Initialize buffer position
@@ -190,15 +192,16 @@ class Logger : public Component {
     if (this->baud_rate_ > 0) {
       this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
-    this->log_callback_.call(level, tag, this->tx_buffer_);
+    this->log_callback_.call(level, tag, this->tx_buffer_, this->tx_buffer_at_);
   }
 
   // Write the body of the log message to the buffer
-  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, int *buffer_at, int buffer_size) {
+  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, uint16_t *buffer_at,
+                                    uint16_t buffer_size) {
     // Calculate available space
-    const int available = buffer_size - *buffer_at;
-    if (available <= 0)
+    if (*buffer_at >= buffer_size)
       return;
+    const uint16_t available = buffer_size - *buffer_at;
 
     // Determine copy length (minimum of remaining capacity and string length)
     const size_t copy_len = (length < static_cast<size_t>(available)) ? length : available;
@@ -211,7 +214,7 @@ class Logger : public Component {
   }
 
   // Format string to explicit buffer with varargs
-  inline void printf_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format, ...) {
+  inline void printf_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format, ...) {
     va_list arg;
     va_start(arg, format);
     this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, arg);
@@ -222,41 +225,50 @@ class Logger : public Component {
   const char *get_uart_selection_();
 #endif
 
+  // Group 4-byte aligned members first
   uint32_t baud_rate_;
   char *tx_buffer_{nullptr};
-  int tx_buffer_at_{0};
-  int tx_buffer_size_{0};
-#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040)
-  UARTSelection uart_{UART_SELECTION_UART0};
-#endif
-#ifdef USE_LIBRETINY
-  UARTSelection uart_{UART_SELECTION_DEFAULT};
-#endif
 #ifdef USE_ARDUINO
   Stream *hw_serial_{nullptr};
 #endif
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  void *main_task_ = nullptr;  // Only used for thread name identification
+#endif
+#ifdef USE_ESP32
+  // Task-specific recursion guards:
+  // - Main task uses a dedicated member variable for efficiency
+  // - Other tasks use pthread TLS with a dynamically created key via pthread_key_create
+  pthread_key_t log_recursion_key_;  // 4 bytes
+#endif
 #ifdef USE_ESP_IDF
-  uart_port_t uart_num_;
+  uart_port_t uart_num_;  // 4 bytes (enum defaults to int size)
 #endif
-  std::map<std::string, int> log_levels_{};
-  CallbackManager<void(int, const char *, const char *)> log_callback_{};
-  int current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
+
+  // Large objects (internally aligned)
+  std::map<std::string, uint8_t> log_levels_{};
+  CallbackManager<void(uint8_t, const char *, const char *, size_t)> log_callback_{};
+  CallbackManager<void(uint8_t)> level_callback_{};
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   std::unique_ptr<logger::TaskLogBuffer> log_buffer_;  // Will be initialized with init_log_buffer
 #endif
+
+  // Group smaller types together at the end
+  uint16_t tx_buffer_at_{0};
+  uint16_t tx_buffer_size_{0};
+  uint8_t current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
+#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040)
+  UARTSelection uart_{UART_SELECTION_UART0};
+#endif
+#ifdef USE_LIBRETINY
+  UARTSelection uart_{UART_SELECTION_DEFAULT};
+#endif
 #ifdef USE_ESP32
-  // Task-specific recursion guards:
-  // - Main task uses a dedicated member variable for efficiency
-  // - Other tasks use pthread TLS with a dynamically created key via pthread_key_create
   bool main_task_recursion_guard_{false};
-  pthread_key_t log_recursion_key_;
 #else
   bool global_recursion_guard_{false};  // Simple global recursion guard for single-task platforms
 #endif
-  CallbackManager<void(int)> level_callback_{};
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  void *main_task_ = nullptr;  // Only used for thread name identification
   const char *HOT get_thread_name_() {
     TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
     if (current_task == main_task_) {
@@ -297,11 +309,10 @@ class Logger : public Component {
   }
 #endif
 
-  inline void HOT write_header_to_buffer_(int level, const char *tag, int line, const char *thread_name, char *buffer,
-                                          int *buffer_at, int buffer_size) {
+  inline void HOT write_header_to_buffer_(uint8_t level, const char *tag, int line, const char *thread_name,
+                                          char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
     // Format header
-    if (level < 0)
-      level = 0;
+    // uint8_t level is already bounded 0-255, just ensure it's <= 7
     if (level > 7)
       level = 7;
 
@@ -320,12 +331,12 @@ class Logger : public Component {
     this->printf_to_buffer_(buffer, buffer_at, buffer_size, "%s[%s][%s:%03u]: ", color, letter, tag, line);
   }
 
-  inline void HOT format_body_to_buffer_(char *buffer, int *buffer_at, int buffer_size, const char *format,
+  inline void HOT format_body_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format,
                                          va_list args) {
     // Get remaining capacity in the buffer
-    const int remaining = buffer_size - *buffer_at;
-    if (remaining <= 0)
+    if (*buffer_at >= buffer_size)
       return;
+    const uint16_t remaining = buffer_size - *buffer_at;
 
     const int ret = vsnprintf(buffer + *buffer_at, remaining, format, args);
 
@@ -334,7 +345,7 @@ class Logger : public Component {
     }
 
     // Update buffer_at with the formatted length (handle truncation)
-    int formatted_len = (ret >= remaining) ? remaining : ret;
+    uint16_t formatted_len = (ret >= remaining) ? remaining : ret;
     *buffer_at += formatted_len;
 
     // Remove all trailing newlines right after formatting
@@ -343,18 +354,38 @@ class Logger : public Component {
     }
   }
 
-  inline void HOT write_footer_to_buffer_(char *buffer, int *buffer_at, int buffer_size) {
-    static const int RESET_COLOR_LEN = strlen(ESPHOME_LOG_RESET_COLOR);
+  inline void HOT write_footer_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
+    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
     this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
   }
+
+#ifdef USE_ESP32
+  // Disable loop when task buffer is empty (with USB CDC check)
+  inline void disable_loop_when_buffer_empty_() {
+    // Thread safety note: This is safe even if another task calls enable_loop_soon_any_context()
+    // concurrently. If that happens between our check and disable_loop(), the enable request
+    // will be processed on the next main loop iteration since:
+    // - disable_loop() takes effect immediately
+    // - enable_loop_soon_any_context() sets a pending flag that's checked at loop start
+#if defined(USE_LOGGER_USB_CDC) && defined(USE_ARDUINO)
+    // Only disable if not using USB CDC (which needs loop for connection detection)
+    if (this->uart_ != UART_SELECTION_USB_CDC) {
+      this->disable_loop();
+    }
+#else
+    // No USB CDC support, always safe to disable
+    this->disable_loop();
+#endif
+  }
+#endif
 };
 extern Logger *global_logger;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-class LoggerMessageTrigger : public Trigger<int, const char *, const char *> {
+class LoggerMessageTrigger : public Trigger<uint8_t, const char *, const char *> {
  public:
-  explicit LoggerMessageTrigger(Logger *parent, int level) {
+  explicit LoggerMessageTrigger(Logger *parent, uint8_t level) {
     this->level_ = level;
-    parent->add_on_log_callback([this](int level, const char *tag, const char *message) {
+    parent->add_on_log_callback([this](uint8_t level, const char *tag, const char *message, size_t message_len) {
       if (level <= this->level_) {
         this->trigger(level, tag, message);
       }
@@ -362,7 +393,7 @@ class LoggerMessageTrigger : public Trigger<int, const char *, const char *> {
   }
 
  protected:
-  int level_;
+  uint8_t level_;
 };
 
 }  // namespace logger

esphome/components/logger/logger_esp32.cpp

@@ -83,9 +83,7 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
   uart_config.parity = UART_PARITY_DISABLE;
   uart_config.stop_bits = UART_STOP_BITS_1;
   uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
   uart_config.source_clk = UART_SCLK_DEFAULT;
-#endif
   uart_param_config(uart_num, &uart_config);
   const int uart_buffer_size = tx_buffer_size;
   // Install UART driver using an event queue here
@@ -186,7 +184,9 @@ void HOT Logger::write_msg_(const char *msg) {
   ) {
     puts(msg);
   } else {
-    uart_write_bytes(this->uart_num_, msg, strlen(msg));
+    // Use tx_buffer_at_ if msg points to tx_buffer_, otherwise fall back to strlen
+    size_t len = (msg == this->tx_buffer_) ? this->tx_buffer_at_ : strlen(msg);
+    uart_write_bytes(this->uart_num_, msg, len);
     uart_write_bytes(this->uart_num_, "\n", 1);
   }
 }

esphome/components/lps22/lps22.cpp

@@ -0,0 +1,75 @@
+#include "lps22.h"
+
+namespace esphome {
+namespace lps22 {
+
+static constexpr const char *const TAG = "lps22";
+
+static constexpr uint8_t WHO_AM_I = 0x0F;
+static constexpr uint8_t LPS22HB_ID = 0xB1;
+static constexpr uint8_t LPS22HH_ID = 0xB3;
+static constexpr uint8_t CTRL_REG2 = 0x11;
+static constexpr uint8_t CTRL_REG2_ONE_SHOT_MASK = 0b1;
+static constexpr uint8_t STATUS = 0x27;
+static constexpr uint8_t STATUS_T_DA_MASK = 0b10;
+static constexpr uint8_t STATUS_P_DA_MASK = 0b01;
+static constexpr uint8_t TEMP_L = 0x2b;
+static constexpr uint8_t PRES_OUT_XL = 0x28;
+static constexpr uint8_t REF_P_XL = 0x28;
+static constexpr uint8_t READ_ATTEMPTS = 10;
+static constexpr uint8_t READ_INTERVAL = 5;
+static constexpr float PRESSURE_SCALE = 1.0f / 4096.0f;
+static constexpr float TEMPERATURE_SCALE = 0.01f;
+
+void LPS22Component::setup() {
+  uint8_t value = 0x00;
+  this->read_register(WHO_AM_I, &value, 1);
+  if (value != LPS22HB_ID && value != LPS22HH_ID) {
+    ESP_LOGW(TAG, "device IDs as %02x, which isn't a known LPS22HB or LPS22HH ID", value);
+    this->mark_failed();
+  }
+}
+
+void LPS22Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "LPS22:");
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void LPS22Component::update() {
+  uint8_t value = 0x00;
+  this->read_register(CTRL_REG2, &value, 1);
+  value |= CTRL_REG2_ONE_SHOT_MASK;
+  this->write_register(CTRL_REG2, &value, 1);
+  this->set_retry(READ_INTERVAL, READ_ATTEMPTS, [this](uint8_t _) { return this->try_read_(); });
+}
+
+RetryResult LPS22Component::try_read_() {
+  uint8_t value = 0x00;
+  this->read_register(STATUS, &value, 1);
+  const uint8_t expected_status_mask = STATUS_T_DA_MASK | STATUS_P_DA_MASK;
+  if ((value & expected_status_mask) != expected_status_mask) {
+    ESP_LOGD(TAG, "STATUS not ready: %x", value);
+    return RetryResult::RETRY;
+  }
+
+  if (this->temperature_sensor_ != nullptr) {
+    uint8_t t_buf[2]{0};
+    this->read_register(TEMP_L, t_buf, 2);
+    int16_t encoded = static_cast<int16_t>(encode_uint16(t_buf[1], t_buf[0]));
+    float temp = TEMPERATURE_SCALE * static_cast<float>(encoded);
+    this->temperature_sensor_->publish_state(temp);
+  }
+  if (this->pressure_sensor_ != nullptr) {
+    uint8_t p_buf[3]{0};
+    this->read_register(PRES_OUT_XL, p_buf, 3);
+    uint32_t p_lsb = encode_uint24(p_buf[2], p_buf[1], p_buf[0]);
+    this->pressure_sensor_->publish_state(PRESSURE_SCALE * static_cast<float>(p_lsb));
+  }
+  return RetryResult::DONE;
+}
+
+}  // namespace lps22
+}  // namespace esphome

esphome/components/lps22/lps22.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace lps22 {
+
+class LPS22Component : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
+ public:
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
+  void set_pressure_sensor(sensor::Sensor *pressure_sensor) { this->pressure_sensor_ = pressure_sensor; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+
+ protected:
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *pressure_sensor_{nullptr};
+
+  RetryResult try_read_();
+};
+
+}  // namespace lps22
+}  // namespace esphome

esphome/components/lps22/sensor.py

@@ -0,0 +1,58 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ID,
+    CONF_TEMPERATURE,
+    CONF_PRESSURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    ICON_THERMOMETER,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+)
+
+CODEOWNERS = ["@nagisa"]
+DEPENDENCIES = ["i2c"]
+
+lps22 = cg.esphome_ns.namespace("lps22")
+
+LPS22Component = lps22.class_("LPS22Component", cg.PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(LPS22Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                icon=ICON_THERMOMETER,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x5D))  # can also be 0x5C
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))

esphome/components/ltr390/ltr390.h

@@ -44,7 +44,6 @@ enum LTR390RESOLUTION {
 
 class LTR390Component : public PollingComponent, public i2c::I2CDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/ltr501/ltr501.h

@@ -25,7 +25,6 @@ class LTRAlsPs501Component : public PollingComponent, public i2c::I2CDevice {
   //
   // EspHome framework functions
   //
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/ltr_als_ps/ltr_als_ps.h

@@ -25,7 +25,6 @@ class LTRAlsPsComponent : public PollingComponent, public i2c::I2CDevice {
   //
   // EspHome framework functions
   //
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/lvgl/__init__.py

@@ -466,7 +466,7 @@ LVGL_SCHEMA = cv.All(
                 ): lvalid.lv_color,
                 cv.Optional(df.CONF_THEME): cv.Schema(
                     {
-                        cv.Optional(name): obj_schema(w)
+                        cv.Optional(name): obj_schema(w).extend(FULL_STYLE_SCHEMA)
                         for name, w in WIDGET_TYPES.items()
                     }
                 ),

esphome/components/lvgl/schemas.py

@@ -21,7 +21,7 @@ from esphome.core.config import StartupTrigger
 from esphome.schema_extractors import SCHEMA_EXTRACT
 
 from . import defines as df, lv_validation as lvalid
-from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR
+from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR, TYPE_GRID
 from .helpers import add_lv_use, requires_component, validate_printf
 from .lv_validation import lv_color, lv_font, lv_gradient, lv_image, opacity
 from .lvcode import LvglComponent, lv_event_t_ptr
@@ -349,7 +349,60 @@ def obj_schema(widget_type: WidgetType):
     )
 
 
+def _validate_grid_layout(config):
+    layout = config[df.CONF_LAYOUT]
+    rows = len(layout[df.CONF_GRID_ROWS])
+    columns = len(layout[df.CONF_GRID_COLUMNS])
+    used_cells = [[None] * columns for _ in range(rows)]
+    for index, widget in enumerate(config[df.CONF_WIDGETS]):
+        _, w = next(iter(widget.items()))
+        if (df.CONF_GRID_CELL_COLUMN_POS in w) != (df.CONF_GRID_CELL_ROW_POS in w):
+            # pylint: disable=raise-missing-from
+            raise cv.Invalid(
+                "Both row and column positions must be specified, or both omitted",
+                [df.CONF_WIDGETS, index],
+            )
+        if df.CONF_GRID_CELL_ROW_POS in w:
+            row = w[df.CONF_GRID_CELL_ROW_POS]
+            column = w[df.CONF_GRID_CELL_COLUMN_POS]
+        else:
+            try:
+                row, column = next(
+                    (r_idx, c_idx)
+                    for r_idx, row in enumerate(used_cells)
+                    for c_idx, value in enumerate(row)
+                    if value is None
+                )
+            except StopIteration:
+                # pylint: disable=raise-missing-from
+                raise cv.Invalid(
+                    "No free cells available in grid layout", [df.CONF_WIDGETS, index]
+                )
+            w[df.CONF_GRID_CELL_ROW_POS] = row
+            w[df.CONF_GRID_CELL_COLUMN_POS] = column
+
+        for i in range(w[df.CONF_GRID_CELL_ROW_SPAN]):
+            for j in range(w[df.CONF_GRID_CELL_COLUMN_SPAN]):
+                if row + i >= rows or column + j >= columns:
+                    # pylint: disable=raise-missing-from
+                    raise cv.Invalid(
+                        f"Cell at {row}/{column} span {w[df.CONF_GRID_CELL_ROW_SPAN]}x{w[df.CONF_GRID_CELL_COLUMN_SPAN]} "
+                        f"exceeds grid size {rows}x{columns}",
+                        [df.CONF_WIDGETS, index],
+                    )
+                if used_cells[row + i][column + j] is not None:
+                    # pylint: disable=raise-missing-from
+                    raise cv.Invalid(
+                        f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
+                        [df.CONF_WIDGETS, index],
+                    )
+                used_cells[row + i][column + j] = index
+
+    return config
+
+
 LAYOUT_SCHEMAS = {}
+LAYOUT_VALIDATORS = {TYPE_GRID: _validate_grid_layout}
 
 ALIGN_TO_SCHEMA = {
     cv.Optional(df.CONF_ALIGN_TO): cv.Schema(
@@ -402,8 +455,8 @@ LAYOUT_SCHEMA = {
 }
 
 GRID_CELL_SCHEMA = {
-    cv.Required(df.CONF_GRID_CELL_ROW_POS): cv.positive_int,
-    cv.Required(df.CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
+    cv.Optional(df.CONF_GRID_CELL_ROW_POS): cv.positive_int,
+    cv.Optional(df.CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_ROW_SPAN, default=1): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_COLUMN_SPAN, default=1): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_X_ALIGN): grid_alignments,
@@ -454,9 +507,13 @@ def container_validator(schema, widget_type: WidgetType):
     """
 
     def validator(value):
-        result = schema
         if w_sch := widget_type.schema:
-            result = result.extend(w_sch)
+            if isinstance(w_sch, dict):
+                w_sch = cv.Schema(w_sch)
+            # order is important here to preserve extras
+            result = w_sch.extend(schema)
+        else:
+            result = schema
         ltype = df.TYPE_NONE
         if value and (layout := value.get(df.CONF_LAYOUT)):
             if not isinstance(layout, dict):
@@ -470,7 +527,10 @@ def container_validator(schema, widget_type: WidgetType):
         result = result.extend(
             LAYOUT_SCHEMAS.get(ltype.lower(), LAYOUT_SCHEMAS[df.TYPE_NONE])
         )
-        return result(value)
+        value = result(value)
+        if layout_validator := LAYOUT_VALIDATORS.get(ltype):
+            value = layout_validator(value)
+        return value
 
     return validator
 

esphome/components/lvgl/styles.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.core import ID
-from esphome.cpp_generator import MockObj
 
 from .defines import (
     CONF_STYLE_DEFINITIONS,
@@ -13,12 +12,13 @@ from .defines import (
     literal,
 )
 from .helpers import add_lv_use
-from .lvcode import LambdaContext, LocalVariable, lv, lv_assign, lv_variable
+from .lvcode import LambdaContext, LocalVariable, lv
 from .schemas import ALL_STYLES, FULL_STYLE_SCHEMA, STYLE_REMAP
-from .types import ObjUpdateAction, lv_lambda_t, lv_obj_t, lv_obj_t_ptr, lv_style_t
+from .types import ObjUpdateAction, lv_obj_t, lv_style_t
 from .widgets import (
     Widget,
     add_widgets,
+    collect_parts,
     set_obj_properties,
     theme_widget_map,
     wait_for_widgets,
@@ -37,12 +37,18 @@ async def style_set(svar, style):
             lv.call(f"style_set_{remapped_prop}", svar, literal(value))
 
 
+async def create_style(style, id_name):
+    style_id = ID(id_name, True, lv_style_t)
+    svar = cg.new_Pvariable(style_id)
+    lv.style_init(svar)
+    await style_set(svar, style)
+    return svar
+
+
 async def styles_to_code(config):
     """Convert styles to C__ code."""
     for style in config.get(CONF_STYLE_DEFINITIONS, ()):
-        svar = cg.new_Pvariable(style[CONF_ID])
-        lv.style_init(svar)
-        await style_set(svar, style)
+        await create_style(style, style[CONF_ID].id)
 
 
 @automation.register_action(
@@ -68,16 +74,18 @@ async def theme_to_code(config):
     if theme := config.get(CONF_THEME):
         add_lv_use(CONF_THEME)
         for w_name, style in theme.items():
-            if not isinstance(style, dict):
-                continue
-
-            lname = "lv_theme_apply_" + w_name
-            apply = lv_variable(lv_lambda_t, lname)
-            theme_widget_map[w_name] = apply
-            ow = Widget.create("obj", MockObj(ID("obj")), obj_spec)
-            async with LambdaContext([(lv_obj_t_ptr, "obj")], where=w_name) as context:
-                await set_obj_properties(ow, style)
-            lv_assign(apply, await context.get_lambda())
+            # Work around Python 3.10 bug with nested async comprehensions
+            # With Python 3.11 this could be simplified
+            styles = {}
+            for part, states in collect_parts(style).items():
+                styles[part] = {
+                    state: await create_style(
+                        props,
+                        "_lv_theme_style_" + w_name + "_" + part + "_" + state,
+                    )
+                    for state, props in states.items()
+                }
+            theme_widget_map[w_name] = styles
 
 
 async def add_top_layer(lv_component, config):