esphome 2025.5.2__py3-none-any.whl → 2025.6.0__py3-none-any.whl

esphome/components/logger/logger_esp32.cpp

@@ -18,12 +18,12 @@
 #endif
 #endif
 
-#include "freertos/FreeRTOS.h"
 #include "esp_idf_version.h"
+#include "freertos/FreeRTOS.h"
 
+#include <fcntl.h>
 #include <cstdint>
 #include <cstdio>
-#include <fcntl.h>
 
 #endif  // USE_ESP_IDF
 
@@ -174,11 +174,11 @@ void Logger::pre_setup() {
 #ifdef USE_ESP_IDF
 void HOT Logger::write_msg_(const char *msg) {
   if (
-#if defined(USE_ESP32_VARIANT_ESP32S2)
+#if defined(USE_LOGGER_USB_CDC) && !defined(USE_LOGGER_USB_SERIAL_JTAG)
       this->uart_ == UART_SELECTION_USB_CDC
-#elif defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
+#elif defined(USE_LOGGER_USB_SERIAL_JTAG) && !defined(USE_LOGGER_USB_CDC)
       this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
-#elif defined(USE_ESP32_VARIANT_ESP32S3)
+#elif defined(USE_LOGGER_USB_CDC) && defined(USE_LOGGER_USB_SERIAL_JTAG)
       this->uart_ == UART_SELECTION_USB_CDC || this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
 #else
       /* DISABLES CODE */ (false)  // NOLINT

esphome/components/ltr390/ltr390.cpp

@@ -148,7 +148,7 @@ void LTR390Component::read_mode_(int mode_index) {
 }
 
 void LTR390Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ltr390...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // reset
   std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
@@ -187,10 +187,13 @@ void LTR390Component::setup() {
 
 void LTR390Component::dump_config() {
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  ALS Gain: X%.0f", GAINVALUES[this->gain_als_]);
-  ESP_LOGCONFIG(TAG, "  ALS Resolution: %u-bit", RESOLUTION_BITS[this->res_als_]);
-  ESP_LOGCONFIG(TAG, "  UV Gain: X%.0f", GAINVALUES[this->gain_uv_]);
-  ESP_LOGCONFIG(TAG, "  UV Resolution: %u-bit", RESOLUTION_BITS[this->res_uv_]);
+  ESP_LOGCONFIG(TAG,
+                "  ALS Gain: X%.0f\n"
+                "  ALS Resolution: %u-bit\n"
+                "  UV Gain: X%.0f\n"
+                "  UV Resolution: %u-bit",
+                GAINVALUES[this->gain_als_], RESOLUTION_BITS[this->res_als_], GAINVALUES[this->gain_uv_],
+                RESOLUTION_BITS[this->res_uv_]);
 }
 
 void LTR390Component::update() {

esphome/components/ltr501/ltr501.cpp

@@ -1,7 +1,7 @@
 #include "ltr501.h"
 #include "esphome/core/application.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 using esphome::i2c::ErrorCode;
 
@@ -74,7 +74,7 @@ static float get_ps_gain_coeff(PsGain501 gain) {
 }
 
 void LTRAlsPs501Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up LTR-501/301/558");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // As per datasheet we need to wait at least 100ms after power on to get ALS chip responsive
   this->set_timeout(100, [this]() { this->state_ = State::DELAYED_SETUP; });
 }
@@ -94,16 +94,21 @@ void LTRAlsPs501Component::dump_config() {
   };
 
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  Device type: %s", get_device_type(this->ltr_type_));
-  ESP_LOGCONFIG(TAG, "  Automatic mode: %s", ONOFF(this->automatic_mode_enabled_));
-  ESP_LOGCONFIG(TAG, "  Gain: %.0fx", get_gain_coeff(this->gain_));
-  ESP_LOGCONFIG(TAG, "  Integration time: %d ms", get_itime_ms(this->integration_time_));
-  ESP_LOGCONFIG(TAG, "  Measurement repeat rate: %d ms", get_meas_time_ms(this->repeat_rate_));
-  ESP_LOGCONFIG(TAG, "  Glass attenuation factor: %f", this->glass_attenuation_factor_);
-  ESP_LOGCONFIG(TAG, "  Proximity gain: %.0fx", get_ps_gain_coeff(this->ps_gain_));
-  ESP_LOGCONFIG(TAG, "  Proximity cooldown time: %d s", this->ps_cooldown_time_s_);
-  ESP_LOGCONFIG(TAG, "  Proximity high threshold: %d", this->ps_threshold_high_);
-  ESP_LOGCONFIG(TAG, "  Proximity low threshold: %d", this->ps_threshold_low_);
+  ESP_LOGCONFIG(TAG,
+                "  Device type: %s\n"
+                "  Automatic mode: %s\n"
+                "  Gain: %.0fx\n"
+                "  Integration time: %d ms\n"
+                "  Measurement repeat rate: %d ms\n"
+                "  Glass attenuation factor: %f\n"
+                "  Proximity gain: %.0fx\n"
+                "  Proximity cooldown time: %d s\n"
+                "  Proximity high threshold: %d\n"
+                "  Proximity low threshold: %d",
+                get_device_type(this->ltr_type_), ONOFF(this->automatic_mode_enabled_), get_gain_coeff(this->gain_),
+                get_itime_ms(this->integration_time_), get_meas_time_ms(this->repeat_rate_),
+                this->glass_attenuation_factor_, get_ps_gain_coeff(this->ps_gain_), this->ps_cooldown_time_s_,
+                this->ps_threshold_high_, this->ps_threshold_low_);
 
   LOG_UPDATE_INTERVAL(this);
 
@@ -113,7 +118,7 @@ void LTRAlsPs501Component::dump_config() {
   LOG_SENSOR("  ", "Actual gain", this->actual_gain_sensor_);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with I2C LTR-501/301/558 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 
@@ -306,7 +311,7 @@ void LTRAlsPs501Component::configure_als_() {
 
   uint8_t tries = MAX_TRIES;
   do {
-    ESP_LOGV(TAG, "Waiting for ALS device to become active...");
+    ESP_LOGV(TAG, "Waiting for ALS device to become active");
     delay(2);
     als_ctrl.raw = this->reg((uint8_t) CommandRegisters::ALS_CONTR).get();
   } while (!als_ctrl.als_mode_active && tries--);  // while active mode is not set - keep waiting

esphome/components/ltr_als_ps/ltr_als_ps.cpp

@@ -1,7 +1,7 @@
 #include "ltr_als_ps.h"
 #include "esphome/core/application.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 using esphome::i2c::ErrorCode;
 
@@ -63,7 +63,7 @@ static float get_ps_gain_coeff(PsGain gain) {
 }
 
 void LTRAlsPsComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up LTR-303/329/55x/659");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // As per datasheet we need to wait at least 100ms after power on to get ALS chip responsive
   this->set_timeout(100, [this]() { this->state_ = State::DELAYED_SETUP; });
 }
@@ -85,27 +85,34 @@ void LTRAlsPsComponent::dump_config() {
   LOG_I2C_DEVICE(this);
   ESP_LOGCONFIG(TAG, "  Device type: %s", get_device_type(this->ltr_type_));
   if (this->is_als_()) {
-    ESP_LOGCONFIG(TAG, "  Automatic mode: %s", ONOFF(this->automatic_mode_enabled_));
-    ESP_LOGCONFIG(TAG, "  Gain: %.0fx", get_gain_coeff(this->gain_));
-    ESP_LOGCONFIG(TAG, "  Integration time: %d ms", get_itime_ms(this->integration_time_));
-    ESP_LOGCONFIG(TAG, "  Measurement repeat rate: %d ms", get_meas_time_ms(this->repeat_rate_));
-    ESP_LOGCONFIG(TAG, "  Glass attenuation factor: %f", this->glass_attenuation_factor_);
+    ESP_LOGCONFIG(TAG,
+                  "  Automatic mode: %s\n"
+                  "  Gain: %.0fx\n"
+                  "  Integration time: %d ms\n"
+                  "  Measurement repeat rate: %d ms\n"
+                  "  Glass attenuation factor: %f",
+                  ONOFF(this->automatic_mode_enabled_), get_gain_coeff(this->gain_),
+                  get_itime_ms(this->integration_time_), get_meas_time_ms(this->repeat_rate_),
+                  this->glass_attenuation_factor_);
     LOG_SENSOR("  ", "ALS calculated lux", this->ambient_light_sensor_);
     LOG_SENSOR("  ", "CH1 Infrared counts", this->infrared_counts_sensor_);
     LOG_SENSOR("  ", "CH0 Visible+IR counts", this->full_spectrum_counts_sensor_);
     LOG_SENSOR("  ", "Actual gain", this->actual_gain_sensor_);
   }
   if (this->is_ps_()) {
-    ESP_LOGCONFIG(TAG, "  Proximity gain: %.0fx", get_ps_gain_coeff(this->ps_gain_));
-    ESP_LOGCONFIG(TAG, "  Proximity cooldown time: %d s", this->ps_cooldown_time_s_);
-    ESP_LOGCONFIG(TAG, "  Proximity high threshold: %d", this->ps_threshold_high_);
-    ESP_LOGCONFIG(TAG, "  Proximity low threshold: %d", this->ps_threshold_low_);
+    ESP_LOGCONFIG(TAG,
+                  "  Proximity gain: %.0fx\n"
+                  "  Proximity cooldown time: %d s\n"
+                  "  Proximity high threshold: %d\n"
+                  "  Proximity low threshold: %d",
+                  get_ps_gain_coeff(this->ps_gain_), this->ps_cooldown_time_s_, this->ps_threshold_high_,
+                  this->ps_threshold_low_);
     LOG_SENSOR("  ", "Proximity counts", this->proximity_counts_sensor_);
   }
   LOG_UPDATE_INTERVAL(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with I2C LTR-303/329/55x/659 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 
@@ -298,7 +305,7 @@ void LTRAlsPsComponent::configure_als_() {
 
   uint8_t tries = MAX_TRIES;
   do {
-    ESP_LOGV(TAG, "Waiting for device to become active...");
+    ESP_LOGV(TAG, "Waiting for device to become active");
     delay(2);
     als_ctrl.raw = this->reg((uint8_t) CommandRegisters::ALS_CONTR).get();
   } while (!als_ctrl.active_mode && tries--);  // while active mode is not set - keep waiting

esphome/components/lvgl/__init__.py

@@ -321,7 +321,7 @@ async def to_code(configs):
             frac = 2
         elif frac > 0.19:
             frac = 4
-        else:
+        elif frac != 0:
             frac = 8
         displays = [
             await cg.get_variable(display) for display in config[df.CONF_DISPLAYS]
@@ -422,7 +422,7 @@ LVGL_SCHEMA = cv.All(
                 ): lvalid.lv_font,
                 cv.Optional(df.CONF_FULL_REFRESH, default=False): cv.boolean,
                 cv.Optional(CONF_DRAW_ROUNDING, default=2): cv.positive_int,
-                cv.Optional(CONF_BUFFER_SIZE, default="100%"): cv.percentage,
+                cv.Optional(CONF_BUFFER_SIZE, default=0): cv.percentage,
                 cv.Optional(df.CONF_LOG_LEVEL, default="WARN"): cv.one_of(
                     *df.LV_LOG_LEVELS, upper=True
                 ),

esphome/components/lvgl/automation.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
@@ -20,7 +21,7 @@ from .defines import (
     literal,
     static_cast,
 )
-from .lv_validation import lv_bool, lv_color, lv_image, opacity
+from .lv_validation import lv_bool, lv_color, lv_image, lv_milliseconds, opacity
 from .lvcode import (
     LVGL_COMP_ARG,
     UPDATE_EVENT,
@@ -128,14 +129,14 @@ async def lvgl_is_paused(config, condition_id, template_arg, args):
     LVGL_SCHEMA.extend(
         {
             cv.Required(CONF_TIMEOUT): cv.templatable(
-                cv.positive_time_period_milliseconds
+                lv_milliseconds,
             )
         }
     ),
 )
 async def lvgl_is_idle(config, condition_id, template_arg, args):
     lvgl = config[CONF_LVGL_ID]
-    timeout = await cg.templatable(config[CONF_TIMEOUT], [], cg.uint32)
+    timeout = await lv_milliseconds.process(config[CONF_TIMEOUT])
     async with LambdaContext(LVGL_COMP_ARG, return_type=cg.bool_) as context:
         lv_add(ReturnStatement(lvgl_comp.is_idle(timeout)))
     var = cg.new_Pvariable(

esphome/components/lvgl/defines.py

@@ -519,8 +519,6 @@ CONF_UPDATE_ON_RELEASE = "update_on_release"
 CONF_VISIBLE_ROW_COUNT = "visible_row_count"
 CONF_WIDGET = "widget"
 CONF_WIDGETS = "widgets"
-CONF_X = "x"
-CONF_Y = "y"
 CONF_ZOOM = "zoom"
 
 # Keypad keys

esphome/components/lvgl/lv_validation.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 import esphome.codegen as cg
 from esphome.components import image
 from esphome.components.color import CONF_HEX, ColorStruct, from_rgbw
@@ -361,7 +359,7 @@ lv_image_list = LValidator(
 lv_bool = LValidator(cv.boolean, cg.bool_, retmapper=literal)
 
 
-def lv_pct(value: Union[int, float]):
+def lv_pct(value: int | float):
     if isinstance(value, float):
         value = int(value * 100)
     return literal(f"lv_pct({value})")

esphome/components/lvgl/lvcode.py

@@ -1,5 +1,4 @@
 import abc
-from typing import Union
 
 from esphome import codegen as cg
 from esphome.config import Config
@@ -75,7 +74,7 @@ class CodeContext(abc.ABC):
     code_context = None
 
     @abc.abstractmethod
-    def add(self, expression: Union[Expression, Statement]):
+    def add(self, expression: Expression | Statement):
         pass
 
     @staticmethod
@@ -89,13 +88,13 @@ class CodeContext(abc.ABC):
         CodeContext.append(RawStatement("}"))
 
     @staticmethod
-    def append(expression: Union[Expression, Statement]):
+    def append(expression: Expression | Statement):
         if CodeContext.code_context is not None:
             CodeContext.code_context.add(expression)
         return expression
 
     def __init__(self):
-        self.previous: Union[CodeContext | None] = None
+        self.previous: CodeContext | None = None
         self.indent_level = 0
 
     async def __aenter__(self):
@@ -121,7 +120,7 @@ class MainContext(CodeContext):
     Code generation into the main() function
     """
 
-    def add(self, expression: Union[Expression, Statement]):
+    def add(self, expression: Expression | Statement):
         return cg.add(self.indented_statement(expression))
 
 
@@ -144,7 +143,7 @@ class LambdaContext(CodeContext):
         self.capture = capture
         self.where = where
 
-    def add(self, expression: Union[Expression, Statement]):
+    def add(self, expression: Expression | Statement):
         self.code_list.append(self.indented_statement(expression))
         return expression
 
@@ -186,7 +185,7 @@ class LvContext(LambdaContext):
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await super().__aexit__(exc_type, exc_val, exc_tb)
 
-    def add(self, expression: Union[Expression, Statement]):
+    def add(self, expression: Expression | Statement):
         cg.add(expression)
         return expression
 
@@ -303,7 +302,7 @@ lvgl_static = MockObj("LvglComponent", "::")
 
 
 # equivalent to cg.add() for the current code context
-def lv_add(expression: Union[Expression, Statement]):
+def lv_add(expression: Expression | Statement):
     return CodeContext.append(expression)
 
 

esphome/components/lvgl/lvgl_esphome.cpp

@@ -1,7 +1,7 @@
 #include "esphome/core/defines.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "lvgl_hal.h"
 #include "lvgl_esphome.h"
 
@@ -11,6 +11,8 @@ namespace esphome {
 namespace lvgl {
 static const char *const TAG = "lvgl";
 
+static const size_t MIN_BUFFER_FRAC = 8;
+
 static const char *const EVENT_NAMES[] = {
     "NONE",
     "PRESSED",
@@ -83,10 +85,14 @@ static void rounder_cb(lv_disp_drv_t *disp_drv, lv_area_t *area) {
 lv_event_code_t lv_api_event;     // NOLINT
 lv_event_code_t lv_update_event;  // NOLINT
 void LvglComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "LVGL:");
-  ESP_LOGCONFIG(TAG, "  Display width/height: %d x %d", this->disp_drv_.hor_res, this->disp_drv_.ver_res);
-  ESP_LOGCONFIG(TAG, "  Rotation: %d", this->rotation);
-  ESP_LOGCONFIG(TAG, "  Draw rounding: %d", (int) this->draw_rounding);
+  ESP_LOGCONFIG(TAG,
+                "LVGL:\n"
+                "  Display width/height: %d x %d\n"
+                "  Buffer size: %zu%%\n"
+                "  Rotation: %d\n"
+                "  Draw rounding: %d",
+                this->disp_drv_.hor_res, this->disp_drv_.ver_res, 100 / this->buffer_frac_, this->rotation,
+                (int) this->draw_rounding);
 }
 void LvglComponent::set_paused(bool paused, bool show_snow) {
   this->paused_ = paused;
@@ -432,18 +438,28 @@ void LvglComponent::setup() {
   auto *display = this->displays_[0];
   auto width = display->get_width();
   auto height = display->get_height();
-  size_t buffer_pixels = width * height / this->buffer_frac_;
+  auto frac = this->buffer_frac_;
+  if (frac == 0)
+    frac = 1;
+  size_t buffer_pixels = width * height / frac;
   auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
   void *buffer = nullptr;
-  if (this->buffer_frac_ >= 4)
+  if (this->buffer_frac_ >= MIN_BUFFER_FRAC / 2)
     buffer = malloc(buf_bytes);  // NOLINT
   if (buffer == nullptr)
     buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
+  // if specific buffer size not set and can't get 100%, try for a smaller one
+  if (buffer == nullptr && this->buffer_frac_ == 0) {
+    frac = MIN_BUFFER_FRAC;
+    buffer_pixels /= MIN_BUFFER_FRAC;
+    buffer = lv_custom_mem_alloc(buf_bytes / MIN_BUFFER_FRAC);  // NOLINT
+  }
   if (buffer == nullptr) {
-    this->mark_failed();
     this->status_set_error("Memory allocation failure");
+    this->mark_failed();
     return;
   }
+  this->buffer_frac_ = frac;
   lv_disp_draw_buf_init(&this->draw_buf_, buffer, nullptr, buffer_pixels);
   this->disp_drv_.hor_res = width;
   this->disp_drv_.ver_res = height;
@@ -453,8 +469,8 @@ void LvglComponent::setup() {
   if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
     this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(buf_bytes));  // NOLINT
     if (this->rotate_buf_ == nullptr) {
-      this->mark_failed();
       this->status_set_error("Memory allocation failure");
+      this->mark_failed();
       return;
     }
   }

esphome/components/lvgl/schemas.py

@@ -13,13 +13,15 @@ from esphome.const import (
     CONF_TIME,
     CONF_TRIGGER_ID,
     CONF_TYPE,
+    CONF_X,
+    CONF_Y,
 )
 from esphome.core import TimePeriod
 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, CONF_X, CONF_Y, LV_GRAD_DIR
+from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR
 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
@@ -261,11 +263,13 @@ FLAG_LIST = cv.ensure_list(df.LvConstant("LV_OBJ_FLAG_", *df.OBJ_FLAGS).one_of)
 def part_schema(parts):
     """
     Generate a schema for the various parts (e.g. main:, indicator:) of a widget type
-    :param parts:  The parts to include in the schema
+    :param parts:  The parts to include
     :return: The schema
     """
-    return cv.Schema({cv.Optional(part): STATE_SCHEMA for part in parts}).extend(
-        STATE_SCHEMA
+    return (
+        cv.Schema({cv.Optional(part): STATE_SCHEMA for part in parts})
+        .extend(STATE_SCHEMA)
+        .extend(FLAG_SCHEMA)
     )
 
 
@@ -302,22 +306,18 @@ def base_update_schema(widget_type, parts):
     :param parts:  The allowable parts to specify
     :return:
     """
-    return (
-        part_schema(parts)
-        .extend(
-            {
-                cv.Required(CONF_ID): cv.ensure_list(
-                    cv.maybe_simple_value(
-                        {
-                            cv.Required(CONF_ID): cv.use_id(widget_type),
-                        },
-                        key=CONF_ID,
-                    )
-                ),
-                cv.Optional(CONF_STATE): SET_STATE_SCHEMA,
-            }
-        )
-        .extend(FLAG_SCHEMA)
+    return part_schema(parts).extend(
+        {
+            cv.Required(CONF_ID): cv.ensure_list(
+                cv.maybe_simple_value(
+                    {
+                        cv.Required(CONF_ID): cv.use_id(widget_type),
+                    },
+                    key=CONF_ID,
+                )
+            ),
+            cv.Optional(CONF_STATE): SET_STATE_SCHEMA,
+        }
     )
 
 
@@ -335,7 +335,6 @@ def obj_schema(widget_type: WidgetType):
     """
     return (
         part_schema(widget_type.parts)
-        .extend(FLAG_SCHEMA)
         .extend(LAYOUT_SCHEMA)
         .extend(ALIGN_TO_SCHEMA)
         .extend(automation_schema(widget_type.w_type))
@@ -357,8 +356,8 @@ ALIGN_TO_SCHEMA = {
         {
             cv.Required(CONF_ID): cv.use_id(lv_obj_t),
             cv.Required(df.CONF_ALIGN): df.ALIGN_ALIGNMENTS.one_of,
-            cv.Optional(df.CONF_X, default=0): lvalid.pixels_or_percent,
-            cv.Optional(df.CONF_Y, default=0): lvalid.pixels_or_percent,
+            cv.Optional(CONF_X, default=0): lvalid.pixels_or_percent,
+            cv.Optional(CONF_Y, default=0): lvalid.pixels_or_percent,
         }
     )
 }

esphome/components/lvgl/trigger.py

@@ -1,12 +1,17 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.const import CONF_ID, CONF_ON_BOOT, CONF_ON_VALUE, CONF_TRIGGER_ID
+from esphome.const import (
+    CONF_ID,
+    CONF_ON_BOOT,
+    CONF_ON_VALUE,
+    CONF_TRIGGER_ID,
+    CONF_X,
+    CONF_Y,
+)
 
 from .defines import (
     CONF_ALIGN,
     CONF_ALIGN_TO,
-    CONF_X,
-    CONF_Y,
     DIRECTIONS,
     LV_EVENT_MAP,
     LV_EVENT_TRIGGERS,

esphome/components/lvgl/widgets/__init__.py

@@ -1,5 +1,5 @@
 import sys
-from typing import Any, Union
+from typing import Any
 
 from esphome import codegen as cg, config_validation as cv
 from esphome.config_validation import Invalid
@@ -262,7 +262,7 @@ async def wait_for_widgets():
     await FakeAwaitable(widgets_wait_generator())
 
 
-async def get_widgets(config: Union[dict, list], id: str = CONF_ID) -> list[Widget]:
+async def get_widgets(config: dict | list, id: str = CONF_ID) -> list[Widget]:
     if not config:
         return []
     if not isinstance(config, list):

esphome/components/lvgl/widgets/canvas.py

@@ -1,6 +1,14 @@
 from esphome import automation, codegen as cg, config_validation as cv
 from esphome.components.display_menu_base import CONF_LABEL
-from esphome.const import CONF_COLOR, CONF_HEIGHT, CONF_ID, CONF_TEXT, CONF_WIDTH
+from esphome.const import (
+    CONF_COLOR,
+    CONF_HEIGHT,
+    CONF_ID,
+    CONF_TEXT,
+    CONF_WIDTH,
+    CONF_X,
+    CONF_Y,
+)
 from esphome.cpp_generator import Literal, MockObj
 
 from ..automation import action_to_code
@@ -13,8 +21,6 @@ from ..defines import (
     CONF_POINTS,
     CONF_SRC,
     CONF_START_ANGLE,
-    CONF_X,
-    CONF_Y,
     literal,
 )
 from ..lv_validation import (

esphome/components/lvgl/widgets/line.py

@@ -1,8 +1,9 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.const import CONF_X, CONF_Y
 from esphome.core import Lambda
 
-from ..defines import CONF_MAIN, CONF_X, CONF_Y, call_lambda
+from ..defines import CONF_MAIN, call_lambda
 from ..lvcode import lv_add
 from ..schemas import point_schema
 from ..types import LvCompound, LvType

esphome/components/lvgl/widgets/tabview.py

@@ -24,6 +24,7 @@ from .obj import obj_spec
 
 CONF_TABVIEW = "tabview"
 CONF_TAB_STYLE = "tab_style"
+CONF_CONTENT_STYLE = "content_style"
 
 lv_tab_t = LvType("lv_obj_t")
 
@@ -39,6 +40,7 @@ TABVIEW_SCHEMA = cv.Schema(
             )
         ),
         cv.Optional(CONF_TAB_STYLE): part_schema(buttonmatrix_spec.parts),
+        cv.Optional(CONF_CONTENT_STYLE): part_schema(obj_spec.parts),
         cv.Optional(CONF_POSITION, default="top"): DIRECTIONS.one_of,
         cv.Optional(CONF_SIZE, default="10%"): size,
     }
@@ -79,6 +81,11 @@ class TabviewType(WidgetType):
                 "tabview_btnmatrix", lv_obj_t, rhs=lv_expr.tabview_get_tab_btns(w.obj)
             ) as btnmatrix_obj:
                 await set_obj_properties(Widget(btnmatrix_obj, obj_spec), button_style)
+        if content_style := config.get(CONF_CONTENT_STYLE):
+            with LocalVariable(
+                "tabview_content", lv_obj_t, rhs=lv_expr.tabview_get_content(w.obj)
+            ) as content_obj:
+                await set_obj_properties(Widget(content_obj, obj_spec), content_style)
 
     def obj_creator(self, parent: MockObjClass, config: dict):
         return lv_expr.call(

esphome/components/m5stack_8angle/m5stack_8angle.cpp

@@ -8,19 +8,19 @@ namespace m5stack_8angle {
 static const char *const TAG = "m5stack_8angle";
 
 void M5Stack8AngleComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up M5STACK_8ANGLE...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   i2c::ErrorCode err;
 
   err = this->read(nullptr, 0);
   if (err != i2c::NO_ERROR) {
-    ESP_LOGE(TAG, "I2C error %02X...", err);
+    ESP_LOGE(TAG, "I2C error %02X", err);
     this->mark_failed();
     return;
   };
 
   err = this->read_register(M5STACK_8ANGLE_REGISTER_FW_VERSION, &this->fw_version_, 1);
   if (err != i2c::NO_ERROR) {
-    ESP_LOGE(TAG, "I2C error %02X...", err);
+    ESP_LOGE(TAG, "I2C error %02X", err);
     this->mark_failed();
     return;
   };

esphome/components/matrix_keypad/matrix_keypad.cpp

@@ -97,8 +97,8 @@ void MatrixKeypad::loop() {
 }
 
 void MatrixKeypad::dump_config() {
-  ESP_LOGCONFIG(TAG, "Matrix Keypad:");
-  ESP_LOGCONFIG(TAG, " Rows:");
+  ESP_LOGCONFIG(TAG, "Matrix Keypad:\n"
+                     " Rows:");
   for (auto &pin : this->rows_) {
     LOG_PIN("  Pin: ", pin);
   }