[api] Optimize protobuf varint encoding for flash savings

.github/workflows/ci-api-proto.yml

@@ -62,7 +62,7 @@ jobs:
         run: git diff
       - if: failure()
         name: Archive artifacts
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: generated-proto-files
           path: |

.github/workflows/ci.yml

@@ -180,7 +180,6 @@ jobs:
       memory_impact: ${{ steps.determine.outputs.memory-impact }}
       cpp-unit-tests-run-all: ${{ steps.determine.outputs.cpp-unit-tests-run-all }}
       cpp-unit-tests-components: ${{ steps.determine.outputs.cpp-unit-tests-components }}
-      component-test-batches: ${{ steps.determine.outputs.component-test-batches }}
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -215,7 +214,6 @@ jobs:
           echo "memory-impact=$(echo "$output" | jq -c '.memory_impact')" >> $GITHUB_OUTPUT
           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
 
   integration-tests:
     name: Run integration tests
@@ -538,18 +536,59 @@ jobs:
         run: script/ci-suggest-changes
         if: always()
 
+  test-build-components-splitter:
+    name: Split components for intelligent grouping (40 weighted per batch)
+    runs-on: ubuntu-24.04
+    needs:
+      - common
+      - determine-jobs
+    if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) > 0
+    outputs:
+      matrix: ${{ steps.split.outputs.components }}
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - name: Restore Python
+        uses: ./.github/actions/restore-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          cache-key: ${{ needs.common.outputs.cache-key }}
+      - name: Split components intelligently based on bus configurations
+        id: split
+        run: |
+          . venv/bin/activate
+
+          # Use intelligent splitter that groups components with same bus configs
+          components='${{ needs.determine-jobs.outputs.changed-components-with-tests }}'
+
+          # Only isolate directly changed components when targeting dev branch
+          # For beta/release branches, group everything for faster CI
+          if [[ "${{ github.base_ref }}" == beta* ]] || [[ "${{ github.base_ref }}" == release* ]]; then
+            directly_changed='[]'
+            echo "Target branch: ${{ github.base_ref }} - grouping all components"
+          else
+            directly_changed='${{ needs.determine-jobs.outputs.directly-changed-components-with-tests }}'
+            echo "Target branch: ${{ github.base_ref }} - isolating directly changed components"
+          fi
+
+          echo "Splitting components intelligently..."
+          output=$(python3 script/split_components_for_ci.py --components "$components" --directly-changed "$directly_changed" --batch-size 40 --output github)
+
+          echo "$output" >> $GITHUB_OUTPUT
+
   test-build-components-split:
     name: Test components batch (${{ matrix.components }})
     runs-on: ubuntu-24.04
     needs:
       - common
       - determine-jobs
+      - test-build-components-splitter
     if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) > 0
     strategy:
       fail-fast: false
       max-parallel: ${{ (startsWith(github.base_ref, 'beta') || startsWith(github.base_ref, 'release')) && 8 || 4 }}
       matrix:
-        components: ${{ fromJson(needs.determine-jobs.outputs.component-test-batches) }}
+        components: ${{ fromJson(needs.test-build-components-splitter.outputs.matrix) }}
     steps:
       - name: Show disk space
         run: |
@@ -810,7 +849,7 @@ jobs:
           fi
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: memory-analysis-target
           path: memory-analysis-target.json
@@ -874,7 +913,7 @@ jobs:
             --platform "$platform"
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: memory-analysis-pr
           path: memory-analysis-pr.json
@@ -904,13 +943,13 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
       - name: Download target analysis JSON
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
         with:
           name: memory-analysis-target
           path: ./memory-analysis
         continue-on-error: true
       - name: Download PR analysis JSON
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
         with:
           name: memory-analysis-pr
           path: ./memory-analysis
@@ -941,6 +980,7 @@ jobs:
       - clang-tidy-nosplit
       - clang-tidy-split
       - determine-jobs
+      - test-build-components-splitter
       - test-build-components-split
       - pre-commit-ci-lite
       - memory-impact-target-branch

.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@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
         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@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -138,7 +138,7 @@ jobs:
       #     version: ${{ needs.init.outputs.tag }}
 
       - name: Upload digests
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: digests-${{ matrix.platform.arch }}
           path: /tmp/digests
@@ -171,7 +171,7 @@ jobs:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Download digests
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
         with:
           pattern: digests-*
           path: /tmp/digests

.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.1
     hooks:
       # Run the linter.
       - id: ruff

esphome/components/alarm_control_panel/__init__.py

@@ -172,6 +172,12 @@ def alarm_control_panel_schema(
     return _ALARM_CONTROL_PANEL_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+ALARM_CONTROL_PANEL_SCHEMA = alarm_control_panel_schema(AlarmControlPanel)
+ALARM_CONTROL_PANEL_SCHEMA.add_extra(
+    cv.deprecated_schema_constant("alarm_control_panel")
+)
+
 ALARM_CONTROL_PANEL_ACTION_SCHEMA = maybe_simple_id(
     {
         cv.GenerateID(): cv.use_id(AlarmControlPanel),

esphome/components/api/api.proto

@@ -1143,7 +1143,7 @@ message ListEntitiesSelectResponse {
   reserved 4; // Deprecated: was string unique_id
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
-  repeated string options = 6 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string options = 6 [(container_pointer) = "std::vector"];
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];

esphome/components/api/api_connection.cpp

@@ -1,5 +1,3 @@
-// random comment
-
 #include "api_connection.h"
 #ifdef USE_API
 #ifdef USE_API_NOISE

esphome/components/api/api_pb2.cpp

@@ -1475,8 +1475,8 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_ENTITY_ICON
   buffer.encode_string(5, this->icon_ref_);
 #endif
-  for (const char *it : *this->options) {
-    buffer.encode_string(6, it, strlen(it), true);
+  for (const auto &it : *this->options) {
+    buffer.encode_string(6, it, true);
   }
   buffer.encode_bool(7, this->disabled_by_default);
   buffer.encode_uint32(8, static_cast<uint32_t>(this->entity_category));
@@ -1492,8 +1492,8 @@ void ListEntitiesSelectResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   if (!this->options->empty()) {
-    for (const char *it : *this->options) {
-      size.add_length_force(1, strlen(it));
+    for (const auto &it : *this->options) {
+      size.add_length_force(1, it.size());
     }
   }
   size.add_bool(1, this->disabled_by_default);

esphome/components/api/api_pb2.h

@@ -1534,7 +1534,7 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_select_response"; }
 #endif
-  const FixedVector<const char *> *options{};
+  const std::vector<std::string> *options{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -88,12 +88,6 @@ static void dump_field(std::string &out, const char *field_name, StringRef value
   out.append("\n");
 }
 
-static void dump_field(std::string &out, const char *field_name, const char *value, int indent = 2) {
-  append_field_prefix(out, field_name, indent);
-  out.append("'").append(value).append("'");
-  out.append("\n");
-}
-
 template<typename T> static void dump_field(std::string &out, const char *field_name, T value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
   out.append(proto_enum_to_string<T>(value));

esphome/components/api/proto.h

@@ -3,10 +3,12 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/macros.h"
 #include "esphome/core/string_ref.h"
 
 #include <cassert>
 #include <cstring>
+#include <type_traits>
 #include <vector>
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
@@ -159,22 +161,6 @@ class ProtoVarInt {
       }
     }
   }
-  void encode(std::vector<uint8_t> &out) {
-    uint64_t val = this->value_;
-    if (val <= 0x7F) {
-      out.push_back(val);
-      return;
-    }
-    while (val) {
-      uint8_t temp = val & 0x7F;
-      val >>= 7;
-      if (val) {
-        out.push_back(temp | 0x80);
-      } else {
-        out.push_back(temp);
-      }
-    }
-  }
 
  protected:
   uint64_t value_;
@@ -233,8 +219,87 @@ class ProtoWriteBuffer {
  public:
   ProtoWriteBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
   void write(uint8_t value) { this->buffer_->push_back(value); }
-  void encode_varint_raw(ProtoVarInt value) { value.encode(*this->buffer_); }
-  void encode_varint_raw(uint32_t value) { this->encode_varint_raw(ProtoVarInt(value)); }
+
+  // Single implementation that all overloads delegate to
+  // Mark noinline to prevent code bloat from inlining into every caller
+  __attribute__((noinline)) void encode_varint(uint64_t value) {
+    auto buffer = this->buffer_;
+    size_t start = buffer->size();
+
+    // Fast paths for common cases (1-3 bytes)
+    if (ESPHOME_LIKELY(value < (1ULL << 7))) {
+      // 1 byte - very common for field IDs and small lengths
+      buffer->resize(start + 1);
+      buffer->data()[start] = static_cast<uint8_t>(value);
+      return;
+    }
+
+    uint8_t *p;
+    if (ESPHOME_LIKELY(value < (1ULL << 14))) {
+      // 2 bytes - common for medium field IDs and lengths
+      buffer->resize(start + 2);
+      p = buffer->data() + start;
+      p[0] = (value & 0x7F) | 0x80;
+      p[1] = (value >> 7) & 0x7F;
+      return;
+    }
+    if (value < (1ULL << 21)) {
+      // 3 bytes - rare
+      buffer->resize(start + 3);
+      p = buffer->data() + start;
+      p[0] = (value & 0x7F) | 0x80;
+      p[1] = ((value >> 7) & 0x7F) | 0x80;
+      p[2] = (value >> 14) & 0x7F;
+      return;
+    }
+
+    // Rare case: 4-10 byte values - calculate size from bit position
+    // Value is guaranteed >= (1ULL << 21), so CLZ is safe (non-zero)
+    uint32_t size;
+#if defined(__GNUC__) || defined(__clang__)
+    // Use compiler intrinsic for efficient bit position lookup
+    size = (64 - __builtin_clzll(value) + 6) / 7;
+#else
+    // Fallback for compilers without __builtin_clzll
+    if (value < (1ULL << 28)) {
+      size = 4;
+    } else if (value < (1ULL << 35)) {
+      size = 5;
+    } else if (value < (1ULL << 42)) {
+      size = 6;
+    } else if (value < (1ULL << 49)) {
+      size = 7;
+    } else if (value < (1ULL << 56)) {
+      size = 8;
+    } else if (value < (1ULL << 63)) {
+      size = 9;
+    } else {
+      size = 10;
+    }
+#endif
+
+    buffer->resize(start + size);
+    p = buffer->data() + start;
+    size_t bytes = 0;
+    while (value) {
+      uint8_t temp = value & 0x7F;
+      value >>= 7;
+      p[bytes++] = value ? temp | 0x80 : temp;
+    }
+  }
+
+  // Common case: uint32_t values (field IDs, lengths, most integers)
+  void encode_varint(uint32_t value) { this->encode_varint(static_cast<uint64_t>(value)); }
+
+  // size_t overload (only enabled if size_t is distinct from uint32_t and uint64_t)
+  template<typename T>
+  void encode_varint(T value) requires(std::is_same_v<T, size_t> && !std::is_same_v<size_t, uint32_t> &&
+                                       !std::is_same_v<size_t, uint64_t>) {
+    this->encode_varint(static_cast<uint64_t>(value));
+  }
+
+  // Rare case: ProtoVarInt wrapper
+  void encode_varint(ProtoVarInt value) { this->encode_varint(value.as_uint64()); }
   /**
    * Encode a field key (tag/wire type combination).
    *
@@ -249,14 +314,14 @@ class ProtoWriteBuffer {
    */
   void encode_field_raw(uint32_t field_id, uint32_t type) {
     uint32_t val = (field_id << 3) | (type & WIRE_TYPE_MASK);
-    this->encode_varint_raw(val);
+    this->encode_varint(val);
   }
   void encode_string(uint32_t field_id, const char *string, size_t len, bool force = false) {
     if (len == 0 && !force)
       return;
 
     this->encode_field_raw(field_id, 2);  // type 2: Length-delimited string
-    this->encode_varint_raw(len);
+    this->encode_varint(len);
 
     // Using resize + memcpy instead of insert provides significant performance improvement:
     // ~10-11x faster for 16-32 byte strings, ~3x faster for 64-byte strings
@@ -278,13 +343,13 @@ class ProtoWriteBuffer {
     if (value == 0 && !force)
       return;
     this->encode_field_raw(field_id, 0);  // type 0: Varint - uint32
-    this->encode_varint_raw(value);
+    this->encode_varint(value);
   }
   void encode_uint64(uint32_t field_id, uint64_t value, bool force = false) {
     if (value == 0 && !force)
       return;
     this->encode_field_raw(field_id, 0);  // type 0: Varint - uint64
-    this->encode_varint_raw(ProtoVarInt(value));
+    this->encode_varint(value);
   }
   void encode_bool(uint32_t field_id, bool value, bool force = false) {
     if (!value && !force)

esphome/components/binary_sensor/__init__.py

@@ -548,6 +548,11 @@ def binary_sensor_schema(
     return _BINARY_SENSOR_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+BINARY_SENSOR_SCHEMA = binary_sensor_schema()
+BINARY_SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("binary_sensor"))
+
+
 async def setup_binary_sensor_core_(var, config):
     await setup_entity(var, config, "binary_sensor")
 

esphome/components/button/__init__.py

@@ -84,6 +84,11 @@ def button_schema(
     return _BUTTON_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+BUTTON_SCHEMA = button_schema(Button)
+BUTTON_SCHEMA.add_extra(cv.deprecated_schema_constant("button"))
+
+
 async def setup_button_core_(var, config):
     await setup_entity(var, config, "button")
 

esphome/components/climate/__init__.py

@@ -270,6 +270,11 @@ def climate_schema(
     return _CLIMATE_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+CLIMATE_SCHEMA = climate_schema(Climate)
+CLIMATE_SCHEMA.add_extra(cv.deprecated_schema_constant("climate"))
+
+
 async def setup_climate_core_(var, config):
     await setup_entity(var, config, "climate")
 

esphome/components/climate_ir/__init__.py

@@ -1,9 +1,10 @@
 import logging
 
+from esphome import core
 import esphome.codegen as cg
 from esphome.components import climate, remote_base, sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_SENSOR, CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT
+from esphome.const import CONF_ID, CONF_SENSOR, CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT
 from esphome.cpp_generator import MockObjClass
 
 _LOGGER = logging.getLogger(__name__)
@@ -51,6 +52,26 @@ def climate_ir_with_receiver_schema(
     )
 
 
+# Remove before 2025.11.0
+def deprecated_schema_constant(config):
+    type: str = "unknown"
+    if (id := config.get(CONF_ID)) is not None and isinstance(id, core.ID):
+        type = str(id.type).split("::", maxsplit=1)[0]
+    _LOGGER.warning(
+        "Using `climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA` is deprecated and will be removed in ESPHome 2025.11.0. "
+        "Please use `climate_ir.climate_ir_with_receiver_schema(...)` instead. "
+        "If you are seeing this, report an issue to the external_component author and ask them to update it. "
+        "https://developers.esphome.io/blog/2025/05/14/_schema-deprecations/. "
+        "Component using this schema: %s",
+        type,
+    )
+    return config
+
+
+CLIMATE_IR_WITH_RECEIVER_SCHEMA = climate_ir_with_receiver_schema(ClimateIR)
+CLIMATE_IR_WITH_RECEIVER_SCHEMA.add_extra(deprecated_schema_constant)
+
+
 async def register_climate_ir(var, config):
     await cg.register_component(var, config)
     await remote_base.register_transmittable(var, config)

esphome/components/cover/__init__.py

@@ -151,6 +151,11 @@ def cover_schema(
     return _COVER_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+COVER_SCHEMA = cover_schema(Cover)
+COVER_SCHEMA.add_extra(cv.deprecated_schema_constant("cover"))
+
+
 async def setup_cover_core_(var, config):
     await setup_entity(var, config, "cover")
 

esphome/components/event/__init__.py

@@ -85,6 +85,11 @@ def event_schema(
     return _EVENT_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+EVENT_SCHEMA = event_schema()
+EVENT_SCHEMA.add_extra(cv.deprecated_schema_constant("event"))
+
+
 async def setup_event_core_(var, config, *, event_types: list[str]):
     await setup_entity(var, config, "event")
 

esphome/components/fan/__init__.py

@@ -189,6 +189,10 @@ def fan_schema(
     return _FAN_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+FAN_SCHEMA = fan_schema(Fan)
+FAN_SCHEMA.add_extra(cv.deprecated_schema_constant("fan"))
+
 _PRESET_MODES_SCHEMA = cv.All(
     cv.ensure_list(cv.string_strict),
     cv.Length(min=1),

esphome/components/image/image.cpp

@@ -125,7 +125,7 @@ lv_img_dsc_t *Image::get_lv_img_dsc() {
 
       case IMAGE_TYPE_RGB:
 #if LV_COLOR_DEPTH == 32
-        switch (this->transparency_) {
+        switch (this->transparent_) {
           case TRANSPARENCY_ALPHA_CHANNEL:
             this->dsc_.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
             break;
@@ -156,8 +156,7 @@ lv_img_dsc_t *Image::get_lv_img_dsc() {
             break;
         }
 #else
-        this->dsc_.header.cf =
-            this->transparency_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
+        this->dsc_.header.cf = this->transparent_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
 #endif
         break;
     }

esphome/components/lock/__init__.py

@@ -91,6 +91,11 @@ def lock_schema(
     return _LOCK_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+LOCK_SCHEMA = lock_schema()
+LOCK_SCHEMA.add_extra(cv.deprecated_schema_constant("lock"))
+
+
 async def _setup_lock_core(var, config):
     await setup_entity(var, config, "lock")
 

esphome/components/lvgl/defines.py

@@ -5,7 +5,6 @@ Constants already defined in esphome.const are not duplicated here and must be i
 """
 
 import logging
-from typing import TYPE_CHECKING, Any
 
 from esphome import codegen as cg, config_validation as cv
 from esphome.const import CONF_ITEMS
@@ -13,7 +12,6 @@ from esphome.core import ID, Lambda
 from esphome.cpp_generator import LambdaExpression, MockObj
 from esphome.cpp_types import uint32
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import Expression, SafeExpType
 
 from .helpers import requires_component
 
@@ -44,13 +42,7 @@ def static_cast(type, value):
 def call_lambda(lamb: LambdaExpression):
     expr = lamb.content.strip()
     if expr.startswith("return") and expr.endswith(";"):
-        return expr[6:-1].strip()
-    # If lambda has parameters, call it with those parameter names
-    # Parameter names come from hardcoded component code (like "x", "it", "event")
-    # not from user input, so they're safe to use directly
-    if lamb.parameters and lamb.parameters.parameters:
-        param_names = ", ".join(str(param.id) for param in lamb.parameters.parameters)
-        return f"{lamb}({param_names})"
+        return expr[6:][:-1].strip()
     return f"{lamb}()"
 
 
@@ -73,20 +65,10 @@ class LValidator:
             return cv.returning_lambda(value)
         return self.validator(value)
 
-    async def process(
-        self, value: Any, args: list[tuple[SafeExpType, str]] | None = None
-    ) -> Expression:
+    async def process(self, value, args=()):
         if value is None:
             return None
         if isinstance(value, Lambda):
-            # Local import to avoid circular import
-            from .lvcode import CodeContext, LambdaContext
-
-            if TYPE_CHECKING:
-                # CodeContext does not have get_automation_parameters
-                # so we need to assert the type here
-                assert isinstance(CodeContext.code_context, LambdaContext)
-            args = args or CodeContext.code_context.get_automation_parameters()
             return cg.RawExpression(
                 call_lambda(
                     await cg.process_lambda(value, args, return_type=self.rtype)

esphome/components/lvgl/lv_validation.py

@@ -1,5 +1,3 @@
-from typing import TYPE_CHECKING, Any
-
 import esphome.codegen as cg
 from esphome.components import image
 from esphome.components.color import CONF_HEX, ColorStruct, from_rgbw
@@ -19,7 +17,6 @@ from esphome.cpp_generator import MockObj
 from esphome.cpp_types import ESPTime, int32, uint32
 from esphome.helpers import cpp_string_escape
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import Expression, SafeExpType
 
 from . import types as ty
 from .defines import (
@@ -391,23 +388,11 @@ class TextValidator(LValidator):
             return value
         return super().__call__(value)
 
-    async def process(
-        self, value: Any, args: list[tuple[SafeExpType, str]] | None = None
-    ) -> Expression:
-        # Local import to avoid circular import at module level
-
-        from .lvcode import CodeContext, LambdaContext
-
-        if TYPE_CHECKING:
-            # CodeContext does not have get_automation_parameters
-            # so we need to assert the type here
-            assert isinstance(CodeContext.code_context, LambdaContext)
-        args = args or CodeContext.code_context.get_automation_parameters()
-
+    async def process(self, value, args=()):
         if isinstance(value, dict):
             if format_str := value.get(CONF_FORMAT):
-                str_args = [str(x) for x in value[CONF_ARGS]]
-                arg_expr = cg.RawExpression(",".join(str_args))
+                args = [str(x) for x in value[CONF_ARGS]]
+                arg_expr = cg.RawExpression(",".join(args))
                 format_str = cpp_string_escape(format_str)
                 return literal(f"str_sprintf({format_str}, {arg_expr}).c_str()")
             if time_format := value.get(CONF_TIME_FORMAT):

esphome/components/lvgl/lvcode.py

@@ -164,9 +164,6 @@ class LambdaContext(CodeContext):
             code_text.append(text)
         return code_text
 
-    def get_automation_parameters(self) -> list[tuple[SafeExpType, str]]:
-        return self.parameters
-
     async def __aenter__(self):
         await super().__aenter__()
         add_line_marks(self.where)
@@ -181,8 +178,9 @@ class LvContext(LambdaContext):
 
     added_lambda_count = 0
 
-    def __init__(self):
-        super().__init__(parameters=LVGL_COMP_ARG)
+    def __init__(self, args=None):
+        self.args = args or LVGL_COMP_ARG
+        super().__init__(parameters=self.args)
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await super().__aexit__(exc_type, exc_val, exc_tb)
@@ -191,11 +189,6 @@ class LvContext(LambdaContext):
         cg.add(expression)
         return expression
 
-    def get_automation_parameters(self) -> list[tuple[SafeExpType, str]]:
-        # When generating automations, we don't want the `lv_component` parameter to be passed
-        # to the lambda.
-        return []
-
     def __call__(self, *args):
         return self.add(*args)
 

esphome/components/lvgl/lvgl_esphome.h

@@ -358,7 +358,7 @@ class LvSelectable : public LvCompound {
   virtual void set_selected_index(size_t index, lv_anim_enable_t anim) = 0;
   void set_selected_text(const std::string &text, lv_anim_enable_t anim);
   std::string get_selected_text();
-  const std::vector<std::string> &get_options() { return this->options_; }
+  std::vector<std::string> get_options() { return this->options_; }
   void set_options(std::vector<std::string> options);
 
  protected:

esphome/components/lvgl/select/lvgl_select.h

@@ -53,17 +53,7 @@ class LVGLSelect : public select::Select, public Component {
     this->widget_->set_selected_text(value, this->anim_);
     this->publish();
   }
-  void set_options_() {
-    // Widget uses std::vector<std::string>, SelectTraits uses FixedVector<const char*>
-    // Convert by extracting c_str() pointers
-    const auto &opts = this->widget_->get_options();
-    FixedVector<const char *> opt_ptrs;
-    opt_ptrs.init(opts.size());
-    for (size_t i = 0; i < opts.size(); i++) {
-      opt_ptrs[i] = opts[i].c_str();
-    }
-    this->traits.set_options(opt_ptrs);
-  }
+  void set_options_() { this->traits.set_options(this->widget_->get_options()); }
 
   LvSelectable *widget_;
   lv_anim_enable_t anim_;

esphome/components/lvgl/sensor/__init__.py

@@ -5,6 +5,7 @@ from ..defines import CONF_WIDGET
 from ..lvcode import (
     API_EVENT,
     EVENT_ARG,
+    LVGL_COMP_ARG,
     UPDATE_EVENT,
     LambdaContext,
     LvContext,
@@ -29,7 +30,7 @@ async def to_code(config):
     await wait_for_widgets()
     async with LambdaContext(EVENT_ARG) as lamb:
         lv_add(sensor.publish_state(widget.get_value()))
-    async with LvContext():
+    async with LvContext(LVGL_COMP_ARG):
         lv_add(
             lvgl_static.add_event_cb(
                 widget.obj,

esphome/components/lvgl/widgets/canvas.py

@@ -33,7 +33,7 @@ from ..lv_validation import (
     pixels,
     size,
 )
-from ..lvcode import LocalVariable, lv, lv_assign, lv_expr
+from ..lvcode import LocalVariable, lv, lv_assign
 from ..schemas import STYLE_PROPS, STYLE_REMAP, TEXT_SCHEMA, point_schema
 from ..types import LvType, ObjUpdateAction, WidgetType
 from . import Widget, get_widgets
@@ -70,18 +70,15 @@ class CanvasType(WidgetType):
         width = config[CONF_WIDTH]
         height = config[CONF_HEIGHT]
         use_alpha = "_ALPHA" if config[CONF_TRANSPARENT] else ""
-        buf_size = literal(
-            f"LV_CANVAS_BUF_SIZE_TRUE_COLOR{use_alpha}({width}, {height})"
+        lv.canvas_set_buffer(
+            w.obj,
+            lv.custom_mem_alloc(
+                literal(f"LV_CANVAS_BUF_SIZE_TRUE_COLOR{use_alpha}({width}, {height})")
+            ),
+            width,
+            height,
+            literal(f"LV_IMG_CF_TRUE_COLOR{use_alpha}"),
         )
-        with LocalVariable("buf", cg.void, lv_expr.custom_mem_alloc(buf_size)) as buf:
-            cg.add(cg.RawExpression(f"memset({buf}, 0, {buf_size});"))
-            lv.canvas_set_buffer(
-                w.obj,
-                buf,
-                width,
-                height,
-                literal(f"LV_IMG_CF_TRUE_COLOR{use_alpha}"),
-            )
 
 
 canvas_spec = CanvasType()

esphome/components/media_player/__init__.py

@@ -192,6 +192,10 @@ def media_player_schema(
     return _MEDIA_PLAYER_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+MEDIA_PLAYER_SCHEMA = media_player_schema(MediaPlayer)
+MEDIA_PLAYER_SCHEMA.add_extra(cv.deprecated_schema_constant("media_player"))
+
 MEDIA_PLAYER_ACTION_SCHEMA = automation.maybe_simple_id(
     cv.Schema(
         {

esphome/components/modbus_controller/select/modbus_select.cpp

@@ -28,7 +28,7 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
 
     if (map_it != this->mapping_.cend()) {
       size_t idx = std::distance(this->mapping_.cbegin(), map_it);
-      new_state = std::string(this->option_at(idx));
+      new_state = this->traits.get_options()[idx];
       ESP_LOGV(TAG, "Found option %s for value %lld", new_state->c_str(), value);
     } else {
       ESP_LOGE(TAG, "No option found for mapping %lld", value);
@@ -41,12 +41,10 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
 }
 
 void ModbusSelect::control(const std::string &value) {
-  auto idx = this->index_of(value);
-  if (!idx.has_value()) {
-    ESP_LOGW(TAG, "Invalid option '%s'", value.c_str());
-    return;
-  }
-  optional<int64_t> mapval = this->mapping_[idx.value()];
+  auto options = this->traits.get_options();
+  auto opt_it = std::find(options.cbegin(), options.cend(), value);
+  size_t idx = std::distance(options.cbegin(), opt_it);
+  optional<int64_t> mapval = this->mapping_[idx];
   ESP_LOGD(TAG, "Found value %lld for option '%s'", *mapval, value.c_str());
 
   std::vector<uint16_t> data;

esphome/components/number/__init__.py

@@ -238,6 +238,11 @@ def number_schema(
     return _NUMBER_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+NUMBER_SCHEMA = number_schema(Number)
+NUMBER_SCHEMA.add_extra(cv.deprecated_schema_constant("number"))
+
+
 async def setup_number_core_(
     var, config, *, min_value: float, max_value: float, step: float
 ):

esphome/components/remote_transmitter/__init__.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
@@ -20,12 +18,9 @@ from esphome.const import (
 )
 from esphome.core import CORE
 
-_LOGGER = logging.getLogger(__name__)
-
 AUTO_LOAD = ["remote_base"]
 
 CONF_EOT_LEVEL = "eot_level"
-CONF_NON_BLOCKING = "non_blocking"
 CONF_ON_TRANSMIT = "on_transmit"
 CONF_ON_COMPLETE = "on_complete"
 CONF_TRANSMITTER_ID = remote_base.CONF_TRANSMITTER_ID
@@ -70,25 +65,11 @@ CONFIG_SCHEMA = cv.Schema(
             esp32_c6=48,
             esp32_h2=48,
         ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
-        cv.Optional(CONF_NON_BLOCKING): cv.All(cv.only_on_esp32, cv.boolean),
         cv.Optional(CONF_ON_TRANSMIT): automation.validate_automation(single=True),
         cv.Optional(CONF_ON_COMPLETE): automation.validate_automation(single=True),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
-
-def _validate_non_blocking(config):
-    if CORE.is_esp32 and CONF_NON_BLOCKING not in config:
-        _LOGGER.warning(
-            "'non_blocking' is not set for 'remote_transmitter' and will default to 'true'.\n"
-            "The default behavior changed in 2025.11.0; previously blocking mode was used.\n"
-            "To silence this warning, explicitly set 'non_blocking: true' (or 'false')."
-        )
-        config[CONF_NON_BLOCKING] = True
-
-
-FINAL_VALIDATE_SCHEMA = _validate_non_blocking
-
 DIGITAL_WRITE_ACTION_SCHEMA = cv.maybe_simple_value(
     {
         cv.GenerateID(CONF_TRANSMITTER_ID): cv.use_id(RemoteTransmitterComponent),
@@ -114,7 +95,6 @@ async def to_code(config):
     if CORE.is_esp32:
         var = cg.new_Pvariable(config[CONF_ID], pin)
         cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
-        cg.add(var.set_non_blocking(config[CONF_NON_BLOCKING]))
         if CONF_CLOCK_RESOLUTION in config:
             cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
         if CONF_USE_DMA in config:

esphome/components/remote_transmitter/remote_transmitter.h

@@ -54,7 +54,6 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #if defined(USE_ESP32)
   void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
   void set_eot_level(bool eot_level) { this->eot_level_ = eot_level; }
-  void set_non_blocking(bool non_blocking) { this->non_blocking_ = non_blocking; }
 #endif
 
   Trigger<> *get_transmit_trigger() const { return this->transmit_trigger_; };
@@ -75,7 +74,6 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 
 #ifdef USE_ESP32
   void configure_rmt_();
-  void wait_for_rmt_();
 
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
   RemoteTransmitterComponentStore store_{};
@@ -92,7 +90,6 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
   esp_err_t error_code_{ESP_OK};
   std::string error_string_{""};
   bool inverted_{false};
-  bool non_blocking_{false};
 #endif
   uint8_t carrier_duty_percent_;
 

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -196,29 +196,12 @@ void RemoteTransmitterComponent::configure_rmt_() {
   }
 }
 
-void RemoteTransmitterComponent::wait_for_rmt_() {
-  esp_err_t error = rmt_tx_wait_all_done(this->channel_, -1);
-  if (error != ESP_OK) {
-    ESP_LOGW(TAG, "rmt_tx_wait_all_done failed: %s", esp_err_to_name(error));
-    this->status_set_warning();
-  }
-
-  this->complete_trigger_->trigger();
-}
-
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
-  uint64_t total_duration = 0;
-
   if (this->is_failed()) {
     return;
   }
 
-  // if the timeout was cancelled, block until the tx is complete
-  if (this->non_blocking_ && this->cancel_timeout("complete")) {
-    this->wait_for_rmt_();
-  }
-
   if (this->current_carrier_frequency_ != this->temp_.get_carrier_frequency()) {
     this->current_carrier_frequency_ = this->temp_.get_carrier_frequency();
     this->configure_rmt_();
@@ -229,7 +212,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
 
   // encode any delay at the start of the buffer to simplify the encoder callback
   // this will be skipped the first time around
-  total_duration += send_wait * (send_times - 1);
   send_wait = this->from_microseconds_(static_cast<uint32_t>(send_wait));
   while (send_wait > 0) {
     int32_t duration = std::min(send_wait, uint32_t(RMT_SYMBOL_DURATION_MAX));
@@ -247,7 +229,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (!level) {
       value = -value;
     }
-    total_duration += value * send_times;
     value = this->from_microseconds_(static_cast<uint32_t>(value));
     while (value > 0) {
       int32_t duration = std::min(value, int32_t(RMT_SYMBOL_DURATION_MAX));
@@ -279,12 +260,13 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   } else {
     this->status_clear_warning();
   }
-
-  if (this->non_blocking_) {
-    this->set_timeout("complete", total_duration / 1000, [this]() { this->wait_for_rmt_(); });
-  } else {
-    this->wait_for_rmt_();
+  error = rmt_tx_wait_all_done(this->channel_, -1);
+  if (error != ESP_OK) {
+    ESP_LOGW(TAG, "rmt_tx_wait_all_done failed: %s", esp_err_to_name(error));
+    this->status_set_warning();
   }
+
+  this->complete_trigger_->trigger();
 }
 #else
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {

esphome/components/select/__init__.py

@@ -86,6 +86,11 @@ def select_schema(
     return _SELECT_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+SELECT_SCHEMA = select_schema(Select)
+SELECT_SCHEMA.add_extra(cv.deprecated_schema_constant("select"))
+
+
 async def setup_select_core_(var, config, *, options: list[str]):
     await setup_entity(var, config, "select")
 

esphome/components/select/select.cpp

@@ -1,6 +1,5 @@
 #include "select.h"
 #include "esphome/core/log.h"
-#include <cstring>
 
 namespace esphome {
 namespace select {
@@ -36,7 +35,7 @@ size_t Select::size() const {
 optional<size_t> Select::index_of(const std::string &option) const {
   const auto &options = traits.get_options();
   for (size_t i = 0; i < options.size(); i++) {
-    if (strcmp(options[i], option.c_str()) == 0) {
+    if (options[i] == option) {
       return i;
     }
   }
@@ -54,13 +53,11 @@ optional<size_t> Select::active_index() const {
 optional<std::string> Select::at(size_t index) const {
   if (this->has_index(index)) {
     const auto &options = traits.get_options();
-    return std::string(options.at(index));
+    return options.at(index);
   } else {
     return {};
   }
 }
 
-const char *Select::option_at(size_t index) const { return traits.get_options().at(index); }
-
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select.h

@@ -56,9 +56,6 @@ class Select : public EntityBase {
   /// Return the (optional) option value at the provided index offset.
   optional<std::string> at(size_t index) const;
 
-  /// Return the option value at the provided index offset (as const char* from flash).
-  const char *option_at(size_t index) const;
-
   void add_on_state_callback(std::function<void(std::string, size_t)> &&callback);
 
  protected:

esphome/components/select/select_traits.cpp

@@ -3,16 +3,9 @@
 namespace esphome {
 namespace select {
 
-void SelectTraits::set_options(const std::initializer_list<const char *> &options) { this->options_ = options; }
+void SelectTraits::set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
 
-void SelectTraits::set_options(const FixedVector<const char *> &options) {
-  this->options_.init(options.size());
-  for (size_t i = 0; i < options.size(); i++) {
-    this->options_[i] = options[i];
-  }
-}
-
-const FixedVector<const char *> &SelectTraits::get_options() const { return this->options_; }
+const std::vector<std::string> &SelectTraits::get_options() const { return this->options_; }
 
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select_traits.h

@@ -1,19 +1,18 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
-#include <initializer_list>
+#include <vector>
+#include <string>
 
 namespace esphome {
 namespace select {
 
 class SelectTraits {
  public:
-  void set_options(const std::initializer_list<const char *> &options);
-  void set_options(const FixedVector<const char *> &options);
-  const FixedVector<const char *> &get_options() const;
+  void set_options(std::vector<std::string> options);
+  const std::vector<std::string> &get_options() const;
 
  protected:
-  FixedVector<const char *> options_;
+  std::vector<std::string> options_;
 };
 
 }  // namespace select

esphome/components/sensor/__init__.py

@@ -369,6 +369,11 @@ def sensor_schema(
     return _SENSOR_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+SENSOR_SCHEMA = sensor_schema()
+SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("sensor"))
+
+
 @FILTER_REGISTRY.register("offset", OffsetFilter, cv.templatable(cv.float_))
 async def offset_filter_to_code(config, filter_id):
     template_ = await cg.templatable(config, [], float)

esphome/components/switch/__init__.py

@@ -139,6 +139,11 @@ def switch_schema(
     return _SWITCH_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+SWITCH_SCHEMA = switch_schema(Switch)
+SWITCH_SCHEMA.add_extra(cv.deprecated_schema_constant("switch"))
+
+
 async def setup_switch_core_(var, config):
     await setup_entity(var, config, "switch")
 

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -25,20 +25,6 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
   this->sensor_data_.push_back(sd);
   this->sensor_map_[sensor].store_index = this->next_store_index_++;
 };
-
-static const LogString *sensor_type_to_string(AlarmSensorType type) {
-  switch (type) {
-    case ALARM_SENSOR_TYPE_INSTANT:
-      return LOG_STR("instant");
-    case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
-      return LOG_STR("delayed_follower");
-    case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
-      return LOG_STR("instant_always");
-    case ALARM_SENSOR_TYPE_DELAYED:
-    default:
-      return LOG_STR("delayed");
-  }
-}
 #endif
 
 void TemplateAlarmControlPanel::dump_config() {
@@ -60,20 +46,35 @@ void TemplateAlarmControlPanel::dump_config() {
                 "  Supported Features: %" PRIu32,
                 (this->pending_time_ / 1000), (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (auto sensor_info : this->sensor_map_) {
+    ESP_LOGCONFIG(TAG, "  Binary Sensor:");
     ESP_LOGCONFIG(TAG,
-                  "  Binary Sensor:\n"
                   "    Name: %s\n"
-                  "    Type: %s\n"
                   "    Armed home bypass: %s\n"
                   "    Armed night bypass: %s\n"
                   "    Auto bypass: %s\n"
                   "    Chime mode: %s",
-                  sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(info.type)),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_CHIME));
+                  sensor_info.first->get_name().c_str(),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME));
+    const char *sensor_type;
+    switch (sensor_info.second.type) {
+      case ALARM_SENSOR_TYPE_INSTANT:
+        sensor_type = "instant";
+        break;
+      case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
+        sensor_type = "delayed_follower";
+        break;
+      case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
+        sensor_type = "instant_always";
+        break;
+      case ALARM_SENSOR_TYPE_DELAYED:
+      default:
+        sensor_type = "delayed";
+    }
+    ESP_LOGCONFIG(TAG, "    Sensor type: %s", sensor_type);
   }
 #endif
 }
@@ -122,37 +123,39 @@ void TemplateAlarmControlPanel::loop() {
   bool instant_sensor_faulted = false;
 
 #ifdef USE_BINARY_SENSOR
-  // Test all of the sensors regardless of the alarm panel state
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  // Test all of the sensors in the list regardless of the alarm panel state
+  for (auto sensor_info : this->sensor_map_) {
     // Check for chime zones
-    if (info.flags & BINARY_SENSOR_MODE_CHIME) {
+    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME)) {
       // Look for the transition from closed to open
-      if ((!this->sensor_data_[info.store_index].last_chime_state) && (sensor->state)) {
+      if ((!this->sensor_data_[sensor_info.second.store_index].last_chime_state) && (sensor_info.first->state)) {
         // Must be disarmed to chime
         if (this->current_state_ == ACP_STATE_DISARMED) {
           this->chime_callback_.call();
         }
       }
       // Record the sensor state change
-      this->sensor_data_[info.store_index].last_chime_state = sensor->state;
+      this->sensor_data_[sensor_info.second.store_index].last_chime_state = sensor_info.first->state;
     }
     // Check for faulted sensors
-    if (sensor->state) {
+    if (sensor_info.first->state) {  // Sensor triggered?
       // Skip if auto bypassed
       if (std::count(this->bypassed_sensor_indicies_.begin(), this->bypassed_sensor_indicies_.end(),
-                     info.store_index) == 1) {
+                     sensor_info.second.store_index) == 1) {
         continue;
       }
       // Skip if bypass armed home
-      if ((this->current_state_ == ACP_STATE_ARMED_HOME) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
+      if (this->current_state_ == ACP_STATE_ARMED_HOME &&
+          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
         continue;
       }
       // Skip if bypass armed night
-      if ((this->current_state_ == ACP_STATE_ARMED_NIGHT) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
+      if (this->current_state_ == ACP_STATE_ARMED_NIGHT &&
+          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
         continue;
       }
 
-      switch (info.type) {
+      switch (sensor_info.second.type) {
         case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
           next_state = ACP_STATE_TRIGGERED;
           [[fallthrough]];
@@ -244,11 +247,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (auto sensor_info : this->sensor_map_) {
     // Check for faulted bypass_auto sensors and remove them from monitoring
-    if ((info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor->state)) {
-      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", sensor->get_name().c_str());
-      this->bypassed_sensor_indicies_.push_back(info.store_index);
+    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor_info.first->state)) {
+      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", sensor_info.first->get_name().c_str());
+      this->bypassed_sensor_indicies_.push_back(sensor_info.second.store_index);
     }
   }
 #endif

esphome/components/template/select/template_select.cpp

@@ -16,12 +16,12 @@ void TemplateSelect::setup() {
     size_t restored_index;
     if (this->pref_.load(&restored_index) && this->has_index(restored_index)) {
       index = restored_index;
-      ESP_LOGD(TAG, "State from restore: %s", this->option_at(index));
+      ESP_LOGD(TAG, "State from restore: %s", this->at(index).value().c_str());
     } else {
-      ESP_LOGD(TAG, "State from initial (could not load or invalid stored index): %s", this->option_at(index));
+      ESP_LOGD(TAG, "State from initial (could not load or invalid stored index): %s", this->at(index).value().c_str());
     }
   } else {
-    ESP_LOGD(TAG, "State from initial: %s", this->option_at(index));
+    ESP_LOGD(TAG, "State from initial: %s", this->at(index).value().c_str());
   }
 
   this->publish_state(this->at(index).value());
@@ -64,7 +64,8 @@ void TemplateSelect::dump_config() {
                 "  Optimistic: %s\n"
                 "  Initial Option: %s\n"
                 "  Restore Value: %s",
-                YESNO(this->optimistic_), this->option_at(this->initial_option_index_), YESNO(this->restore_value_));
+                YESNO(this->optimistic_), this->at(this->initial_option_index_).value().c_str(),
+                YESNO(this->restore_value_));
 }
 
 }  // namespace template_

esphome/components/text/__init__.py

@@ -84,6 +84,11 @@ def text_schema(
     return _TEXT_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+TEXT_SCHEMA = text_schema()
+TEXT_SCHEMA.add_extra(cv.deprecated_schema_constant("text"))
+
+
 async def setup_text_core_(
     var,
     config,

esphome/components/text_sensor/__init__.py

@@ -193,6 +193,11 @@ def text_sensor_schema(
     return _TEXT_SENSOR_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+TEXT_SENSOR_SCHEMA = text_sensor_schema()
+TEXT_SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("text_sensor"))
+
+
 async def build_filters(config):
     return await cg.build_registry_list(FILTER_REGISTRY, config)
 

esphome/components/tuya/select/tuya_select.cpp

@@ -10,6 +10,7 @@ void TuyaSelect::setup() {
   this->parent_->register_listener(this->select_id_, [this](const TuyaDatapoint &datapoint) {
     uint8_t enum_value = datapoint.value_enum;
     ESP_LOGV(TAG, "MCU reported select %u value %u", this->select_id_, enum_value);
+    auto options = this->traits.get_options();
     auto mappings = this->mappings_;
     auto it = std::find(mappings.cbegin(), mappings.cend(), enum_value);
     if (it == mappings.end()) {
@@ -48,9 +49,9 @@ void TuyaSelect::dump_config() {
                 "  Data type: %s\n"
                 "  Options are:",
                 this->select_id_, this->is_int_ ? "int" : "enum");
-  const auto &options = this->traits.get_options();
+  auto options = this->traits.get_options();
   for (size_t i = 0; i < this->mappings_.size(); i++) {
-    ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i));
+    ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i).c_str());
   }
 }
 

esphome/components/update/__init__.py

@@ -84,6 +84,11 @@ def update_schema(
     return _UPDATE_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+UPDATE_SCHEMA = update_schema()
+UPDATE_SCHEMA.add_extra(cv.deprecated_schema_constant("update"))
+
+
 async def setup_update_core_(var, config):
     await setup_entity(var, config, "update")
 

esphome/components/valve/__init__.py

@@ -129,6 +129,11 @@ def valve_schema(
     return _VALVE_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+VALVE_SCHEMA = valve_schema()
+VALVE_SCHEMA.add_extra(cv.deprecated_schema_constant("valve"))
+
+
 async def _setup_valve_core(var, config):
     await setup_entity(var, config, "valve")
 

esphome/config.py

@@ -319,9 +319,6 @@ def iter_ids(config, path=None):
             yield from iter_ids(item, path + [i])
     elif isinstance(config, dict):
         for key, value in config.items():
-            if len(path) == 0 and key == CONF_SUBSTITUTIONS:
-                # Ignore IDs in substitution definitions.
-                continue
             if isinstance(key, core.ID):
                 yield key, path
             yield from iter_ids(value, path + [key])

esphome/config_validation.py

@@ -2195,3 +2195,26 @@ def rename_key(old_key, new_key):
         return config
 
     return validator
+
+
+# Remove before 2025.11.0
+def deprecated_schema_constant(entity_type: str):
+    def validator(config):
+        type: str = "unknown"
+        if (id := config.get(CONF_ID)) is not None and isinstance(id, core.ID):
+            type = str(id.type).split("::", maxsplit=1)[0]
+        _LOGGER.warning(
+            "Using `%s.%s_SCHEMA` is deprecated and will be removed in ESPHome 2025.11.0. "
+            "Please use `%s.%s_schema(...)` instead. "
+            "If you are seeing this, report an issue to the external_component author and ask them to update it. "
+            "https://developers.esphome.io/blog/2025/05/14/_schema-deprecations/. "
+            "Component using this schema: %s",
+            entity_type,
+            entity_type.upper(),
+            entity_type,
+            entity_type,
+            type,
+        )
+        return config
+
+    return validator

esphome/core/helpers.h

@@ -304,11 +304,6 @@ template<typename T> class FixedVector {
     return data_[size_ - 1];
   }
 
-  /// Access first element (no bounds checking - matches std::vector behavior)
-  /// Caller must ensure vector is not empty (size() > 0)
-  T &front() { return data_[0]; }
-  const T &front() const { return data_[0]; }
-
   /// Access last element (no bounds checking - matches std::vector behavior)
   /// Caller must ensure vector is not empty (size() > 0)
   T &back() { return data_[size_ - 1]; }
@@ -322,11 +317,6 @@ template<typename T> class FixedVector {
   T &operator[](size_t i) { return data_[i]; }
   const T &operator[](size_t i) const { return data_[i]; }
 
-  /// Access element with bounds checking (matches std::vector behavior)
-  /// Note: No exception thrown on out of bounds - caller must ensure index is valid
-  T &at(size_t i) { return data_[i]; }
-  const T &at(size_t i) const { return data_[i]; }
-
   // Iterator support for range-based for loops
   T *begin() { return data_; }
   T *end() { return data_ + size_; }

esphome/core/macros.h

@@ -3,6 +3,17 @@
 // Helper macro to define a version code, whose value can be compared against other version codes.
 #define VERSION_CODE(major, minor, patch) ((major) << 16 | (minor) << 8 | (patch))
 
+// Branch prediction hints for performance-critical paths
+#if defined(__GNUC__) || defined(__clang__)
+// GCC and Clang: use __builtin_expect for better optimization
+#define ESPHOME_LIKELY(x) __builtin_expect(!!(x), 1)
+#define ESPHOME_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+// Other C++20 compilers: use standard attributes
+#define ESPHOME_LIKELY(x) (x) [[likely]]
+#define ESPHOME_UNLIKELY(x) (x) [[unlikely]]
+#endif
+
 #ifdef USE_ARDUINO
 #include <Arduino.h>
 #endif

requirements.txt

@@ -12,7 +12,7 @@ platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20251013.0
-aioesphomeapi==42.5.0
+aioesphomeapi==42.4.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.18.16 # dashboard_import

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.1  # 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

@@ -1162,11 +1162,7 @@ class SInt64Type(TypeInfo):
 
 
 def _generate_array_dump_content(
-    ti,
-    field_name: str,
-    name: str,
-    is_bool: bool = False,
-    is_const_char_ptr: bool = False,
+    ti, field_name: str, name: str, is_bool: bool = False
 ) -> str:
     """Generate dump content for array types (repeated or fixed array).
 
@@ -1174,10 +1170,7 @@ def _generate_array_dump_content(
     """
     o = f"for (const auto {'' if is_bool else '&'}it : {field_name}) {{\n"
     # Check if underlying type can use dump_field
-    if is_const_char_ptr:
-        # Special case for const char* - use it directly
-        o += f'  dump_field(out, "{name}", it, 4);\n'
-    elif ti.can_use_dump_field():
+    if ti.can_use_dump_field():
         # For types that have dump_field overloads, use them with extra indent
         # std::vector<bool> iterators return proxy objects, need explicit cast
         value_expr = "static_cast<bool>(it)" if is_bool else ti.dump_field_value("it")
@@ -1540,16 +1533,11 @@ class RepeatedTypeInfo(TypeInfo):
     def encode_content(self) -> str:
         if self._use_pointer:
             # For pointer fields, just dereference (pointer should never be null in our use case)
-            # Special handling for const char* elements (when container_no_template contains "const char")
-            if "const char" in self._container_no_template:
-                o = f"for (const char *it : *this->{self.field_name}) {{\n"
-                o += f"  buffer.{self._ti.encode_func}({self.number}, it, strlen(it), true);\n"
+            o = f"for (const auto &it : *this->{self.field_name}) {{\n"
+            if isinstance(self._ti, EnumType):
+                o += f"  buffer.{self._ti.encode_func}({self.number}, static_cast<uint32_t>(it), true);\n"
             else:
-                o = f"for (const auto &it : *this->{self.field_name}) {{\n"
-                if isinstance(self._ti, EnumType):
-                    o += f"  buffer.{self._ti.encode_func}({self.number}, static_cast<uint32_t>(it), true);\n"
-                else:
-                    o += f"  buffer.{self._ti.encode_func}({self.number}, it, true);\n"
+                o += f"  buffer.{self._ti.encode_func}({self.number}, it, true);\n"
             o += "}"
             return o
         o = f"for (auto {'' if self._ti_is_bool else '&'}it : this->{self.field_name}) {{\n"
@@ -1562,18 +1550,10 @@ class RepeatedTypeInfo(TypeInfo):
 
     @property
     def dump_content(self) -> str:
-        # Check if this is const char* elements
-        is_const_char_ptr = (
-            self._use_pointer and "const char" in self._container_no_template
-        )
         if self._use_pointer:
             # For pointer fields, dereference and use the existing helper
             return _generate_array_dump_content(
-                self._ti,
-                f"*this->{self.field_name}",
-                self.name,
-                is_bool=False,
-                is_const_char_ptr=is_const_char_ptr,
+                self._ti, f"*this->{self.field_name}", self.name, is_bool=False
             )
         return _generate_array_dump_content(
             self._ti, f"this->{self.field_name}", self.name, is_bool=self._ti_is_bool
@@ -1608,14 +1588,9 @@ class RepeatedTypeInfo(TypeInfo):
             o += f"  size.add_precalculated_size({size_expr} * {bytes_per_element});\n"
         else:
             # Other types need the actual value
-            # Special handling for const char* elements
-            if self._use_pointer and "const char" in self._container_no_template:
-                o += f"  for (const char *it : {container_ref}) {{\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"
-                o += f"    {self._ti.get_size_calculation('it', True)}\n"
+            auto_ref = "" if self._ti_is_bool else "&"
+            o += f"  for (const auto {auto_ref}it : {container_ref}) {{\n"
+            o += f"    {self._ti.get_size_calculation('it', True)}\n"
             o += "  }\n"
 
         o += "}"
@@ -2567,12 +2542,6 @@ static void dump_field(std::string &out, const char *field_name, StringRef value
   out.append("\\n");
 }
 
-static void dump_field(std::string &out, const char *field_name, const char *value, int indent = 2) {
-  append_field_prefix(out, field_name, indent);
-  out.append("'").append(value).append("'");
-  out.append("\\n");
-}
-
 template<typename T>
 static void dump_field(std::string &out, const char *field_name, T value, int indent = 2) {
   append_field_prefix(out, field_name, indent);

script/build_language_schema.py

@@ -300,7 +300,7 @@ def fix_remote_receiver():
     remote_receiver_schema["CONFIG_SCHEMA"] = {
         "type": "schema",
         "schema": {
-            "extends": ["binary_sensor._BINARY_SENSOR_SCHEMA", "core.COMPONENT_SCHEMA"],
+            "extends": ["binary_sensor.BINARY_SENSOR_SCHEMA", "core.COMPONENT_SCHEMA"],
             "config_vars": output["remote_base"].pop("binary"),
         },
     }

script/determine-jobs.py

@@ -43,14 +43,12 @@ from enum import StrEnum
 from functools import cache
 import json
 import os
-from pathlib import Path
 import subprocess
 import sys
 from typing import Any
 
 from helpers import (
     CPP_FILE_EXTENSIONS,
-    ESPHOME_TESTS_COMPONENTS_PATH,
     PYTHON_FILE_EXTENSIONS,
     changed_files,
     core_changed,
@@ -67,17 +65,12 @@ from helpers import (
     parse_test_filename,
     root_path,
 )
-from split_components_for_ci import create_intelligent_batches
 
 # Threshold for splitting clang-tidy jobs
 # For small PRs (< 65 files), use nosplit for faster CI
 # For large PRs (>= 65 files), use split for better parallelization
 CLANG_TIDY_SPLIT_THRESHOLD = 65
 
-# Component test batch size (weighted)
-# Isolated components count as 10x, groupable components count as 1x
-COMPONENT_TEST_BATCH_SIZE = 40
-
 
 class Platform(StrEnum):
     """Platform identifiers for memory impact analysis."""
@@ -693,22 +686,6 @@ def main() -> None:
     # Determine which C++ unit tests to run
     cpp_run_all, cpp_components = determine_cpp_unit_tests(args.branch)
 
-    # Split components into batches for CI testing
-    # This intelligently groups components with similar bus configurations
-    component_test_batches: list[str]
-    if changed_components_with_tests:
-        tests_dir = Path(root_path) / ESPHOME_TESTS_COMPONENTS_PATH
-        batches, _ = create_intelligent_batches(
-            components=changed_components_with_tests,
-            tests_dir=tests_dir,
-            batch_size=COMPONENT_TEST_BATCH_SIZE,
-            directly_changed=directly_changed_with_tests,
-        )
-        # Convert batches to space-separated strings for CI matrix
-        component_test_batches = [" ".join(batch) for batch in batches]
-    else:
-        component_test_batches = []
-
     output: dict[str, Any] = {
         "integration_tests": run_integration,
         "clang_tidy": run_clang_tidy,
@@ -726,7 +703,6 @@ def main() -> None:
         "memory_impact": memory_impact,
         "cpp_unit_tests_run_all": cpp_run_all,
         "cpp_unit_tests_components": cpp_components,
-        "component_test_batches": component_test_batches,
     }
 
     # Output as JSON

script/helpers.py

@@ -90,18 +90,16 @@ def get_component_from_path(file_path: str) -> str | None:
     """Extract component name from a file path.
 
     Args:
-        file_path: Path to a file (e.g., "esphome/components/wifi/wifi.cpp"
-                                or "tests/components/uart/test.esp32-idf.yaml")
+        file_path: Path to a file (e.g., "esphome/components/wifi/wifi.cpp")
 
     Returns:
-        Component name if path is in components or tests directory, None otherwise
+        Component name if path is in components directory, None otherwise
     """
-    if file_path.startswith(ESPHOME_COMPONENTS_PATH) or file_path.startswith(
-        ESPHOME_TESTS_COMPONENTS_PATH
-    ):
-        parts = file_path.split("/")
-        if len(parts) >= 3 and parts[2]:
-            return parts[2]
+    if not file_path.startswith(ESPHOME_COMPONENTS_PATH):
+        return None
+    parts = file_path.split("/")
+    if len(parts) >= 3:
+        return parts[2]
     return None
 
 

script/split_components_for_ci.py

@@ -62,10 +62,6 @@ def create_intelligent_batches(
 ) -> tuple[list[list[str]], dict[tuple[str, str], list[str]]]:
     """Create batches optimized for component grouping.
 
-    IMPORTANT: This function is called from both split_components_for_ci.py (standalone script)
-    and determine-jobs.py (integrated into job determination). Be careful when refactoring
-    to ensure changes work in both contexts.
-
     Args:
         components: List of component names to batch
         tests_dir: Path to tests/components directory

tests/components/lvgl/common.yaml

@@ -52,19 +52,6 @@ number:
     widget: spinbox_id
     id: lvgl_spinbox_number
     name: LVGL Spinbox Number
-  - platform: template
-    id: test_brightness
-    name: "Test Brightness"
-    min_value: 0
-    max_value: 255
-    step: 1
-    optimistic: true
-    # Test lambda in automation accessing x parameter directly
-    # This is a real-world pattern from user configs
-    on_value:
-      - lambda: !lambda |-
-          // Direct use of x parameter in automation
-          ESP_LOGD("test", "Brightness: %.0f", x);
 
 light:
   - platform: lvgl
@@ -123,21 +110,3 @@ text:
     platform: lvgl
     widget: hello_label
     mode: text
-
-text_sensor:
-  - platform: template
-    id: test_text_sensor
-    name: "Test Text Sensor"
-    # Test nested lambdas in LVGL actions can access automation parameters
-    on_value:
-      - lvgl.label.update:
-          id: hello_label
-          text: !lambda return x.c_str();
-      - lvgl.label.update:
-          id: hello_label
-          text: !lambda |-
-            // Test complex lambda with conditionals accessing x parameter
-            if (x == "*") {
-              return "WILDCARD";
-            }
-            return x.c_str();

tests/components/lvgl/lvgl-package.yaml

@@ -257,30 +257,7 @@ lvgl:
             text: "Hello shiny day"
             text_color: 0xFFFFFF
             align: bottom_mid
-        - label:
-            id: setup_lambda_label
-            # Test lambda in widget property during setup (LvContext)
-            # Should NOT receive lv_component parameter
-            text: !lambda |-
-              char buf[32];
-              snprintf(buf, sizeof(buf), "Setup: %d", 42);
-              return std::string(buf);
-            align: top_mid
             text_font: space16
-        - label:
-            id: chip_info_label
-            # Test complex setup lambda (real-world pattern)
-            # Should NOT receive lv_component parameter
-            text: !lambda |-
-              // Test conditional compilation and string formatting
-              char buf[64];
-              #ifdef USE_ESP_IDF
-              snprintf(buf, sizeof(buf), "IDF: v%d.%d", ESP_IDF_VERSION_MAJOR, ESP_IDF_VERSION_MINOR);
-              #else
-              snprintf(buf, sizeof(buf), "Arduino");
-              #endif
-              return std::string(buf);
-            align: top_left
         - obj:
             align: center
             arc_opa: COVER

tests/components/remote_transmitter/esp32-common.yaml

@@ -2,7 +2,6 @@ remote_transmitter:
   - id: xmitr
     pin: ${pin}
     carrier_duty_percent: 50%
-    non_blocking: true
     clock_resolution: ${clock_resolution}
     rmt_symbols: ${rmt_symbols}
 

tests/script/test_determine_jobs.py

@@ -152,14 +152,6 @@ def test_main_all_tests_should_run(
     assert output["memory_impact"]["should_run"] == "false"
     assert output["cpp_unit_tests_run_all"] is False
     assert output["cpp_unit_tests_components"] == ["wifi", "api", "sensor"]
-    # component_test_batches should be present and be a list of space-separated strings
-    assert "component_test_batches" in output
-    assert isinstance(output["component_test_batches"], list)
-    # Each batch should be a space-separated string of component names
-    for batch in output["component_test_batches"]:
-        assert isinstance(batch, str)
-        # Should contain at least one component (no empty batches)
-        assert len(batch) > 0
 
 
 def test_main_no_tests_should_run(
@@ -217,9 +209,6 @@ def test_main_no_tests_should_run(
     assert output["memory_impact"]["should_run"] == "false"
     assert output["cpp_unit_tests_run_all"] is False
     assert output["cpp_unit_tests_components"] == []
-    # component_test_batches should be empty list
-    assert "component_test_batches" in output
-    assert output["component_test_batches"] == []
 
 
 def test_main_with_branch_argument(

tests/script/test_helpers.py

@@ -1065,39 +1065,3 @@ def test_parse_list_components_output(output: str, expected: list[str]) -> None:
     """Test parse_list_components_output function."""
     result = helpers.parse_list_components_output(output)
     assert result == expected
-
-
-@pytest.mark.parametrize(
-    ("file_path", "expected_component"),
-    [
-        # Component files
-        ("esphome/components/wifi/wifi.cpp", "wifi"),
-        ("esphome/components/uart/uart.h", "uart"),
-        ("esphome/components/api/api_server.cpp", "api"),
-        ("esphome/components/sensor/sensor.cpp", "sensor"),
-        # Test files
-        ("tests/components/uart/test.esp32-idf.yaml", "uart"),
-        ("tests/components/wifi/test.esp8266-ard.yaml", "wifi"),
-        ("tests/components/sensor/test.esp32-idf.yaml", "sensor"),
-        ("tests/components/api/test_api.cpp", "api"),
-        ("tests/components/uart/common.h", "uart"),
-        # Non-component files
-        ("esphome/core/component.cpp", None),
-        ("esphome/core/helpers.h", None),
-        ("tests/integration/test_api.py", None),
-        ("tests/unit_tests/test_helpers.py", None),
-        ("README.md", None),
-        ("script/helpers.py", None),
-        # Edge cases
-        ("esphome/components/", None),  # No component name
-        ("tests/components/", None),  # No component name
-        ("esphome/components", None),  # No trailing slash
-        ("tests/components", None),  # No trailing slash
-    ],
-)
-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

tests/unit_tests/core/test_config.py

@@ -261,17 +261,6 @@ def test_device_duplicate_id(
     assert "ID duplicate_device redefined!" in captured.out
 
 
-def test_substitution_with_id(
-    yaml_file: Callable[[str], str], capsys: pytest.CaptureFixture[str]
-) -> None:
-    """Test that a ids coming from substitutions do not cause false positive ID redefinition."""
-    load_config_from_fixture(
-        yaml_file, "id_collision_with_substitution.yaml", FIXTURES_DIR
-    )
-    captured = capsys.readouterr()
-    assert "ID some_switch_id redefined!" not in captured.out
-
-
 def test_add_platform_defines_priority() -> None:
     """Test that _add_platform_defines runs after globals.
 

tests/unit_tests/fixtures/core/config/id_collision_with_substitution.yaml

@@ -1,12 +0,0 @@
-esphome:
-  name: test
-
-host:
-
-substitutions:
-  support_switches:
-    - platform: gpio
-      id: some_switch_id
-      pin: 12
-
-switch: $support_switches