DNM: Test CI

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>

.github/workflows/ci.yml

@@ -192,6 +192,11 @@ jobs:
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
+      - name: Restore components graph cache
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: .temp/components_graph.json
+          key: components-graph-${{ hashFiles('esphome/components/**/__init__.py') }}
       - name: Determine which tests to run
         id: determine
         env:
@@ -216,6 +221,12 @@ jobs:
           echo "cpp-unit-tests-run-all=$(echo "$output" | jq -r '.cpp_unit_tests_run_all')" >> $GITHUB_OUTPUT
           echo "cpp-unit-tests-components=$(echo "$output" | jq -c '.cpp_unit_tests_components')" >> $GITHUB_OUTPUT
           echo "component-test-batches=$(echo "$output" | jq -c '.component_test_batches')" >> $GITHUB_OUTPUT
+      - name: Save components graph cache
+#        if: github.ref == 'refs/heads/dev'
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: .temp/components_graph.json
+          key: components-graph-${{ hashFiles('esphome/components/**/__init__.py') }}
 
   integration-tests:
     name: Run integration tests

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.2
+    rev: v0.14.3
     hooks:
       # Run the linter.
       - id: ruff

esphome/__main__.py

@@ -207,14 +207,14 @@ def choose_upload_log_host(
                     if has_mqtt_logging():
                         resolved.append("MQTT")
 
-                    if has_api() and has_non_ip_address():
+                    if has_api() and has_non_ip_address() and has_resolvable_address():
                         resolved.extend(_resolve_with_cache(CORE.address, purpose))
 
                 elif purpose == Purpose.UPLOADING:
                     if has_ota() and has_mqtt_ip_lookup():
                         resolved.append("MQTTIP")
 
-                    if has_ota() and has_non_ip_address():
+                    if has_ota() and has_non_ip_address() and has_resolvable_address():
                         resolved.extend(_resolve_with_cache(CORE.address, purpose))
             else:
                 resolved.append(device)
@@ -318,7 +318,17 @@ def has_resolvable_address() -> bool:
     """Check if CORE.address is resolvable (via mDNS, DNS, or is an IP address)."""
     # Any address (IP, mDNS hostname, or regular DNS hostname) is resolvable
     # The resolve_ip_address() function in helpers.py handles all types via AsyncResolver
-    return CORE.address is not None
+    if CORE.address is None:
+        return False
+
+    if has_ip_address():
+        return True
+
+    if has_mdns():
+        return True
+
+    # .local mDNS hostnames are only resolvable if mDNS is enabled
+    return not CORE.address.endswith(".local")
 
 
 def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):

esphome/automation.py

@@ -182,7 +182,7 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
             value = cv.Schema([extra_validators])(value)
         if single:
             if len(value) != 1:
-                raise cv.Invalid("Cannot have more than 1 automation for templates")
+                raise cv.Invalid("This trigger allows only a single automation")
             return value[0]
         return value
 

esphome/components/api/api.proto

@@ -1000,9 +1000,9 @@ message ListEntitiesClimateResponse {
   bool supports_action = 12; // Deprecated: use feature_flags
   repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
   repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "std::vector<const char *>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::vector"];
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
+  repeated string supported_custom_presets = 17 [(container_pointer) = "std::vector"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;

esphome/components/api/api_connection.cpp

@@ -1,3 +1,4 @@
+// X:
 #include "api_connection.h"
 #ifdef USE_API
 #ifdef USE_API_NOISE

esphome/components/api/api_pb2.cpp

@@ -1179,14 +1179,14 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   for (const auto &it : *this->supported_swing_modes) {
     buffer.encode_uint32(14, static_cast<uint32_t>(it), true);
   }
-  for (const char *it : *this->supported_custom_fan_modes) {
-    buffer.encode_string(15, it, strlen(it), true);
+  for (const auto &it : *this->supported_custom_fan_modes) {
+    buffer.encode_string(15, it, true);
   }
   for (const auto &it : *this->supported_presets) {
     buffer.encode_uint32(16, static_cast<uint32_t>(it), true);
   }
-  for (const char *it : *this->supported_custom_presets) {
-    buffer.encode_string(17, it, strlen(it), true);
+  for (const auto &it : *this->supported_custom_presets) {
+    buffer.encode_string(17, it, true);
   }
   buffer.encode_bool(18, this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
@@ -1229,8 +1229,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_fan_modes->empty()) {
-    for (const char *it : *this->supported_custom_fan_modes) {
-      size.add_length_force(1, strlen(it));
+    for (const auto &it : *this->supported_custom_fan_modes) {
+      size.add_length_force(1, it.size());
     }
   }
   if (!this->supported_presets->empty()) {
@@ -1239,8 +1239,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_presets->empty()) {
-    for (const char *it : *this->supported_custom_presets) {
-      size.add_length_force(2, strlen(it));
+    for (const auto &it : *this->supported_custom_presets) {
+      size.add_length_force(2, it.size());
     }
   }
   size.add_bool(2, this->disabled_by_default);

esphome/components/api/api_pb2.h

@@ -1384,9 +1384,9 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   bool supports_action{false};
   const climate::ClimateFanModeMask *supported_fan_modes{};
   const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const std::vector<const char *> *supported_custom_fan_modes{};
+  const std::vector<std::string> *supported_custom_fan_modes{};
   const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<const char *> *supported_custom_presets{};
+  const std::vector<std::string> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};

esphome/components/bedjet/climate/bedjet_climate.h

@@ -50,13 +50,21 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
         // Climate doesn't have a "TURBO" mode, but we can use the BOOST preset instead.
         climate::CLIMATE_PRESET_BOOST,
     });
-    // String literals are stored in rodata and valid for program lifetime
     traits.set_supported_custom_presets({
-        this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
+        // We could fetch biodata from bedjet and set these names that way.
+        // But then we have to invert the lookup in order to send the right preset.
+        // For now, we can leave them as M1-3 to match the remote buttons.
+        // EXT HT added to match remote button.
+        "EXT HT",
         "M1",
         "M2",
         "M3",
     });
+    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+      traits.add_supported_custom_preset("LTD HT");
+    } else {
+      traits.add_supported_custom_preset("EXT HT");
+    }
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);

esphome/components/climate/climate.cpp

@@ -387,8 +387,8 @@ void Climate::save_state_() {
     const auto &supported = traits.get_supported_custom_fan_modes();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const char *mode : supported) {
-      if (strcmp(mode, custom_fan_mode.value().c_str()) == 0) {
+    for (const auto &mode : supported) {
+      if (mode == custom_fan_mode) {
         state.custom_fan_mode = i;
         break;
       }
@@ -404,8 +404,8 @@ void Climate::save_state_() {
     const auto &supported = traits.get_supported_custom_presets();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const char *preset : supported) {
-      if (strcmp(preset, custom_preset.value().c_str()) == 0) {
+    for (const auto &preset : supported) {
+      if (preset == custom_preset) {
         state.custom_preset = i;
         break;
       }
@@ -527,7 +527,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       call.fan_mode_.reset();
-      call.custom_fan_mode_ = std::string(traits.get_supported_custom_fan_modes()[this->custom_fan_mode]);
+      call.custom_fan_mode_ = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     call.set_fan_mode(this->fan_mode);
@@ -535,7 +535,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       call.preset_.reset();
-      call.custom_preset_ = std::string(traits.get_supported_custom_presets()[this->custom_preset]);
+      call.custom_preset_ = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
     }
   } else if (traits.supports_preset(this->preset)) {
     call.set_preset(this->preset);
@@ -562,7 +562,7 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       climate->fan_mode.reset();
-      climate->custom_fan_mode = std::string(traits.get_supported_custom_fan_modes()[this->custom_fan_mode]);
+      climate->custom_fan_mode = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     climate->fan_mode = this->fan_mode;
@@ -571,7 +571,7 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       climate->preset.reset();
-      climate->custom_preset = std::string(traits.get_supported_custom_presets()[this->custom_preset]);
+      climate->custom_preset = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
     }
   } else if (traits.supports_preset(this->preset)) {
     climate->preset = this->preset;
@@ -656,8 +656,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_fan_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom fan modes:");
-    for (const char *s : traits.get_supported_custom_fan_modes())
-      ESP_LOGCONFIG(tag, "  - %s", s);
+    for (const std::string &s : traits.get_supported_custom_fan_modes())
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported presets:");
@@ -666,8 +666,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom presets:");
-    for (const char *s : traits.get_supported_custom_presets())
-      ESP_LOGCONFIG(tag, "  - %s", s);
+    for (const std::string &s : traits.get_supported_custom_presets())
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_swing_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported swing modes:");

esphome/components/climate/climate_traits.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cstring>
 #include <vector>
 #include "climate_mode.h"
 #include "esphome/core/finite_set_mask.h"
@@ -19,6 +18,16 @@ using ClimateSwingModeMask =
     FiniteSetMask<ClimateSwingMode, DefaultBitPolicy<ClimateSwingMode, CLIMATE_SWING_HORIZONTAL + 1>>;
 using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimatePreset, CLIMATE_PRESET_ACTIVITY + 1>>;
 
+// Lightweight linear search for small vectors (1-20 items)
+// Avoids std::find template overhead
+template<typename T> inline bool vector_contains(const std::vector<T> &vec, const T &value) {
+  for (const auto &item : vec) {
+    if (item == value)
+      return true;
+  }
+  return false;
+}
+
 /** This class contains all static data for climate devices.
  *
  * All climate devices must support these features:
@@ -119,46 +128,46 @@ class ClimateTraits {
 
   void set_supported_fan_modes(ClimateFanModeMask modes) { this->supported_fan_modes_ = modes; }
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
+  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.push_back(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
     return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
   const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
+  void set_supported_custom_fan_modes(std::vector<std::string> supported_custom_fan_modes) {
+    this->supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
+  }
+  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) {
     this->supported_custom_fan_modes_ = modes;
   }
-  void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
-    this->supported_custom_fan_modes_ = modes;
+  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
+    this->supported_custom_fan_modes_.assign(modes, modes + N);
   }
-  const std::vector<const char *> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
+  const std::vector<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
   bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
-    for (const char *mode : this->supported_custom_fan_modes_) {
-      if (strcmp(mode, custom_fan_mode.c_str()) == 0)
-        return true;
-    }
-    return false;
+    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
   }
 
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
   void add_supported_preset(ClimatePreset preset) { this->supported_presets_.insert(preset); }
+  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.push_back(preset); }
   bool supports_preset(ClimatePreset preset) const { return this->supported_presets_.count(preset); }
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
   const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
 
-  void set_supported_custom_presets(std::initializer_list<const char *> presets) {
+  void set_supported_custom_presets(std::vector<std::string> supported_custom_presets) {
+    this->supported_custom_presets_ = std::move(supported_custom_presets);
+  }
+  void set_supported_custom_presets(std::initializer_list<std::string> presets) {
     this->supported_custom_presets_ = presets;
   }
-  void set_supported_custom_presets(const std::vector<const char *> &presets) {
-    this->supported_custom_presets_ = presets;
+  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
+    this->supported_custom_presets_.assign(presets, presets + N);
   }
-  const std::vector<const char *> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
+  const std::vector<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
   bool supports_custom_preset(const std::string &custom_preset) const {
-    for (const char *preset : this->supported_custom_presets_) {
-      if (strcmp(preset, custom_preset.c_str()) == 0)
-        return true;
-    }
-    return false;
+    return vector_contains(this->supported_custom_presets_, custom_preset);
   }
 
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
@@ -230,11 +239,8 @@ class ClimateTraits {
   climate::ClimateFanModeMask supported_fan_modes_;
   climate::ClimateSwingModeMask supported_swing_modes_;
   climate::ClimatePresetMask supported_presets_;
-  // Store const char* pointers to avoid std::string overhead
-  // Pointers must remain valid for traits lifetime (typically string literals in rodata,
-  // or pointers to strings with sufficient lifetime like member variables)
-  std::vector<const char *> supported_custom_fan_modes_;
-  std::vector<const char *> supported_custom_presets_;
+  std::vector<std::string> supported_custom_fan_modes_;
+  std::vector<std::string> supported_custom_presets_;
 };
 
 }  // namespace climate

esphome/components/image/__init__.py

@@ -671,18 +671,33 @@ async def write_image(config, all_frames=False):
     resize = config.get(CONF_RESIZE)
     if is_svg_file(path):
         # Local import so use of non-SVG files needn't require cairosvg installed
+        from pyexpat import ExpatError
+        from xml.etree.ElementTree import ParseError
+
         from cairosvg import svg2png
+        from cairosvg.helpers import PointError
 
         if not resize:
             resize = (None, None)
-        with open(path, "rb") as file:
-            image = svg2png(
-                file_obj=file,
-                output_width=resize[0],
-                output_height=resize[1],
-            )
-        image = Image.open(io.BytesIO(image))
-        width, height = image.size
+        try:
+            with open(path, "rb") as file:
+                image = svg2png(
+                    file_obj=file,
+                    output_width=resize[0],
+                    output_height=resize[1],
+                )
+            image = Image.open(io.BytesIO(image))
+            width, height = image.size
+        except (
+            ValueError,
+            ParseError,
+            IndexError,
+            ExpatError,
+            AttributeError,
+            TypeError,
+            PointError,
+        ) as e:
+            raise core.EsphomeError(f"Could not load SVG image {path}: {e}") from e
     else:
         image = Image.open(path)
         width, height = image.size

esphome/components/lvgl/__init__.py

@@ -58,7 +58,7 @@ from .types import (
     FontEngine,
     IdleTrigger,
     ObjUpdateAction,
-    PauseTrigger,
+    PlainTrigger,
     lv_font_t,
     lv_group_t,
     lv_style_t,
@@ -151,6 +151,13 @@ for w_type in WIDGET_TYPES.values():
         create_modify_schema(w_type),
     )(update_to_code)
 
+SIMPLE_TRIGGERS = (
+    df.CONF_ON_PAUSE,
+    df.CONF_ON_RESUME,
+    df.CONF_ON_DRAW_START,
+    df.CONF_ON_DRAW_END,
+)
+
 
 def as_macro(macro, value):
     if value is None:
@@ -244,9 +251,9 @@ def final_validation(configs):
         for w in refreshed_widgets:
             path = global_config.get_path_for_id(w)
             widget_conf = global_config.get_config_for_path(path[:-1])
-            if not any(isinstance(v, Lambda) for v in widget_conf.values()):
+            if not any(isinstance(v, (Lambda, dict)) for v in widget_conf.values()):
                 raise cv.Invalid(
-                    f"Widget '{w}' does not have any templated properties to refresh",
+                    f"Widget '{w}' does not have any dynamic properties to refresh",
                 )
 
 
@@ -366,16 +373,16 @@ async def to_code(configs):
                     conf[CONF_TRIGGER_ID], lv_component, templ
                 )
                 await build_automation(idle_trigger, [], conf)
-            for conf in config.get(df.CONF_ON_PAUSE, ()):
-                pause_trigger = cg.new_Pvariable(
-                    conf[CONF_TRIGGER_ID], lv_component, True
-                )
-                await build_automation(pause_trigger, [], conf)
-            for conf in config.get(df.CONF_ON_RESUME, ()):
-                resume_trigger = cg.new_Pvariable(
-                    conf[CONF_TRIGGER_ID], lv_component, False
-                )
-                await build_automation(resume_trigger, [], conf)
+            for trigger_name in SIMPLE_TRIGGERS:
+                if conf := config.get(trigger_name):
+                    trigger_var = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
+                    await build_automation(trigger_var, [], conf)
+                    cg.add(
+                        getattr(
+                            lv_component,
+                            f"set_{trigger_name.removeprefix('on_')}_trigger",
+                        )(trigger_var)
+                    )
             await add_on_boot_triggers(config.get(CONF_ON_BOOT, ()))
 
     # This must be done after all widgets are created
@@ -443,16 +450,15 @@ LVGL_SCHEMA = cv.All(
                         ),
                     }
                 ),
-                cv.Optional(df.CONF_ON_PAUSE): validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
-                    }
-                ),
-                cv.Optional(df.CONF_ON_RESUME): validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
-                    }
-                ),
+                **{
+                    cv.Optional(x): validate_automation(
+                        {
+                            cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PlainTrigger),
+                        },
+                        single=True,
+                    )
+                    for x in SIMPLE_TRIGGERS
+                },
                 cv.Exclusive(df.CONF_WIDGETS, CONF_PAGES): cv.ensure_list(
                     WIDGET_SCHEMA
                 ),

esphome/components/lvgl/automation.py

@@ -400,7 +400,8 @@ async def obj_refresh_to_code(config, action_id, template_arg, args):
         # must pass all widget-specific options here, even if not templated, but only do so if at least one is
         # templated. First filter out common style properties.
         config = {k: v for k, v in widget.config.items() if k not in ALL_STYLES}
-        if any(isinstance(v, Lambda) for v in config.values()):
+        # Check if v is a Lambda or a dict, implying it is dynamic
+        if any(isinstance(v, (Lambda, dict)) for v in config.values()):
             await widget.type.to_code(widget, config)
             if (
                 widget.type.w_type.value_property is not None

esphome/components/lvgl/binary_sensor/__init__.py

@@ -31,7 +31,7 @@ async def to_code(config):
             lvgl_static.add_event_cb(
                 widget.obj,
                 await pressed_ctx.get_lambda(),
-                LV_EVENT.PRESSING,
+                LV_EVENT.PRESSED,
                 LV_EVENT.RELEASED,
             )
         )

esphome/components/lvgl/defines.py

@@ -483,6 +483,8 @@ CONF_MSGBOXES = "msgboxes"
 CONF_OBJ = "obj"
 CONF_ONE_CHECKED = "one_checked"
 CONF_ONE_LINE = "one_line"
+CONF_ON_DRAW_START = "on_draw_start"
+CONF_ON_DRAW_END = "on_draw_end"
 CONF_ON_PAUSE = "on_pause"
 CONF_ON_RESUME = "on_resume"
 CONF_ON_SELECT = "on_select"

esphome/components/lvgl/lvgl_esphome.cpp

@@ -82,6 +82,18 @@ static void rounder_cb(lv_disp_drv_t *disp_drv, lv_area_t *area) {
   area->y2 = (area->y2 + draw_rounding) / draw_rounding * draw_rounding - 1;
 }
 
+void LvglComponent::monitor_cb(lv_disp_drv_t *disp_drv, uint32_t time, uint32_t px) {
+  ESP_LOGVV(TAG, "Draw end: %" PRIu32 " pixels in %" PRIu32 " ms", px, time);
+  auto *comp = static_cast<LvglComponent *>(disp_drv->user_data);
+  comp->draw_end_();
+}
+
+void LvglComponent::render_start_cb(lv_disp_drv_t *disp_drv) {
+  ESP_LOGVV(TAG, "Draw start");
+  auto *comp = static_cast<LvglComponent *>(disp_drv->user_data);
+  comp->draw_start_();
+}
+
 lv_event_code_t lv_api_event;     // NOLINT
 lv_event_code_t lv_update_event;  // NOLINT
 void LvglComponent::dump_config() {
@@ -101,7 +113,10 @@ void LvglComponent::set_paused(bool paused, bool show_snow) {
     lv_disp_trig_activity(this->disp_);  // resets the inactivity time
     lv_obj_invalidate(lv_scr_act());
   }
-  this->pause_callbacks_.call(paused);
+  if (paused && this->pause_callback_ != nullptr)
+    this->pause_callback_->trigger();
+  if (!paused && this->resume_callback_ != nullptr)
+    this->resume_callback_->trigger();
 }
 
 void LvglComponent::esphome_lvgl_init() {
@@ -225,13 +240,6 @@ IdleTrigger::IdleTrigger(LvglComponent *parent, TemplatableValue<uint32_t> timeo
   });
 }
 
-PauseTrigger::PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused) : paused_(std::move(paused)) {
-  parent->add_on_pause_callback([this](bool pausing) {
-    if (this->paused_.value() == pausing)
-      this->trigger();
-  });
-}
-
 #ifdef USE_LVGL_TOUCHSCREEN
 LVTouchListener::LVTouchListener(uint16_t long_press_time, uint16_t long_press_repeat_time, LvglComponent *parent) {
   this->set_parent(parent);
@@ -474,6 +482,12 @@ void LvglComponent::setup() {
       return;
     }
   }
+  if (this->draw_start_callback_ != nullptr) {
+    this->disp_drv_.render_start_cb = render_start_cb;
+  }
+  if (this->draw_end_callback_ != nullptr) {
+    this->disp_drv_.monitor_cb = monitor_cb;
+  }
 #if LV_USE_LOG
   lv_log_register_print_cb([](const char *buf) {
     auto next = strchr(buf, ')');
@@ -502,8 +516,9 @@ void LvglComponent::loop() {
   if (this->paused_) {
     if (this->show_snow_)
       this->write_random_();
+  } else {
+    lv_timer_handler_run_in_period(5);
   }
-  lv_timer_handler_run_in_period(5);
 }
 
 #ifdef USE_LVGL_ANIMIMG

esphome/components/lvgl/lvgl_esphome.h

@@ -171,7 +171,9 @@ class LvglComponent : public PollingComponent {
   void add_on_idle_callback(std::function<void(uint32_t)> &&callback) {
     this->idle_callbacks_.add(std::move(callback));
   }
-  void add_on_pause_callback(std::function<void(bool)> &&callback) { this->pause_callbacks_.add(std::move(callback)); }
+
+  static void monitor_cb(lv_disp_drv_t *disp_drv, uint32_t time, uint32_t px);
+  static void render_start_cb(lv_disp_drv_t *disp_drv);
   void dump_config() override;
   bool is_idle(uint32_t idle_ms) { return lv_disp_get_inactive_time(this->disp_) > idle_ms; }
   lv_disp_t *get_disp() { return this->disp_; }
@@ -213,12 +215,20 @@ class LvglComponent : public PollingComponent {
   size_t draw_rounding{2};
 
   display::DisplayRotation rotation{display::DISPLAY_ROTATION_0_DEGREES};
+  void set_pause_trigger(Trigger<> *trigger) { this->pause_callback_ = trigger; }
+  void set_resume_trigger(Trigger<> *trigger) { this->resume_callback_ = trigger; }
+  void set_draw_start_trigger(Trigger<> *trigger) { this->draw_start_callback_ = trigger; }
+  void set_draw_end_trigger(Trigger<> *trigger) { this->draw_end_callback_ = trigger; }
 
  protected:
+  // these functions are never called unless the callbacks are non-null since the
+  // LVGL callbacks that call them are not set unless the start/end callbacks are non-null
+  void draw_start_() const { this->draw_start_callback_->trigger(); }
+  void draw_end_() const { this->draw_end_callback_->trigger(); }
+
   void write_random_();
   void draw_buffer_(const lv_area_t *area, lv_color_t *ptr);
   void flush_cb_(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);
-
   std::vector<display::Display *> displays_{};
   size_t buffer_frac_{1};
   bool full_refresh_{};
@@ -235,7 +245,10 @@ class LvglComponent : public PollingComponent {
   std::map<lv_group_t *, lv_obj_t *> focus_marks_{};
 
   CallbackManager<void(uint32_t)> idle_callbacks_{};
-  CallbackManager<void(bool)> pause_callbacks_{};
+  Trigger<> *pause_callback_{};
+  Trigger<> *resume_callback_{};
+  Trigger<> *draw_start_callback_{};
+  Trigger<> *draw_end_callback_{};
   lv_color_t *rotate_buf_{};
 };
 
@@ -248,14 +261,6 @@ class IdleTrigger : public Trigger<> {
   bool is_idle_{};
 };
 
-class PauseTrigger : public Trigger<> {
- public:
-  explicit PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused);
-
- protected:
-  TemplatableValue<bool> paused_;
-};
-
 template<typename... Ts> class LvglAction : public Action<Ts...>, public Parented<LvglComponent> {
  public:
   explicit LvglAction(std::function<void(LvglComponent *)> &&lamb) : action_(std::move(lamb)) {}

esphome/components/lvgl/types.py

@@ -3,6 +3,7 @@ import sys
 from esphome import automation, codegen as cg
 from esphome.const import CONF_MAX_VALUE, CONF_MIN_VALUE, CONF_TEXT, CONF_VALUE
 from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_types import esphome_ns
 
 from .defines import lvgl_ns
 from .lvcode import lv_expr
@@ -42,8 +43,11 @@ lv_event_code_t = cg.global_ns.enum("lv_event_code_t")
 lv_indev_type_t = cg.global_ns.enum("lv_indev_type_t")
 lv_key_t = cg.global_ns.enum("lv_key_t")
 FontEngine = lvgl_ns.class_("FontEngine")
+PlainTrigger = esphome_ns.class_("Trigger<>", automation.Trigger.template())
+DrawEndTrigger = esphome_ns.class_(
+    "Trigger<uint32_t, uint32_t>", automation.Trigger.template(cg.uint32, cg.uint32)
+)
 IdleTrigger = lvgl_ns.class_("IdleTrigger", automation.Trigger.template())
-PauseTrigger = lvgl_ns.class_("PauseTrigger", automation.Trigger.template())
 ObjUpdateAction = lvgl_ns.class_("ObjUpdateAction", automation.Action)
 LvglCondition = lvgl_ns.class_("LvglCondition", automation.Condition)
 LvglAction = lvgl_ns.class_("LvglAction", automation.Action)

esphome/components/midea/ac_adapter.cpp

@@ -8,9 +8,9 @@ namespace midea {
 namespace ac {
 
 const char *const Constants::TAG = "midea";
-const char *const Constants::FREEZE_PROTECTION = "freeze protection";
-const char *const Constants::SILENT = "silent";
-const char *const Constants::TURBO = "turbo";
+const std::string Constants::FREEZE_PROTECTION = "freeze protection";
+const std::string Constants::SILENT = "silent";
+const std::string Constants::TURBO = "turbo";
 
 ClimateMode Converters::to_climate_mode(MideaMode mode) {
   switch (mode) {
@@ -108,7 +108,7 @@ bool Converters::is_custom_midea_fan_mode(MideaFanMode mode) {
   }
 }
 
-const char *Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
+const std::string &Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
   switch (mode) {
     case MideaFanMode::FAN_SILENT:
       return Constants::SILENT;
@@ -151,7 +151,7 @@ ClimatePreset Converters::to_climate_preset(MideaPreset preset) {
 
 bool Converters::is_custom_midea_preset(MideaPreset preset) { return preset == MideaPreset::PRESET_FREEZE_PROTECTION; }
 
-const char *Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
+const std::string &Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
 
 MideaPreset Converters::to_midea_preset(const std::string &preset) { return MideaPreset::PRESET_FREEZE_PROTECTION; }
 
@@ -169,7 +169,7 @@ void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::
   if (capabilities.supportEcoPreset())
     traits.add_supported_preset(ClimatePreset::CLIMATE_PRESET_ECO);
   if (capabilities.supportFrostProtectionPreset())
-    traits.set_supported_custom_presets({Constants::FREEZE_PROTECTION});
+    traits.add_supported_custom_preset(Constants::FREEZE_PROTECTION);
 }
 
 }  // namespace ac

esphome/components/midea/ac_adapter.h

@@ -20,9 +20,9 @@ using MideaPreset = dudanov::midea::ac::Preset;
 class Constants {
  public:
   static const char *const TAG;
-  static const char *const FREEZE_PROTECTION;
-  static const char *const SILENT;
-  static const char *const TURBO;
+  static const std::string FREEZE_PROTECTION;
+  static const std::string SILENT;
+  static const std::string TURBO;
 };
 
 class Converters {
@@ -35,12 +35,12 @@ class Converters {
   static MideaPreset to_midea_preset(const std::string &preset);
   static bool is_custom_midea_preset(MideaPreset preset);
   static ClimatePreset to_climate_preset(MideaPreset preset);
-  static const char *to_custom_climate_preset(MideaPreset preset);
+  static const std::string &to_custom_climate_preset(MideaPreset preset);
   static MideaFanMode to_midea_fan_mode(ClimateFanMode fan_mode);
   static MideaFanMode to_midea_fan_mode(const std::string &fan_mode);
   static bool is_custom_midea_fan_mode(MideaFanMode fan_mode);
   static ClimateFanMode to_climate_fan_mode(MideaFanMode fan_mode);
-  static const char *to_custom_climate_fan_mode(MideaFanMode fan_mode);
+  static const std::string &to_custom_climate_fan_mode(MideaFanMode fan_mode);
   static void to_climate_traits(ClimateTraits &traits, const dudanov::midea::ac::Capabilities &capabilities);
 };
 

esphome/components/midea/air_conditioner.cpp

@@ -84,10 +84,8 @@ ClimateTraits AirConditioner::traits() {
   traits.set_supported_modes(this->supported_modes_);
   traits.set_supported_swing_modes(this->supported_swing_modes_);
   traits.set_supported_presets(this->supported_presets_);
-  if (!this->supported_custom_presets_.empty())
-    traits.set_supported_custom_presets(this->supported_custom_presets_);
-  if (!this->supported_custom_fan_modes_.empty())
-    traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
+  traits.set_supported_custom_presets(this->supported_custom_presets_);
+  traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
   /* + MINIMAL SET OF CAPABILITIES */
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_AUTO);
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_LOW);

esphome/components/midea/air_conditioner.h

@@ -46,8 +46,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(std::initializer_list<const char *> presets) { this->supported_custom_presets_ = presets; }
-  void set_custom_fan_modes(std::initializer_list<const char *> modes) { this->supported_custom_fan_modes_ = modes; }
+  void set_custom_presets(const std::vector<std::string> &presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(const std::vector<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
@@ -55,8 +55,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   ClimateModeMask supported_modes_{};
   ClimateSwingModeMask supported_swing_modes_{};
   ClimatePresetMask supported_presets_{};
-  std::vector<const char *> supported_custom_presets_{};
-  std::vector<const char *> supported_custom_fan_modes_{};
+  std::vector<std::string> supported_custom_presets_{};
+  std::vector<std::string> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/sdl/binary_sensor.py

@@ -12,241 +12,256 @@ CODEOWNERS = ["@bdm310"]
 
 STATE_ARG = "state"
 
-SDL_KEYMAP = {
-    "SDLK_UNKNOWN": 0,
-    "SDLK_FIRST": 0,
-    "SDLK_BACKSPACE": 8,
-    "SDLK_TAB": 9,
-    "SDLK_CLEAR": 12,
-    "SDLK_RETURN": 13,
-    "SDLK_PAUSE": 19,
-    "SDLK_ESCAPE": 27,
-    "SDLK_SPACE": 32,
-    "SDLK_EXCLAIM": 33,
-    "SDLK_QUOTEDBL": 34,
-    "SDLK_HASH": 35,
-    "SDLK_DOLLAR": 36,
-    "SDLK_AMPERSAND": 38,
-    "SDLK_QUOTE": 39,
-    "SDLK_LEFTPAREN": 40,
-    "SDLK_RIGHTPAREN": 41,
-    "SDLK_ASTERISK": 42,
-    "SDLK_PLUS": 43,
-    "SDLK_COMMA": 44,
-    "SDLK_MINUS": 45,
-    "SDLK_PERIOD": 46,
-    "SDLK_SLASH": 47,
-    "SDLK_0": 48,
-    "SDLK_1": 49,
-    "SDLK_2": 50,
-    "SDLK_3": 51,
-    "SDLK_4": 52,
-    "SDLK_5": 53,
-    "SDLK_6": 54,
-    "SDLK_7": 55,
-    "SDLK_8": 56,
-    "SDLK_9": 57,
-    "SDLK_COLON": 58,
-    "SDLK_SEMICOLON": 59,
-    "SDLK_LESS": 60,
-    "SDLK_EQUALS": 61,
-    "SDLK_GREATER": 62,
-    "SDLK_QUESTION": 63,
-    "SDLK_AT": 64,
-    "SDLK_LEFTBRACKET": 91,
-    "SDLK_BACKSLASH": 92,
-    "SDLK_RIGHTBRACKET": 93,
-    "SDLK_CARET": 94,
-    "SDLK_UNDERSCORE": 95,
-    "SDLK_BACKQUOTE": 96,
-    "SDLK_a": 97,
-    "SDLK_b": 98,
-    "SDLK_c": 99,
-    "SDLK_d": 100,
-    "SDLK_e": 101,
-    "SDLK_f": 102,
-    "SDLK_g": 103,
-    "SDLK_h": 104,
-    "SDLK_i": 105,
-    "SDLK_j": 106,
-    "SDLK_k": 107,
-    "SDLK_l": 108,
-    "SDLK_m": 109,
-    "SDLK_n": 110,
-    "SDLK_o": 111,
-    "SDLK_p": 112,
-    "SDLK_q": 113,
-    "SDLK_r": 114,
-    "SDLK_s": 115,
-    "SDLK_t": 116,
-    "SDLK_u": 117,
-    "SDLK_v": 118,
-    "SDLK_w": 119,
-    "SDLK_x": 120,
-    "SDLK_y": 121,
-    "SDLK_z": 122,
-    "SDLK_DELETE": 127,
-    "SDLK_WORLD_0": 160,
-    "SDLK_WORLD_1": 161,
-    "SDLK_WORLD_2": 162,
-    "SDLK_WORLD_3": 163,
-    "SDLK_WORLD_4": 164,
-    "SDLK_WORLD_5": 165,
-    "SDLK_WORLD_6": 166,
-    "SDLK_WORLD_7": 167,
-    "SDLK_WORLD_8": 168,
-    "SDLK_WORLD_9": 169,
-    "SDLK_WORLD_10": 170,
-    "SDLK_WORLD_11": 171,
-    "SDLK_WORLD_12": 172,
-    "SDLK_WORLD_13": 173,
-    "SDLK_WORLD_14": 174,
-    "SDLK_WORLD_15": 175,
-    "SDLK_WORLD_16": 176,
-    "SDLK_WORLD_17": 177,
-    "SDLK_WORLD_18": 178,
-    "SDLK_WORLD_19": 179,
-    "SDLK_WORLD_20": 180,
-    "SDLK_WORLD_21": 181,
-    "SDLK_WORLD_22": 182,
-    "SDLK_WORLD_23": 183,
-    "SDLK_WORLD_24": 184,
-    "SDLK_WORLD_25": 185,
-    "SDLK_WORLD_26": 186,
-    "SDLK_WORLD_27": 187,
-    "SDLK_WORLD_28": 188,
-    "SDLK_WORLD_29": 189,
-    "SDLK_WORLD_30": 190,
-    "SDLK_WORLD_31": 191,
-    "SDLK_WORLD_32": 192,
-    "SDLK_WORLD_33": 193,
-    "SDLK_WORLD_34": 194,
-    "SDLK_WORLD_35": 195,
-    "SDLK_WORLD_36": 196,
-    "SDLK_WORLD_37": 197,
-    "SDLK_WORLD_38": 198,
-    "SDLK_WORLD_39": 199,
-    "SDLK_WORLD_40": 200,
-    "SDLK_WORLD_41": 201,
-    "SDLK_WORLD_42": 202,
-    "SDLK_WORLD_43": 203,
-    "SDLK_WORLD_44": 204,
-    "SDLK_WORLD_45": 205,
-    "SDLK_WORLD_46": 206,
-    "SDLK_WORLD_47": 207,
-    "SDLK_WORLD_48": 208,
-    "SDLK_WORLD_49": 209,
-    "SDLK_WORLD_50": 210,
-    "SDLK_WORLD_51": 211,
-    "SDLK_WORLD_52": 212,
-    "SDLK_WORLD_53": 213,
-    "SDLK_WORLD_54": 214,
-    "SDLK_WORLD_55": 215,
-    "SDLK_WORLD_56": 216,
-    "SDLK_WORLD_57": 217,
-    "SDLK_WORLD_58": 218,
-    "SDLK_WORLD_59": 219,
-    "SDLK_WORLD_60": 220,
-    "SDLK_WORLD_61": 221,
-    "SDLK_WORLD_62": 222,
-    "SDLK_WORLD_63": 223,
-    "SDLK_WORLD_64": 224,
-    "SDLK_WORLD_65": 225,
-    "SDLK_WORLD_66": 226,
-    "SDLK_WORLD_67": 227,
-    "SDLK_WORLD_68": 228,
-    "SDLK_WORLD_69": 229,
-    "SDLK_WORLD_70": 230,
-    "SDLK_WORLD_71": 231,
-    "SDLK_WORLD_72": 232,
-    "SDLK_WORLD_73": 233,
-    "SDLK_WORLD_74": 234,
-    "SDLK_WORLD_75": 235,
-    "SDLK_WORLD_76": 236,
-    "SDLK_WORLD_77": 237,
-    "SDLK_WORLD_78": 238,
-    "SDLK_WORLD_79": 239,
-    "SDLK_WORLD_80": 240,
-    "SDLK_WORLD_81": 241,
-    "SDLK_WORLD_82": 242,
-    "SDLK_WORLD_83": 243,
-    "SDLK_WORLD_84": 244,
-    "SDLK_WORLD_85": 245,
-    "SDLK_WORLD_86": 246,
-    "SDLK_WORLD_87": 247,
-    "SDLK_WORLD_88": 248,
-    "SDLK_WORLD_89": 249,
-    "SDLK_WORLD_90": 250,
-    "SDLK_WORLD_91": 251,
-    "SDLK_WORLD_92": 252,
-    "SDLK_WORLD_93": 253,
-    "SDLK_WORLD_94": 254,
-    "SDLK_WORLD_95": 255,
-    "SDLK_KP0": 256,
-    "SDLK_KP1": 257,
-    "SDLK_KP2": 258,
-    "SDLK_KP3": 259,
-    "SDLK_KP4": 260,
-    "SDLK_KP5": 261,
-    "SDLK_KP6": 262,
-    "SDLK_KP7": 263,
-    "SDLK_KP8": 264,
-    "SDLK_KP9": 265,
-    "SDLK_KP_PERIOD": 266,
-    "SDLK_KP_DIVIDE": 267,
-    "SDLK_KP_MULTIPLY": 268,
-    "SDLK_KP_MINUS": 269,
-    "SDLK_KP_PLUS": 270,
-    "SDLK_KP_ENTER": 271,
-    "SDLK_KP_EQUALS": 272,
-    "SDLK_UP": 273,
-    "SDLK_DOWN": 274,
-    "SDLK_RIGHT": 275,
-    "SDLK_LEFT": 276,
-    "SDLK_INSERT": 277,
-    "SDLK_HOME": 278,
-    "SDLK_END": 279,
-    "SDLK_PAGEUP": 280,
-    "SDLK_PAGEDOWN": 281,
-    "SDLK_F1": 282,
-    "SDLK_F2": 283,
-    "SDLK_F3": 284,
-    "SDLK_F4": 285,
-    "SDLK_F5": 286,
-    "SDLK_F6": 287,
-    "SDLK_F7": 288,
-    "SDLK_F8": 289,
-    "SDLK_F9": 290,
-    "SDLK_F10": 291,
-    "SDLK_F11": 292,
-    "SDLK_F12": 293,
-    "SDLK_F13": 294,
-    "SDLK_F14": 295,
-    "SDLK_F15": 296,
-    "SDLK_NUMLOCK": 300,
-    "SDLK_CAPSLOCK": 301,
-    "SDLK_SCROLLOCK": 302,
-    "SDLK_RSHIFT": 303,
-    "SDLK_LSHIFT": 304,
-    "SDLK_RCTRL": 305,
-    "SDLK_LCTRL": 306,
-    "SDLK_RALT": 307,
-    "SDLK_LALT": 308,
-    "SDLK_RMETA": 309,
-    "SDLK_LMETA": 310,
-    "SDLK_LSUPER": 311,
-    "SDLK_RSUPER": 312,
-    "SDLK_MODE": 313,
-    "SDLK_COMPOSE": 314,
-    "SDLK_HELP": 315,
-    "SDLK_PRINT": 316,
-    "SDLK_SYSREQ": 317,
-    "SDLK_BREAK": 318,
-    "SDLK_MENU": 319,
-    "SDLK_POWER": 320,
-    "SDLK_EURO": 321,
-    "SDLK_UNDO": 322,
-}
+SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
+
+SDL_KEYS = (
+    "SDLK_UNKNOWN",
+    "SDLK_RETURN",
+    "SDLK_ESCAPE",
+    "SDLK_BACKSPACE",
+    "SDLK_TAB",
+    "SDLK_SPACE",
+    "SDLK_EXCLAIM",
+    "SDLK_QUOTEDBL",
+    "SDLK_HASH",
+    "SDLK_PERCENT",
+    "SDLK_DOLLAR",
+    "SDLK_AMPERSAND",
+    "SDLK_QUOTE",
+    "SDLK_LEFTPAREN",
+    "SDLK_RIGHTPAREN",
+    "SDLK_ASTERISK",
+    "SDLK_PLUS",
+    "SDLK_COMMA",
+    "SDLK_MINUS",
+    "SDLK_PERIOD",
+    "SDLK_SLASH",
+    "SDLK_0",
+    "SDLK_1",
+    "SDLK_2",
+    "SDLK_3",
+    "SDLK_4",
+    "SDLK_5",
+    "SDLK_6",
+    "SDLK_7",
+    "SDLK_8",
+    "SDLK_9",
+    "SDLK_COLON",
+    "SDLK_SEMICOLON",
+    "SDLK_LESS",
+    "SDLK_EQUALS",
+    "SDLK_GREATER",
+    "SDLK_QUESTION",
+    "SDLK_AT",
+    "SDLK_LEFTBRACKET",
+    "SDLK_BACKSLASH",
+    "SDLK_RIGHTBRACKET",
+    "SDLK_CARET",
+    "SDLK_UNDERSCORE",
+    "SDLK_BACKQUOTE",
+    "SDLK_a",
+    "SDLK_b",
+    "SDLK_c",
+    "SDLK_d",
+    "SDLK_e",
+    "SDLK_f",
+    "SDLK_g",
+    "SDLK_h",
+    "SDLK_i",
+    "SDLK_j",
+    "SDLK_k",
+    "SDLK_l",
+    "SDLK_m",
+    "SDLK_n",
+    "SDLK_o",
+    "SDLK_p",
+    "SDLK_q",
+    "SDLK_r",
+    "SDLK_s",
+    "SDLK_t",
+    "SDLK_u",
+    "SDLK_v",
+    "SDLK_w",
+    "SDLK_x",
+    "SDLK_y",
+    "SDLK_z",
+    "SDLK_CAPSLOCK",
+    "SDLK_F1",
+    "SDLK_F2",
+    "SDLK_F3",
+    "SDLK_F4",
+    "SDLK_F5",
+    "SDLK_F6",
+    "SDLK_F7",
+    "SDLK_F8",
+    "SDLK_F9",
+    "SDLK_F10",
+    "SDLK_F11",
+    "SDLK_F12",
+    "SDLK_PRINTSCREEN",
+    "SDLK_SCROLLLOCK",
+    "SDLK_PAUSE",
+    "SDLK_INSERT",
+    "SDLK_HOME",
+    "SDLK_PAGEUP",
+    "SDLK_DELETE",
+    "SDLK_END",
+    "SDLK_PAGEDOWN",
+    "SDLK_RIGHT",
+    "SDLK_LEFT",
+    "SDLK_DOWN",
+    "SDLK_UP",
+    "SDLK_NUMLOCKCLEAR",
+    "SDLK_KP_DIVIDE",
+    "SDLK_KP_MULTIPLY",
+    "SDLK_KP_MINUS",
+    "SDLK_KP_PLUS",
+    "SDLK_KP_ENTER",
+    "SDLK_KP_1",
+    "SDLK_KP_2",
+    "SDLK_KP_3",
+    "SDLK_KP_4",
+    "SDLK_KP_5",
+    "SDLK_KP_6",
+    "SDLK_KP_7",
+    "SDLK_KP_8",
+    "SDLK_KP_9",
+    "SDLK_KP_0",
+    "SDLK_KP_PERIOD",
+    "SDLK_APPLICATION",
+    "SDLK_POWER",
+    "SDLK_KP_EQUALS",
+    "SDLK_F13",
+    "SDLK_F14",
+    "SDLK_F15",
+    "SDLK_F16",
+    "SDLK_F17",
+    "SDLK_F18",
+    "SDLK_F19",
+    "SDLK_F20",
+    "SDLK_F21",
+    "SDLK_F22",
+    "SDLK_F23",
+    "SDLK_F24",
+    "SDLK_EXECUTE",
+    "SDLK_HELP",
+    "SDLK_MENU",
+    "SDLK_SELECT",
+    "SDLK_STOP",
+    "SDLK_AGAIN",
+    "SDLK_UNDO",
+    "SDLK_CUT",
+    "SDLK_COPY",
+    "SDLK_PASTE",
+    "SDLK_FIND",
+    "SDLK_MUTE",
+    "SDLK_VOLUMEUP",
+    "SDLK_VOLUMEDOWN",
+    "SDLK_KP_COMMA",
+    "SDLK_KP_EQUALSAS400",
+    "SDLK_ALTERASE",
+    "SDLK_SYSREQ",
+    "SDLK_CANCEL",
+    "SDLK_CLEAR",
+    "SDLK_PRIOR",
+    "SDLK_RETURN2",
+    "SDLK_SEPARATOR",
+    "SDLK_OUT",
+    "SDLK_OPER",
+    "SDLK_CLEARAGAIN",
+    "SDLK_CRSEL",
+    "SDLK_EXSEL",
+    "SDLK_KP_00",
+    "SDLK_KP_000",
+    "SDLK_THOUSANDSSEPARATOR",
+    "SDLK_DECIMALSEPARATOR",
+    "SDLK_CURRENCYUNIT",
+    "SDLK_CURRENCYSUBUNIT",
+    "SDLK_KP_LEFTPAREN",
+    "SDLK_KP_RIGHTPAREN",
+    "SDLK_KP_LEFTBRACE",
+    "SDLK_KP_RIGHTBRACE",
+    "SDLK_KP_TAB",
+    "SDLK_KP_BACKSPACE",
+    "SDLK_KP_A",
+    "SDLK_KP_B",
+    "SDLK_KP_C",
+    "SDLK_KP_D",
+    "SDLK_KP_E",
+    "SDLK_KP_F",
+    "SDLK_KP_XOR",
+    "SDLK_KP_POWER",
+    "SDLK_KP_PERCENT",
+    "SDLK_KP_LESS",
+    "SDLK_KP_GREATER",
+    "SDLK_KP_AMPERSAND",
+    "SDLK_KP_DBLAMPERSAND",
+    "SDLK_KP_VERTICALBAR",
+    "SDLK_KP_DBLVERTICALBAR",
+    "SDLK_KP_COLON",
+    "SDLK_KP_HASH",
+    "SDLK_KP_SPACE",
+    "SDLK_KP_AT",
+    "SDLK_KP_EXCLAM",
+    "SDLK_KP_MEMSTORE",
+    "SDLK_KP_MEMRECALL",
+    "SDLK_KP_MEMCLEAR",
+    "SDLK_KP_MEMADD",
+    "SDLK_KP_MEMSUBTRACT",
+    "SDLK_KP_MEMMULTIPLY",
+    "SDLK_KP_MEMDIVIDE",
+    "SDLK_KP_PLUSMINUS",
+    "SDLK_KP_CLEAR",
+    "SDLK_KP_CLEARENTRY",
+    "SDLK_KP_BINARY",
+    "SDLK_KP_OCTAL",
+    "SDLK_KP_DECIMAL",
+    "SDLK_KP_HEXADECIMAL",
+    "SDLK_LCTRL",
+    "SDLK_LSHIFT",
+    "SDLK_LALT",
+    "SDLK_LGUI",
+    "SDLK_RCTRL",
+    "SDLK_RSHIFT",
+    "SDLK_RALT",
+    "SDLK_RGUI",
+    "SDLK_MODE",
+    "SDLK_AUDIONEXT",
+    "SDLK_AUDIOPREV",
+    "SDLK_AUDIOSTOP",
+    "SDLK_AUDIOPLAY",
+    "SDLK_AUDIOMUTE",
+    "SDLK_MEDIASELECT",
+    "SDLK_WWW",
+    "SDLK_MAIL",
+    "SDLK_CALCULATOR",
+    "SDLK_COMPUTER",
+    "SDLK_AC_SEARCH",
+    "SDLK_AC_HOME",
+    "SDLK_AC_BACK",
+    "SDLK_AC_FORWARD",
+    "SDLK_AC_STOP",
+    "SDLK_AC_REFRESH",
+    "SDLK_AC_BOOKMARKS",
+    "SDLK_BRIGHTNESSDOWN",
+    "SDLK_BRIGHTNESSUP",
+    "SDLK_DISPLAYSWITCH",
+    "SDLK_KBDILLUMTOGGLE",
+    "SDLK_KBDILLUMDOWN",
+    "SDLK_KBDILLUMUP",
+    "SDLK_EJECT",
+    "SDLK_SLEEP",
+    "SDLK_APP1",
+    "SDLK_APP2",
+    "SDLK_AUDIOREWIND",
+    "SDLK_AUDIOFASTFORWARD",
+    "SDLK_SOFTLEFT",
+    "SDLK_SOFTRIGHT",
+    "SDLK_CALL",
+    "SDLK_ENDCALL",
+)
+
+SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
 
 CONFIG_SCHEMA = (
     binary_sensor.binary_sensor_schema(BinarySensor)

esphome/components/substitutions/jinja.py

@@ -138,6 +138,7 @@ def _concat_nodes_override(values: Iterator[Any]) -> Any:
             values = chain(head, values)
         raw = "".join([str(v) for v in values])
 
+    result = None
     try:
         # Attempt to parse the concatenated string into a Python literal.
         # This allows expressions like "1 + 2" to be evaluated to the integer 3.
@@ -145,11 +146,16 @@ def _concat_nodes_override(values: Iterator[Any]) -> Any:
         # fall back to returning the raw string. This is consistent with
         #  Home Assistant's behavior when evaluating templates
         result = literal_eval(raw)
+    except (ValueError, SyntaxError, MemoryError, TypeError):
+        pass
+    else:
+        if isinstance(result, set):
+            # Sets are not supported, return raw string
+            return raw
+
         if not isinstance(result, str):
             return result
 
-    except (ValueError, SyntaxError, MemoryError, TypeError):
-        pass
     return raw
 
 

esphome/components/thermostat/climate.py

@@ -9,8 +9,6 @@ from esphome.const import (
     CONF_COOL_DEADBAND,
     CONF_COOL_MODE,
     CONF_COOL_OVERRUN,
-    CONF_CUSTOM_FAN_MODES,
-    CONF_CUSTOM_PRESETS,
     CONF_DEFAULT_MODE,
     CONF_DEFAULT_TARGET_TEMPERATURE_HIGH,
     CONF_DEFAULT_TARGET_TEMPERATURE_LOW,
@@ -660,8 +658,6 @@ CONFIG_SCHEMA = cv.All(
                 }
             ),
             cv.Optional(CONF_PRESET): cv.ensure_list(PRESET_CONFIG_SCHEMA),
-            cv.Optional(CONF_CUSTOM_FAN_MODES): cv.ensure_list(cv.string_strict),
-            cv.Optional(CONF_CUSTOM_PRESETS): cv.ensure_list(cv.string_strict),
             cv.Optional(CONF_ON_BOOT_RESTORE_FROM): validate_on_boot_restore_from,
             cv.Optional(CONF_PRESET_CHANGE): automation.validate_automation(
                 single=True
@@ -1012,22 +1008,3 @@ async def to_code(config):
         await automation.build_automation(
             var.get_preset_change_trigger(), [], config[CONF_PRESET_CHANGE]
         )
-
-    # Collect custom preset names from preset map (non-standard) and custom_presets list
-    custom_preset_names = [
-        preset_config[CONF_NAME]
-        for preset_config in config.get(CONF_PRESET, [])
-        if preset_config[CONF_NAME].upper() not in climate.CLIMATE_PRESETS
-    ]
-    custom_preset_names.extend(config.get(CONF_CUSTOM_PRESETS, []))
-    if custom_preset_names:
-        cg.add(var.set_custom_presets(custom_preset_names))
-
-    # Collect custom fan modes (filter out standard enum fan modes)
-    custom_fan_modes = [
-        mode
-        for mode in config.get(CONF_CUSTOM_FAN_MODES, [])
-        if mode.upper() not in climate.CLIMATE_FAN_MODES
-    ]
-    if custom_fan_modes:
-        cg.add(var.set_custom_fan_modes(custom_fan_modes))

esphome/components/thermostat/thermostat_climate.cpp

@@ -321,12 +321,8 @@ climate::ClimateTraits ThermostatClimate::traits() {
   for (auto &it : this->preset_config_) {
     traits.add_supported_preset(it.first);
   }
-  // Custom presets and fan modes are set directly from Python (includes both map entries and additional lists)
-  if (!this->additional_custom_presets_.empty()) {
-    traits.set_supported_custom_presets(this->additional_custom_presets_);
-  }
-  if (!this->additional_custom_fan_modes_.empty()) {
-    traits.set_supported_custom_fan_modes(this->additional_custom_fan_modes_);
+  for (auto &it : this->custom_preset_config_) {
+    traits.add_supported_custom_preset(it.first);
   }
   return traits;
 }
@@ -1252,14 +1248,6 @@ void ThermostatClimate::set_custom_preset_config(const std::string &name,
   this->custom_preset_config_[name] = config;
 }
 
-void ThermostatClimate::set_custom_fan_modes(std::initializer_list<const char *> custom_fan_modes) {
-  this->additional_custom_fan_modes_ = custom_fan_modes;
-}
-
-void ThermostatClimate::set_custom_presets(std::initializer_list<const char *> custom_presets) {
-  this->additional_custom_presets_ = custom_presets;
-}
-
 ThermostatClimate::ThermostatClimate()
     : cool_action_trigger_(new Trigger<>()),
       supplemental_cool_action_trigger_(new Trigger<>()),

esphome/components/thermostat/thermostat_climate.h

@@ -133,8 +133,6 @@ class ThermostatClimate : public climate::Climate, public Component {
 
   void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config);
   void set_custom_preset_config(const std::string &name, const ThermostatClimateTargetTempConfig &config);
-  void set_custom_fan_modes(std::initializer_list<const char *> custom_fan_modes);
-  void set_custom_presets(std::initializer_list<const char *> custom_presets);
 
   Trigger<> *get_cool_action_trigger() const;
   Trigger<> *get_supplemental_cool_action_trigger() const;
@@ -539,10 +537,6 @@ class ThermostatClimate : public climate::Climate, public Component {
   std::map<climate::ClimatePreset, ThermostatClimateTargetTempConfig> preset_config_{};
   /// The set of custom preset configurations this thermostat supports (eg. "My Custom Preset")
   std::map<std::string, ThermostatClimateTargetTempConfig> custom_preset_config_{};
-  /// Additional custom fan modes to expose (beyond those with actions)
-  std::vector<const char *> additional_custom_fan_modes_{};
-  /// Additional custom presets to expose (beyond those in custom_preset_config_)
-  std::vector<const char *> additional_custom_presets_{};
 };
 
 }  // namespace thermostat

pyproject.toml

@@ -133,7 +133,6 @@ ignore = [
   "PLW1641", # Object does not implement `__hash__` method
   "PLR2004", # Magic value used in comparison, consider replacing {value} with a constant variable
   "PLW2901", # Outer {outer_kind} variable {name} overwritten by inner {inner_kind} target
-  "UP038", # https://github.com/astral-sh/ruff/issues/7871 https://github.com/astral-sh/ruff/pull/16681
 ]
 
 [tool.ruff.lint.isort]

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==4.0.2
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.2  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.3  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.0  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

script/api_protobuf/api_protobuf.py

@@ -1610,9 +1610,8 @@ class RepeatedTypeInfo(TypeInfo):
             # Other types need the actual value
             # Special handling for const char* elements
             if self._use_pointer and "const char" in self._container_no_template:
-                field_id_size = self.calculate_field_id_size()
                 o += f"  for (const char *it : {container_ref}) {{\n"
-                o += f"    size.add_length_force({field_id_size}, strlen(it));\n"
+                o += "    size.add_length_force(1, strlen(it));\n"
             else:
                 auto_ref = "" if self._ti_is_bool else "&"
                 o += f"  for (const auto {auto_ref}it : {container_ref}) {{\n"

script/helpers.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from functools import cache
+import hashlib
 import json
 import os
 import os.path
@@ -52,6 +53,10 @@ BASE_BUS_COMPONENTS = {
     "remote_receiver",
 }
 
+# Cache version for components graph
+# Increment this when the cache format or graph building logic changes
+COMPONENTS_GRAPH_CACHE_VERSION = 1
+
 
 def parse_list_components_output(output: str) -> list[str]:
     """Parse the output from list-components.py script.
@@ -752,20 +757,68 @@ def resolve_auto_load(
     return auto_load()
 
 
+@cache
+def get_components_graph_cache_key() -> str:
+    """Generate cache key based on all component __init__.py file hashes.
+
+    Uses git ls-files with sha1 hashes to generate a stable cache key that works
+    across different machines and CI runs. This is faster and more reliable than
+    reading file contents or using modification times.
+
+    Returns:
+        SHA256 hex string uniquely identifying the current component state
+    """
+    # Use git ls-files -s to get sha1 hashes of all component __init__.py files
+    # Format: <mode> <sha1> <stage> <path>
+    # This is fast and works consistently across CI and local dev
+    cmd = ["git", "ls-files", "-s", "esphome/components/**/__init__.py"]
+    result = subprocess.run(
+        cmd, capture_output=True, text=True, check=True, cwd=root_path, close_fds=False
+    )
+
+    # Hash the git output (includes file paths and their sha1 hashes)
+    # This changes only when component __init__.py files actually change
+    hasher = hashlib.sha256()
+    hasher.update(result.stdout.encode())
+
+    return hasher.hexdigest()
+
+
 def create_components_graph() -> dict[str, list[str]]:
-    """Create a graph of component dependencies.
+    """Create a graph of component dependencies (cached).
+
+    This function is expensive (5-6 seconds) because it imports all ESPHome components
+    to extract their DEPENDENCIES and AUTO_LOAD metadata. The result is cached based
+    on component file modification times, so unchanged components don't trigger a rebuild.
 
     Returns:
         Dictionary mapping parent components to their children (dependencies)
     """
-    from pathlib import Path
+    # Check cache first - use fixed filename since GitHub Actions cache doesn't support wildcards
+    cache_file = Path(temp_folder) / "components_graph.json"
+
+    if cache_file.exists():
+        try:
+            cached_data = json.loads(cache_file.read_text())
+        except (OSError, json.JSONDecodeError):
+            # Cache file corrupted or unreadable, rebuild
+            pass
+        else:
+            # Verify cache version matches
+            if cached_data.get("_version") == COMPONENTS_GRAPH_CACHE_VERSION:
+                # Verify cache is for current component state
+                cache_key = get_components_graph_cache_key()
+                if cached_data.get("_cache_key") == cache_key:
+                    return cached_data.get("graph", {})
+                # Cache key mismatch - stale cache, rebuild
+            # Cache version mismatch - incompatible format, rebuild
 
     from esphome import const
     from esphome.core import CORE
     from esphome.loader import ComponentManifest, get_component, get_platform
 
     # The root directory of the repo
-    root = Path(__file__).parent.parent
+    root = Path(root_path)
     components_dir = root / ESPHOME_COMPONENTS_PATH
     # Fake some directory so that get_component works
     CORE.config_path = root
@@ -842,6 +895,15 @@ def create_components_graph() -> dict[str, list[str]]:
             # restore config
             CORE.data[KEY_CORE] = TARGET_CONFIGURATIONS[0]
 
+    # Save to cache with version and cache key for validation
+    cache_data = {
+        "_version": COMPONENTS_GRAPH_CACHE_VERSION,
+        "_cache_key": get_components_graph_cache_key(),
+        "graph": components_graph,
+    }
+    cache_file.parent.mkdir(exist_ok=True)
+    cache_file.write_text(json.dumps(cache_data))
+
     return components_graph
 
 

tests/components/lvgl/test.esp32-idf.yaml

@@ -68,5 +68,13 @@ lvgl:
     enter_button: pushbutton
     group: general
     initial_focus: lv_roller
+  on_draw_start:
+    - logger.log: draw started
+  on_draw_end:
+    - logger.log: draw ended
+    - lvgl.pause:
+    - component.update: tft_display
+    - delay: 60s
+    - lvgl.resume:
 
 <<: !include common.yaml

tests/components/sdl/common.yaml

@@ -14,10 +14,10 @@ display:
 binary_sensor:
   - platform: sdl
     id: key_up
-    key: SDLK_a
+    key: SDLK_UP
   - platform: sdl
     id: key_down
-    key: SDLK_d
+    key: SDLK_DOWN
   - platform: sdl
     id: key_enter
-    key: SDLK_s
+    key: SDLK_RETURN

tests/components/thermostat/common.yaml

@@ -15,12 +15,6 @@ climate:
       - name: Away
         default_target_temperature_low: 16°C
         default_target_temperature_high: 20°C
-    custom_fan_modes:
-      - "Custom Fan 1"
-      - "Custom Fan 2"
-    custom_presets:
-      - "Custom Preset 1"
-      - "Custom Preset 2"
     idle_action:
       - logger.log: idle_action
     cool_action:

tests/integration/fixtures/climate_custom_fan_modes_and_presets.yaml

@@ -1,39 +0,0 @@
-esphome:
-  name: climate-custom-modes-test
-host:
-api:
-logger:
-
-sensor:
-  - platform: template
-    id: thermostat_sensor
-    lambda: "return 22.0;"
-
-climate:
-  - platform: thermostat
-    id: test_thermostat
-    name: Test Thermostat Custom Modes
-    sensor: thermostat_sensor
-    preset:
-      - name: Away
-        default_target_temperature_low: 16°C
-        default_target_temperature_high: 20°C
-    custom_fan_modes:
-      - "Turbo"
-      - "Silent"
-      - "Sleep Mode"
-    custom_presets:
-      - "Eco Plus"
-      - "Comfort"
-      - "Vacation Mode"
-    idle_action:
-      - logger.log: idle_action
-    cool_action:
-      - logger.log: cool_action
-    heat_action:
-      - logger.log: heat_action
-    min_cooling_off_time: 10s
-    min_cooling_run_time: 10s
-    min_heating_off_time: 10s
-    min_heating_run_time: 10s
-    min_idle_time: 10s

tests/integration/test_climate_custom_modes.py

@@ -1,51 +0,0 @@
-"""Integration test for climate custom fan modes and presets."""
-
-from __future__ import annotations
-
-from aioesphomeapi import ClimateInfo, ClimatePreset
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_climate_custom_fan_modes_and_presets(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that custom fan modes and presets are properly exposed via API."""
-    async with run_compiled(yaml_config), api_client_connected() as client:
-        # Get entities and services
-        entities, services = await client.list_entities_services()
-        climate_infos = [e for e in entities if isinstance(e, ClimateInfo)]
-        assert len(climate_infos) == 1, "Expected exactly 1 climate entity"
-
-        test_climate = climate_infos[0]
-
-        # Verify custom fan modes are exposed
-        custom_fan_modes = test_climate.supported_custom_fan_modes
-        assert len(custom_fan_modes) == 3, (
-            f"Expected 3 custom fan modes, got {len(custom_fan_modes)}"
-        )
-        assert "Turbo" in custom_fan_modes, "Expected 'Turbo' in custom fan modes"
-        assert "Silent" in custom_fan_modes, "Expected 'Silent' in custom fan modes"
-        assert "Sleep Mode" in custom_fan_modes, (
-            "Expected 'Sleep Mode' in custom fan modes"
-        )
-
-        # Verify enum presets are exposed (from preset: config map)
-        assert ClimatePreset.AWAY in test_climate.supported_presets, (
-            "Expected AWAY in enum presets"
-        )
-
-        # Verify custom string presets are exposed (from custom_presets: config list)
-        custom_presets = test_climate.supported_custom_presets
-        assert len(custom_presets) == 3, (
-            f"Expected 3 custom presets, got {len(custom_presets)}: {custom_presets}"
-        )
-        assert "Eco Plus" in custom_presets, "Expected 'Eco Plus' in custom presets"
-        assert "Comfort" in custom_presets, "Expected 'Comfort' in custom presets"
-        assert "Vacation Mode" in custom_presets, (
-            "Expected 'Vacation Mode' in custom presets"
-        )

tests/script/test_determine_jobs.py

@@ -543,6 +543,7 @@ def test_main_filters_components_without_tests(
     with (
         patch.object(determine_jobs, "root_path", str(tmp_path)),
         patch.object(helpers, "root_path", str(tmp_path)),
+        patch.object(helpers, "create_components_graph", return_value={}),
         patch("sys.argv", ["determine-jobs.py"]),
         patch.object(
             determine_jobs,
@@ -640,6 +641,7 @@ def test_main_detects_components_with_variant_tests(
     with (
         patch.object(determine_jobs, "root_path", str(tmp_path)),
         patch.object(helpers, "root_path", str(tmp_path)),
+        patch.object(helpers, "create_components_graph", return_value={}),
         patch("sys.argv", ["determine-jobs.py"]),
         patch.object(
             determine_jobs,

tests/script/test_helpers.py

@@ -1,5 +1,6 @@
 """Unit tests for script/helpers.py module."""
 
+from collections.abc import Generator
 import json
 import os
 from pathlib import Path
@@ -1099,5 +1100,244 @@ def test_get_component_from_path(
     file_path: str, expected_component: str | None
 ) -> None:
     """Test extraction of component names from file paths."""
-    result = helpers.get_component_from_path(file_path)
-    assert result == expected_component
+
+
+# Components graph cache tests
+
+
+@pytest.fixture
+def mock_git_output() -> str:
+    """Fixture for mock git ls-files output."""
+    return (
+        "100644 abc123... 0 esphome/components/wifi/__init__.py\n"
+        "100644 def456... 0 esphome/components/api/__init__.py\n"
+    )
+
+
+@pytest.fixture
+def mock_cache_file(tmp_path: Path) -> Path:
+    """Fixture for a temporary cache file path."""
+    return tmp_path / "components_graph.json"
+
+
+@pytest.fixture(autouse=True)
+def clear_cache_key_cache() -> None:
+    """Clear the components graph cache key cache before each test."""
+    helpers.get_components_graph_cache_key.cache_clear()
+
+
+@pytest.fixture
+def mock_subprocess_run() -> Generator[Mock, None, None]:
+    """Fixture to mock subprocess.run for git commands."""
+    with patch("subprocess.run") as mock_run:
+        yield mock_run
+
+
+def test_cache_key_generation(mock_git_output: str, mock_subprocess_run: Mock) -> None:
+    """Test that cache key is generated based on git file hashes."""
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    key = helpers.get_components_graph_cache_key()
+
+    # Should be a 64-character hex string (SHA256)
+    assert len(key) == 64
+    assert all(c in "0123456789abcdef" for c in key)
+
+
+def test_cache_key_consistent_for_same_files(
+    mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that same git output produces same cache key."""
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    key1 = helpers.get_components_graph_cache_key()
+    key2 = helpers.get_components_graph_cache_key()
+
+    assert key1 == key2
+
+
+def test_cache_key_different_for_changed_files(mock_subprocess_run: Mock) -> None:
+    """Test that different git output produces different cache key."""
+    mock_result1 = Mock()
+    mock_result1.stdout = "100644 abc123... 0 esphome/components/wifi/__init__.py\n"
+
+    mock_result2 = Mock()
+    mock_result2.stdout = "100644 xyz789... 0 esphome/components/wifi/__init__.py\n"
+
+    mock_subprocess_run.return_value = mock_result1
+    key1 = helpers.get_components_graph_cache_key()
+
+    helpers.get_components_graph_cache_key.cache_clear()
+    mock_subprocess_run.return_value = mock_result2
+    key2 = helpers.get_components_graph_cache_key()
+
+    assert key1 != key2
+
+
+def test_cache_key_uses_git_ls_files(
+    mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that git ls-files command is called correctly."""
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    helpers.get_components_graph_cache_key()
+
+    # Verify git ls-files was called with correct arguments
+    mock_subprocess_run.assert_called_once()
+    call_args = mock_subprocess_run.call_args
+    assert call_args[0][0] == [
+        "git",
+        "ls-files",
+        "-s",
+        "esphome/components/**/__init__.py",
+    ]
+    assert call_args[1]["capture_output"] is True
+    assert call_args[1]["text"] is True
+    assert call_args[1]["check"] is True
+    assert call_args[1]["close_fds"] is False
+
+
+def test_cache_hit_returns_cached_graph(
+    tmp_path: Path, mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that cache hit returns cached data without rebuilding."""
+    mock_graph = {"wifi": ["network"], "api": ["socket"]}
+    cache_key = "a" * 64
+    cache_data = {
+        "_version": helpers.COMPONENTS_GRAPH_CACHE_VERSION,
+        "_cache_key": cache_key,
+        "graph": mock_graph,
+    }
+
+    # Write cache file
+    cache_file = tmp_path / "components_graph.json"
+    cache_file.write_text(json.dumps(cache_data))
+
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    with (
+        patch("helpers.get_components_graph_cache_key", return_value=cache_key),
+        patch("helpers.temp_folder", str(tmp_path)),
+    ):
+        result = helpers.create_components_graph()
+        assert result == mock_graph
+
+
+def test_cache_miss_no_cache_file(
+    tmp_path: Path, mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that cache miss rebuilds graph when no cache file exists."""
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    # Create minimal components directory structure
+    components_dir = tmp_path / "esphome" / "components"
+    components_dir.mkdir(parents=True)
+
+    with (
+        patch("helpers.root_path", str(tmp_path)),
+        patch("helpers.temp_folder", str(tmp_path / ".temp")),
+        patch("helpers.get_components_graph_cache_key", return_value="test_key"),
+    ):
+        result = helpers.create_components_graph()
+        # Should return empty graph for empty components directory
+        assert result == {}
+
+
+def test_cache_miss_version_mismatch(
+    tmp_path: Path, mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that cache miss rebuilds graph when version doesn't match."""
+    cache_data = {
+        "_version": 999,  # Wrong version
+        "_cache_key": "test_key",
+        "graph": {"old": ["data"]},
+    }
+
+    cache_file = tmp_path / ".temp" / "components_graph.json"
+    cache_file.parent.mkdir(parents=True)
+    cache_file.write_text(json.dumps(cache_data))
+
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    # Create minimal components directory structure
+    components_dir = tmp_path / "esphome" / "components"
+    components_dir.mkdir(parents=True)
+
+    with (
+        patch("helpers.root_path", str(tmp_path)),
+        patch("helpers.temp_folder", str(tmp_path / ".temp")),
+        patch("helpers.get_components_graph_cache_key", return_value="test_key"),
+    ):
+        result = helpers.create_components_graph()
+        # Should rebuild and return empty graph, not use cached data
+        assert result == {}
+
+
+def test_cache_miss_key_mismatch(
+    tmp_path: Path, mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that cache miss rebuilds graph when cache key doesn't match."""
+    cache_data = {
+        "_version": helpers.COMPONENTS_GRAPH_CACHE_VERSION,
+        "_cache_key": "old_key",
+        "graph": {"old": ["data"]},
+    }
+
+    cache_file = tmp_path / ".temp" / "components_graph.json"
+    cache_file.parent.mkdir(parents=True)
+    cache_file.write_text(json.dumps(cache_data))
+
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    # Create minimal components directory structure
+    components_dir = tmp_path / "esphome" / "components"
+    components_dir.mkdir(parents=True)
+
+    with (
+        patch("helpers.root_path", str(tmp_path)),
+        patch("helpers.temp_folder", str(tmp_path / ".temp")),
+        patch("helpers.get_components_graph_cache_key", return_value="new_key"),
+    ):
+        result = helpers.create_components_graph()
+        # Should rebuild and return empty graph, not use cached data with old key
+        assert result == {}
+
+
+def test_cache_miss_corrupted_json(
+    tmp_path: Path, mock_git_output: str, mock_subprocess_run: Mock
+) -> None:
+    """Test that cache miss rebuilds graph when cache file has invalid JSON."""
+    cache_file = tmp_path / ".temp" / "components_graph.json"
+    cache_file.parent.mkdir(parents=True)
+    cache_file.write_text("{invalid json")
+
+    mock_result = Mock()
+    mock_result.stdout = mock_git_output
+    mock_subprocess_run.return_value = mock_result
+
+    # Create minimal components directory structure
+    components_dir = tmp_path / "esphome" / "components"
+    components_dir.mkdir(parents=True)
+
+    with (
+        patch("helpers.root_path", str(tmp_path)),
+        patch("helpers.temp_folder", str(tmp_path / ".temp")),
+        patch("helpers.get_components_graph_cache_key", return_value="test_key"),
+    ):
+        result = helpers.create_components_graph()
+        # Should handle corruption gracefully and rebuild
+        assert result == {}

tests/unit_tests/fixtures/substitutions/00-simple_var.approved.yaml

@@ -33,3 +33,4 @@ test_list:
     {{{ "x", "79"}, { "y", "82"}}}
   - '{{{"AA"}}}'
   - '"HELLO"'
+  - '{ 79, 82 }'

tests/unit_tests/fixtures/substitutions/00-simple_var.input.yaml

@@ -34,3 +34,4 @@ test_list:
     {{{ "x", "${ position.x }"}, { "y", "${ position.y }"}}}
   - ${ '{{{"AA"}}}' }
   - ${ '"HELLO"' }
+  - '{ ${position.x}, ${position.y} }'

tests/unit_tests/test_main.py

@@ -744,7 +744,7 @@ def test_choose_upload_log_host_ota_local_all_options() -> None:
         check_default=None,
         purpose=Purpose.UPLOADING,
     )
-    assert result == ["MQTTIP", "test.local"]
+    assert result == ["MQTTIP"]
 
 
 @pytest.mark.usefixtures("mock_serial_ports")
@@ -794,7 +794,7 @@ def test_choose_upload_log_host_ota_local_all_options_logging() -> None:
         check_default=None,
         purpose=Purpose.LOGGING,
     )
-    assert result == ["MQTTIP", "MQTT", "test.local"]
+    assert result == ["MQTTIP", "MQTT"]
 
 
 @pytest.mark.usefixtures("mock_no_mqtt_logging")
@@ -1564,7 +1564,7 @@ def test_has_resolvable_address() -> None:
     setup_core(
         config={CONF_MDNS: {CONF_DISABLED: True}}, address="esphome-device.local"
     )
-    assert has_resolvable_address() is True
+    assert has_resolvable_address() is False
 
     # Test with mDNS disabled and regular DNS hostname (resolvable)
     setup_core(config={CONF_MDNS: {CONF_DISABLED: True}}, address="device.example.com")