Merge branch 'determine_jobs_comp_split' into determine_jobs_comp_split_test

Co-authored-by: clydebarrow <2366188+clydebarrow@users.noreply.github.com>

.github/workflows/auto-label-pr.yml

@@ -416,7 +416,7 @@ jobs:
             }
 
             // Generate review messages
-            function generateReviewMessages(finalLabels) {
+            function generateReviewMessages(finalLabels, originalLabelCount) {
               const messages = [];
               const prAuthor = context.payload.pull_request.user.login;
 
@@ -430,15 +430,15 @@ jobs:
                   .reduce((sum, file) => sum + (file.deletions || 0), 0);
                 const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
 
-                const tooManyLabels = finalLabels.length > MAX_LABELS;
+                const tooManyLabels = originalLabelCount > MAX_LABELS;
                 const tooManyChanges = nonTestChanges > TOO_BIG_THRESHOLD;
 
                 let message = `${TOO_BIG_MARKER}\n### 📦 Pull Request Size\n\n`;
 
                 if (tooManyLabels && tooManyChanges) {
-                  message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${finalLabels.length} different components/areas.`;
+                  message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${originalLabelCount} different components/areas.`;
                 } else if (tooManyLabels) {
-                  message += `This PR affects ${finalLabels.length} different components/areas.`;
+                  message += `This PR affects ${originalLabelCount} different components/areas.`;
                 } else {
                   message += `This PR is too large with ${nonTestChanges} line changes (excluding tests).`;
                 }
@@ -466,8 +466,8 @@ jobs:
             }
 
             // Handle reviews
-            async function handleReviews(finalLabels) {
-              const reviewMessages = generateReviewMessages(finalLabels);
+            async function handleReviews(finalLabels, originalLabelCount) {
+              const reviewMessages = generateReviewMessages(finalLabels, originalLabelCount);
               const hasReviewableLabels = finalLabels.some(label =>
                 ['too-big', 'needs-codeowners'].includes(label)
               );
@@ -627,6 +627,7 @@ jobs:
 
             // Handle too many labels (only for non-mega PRs)
             const tooManyLabels = finalLabels.length > MAX_LABELS;
+            const originalLabelCount = finalLabels.length;
 
             if (tooManyLabels && !isMegaPR && !finalLabels.includes('too-big')) {
               finalLabels = ['too-big'];
@@ -635,7 +636,7 @@ jobs:
             console.log('Computed labels:', finalLabels.join(', '));
 
             // Handle reviews
-            await handleReviews(finalLabels);
+            await handleReviews(finalLabels, originalLabelCount);
 
             // Apply labels
             if (finalLabels.length > 0) {

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

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

.github/workflows/ci.yml

@@ -114,7 +114,7 @@ jobs:
       matrix:
         python-version:
           - "3.11"
-          - "3.14"
+          - "3.13"
         os:
           - ubuntu-latest
           - macOS-latest
@@ -123,9 +123,9 @@ jobs:
           # Minimize CI resource usage
           # by only running the Python version
           # version used for docker images on Windows and macOS
-          - python-version: "3.14"
+          - python-version: "3.13"
             os: windows-latest
-          - python-version: "3.14"
+          - python-version: "3.13"
             os: macOS-latest
     runs-on: ${{ matrix.os }}
     needs:
@@ -180,6 +180,7 @@ 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
@@ -214,6 +215,7 @@ 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
@@ -536,59 +538,18 @@ 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.test-build-components-splitter.outputs.matrix) }}
+        components: ${{ fromJson(needs.determine-jobs.outputs.component-test-batches) }}
     steps:
       - name: Show disk space
         run: |
@@ -849,7 +810,7 @@ jobs:
           fi
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: memory-analysis-target
           path: memory-analysis-target.json
@@ -913,7 +874,7 @@ jobs:
             --platform "$platform"
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: memory-analysis-pr
           path: memory-analysis-pr.json
@@ -943,13 +904,13 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
       - name: Download target analysis JSON
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
         with:
           name: memory-analysis-target
           path: ./memory-analysis
         continue-on-error: true
       - name: Download PR analysis JSON
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
         with:
           name: memory-analysis-pr
           path: ./memory-analysis
@@ -980,7 +941,6 @@ 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@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
+        uses: github/codeql-action/init@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         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@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
+        uses: github/codeql-action/analyze@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         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@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.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.1
+    rev: v0.14.2
     hooks:
       # Run the linter.
       - id: ruff

esphome/__main__.py

@@ -731,13 +731,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1199,17 +1192,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -1,7 +1,6 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
-import json
 import sys
 
 from . import (
@@ -284,28 +283,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/alarm_control_panel/__init__.py

@@ -172,12 +172,6 @@ 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

@@ -425,7 +425,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer) = "std::vector"];
+  repeated string supported_preset_modes = 12 [(container_pointer) = "std::set"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields

esphome/components/api/api_connection.cpp

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

esphome/components/api/api_frame_helper_noise.cpp

@@ -142,11 +142,6 @@ APIError APINoiseFrameHelper::loop() {
  * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
  */
 APIError APINoiseFrameHelper::try_read_frame_() {
-  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
-  if (this->rx_buf_len_ == 0) {
-    this->rx_buf_.clear();
-  }
-
   // read header
   if (rx_header_buf_len_ < 3) {
     // no header information yet

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -54,11 +54,6 @@ APIError APIPlaintextFrameHelper::loop() {
  * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  */
 APIError APIPlaintextFrameHelper::try_read_frame_() {
-  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
-  if (this->rx_buf_len_ == 0) {
-    this->rx_buf_.clear();
-  }
-
   // read header
   while (!rx_header_parsed_) {
     // Now that we know when the socket is ready, we can read up to 3 bytes

esphome/components/api/api_pb2.h

@@ -725,7 +725,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::vector<std::string> *supported_preset_modes{};
+  const std::set<std::string> *supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/proto.h

@@ -7,7 +7,6 @@
 
 #include <cassert>
 #include <cstring>
-#include <type_traits>
 #include <vector>
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
@@ -160,6 +159,22 @@ 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_;
@@ -218,86 +233,8 @@ class ProtoWriteBuffer {
  public:
   ProtoWriteBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
   void write(uint8_t value) { this->buffer_->push_back(value); }
-
-  // Single implementation that all overloads delegate to
-  void encode_varint(uint64_t value) {
-    auto buffer = this->buffer_;
-    size_t start = buffer->size();
-
-    // Fast paths for common cases (1-3 bytes)
-    if (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 (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()); }
+  void encode_varint_raw(ProtoVarInt value) { value.encode(*this->buffer_); }
+  void encode_varint_raw(uint32_t value) { this->encode_varint_raw(ProtoVarInt(value)); }
   /**
    * Encode a field key (tag/wire type combination).
    *
@@ -312,14 +249,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(val);
+    this->encode_varint_raw(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(len);
+    this->encode_varint_raw(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
@@ -341,13 +278,13 @@ class ProtoWriteBuffer {
     if (value == 0 && !force)
       return;
     this->encode_field_raw(field_id, 0);  // type 0: Varint - uint32
-    this->encode_varint(value);
+    this->encode_varint_raw(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(value);
+    this->encode_varint_raw(ProtoVarInt(value));
   }
   void encode_bool(uint32_t field_id, bool value, bool force = false) {
     if (!value && !force)

esphome/components/binary_sensor/__init__.py

@@ -548,11 +548,6 @@ 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,11 +84,6 @@ 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,11 +270,6 @@ 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,10 +1,9 @@
 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_ID, CONF_SENSOR, CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT
+from esphome.const import CONF_SENSOR, CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT
 from esphome.cpp_generator import MockObjClass
 
 _LOGGER = logging.getLogger(__name__)
@@ -52,26 +51,6 @@ 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,11 +151,6 @@ 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/esp32_ble/ble.cpp

@@ -76,10 +76,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -37,7 +37,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/event/__init__.py

@@ -85,11 +85,6 @@ 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,10 +189,6 @@ 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/fan/fan.cpp

@@ -51,14 +51,7 @@ void FanCall::validate_() {
 
   if (!this->preset_mode_.empty()) {
     const auto &preset_modes = traits.supported_preset_modes();
-    bool found = false;
-    for (const auto &mode : preset_modes) {
-      if (mode == this->preset_mode_) {
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
+    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
       ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
       this->preset_mode_.clear();
     }
@@ -198,14 +191,9 @@ void Fan::save_state_() {
   if (this->get_traits().supports_preset_modes() && !this->preset_mode.empty()) {
     const auto &preset_modes = this->get_traits().supported_preset_modes();
     // Store index of current preset mode
-    size_t i = 0;
-    for (const auto &mode : preset_modes) {
-      if (mode == this->preset_mode) {
-        state.preset_mode = i;
-        break;
-      }
-      i++;
-    }
+    auto preset_iterator = preset_modes.find(this->preset_mode);
+    if (preset_iterator != preset_modes.end())
+      state.preset_mode = std::distance(preset_modes.begin(), preset_iterator);
   }
 
   this->rtc_.save(&state);

esphome/components/fan/fan.h

@@ -60,8 +60,6 @@ class FanCall {
     this->speed_ = speed;
     return *this;
   }
-  ESPDEPRECATED("set_speed() with string argument is deprecated, use integer argument instead.", "2021.9")
-  FanCall &set_speed(const char *legacy_speed);
   optional<int> get_speed() const { return this->speed_; }
   FanCall &set_direction(FanDirection direction) {
     this->direction_ = direction;

esphome/components/fan/fan_traits.h

@@ -1,6 +1,7 @@
-#pragma once
+#include <set>
+#include <utility>
 
-#include <vector>
+#pragma once
 
 namespace esphome {
 
@@ -35,9 +36,9 @@ class FanTraits {
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
   /// Return the preset modes supported by the fan.
-  const std::vector<std::string> &supported_preset_modes() const { return this->preset_modes_; }
+  std::set<std::string> supported_preset_modes() const { return this->preset_modes_; }
   /// Set the preset modes supported by the fan.
-  void set_supported_preset_modes(const std::vector<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
+  void set_supported_preset_modes(const std::set<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
   /// Return if preset modes are supported
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
@@ -45,17 +46,17 @@ class FanTraits {
 #ifdef USE_API
   // The API connection is a friend class to access internal methods
   friend class api::APIConnection;
-  // This method returns a reference to the internal preset modes.
+  // This method returns a reference to the internal preset modes set.
   // It is used by the API to avoid copying data when encoding messages.
   // Warning: Do not use this method outside of the API connection code.
   // It returns a reference to internal data that can be invalidated.
-  const std::vector<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
+  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
 #endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace fan

esphome/components/hbridge/fan/hbridge_fan.h

@@ -22,7 +22,7 @@ class HBridgeFan : public Component, public fan::Fan {
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
   void set_enable_pin(output::FloatOutput *enable) { enable_ = enable; }
-  void set_preset_modes(const std::vector<std::string> &presets) { preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { preset_modes_ = presets; }
 
   void setup() override;
   void dump_config() override;
@@ -38,7 +38,7 @@ class HBridgeFan : public Component, public fan::Fan {
   int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 
   void control(const fan::FanCall &call) override;
   void write_state_();

esphome/components/http_request/__init__.py

@@ -12,7 +12,6 @@ from esphome.const import (
     CONF_ON_ERROR,
     CONF_ON_RESPONSE,
     CONF_TIMEOUT,
-    CONF_TRIGGER_ID,
     CONF_URL,
     CONF_WATCHDOG_TIMEOUT,
     PLATFORM_HOST,
@@ -216,16 +215,8 @@ HTTP_REQUEST_ACTION_SCHEMA = cv.Schema(
             f"{CONF_VERIFY_SSL} has moved to the base component configuration."
         ),
         cv.Optional(CONF_CAPTURE_RESPONSE, default=False): cv.boolean,
-        cv.Optional(CONF_ON_RESPONSE): automation.validate_automation(
-            {cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(HttpRequestResponseTrigger)}
-        ),
-        cv.Optional(CONF_ON_ERROR): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    automation.Trigger.template()
-                )
-            }
-        ),
+        cv.Optional(CONF_ON_RESPONSE): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_ERROR): automation.validate_automation(single=True),
         cv.Optional(CONF_MAX_RESPONSE_BUFFER_SIZE, default="1kB"): cv.validate_bytes,
     }
 )
@@ -280,7 +271,12 @@ async def http_request_action_to_code(config, action_id, template_arg, args):
     template_ = await cg.templatable(config[CONF_URL], args, cg.std_string)
     cg.add(var.set_url(template_))
     cg.add(var.set_method(config[CONF_METHOD]))
-    cg.add(var.set_capture_response(config[CONF_CAPTURE_RESPONSE]))
+
+    capture_response = config[CONF_CAPTURE_RESPONSE]
+    if capture_response:
+        cg.add(var.set_capture_response(capture_response))
+        cg.add_define("USE_HTTP_REQUEST_RESPONSE")
+
     cg.add(var.set_max_response_buffer_size(config[CONF_MAX_RESPONSE_BUFFER_SIZE]))
 
     if CONF_BODY in config:
@@ -303,21 +299,26 @@ async def http_request_action_to_code(config, action_id, template_arg, args):
     for value in config.get(CONF_COLLECT_HEADERS, []):
         cg.add(var.add_collect_header(value))
 
-    for conf in config.get(CONF_ON_RESPONSE, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
-        cg.add(var.register_response_trigger(trigger))
-        await automation.build_automation(
-            trigger,
-            [
-                (cg.std_shared_ptr.template(HttpContainer), "response"),
-                (cg.std_string_ref, "body"),
-            ],
-            conf,
-        )
-    for conf in config.get(CONF_ON_ERROR, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
-        cg.add(var.register_error_trigger(trigger))
-        await automation.build_automation(trigger, [], conf)
+    if response_conf := config.get(CONF_ON_RESPONSE):
+        if capture_response:
+            await automation.build_automation(
+                var.get_success_trigger_with_response(),
+                [
+                    (cg.std_shared_ptr.template(HttpContainer), "response"),
+                    (cg.std_string_ref, "body"),
+                    *args,
+                ],
+                response_conf,
+            )
+        else:
+            await automation.build_automation(
+                var.get_success_trigger(),
+                [(cg.std_shared_ptr.template(HttpContainer), "response"), *args],
+                response_conf,
+            )
+
+    if error_conf := config.get(CONF_ON_ERROR):
+        await automation.build_automation(var.get_error_trigger(), args, error_conf)
 
     return var
 

esphome/components/http_request/http_request.h

@@ -183,7 +183,9 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   TEMPLATABLE_VALUE(std::string, url)
   TEMPLATABLE_VALUE(const char *, method)
   TEMPLATABLE_VALUE(std::string, body)
+#ifdef USE_HTTP_REQUEST_RESPONSE
   TEMPLATABLE_VALUE(bool, capture_response)
+#endif
 
   void add_request_header(const char *key, TemplatableValue<const char *, Ts...> value) {
     this->request_headers_.insert({key, value});
@@ -195,9 +197,14 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
 
   void set_json(std::function<void(Ts..., JsonObject)> json_func) { this->json_func_ = json_func; }
 
-  void register_response_trigger(HttpRequestResponseTrigger *trigger) { this->response_triggers_.push_back(trigger); }
+#ifdef USE_HTTP_REQUEST_RESPONSE
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *get_success_trigger_with_response() const {
+    return this->success_trigger_with_response_;
+  }
+#endif
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> *get_success_trigger() const { return this->success_trigger_; }
 
-  void register_error_trigger(Trigger<> *trigger) { this->error_triggers_.push_back(trigger); }
+  Trigger<Ts...> *get_error_trigger() const { return this->error_trigger_; }
 
   void set_max_response_buffer_size(size_t max_response_buffer_size) {
     this->max_response_buffer_size_ = max_response_buffer_size;
@@ -228,17 +235,20 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
     auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, request_headers,
                                           this->collect_headers_);
 
+    auto captured_args = std::make_tuple(x...);
+
     if (container == nullptr) {
-      for (auto *trigger : this->error_triggers_)
-        trigger->trigger();
+      std::apply([this](Ts... captured_args_inner) { this->error_trigger_->trigger(captured_args_inner...); },
+                 captured_args);
       return;
     }
 
     size_t content_length = container->content_length;
     size_t max_length = std::min(content_length, this->max_response_buffer_size_);
 
-    std::string response_body;
+#ifdef USE_HTTP_REQUEST_RESPONSE
     if (this->capture_response_.value(x...)) {
+      std::string response_body;
       RAMAllocator<uint8_t> allocator;
       uint8_t *buf = allocator.allocate(max_length);
       if (buf != nullptr) {
@@ -253,19 +263,17 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
         response_body.assign((char *) buf, read_index);
         allocator.deallocate(buf, max_length);
       }
-    }
-
-    if (this->response_triggers_.size() == 1) {
-      // if there is only one trigger, no need to copy the response body
-      this->response_triggers_[0]->process(container, response_body);
-    } else {
-      for (auto *trigger : this->response_triggers_) {
-        // with multiple triggers, pass a copy of the response body to each
-        // one so that modifications made in one trigger are not visible to
-        // the others
-        auto response_body_copy = std::string(response_body);
-        trigger->process(container, response_body_copy);
-      }
+      std::apply(
+          [this, &container, &response_body](Ts... captured_args_inner) {
+            this->success_trigger_with_response_->trigger(container, response_body, captured_args_inner...);
+          },
+          captured_args);
+    } else
+#endif
+    {
+      std::apply([this, &container](
+                     Ts... captured_args_inner) { this->success_trigger_->trigger(container, captured_args_inner...); },
+                 captured_args);
     }
     container->end();
   }
@@ -283,8 +291,13 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   std::set<std::string> collect_headers_{"content-type", "content-length"};
   std::map<const char *, TemplatableValue<std::string, Ts...>> json_{};
   std::function<void(Ts..., JsonObject)> json_func_{nullptr};
-  std::vector<HttpRequestResponseTrigger *> response_triggers_{};
-  std::vector<Trigger<> *> error_triggers_{};
+#ifdef USE_HTTP_REQUEST_RESPONSE
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *success_trigger_with_response_ =
+      new Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...>();
+#endif
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> *success_trigger_ =
+      new Trigger<std::shared_ptr<HttpContainer>, Ts...>();
+  Trigger<Ts...> *error_trigger_ = new Trigger<Ts...>();
 
   size_t max_response_buffer_size_{SIZE_MAX};
 };

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -107,7 +107,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

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->transparent_) {
+        switch (this->transparency_) {
           case TRANSPARENCY_ALPHA_CHANNEL:
             this->dsc_.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
             break;
@@ -156,7 +156,8 @@ lv_img_dsc_t *Image::get_lv_img_dsc() {
             break;
         }
 #else
-        this->dsc_.header.cf = this->transparent_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
+        this->dsc_.header.cf =
+            this->transparency_ == TRANSPARENCY_ALPHA_CHANNEL ? LV_IMG_CF_RGB565A8 : LV_IMG_CF_RGB565;
 #endif
         break;
     }

esphome/components/lock/__init__.py

@@ -91,11 +91,6 @@ 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/logger/__init__.py

@@ -173,14 +173,34 @@ def uart_selection(value):
     raise NotImplementedError
 
 
-def validate_local_no_higher_than_global(value):
-    global_level = LOG_LEVEL_SEVERITY.index(value[CONF_LEVEL])
-    for tag, level in value.get(CONF_LOGS, {}).items():
-        if LOG_LEVEL_SEVERITY.index(level) > global_level:
-            raise cv.Invalid(
-                f"The configured log level for {tag} ({level}) must be no more severe than the global log level {value[CONF_LEVEL]}."
+def validate_local_no_higher_than_global(config):
+    global_level = config[CONF_LEVEL]
+    global_level_index = LOG_LEVEL_SEVERITY.index(global_level)
+    errs = []
+    for tag, level in config.get(CONF_LOGS, {}).items():
+        if LOG_LEVEL_SEVERITY.index(level) > global_level_index:
+            errs.append(
+                cv.Invalid(
+                    f"The configured log level for {tag} ({level}) must not be less severe than the global log level ({global_level})",
+                    [CONF_LOGS, tag],
+                )
             )
-    return value
+    if errs:
+        raise cv.MultipleInvalid(errs)
+    return config
+
+
+def validate_initial_no_higher_than_global(config):
+    if initial_level := config.get(CONF_INITIAL_LEVEL):
+        global_level = config[CONF_LEVEL]
+        if LOG_LEVEL_SEVERITY.index(initial_level) > LOG_LEVEL_SEVERITY.index(
+            global_level
+        ):
+            raise cv.Invalid(
+                f"The initial log level ({initial_level}) must not be less severe than the global log level ({global_level})",
+                [CONF_INITIAL_LEVEL],
+            )
+    return config
 
 
 Logger = logger_ns.class_("Logger", cg.Component)
@@ -263,6 +283,7 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     validate_local_no_higher_than_global,
+    validate_initial_no_higher_than_global,
 )
 
 

esphome/components/lvgl/defines.py

@@ -5,6 +5,7 @@ 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
@@ -12,6 +13,7 @@ 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
 
@@ -42,7 +44,13 @@ 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()
+        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 f"{lamb}()"
 
 
@@ -65,10 +73,20 @@ class LValidator:
             return cv.returning_lambda(value)
         return self.validator(value)
 
-    async def process(self, value, args=()):
+    async def process(
+        self, value: Any, args: list[tuple[SafeExpType, str]] | None = None
+    ) -> Expression:
         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,3 +1,5 @@
+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
@@ -17,6 +19,7 @@ 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 (
@@ -388,11 +391,23 @@ class TextValidator(LValidator):
             return value
         return super().__call__(value)
 
-    async def process(self, value, args=()):
+    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()
+
         if isinstance(value, dict):
             if format_str := value.get(CONF_FORMAT):
-                args = [str(x) for x in value[CONF_ARGS]]
-                arg_expr = cg.RawExpression(",".join(args))
+                str_args = [str(x) for x in value[CONF_ARGS]]
+                arg_expr = cg.RawExpression(",".join(str_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,6 +164,9 @@ 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)
@@ -178,9 +181,8 @@ class LvContext(LambdaContext):
 
     added_lambda_count = 0
 
-    def __init__(self, args=None):
-        self.args = args or LVGL_COMP_ARG
-        super().__init__(parameters=self.args)
+    def __init__(self):
+        super().__init__(parameters=LVGL_COMP_ARG)
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await super().__aexit__(exc_type, exc_val, exc_tb)
@@ -189,6 +191,11 @@ 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/sensor/__init__.py

@@ -5,7 +5,6 @@ from ..defines import CONF_WIDGET
 from ..lvcode import (
     API_EVENT,
     EVENT_ARG,
-    LVGL_COMP_ARG,
     UPDATE_EVENT,
     LambdaContext,
     LvContext,
@@ -30,7 +29,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(LVGL_COMP_ARG):
+    async with LvContext():
         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
+from ..lvcode import LocalVariable, lv, lv_assign, lv_expr
 from ..schemas import STYLE_PROPS, STYLE_REMAP, TEXT_SCHEMA, point_schema
 from ..types import LvType, ObjUpdateAction, WidgetType
 from . import Widget, get_widgets
@@ -70,15 +70,18 @@ class CanvasType(WidgetType):
         width = config[CONF_WIDTH]
         height = config[CONF_HEIGHT]
         use_alpha = "_ALPHA" if config[CONF_TRANSPARENT] else ""
-        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}"),
+        buf_size = literal(
+            f"LV_CANVAS_BUF_SIZE_TRUE_COLOR{use_alpha}({width}, {height})"
         )
+        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/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/media_player/__init__.py

@@ -192,10 +192,6 @@ 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/mipi/__init__.py

@@ -384,6 +384,18 @@ class DriverChip:
             transform[CONF_TRANSFORM] = True
         return transform
 
+    def swap_xy_schema(self):
+        uses_swap = self.get_default(CONF_SWAP_XY, None) != cv.UNDEFINED
+
+        def validator(value):
+            if value:
+                raise cv.Invalid("Axis swapping not supported by this model")
+            return cv.boolean(value)
+
+        if uses_swap:
+            return {cv.Required(CONF_SWAP_XY): cv.boolean}
+        return {cv.Optional(CONF_SWAP_XY, default=False): validator}
+
     def add_madctl(self, sequence: list, config: dict):
         # Add the MADCTL command to the sequence based on the configuration.
         use_flip = config.get(CONF_USE_AXIS_FLIPS)

esphome/components/mipi_rgb/display.py

@@ -46,6 +46,7 @@ from esphome.const import (
     CONF_DATA_RATE,
     CONF_DC_PIN,
     CONF_DIMENSIONS,
+    CONF_DISABLED,
     CONF_ENABLE_PIN,
     CONF_GREEN,
     CONF_HSYNC_PIN,
@@ -117,16 +118,16 @@ def data_pin_set(length):
 
 def model_schema(config):
     model = MODELS[config[CONF_MODEL].upper()]
-    if transforms := model.transforms:
-        transform = cv.Schema({cv.Required(x): cv.boolean for x in transforms})
-        for x in (CONF_SWAP_XY, CONF_MIRROR_X, CONF_MIRROR_Y):
-            if x not in transforms:
-                transform = transform.extend(
-                    {cv.Optional(x): cv.invalid(f"{x} not supported by this model")}
-                )
-    else:
-        transform = cv.invalid("This model does not support transforms")
-
+    transform = cv.Any(
+        cv.Schema(
+            {
+                cv.Required(CONF_MIRROR_X): cv.boolean,
+                cv.Required(CONF_MIRROR_Y): cv.boolean,
+                **model.swap_xy_schema(),
+            }
+        ),
+        cv.one_of(CONF_DISABLED, lower=True),
+    )
     # RPI model does not use an init sequence, indicates with empty list
     if model.initsequence is None:
         # Custom model requires an init sequence
@@ -135,12 +136,16 @@ def model_schema(config):
     else:
         iseqconf = cv.Optional(CONF_INIT_SEQUENCE)
         uses_spi = CONF_INIT_SEQUENCE in config or len(model.initsequence) != 0
-    swap_xy = config.get(CONF_TRANSFORM, {}).get(CONF_SWAP_XY, False)
-
-    # Dimensions are optional if the model has a default width and the swap_xy transform is not overridden
-    cv_dimensions = (
-        cv.Optional if model.get_default(CONF_WIDTH) and not swap_xy else cv.Required
+    # Dimensions are optional if the model has a default width and the x-y transform is not overridden
+    transform_config = config.get(CONF_TRANSFORM, {})
+    is_swapped = (
+        isinstance(transform_config, dict)
+        and transform_config.get(CONF_SWAP_XY, False) is True
     )
+    cv_dimensions = (
+        cv.Optional if model.get_default(CONF_WIDTH) and not is_swapped else cv.Required
+    )
+
     pixel_modes = (PIXEL_MODE_16BIT, PIXEL_MODE_18BIT, "16", "18")
     schema = display.FULL_DISPLAY_SCHEMA.extend(
         {
@@ -157,7 +162,7 @@ def model_schema(config):
             model.option(CONF_PIXEL_MODE, PIXEL_MODE_16BIT): cv.one_of(
                 *pixel_modes, lower=True
             ),
-            model.option(CONF_TRANSFORM, cv.UNDEFINED): transform,
+            cv.Optional(CONF_TRANSFORM): transform,
             cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
             model.option(CONF_INVERT_COLORS, False): cv.boolean,
             model.option(CONF_USE_AXIS_FLIPS, True): cv.boolean,
@@ -270,7 +275,6 @@ async def to_code(config):
     cg.add(var.set_vsync_front_porch(config[CONF_VSYNC_FRONT_PORCH]))
     cg.add(var.set_pclk_inverted(config[CONF_PCLK_INVERTED]))
     cg.add(var.set_pclk_frequency(config[CONF_PCLK_FREQUENCY]))
-    index = 0
     dpins = []
     if CONF_RED in config[CONF_DATA_PINS]:
         red_pins = config[CONF_DATA_PINS][CONF_RED]

esphome/components/mipi_spi/display.py

@@ -131,19 +131,6 @@ def denominator(config):
         ) from StopIteration
 
 
-def swap_xy_schema(model):
-    uses_swap = model.get_default(CONF_SWAP_XY, None) != cv.UNDEFINED
-
-    def validator(value):
-        if value:
-            raise cv.Invalid("Axis swapping not supported by this model")
-        return cv.boolean(value)
-
-    if uses_swap:
-        return {cv.Required(CONF_SWAP_XY): cv.boolean}
-    return {cv.Optional(CONF_SWAP_XY, default=False): validator}
-
-
 def model_schema(config):
     model = MODELS[config[CONF_MODEL]]
     bus_mode = config[CONF_BUS_MODE]
@@ -152,7 +139,7 @@ def model_schema(config):
             {
                 cv.Required(CONF_MIRROR_X): cv.boolean,
                 cv.Required(CONF_MIRROR_Y): cv.boolean,
-                **swap_xy_schema(model),
+                **model.swap_xy_schema(),
             }
         ),
         cv.one_of(CONF_DISABLED, lower=True),

esphome/components/number/__init__.py

@@ -238,11 +238,6 @@ 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/packages/__init__.py

@@ -102,7 +102,7 @@ CONFIG_SCHEMA = cv.Any(
             str: PACKAGE_SCHEMA,
         }
     ),
-    cv.ensure_list(PACKAGE_SCHEMA),
+    [PACKAGE_SCHEMA],
 )
 
 

esphome/components/remote_transmitter/__init__.py

@@ -1,3 +1,5 @@
+import logging
+
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
@@ -18,9 +20,12 @@ 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
@@ -65,11 +70,25 @@ 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),
@@ -95,6 +114,7 @@ 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,6 +54,7 @@ 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_; };
@@ -74,6 +75,7 @@ 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_{};
@@ -90,6 +92,7 @@ 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,12 +196,29 @@ 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_();
@@ -212,6 +229,7 @@ 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));
@@ -229,6 +247,7 @@ 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));
@@ -260,13 +279,12 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   } else {
     this->status_clear_warning();
   }
-  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 (this->non_blocking_) {
+    this->set_timeout("complete", total_duration / 1000, [this]() { this->wait_for_rmt_(); });
+  } else {
+    this->wait_for_rmt_();
+  }
 }
 #else
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {

esphome/components/select/__init__.py

@@ -86,11 +86,6 @@ 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/sensor/__init__.py

@@ -369,11 +369,6 @@ 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/speed/fan/speed_fan.h

@@ -18,7 +18,7 @@ class SpeedFan : public Component, public fan::Fan {
   void set_output(output::FloatOutput *output) { this->output_ = output; }
   void set_oscillating(output::BinaryOutput *oscillating) { this->oscillating_ = oscillating; }
   void set_direction(output::BinaryOutput *direction) { this->direction_ = direction; }
-  void set_preset_modes(const std::vector<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -30,7 +30,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::BinaryOutput *direction_{nullptr};
   int speed_count_{};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace speed

esphome/components/switch/__init__.py

@@ -139,11 +139,6 @@ 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,6 +25,20 @@ 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() {
@@ -46,53 +60,31 @@ 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 sensor_info : this->sensor_map_) {
-    ESP_LOGCONFIG(TAG, "  Binary Sensor:");
+  for (auto const &[sensor, info] : this->sensor_map_) {
     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_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);
+                  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));
   }
 #endif
 }
 
 void TemplateAlarmControlPanel::setup() {
-  switch (this->restore_mode_) {
-    case ALARM_CONTROL_PANEL_ALWAYS_DISARMED:
-      this->current_state_ = ACP_STATE_DISARMED;
-      break;
-    case ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED: {
-      uint8_t value;
-      this->pref_ = global_preferences->make_preference<uint8_t>(this->get_preference_hash());
-      if (this->pref_.load(&value)) {
-        this->current_state_ = static_cast<alarm_control_panel::AlarmControlPanelState>(value);
-      } else {
-        this->current_state_ = ACP_STATE_DISARMED;
-      }
-      break;
+  this->current_state_ = ACP_STATE_DISARMED;
+  if (this->restore_mode_ == ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED) {
+    uint8_t value;
+    this->pref_ = global_preferences->make_preference<uint8_t>(this->get_preference_hash());
+    if (this->pref_.load(&value)) {
+      this->current_state_ = static_cast<alarm_control_panel::AlarmControlPanelState>(value);
     }
   }
   this->desired_state_ = this->current_state_;
@@ -119,86 +111,83 @@ void TemplateAlarmControlPanel::loop() {
     this->publish_state(ACP_STATE_TRIGGERED);
     return;
   }
-  auto future_state = this->current_state_;
+  auto next_state = this->current_state_;
   // reset triggered if all clear
   if (this->current_state_ == ACP_STATE_TRIGGERED && this->trigger_time_ > 0 &&
       (millis() - this->last_update_) > this->trigger_time_) {
-    future_state = this->desired_state_;
+    next_state = this->desired_state_;
   }
 
-  bool delayed_sensor_not_ready = false;
-  bool instant_sensor_not_ready = false;
+  bool delayed_sensor_faulted = false;
+  bool instant_sensor_faulted = false;
 
 #ifdef USE_BINARY_SENSOR
-  // Test all of the sensors in the list regardless of the alarm panel state
-  for (auto sensor_info : this->sensor_map_) {
+  // Test all of the sensors regardless of the alarm panel state
+  for (auto const &[sensor, info] : this->sensor_map_) {
     // Check for chime zones
-    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME)) {
+    if (info.flags & BINARY_SENSOR_MODE_CHIME) {
       // Look for the transition from closed to open
-      if ((!this->sensor_data_[sensor_info.second.store_index].last_chime_state) && (sensor_info.first->state)) {
+      if ((!this->sensor_data_[info.store_index].last_chime_state) && (sensor->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_[sensor_info.second.store_index].last_chime_state = sensor_info.first->state;
+      this->sensor_data_[info.store_index].last_chime_state = sensor->state;
     }
-    // Check for triggered sensors
-    if (sensor_info.first->state) {  // Sensor triggered?
+    // Check for faulted sensors
+    if (sensor->state) {
       // Skip if auto bypassed
       if (std::count(this->bypassed_sensor_indicies_.begin(), this->bypassed_sensor_indicies_.end(),
-                     sensor_info.second.store_index) == 1) {
+                     info.store_index) == 1) {
         continue;
       }
       // Skip if bypass armed home
-      if (this->current_state_ == ACP_STATE_ARMED_HOME &&
-          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
+      if ((this->current_state_ == ACP_STATE_ARMED_HOME) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
         continue;
       }
       // Skip if bypass armed night
-      if (this->current_state_ == ACP_STATE_ARMED_NIGHT &&
-          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
+      if ((this->current_state_ == ACP_STATE_ARMED_NIGHT) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
         continue;
       }
 
-      switch (sensor_info.second.type) {
-        case ALARM_SENSOR_TYPE_INSTANT:
-          instant_sensor_not_ready = true;
-          break;
+      switch (info.type) {
         case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
-          instant_sensor_not_ready = true;
-          future_state = ACP_STATE_TRIGGERED;
+          next_state = ACP_STATE_TRIGGERED;
+          [[fallthrough]];
+        case ALARM_SENSOR_TYPE_INSTANT:
+          instant_sensor_faulted = true;
           break;
         case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
           // Look to see if we are in the pending state
           if (this->current_state_ == ACP_STATE_PENDING) {
-            delayed_sensor_not_ready = true;
+            delayed_sensor_faulted = true;
           } else {
-            instant_sensor_not_ready = true;
+            instant_sensor_faulted = true;
           }
           break;
         case ALARM_SENSOR_TYPE_DELAYED:
         default:
-          delayed_sensor_not_ready = true;
+          delayed_sensor_faulted = true;
       }
     }
   }
-  // Update all sensors not ready flag
-  this->sensors_ready_ = ((!instant_sensor_not_ready) && (!delayed_sensor_not_ready));
+  // Update all sensors ready flag
+  bool sensors_ready = !(instant_sensor_faulted || delayed_sensor_faulted);
 
   // Call the ready state change callback if there was a change
-  if (this->sensors_ready_ != this->sensors_ready_last_) {
+  if (this->sensors_ready_ != sensors_ready) {
+    this->sensors_ready_ = sensors_ready;
     this->ready_callback_.call();
-    this->sensors_ready_last_ = this->sensors_ready_;
   }
 
 #endif
-  if (this->is_state_armed(future_state) && (!this->sensors_ready_)) {
+  if (this->is_state_armed(next_state) && (!this->sensors_ready_)) {
     // Instant sensors
-    if (instant_sensor_not_ready) {
+    if (instant_sensor_faulted) {
       this->publish_state(ACP_STATE_TRIGGERED);
-    } else if (delayed_sensor_not_ready) {
+    } else if (delayed_sensor_faulted) {
       // Delayed sensors
       if ((this->pending_time_ > 0) && (this->current_state_ != ACP_STATE_TRIGGERED)) {
         this->publish_state(ACP_STATE_PENDING);
@@ -206,8 +195,8 @@ void TemplateAlarmControlPanel::loop() {
         this->publish_state(ACP_STATE_TRIGGERED);
       }
     }
-  } else if (future_state != this->current_state_) {
-    this->publish_state(future_state);
+  } else if (next_state != this->current_state_) {
+    this->publish_state(next_state);
   }
 }
 
@@ -234,8 +223,6 @@ uint32_t TemplateAlarmControlPanel::get_supported_features() const {
   return features;
 }
 
-bool TemplateAlarmControlPanel::get_requires_code() const { return !this->codes_.empty(); }
-
 void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_panel::AlarmControlPanelState state,
                                      uint32_t delay) {
   if (this->current_state_ != ACP_STATE_DISARMED) {
@@ -257,11 +244,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (auto sensor_info : this->sensor_map_) {
-    // Check for sensors left on and set to bypass automatically and remove them from monitoring
-    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor_info.first->state)) {
-      ESP_LOGW(TAG, "'%s' is left on and will be automatically bypassed", sensor_info.first->get_name().c_str());
-      this->bypassed_sensor_indicies_.push_back(sensor_info.second.store_index);
+  for (auto const &[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);
     }
   }
 #endif

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -56,7 +56,7 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
   void setup() override;
   void loop() override;
   uint32_t get_supported_features() const override;
-  bool get_requires_code() const override;
+  bool get_requires_code() const override { return !this->codes_.empty(); }
   bool get_requires_code_to_arm() const override { return this->requires_code_to_arm_; }
   bool get_all_sensors_ready() { return this->sensors_ready_; };
   void set_restore_mode(TemplateAlarmControlPanelRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
@@ -66,7 +66,8 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
   /** Add a binary_sensor to the alarm_panel.
    *
    * @param sensor The BinarySensor instance.
-   * @param ignore_when_home if this should be ignored when armed_home mode
+   * @param flags The OR of BinarySensorFlags for the sensor.
+   * @param type The sensor type which determines its triggering behaviour.
    */
   void add_sensor(binary_sensor::BinarySensor *sensor, uint16_t flags = 0,
                   AlarmSensorType type = ALARM_SENSOR_TYPE_DELAYED);
@@ -121,7 +122,7 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
  protected:
   void control(const alarm_control_panel::AlarmControlPanelCall &call) override;
 #ifdef USE_BINARY_SENSOR
-  // This maps a binary sensor to its type and attribute bits
+  // This maps a binary sensor to its alarm specific info
   std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
   // a list of automatically bypassed sensors
   std::vector<uint8_t> bypassed_sensor_indicies_;
@@ -147,7 +148,6 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
   bool supports_arm_home_ = false;
   bool supports_arm_night_ = false;
   bool sensors_ready_ = false;
-  bool sensors_ready_last_ = false;
   uint8_t next_store_index_ = 0;
   // check if the code is valid
   bool is_code_valid_(optional<std::string> code);

esphome/components/template/fan/template_fan.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <vector>
+#include <set>
 
 #include "esphome/core/component.h"
 #include "esphome/components/fan/fan.h"
@@ -16,7 +16,7 @@ class TemplateFan : public Component, public fan::Fan {
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
   void set_speed_count(int count) { this->speed_count_ = count; }
-  void set_preset_modes(const std::initializer_list<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -26,7 +26,7 @@ class TemplateFan : public Component, public fan::Fan {
   bool has_direction_{false};
   int speed_count_{0};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace template_

esphome/components/text/__init__.py

@@ -84,11 +84,6 @@ 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,11 +193,6 @@ 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/uart/__init__.py

@@ -446,7 +446,7 @@ async def uart_write_to_code(config, action_id, template_arg, args):
         templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
         cg.add(var.set_data_template(templ))
     else:
-        cg.add(var.set_data_static(data))
+        cg.add(var.set_data_static(cg.ArrayInitializer(*data)))
     return var
 
 

esphome/components/uart/automation.h

@@ -14,8 +14,12 @@ template<typename... Ts> class UARTWriteAction : public Action<Ts...>, public Pa
     this->data_func_ = func;
     this->static_ = false;
   }
-  void set_data_static(const std::vector<uint8_t> &data) {
-    this->data_static_ = data;
+  void set_data_static(std::vector<uint8_t> &&data) {
+    this->data_static_ = std::move(data);
+    this->static_ = true;
+  }
+  void set_data_static(std::initializer_list<uint8_t> data) {
+    this->data_static_ = std::vector<uint8_t>(data);
     this->static_ = true;
   }
 

esphome/components/uart/button/__init__.py

@@ -33,4 +33,4 @@ async def to_code(config):
     data = config[CONF_DATA]
     if isinstance(data, bytes):
         data = [HexInt(x) for x in data]
-    cg.add(var.set_data(data))
+    cg.add(var.set_data(cg.ArrayInitializer(*data)))

esphome/components/uart/button/uart_button.h

@@ -11,7 +11,8 @@ namespace uart {
 
 class UARTButton : public button::Button, public UARTDevice, public Component {
  public:
-  void set_data(const std::vector<uint8_t> &data) { this->data_ = data; }
+  void set_data(std::vector<uint8_t> &&data) { this->data_ = std::move(data); }
+  void set_data(std::initializer_list<uint8_t> data) { this->data_ = std::vector<uint8_t>(data); }
 
   void dump_config() override;
 

esphome/components/uart/switch/__init__.py

@@ -44,16 +44,16 @@ async def to_code(config):
         if data_on := data.get(CONF_TURN_ON):
             if isinstance(data_on, bytes):
                 data_on = [HexInt(x) for x in data_on]
-            cg.add(var.set_data_on(data_on))
+            cg.add(var.set_data_on(cg.ArrayInitializer(*data_on)))
         if data_off := data.get(CONF_TURN_OFF):
             if isinstance(data_off, bytes):
                 data_off = [HexInt(x) for x in data_off]
-            cg.add(var.set_data_off(data_off))
+            cg.add(var.set_data_off(cg.ArrayInitializer(*data_off)))
     else:
         data = config[CONF_DATA]
         if isinstance(data, bytes):
             data = [HexInt(x) for x in data]
-        cg.add(var.set_data_on(data))
+        cg.add(var.set_data_on(cg.ArrayInitializer(*data)))
         cg.add(var.set_single_state(True))
     if CONF_SEND_EVERY in config:
         cg.add(var.set_send_every(config[CONF_SEND_EVERY]))

esphome/components/uart/switch/uart_switch.h

@@ -14,8 +14,10 @@ class UARTSwitch : public switch_::Switch, public UARTDevice, public Component {
  public:
   void loop() override;
 
-  void set_data_on(const std::vector<uint8_t> &data) { this->data_on_ = data; }
-  void set_data_off(const std::vector<uint8_t> &data) { this->data_off_ = data; }
+  void set_data_on(std::vector<uint8_t> &&data) { this->data_on_ = std::move(data); }
+  void set_data_on(std::initializer_list<uint8_t> data) { this->data_on_ = std::vector<uint8_t>(data); }
+  void set_data_off(std::vector<uint8_t> &&data) { this->data_off_ = std::move(data); }
+  void set_data_off(std::initializer_list<uint8_t> data) { this->data_off_ = std::vector<uint8_t>(data); }
   void set_send_every(uint32_t send_every) { this->send_every_ = send_every; }
   void set_single_state(bool single) { this->single_state_ = single; }
 

esphome/components/uart/uart_component_libretiny.cpp

@@ -46,40 +46,58 @@ uint16_t LibreTinyUARTComponent::get_config() {
 }
 
 void LibreTinyUARTComponent::setup() {
-  if (this->rx_pin_) {
-    this->rx_pin_->setup();
-  }
-  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
-    this->tx_pin_->setup();
-  }
-
   int8_t tx_pin = tx_pin_ == nullptr ? -1 : tx_pin_->get_pin();
   int8_t rx_pin = rx_pin_ == nullptr ? -1 : rx_pin_->get_pin();
   bool tx_inverted = tx_pin_ != nullptr && tx_pin_->is_inverted();
   bool rx_inverted = rx_pin_ != nullptr && rx_pin_->is_inverted();
 
+  auto shouldFallbackToSoftwareSerial = [&]() -> bool {
+    auto hasFlags = [](InternalGPIOPin *pin, const gpio::Flags mask) -> bool {
+      return pin && pin->get_flags() & mask != gpio::Flags::FLAG_NONE;
+    };
+    if (hasFlags(this->tx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN) ||
+        hasFlags(this->rx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN)) {
+#if LT_ARD_HAS_SOFTSERIAL
+      ESP_LOGI(TAG, "Pins has flags set. Using Software Serial");
+      return true;
+#else
+      ESP_LOGW(TAG, "Pin flags are set but not supported for hardware serial. Ignoring");
+#endif
+    }
+    return false;
+  };
+
   if (false)
     return;
 #if LT_HW_UART0
-  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX)) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX) &&
+           !shouldFallbackToSoftwareSerial()) {
     this->serial_ = &Serial0;
     this->hardware_idx_ = 0;
   }
 #endif
 #if LT_HW_UART1
-  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL1_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL1_RX)) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL1_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL1_RX) &&
+           !shouldFallbackToSoftwareSerial()) {
     this->serial_ = &Serial1;
     this->hardware_idx_ = 1;
   }
 #endif
 #if LT_HW_UART2
-  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL2_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL2_RX)) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL2_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL2_RX) &&
+           !shouldFallbackToSoftwareSerial()) {
     this->serial_ = &Serial2;
     this->hardware_idx_ = 2;
   }
 #endif
   else {
 #if LT_ARD_HAS_SOFTSERIAL
+    if (this->rx_pin_) {
+      this->rx_pin_->setup();
+    }
+    if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
+      this->tx_pin_->setup();
+    }
     this->serial_ = new SoftwareSerial(rx_pin, tx_pin, rx_inverted || tx_inverted);
 #else
     this->serial_ = &Serial;

esphome/components/update/__init__.py

@@ -84,11 +84,6 @@ 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/usb_host/usb_host.h

@@ -82,12 +82,6 @@ struct TransferStatus {
 
 using transfer_cb_t = std::function<void(const TransferStatus &)>;
 
-enum TransferResult : uint8_t {
-  TRANSFER_OK = 0,
-  TRANSFER_ERROR_NO_SLOTS,
-  TRANSFER_ERROR_SUBMIT_FAILED,
-};
-
 class USBClient;
 
 // struct used to capture all data needed for a transfer
@@ -140,7 +134,7 @@ class USBClient : public Component {
   void on_opened(uint8_t addr);
   void on_removed(usb_device_handle_t handle);
   void control_transfer_callback(const usb_transfer_t *xfer) const;
-  TransferResult transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length);
+  void transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length);
   void transfer_out(uint8_t ep_address, const transfer_cb_t &callback, const uint8_t *data, uint16_t length);
   void dump_config() override;
   void release_trq(TransferRequest *trq);

esphome/components/usb_host/usb_host_client.cpp

@@ -334,7 +334,7 @@ static void control_callback(const usb_transfer_t *xfer) {
 // This multi-threaded access is intentional for performance - USB task can
 // immediately restart transfers without waiting for main loop scheduling.
 TransferRequest *USBClient::get_trq_() {
-  trq_bitmask_t mask = this->trq_in_use_.load(std::memory_order_acquire);
+  trq_bitmask_t mask = this->trq_in_use_.load(std::memory_order_relaxed);
 
   // Find first available slot (bit = 0) and try to claim it atomically
   // We use a while loop to allow retrying the same slot after CAS failure
@@ -443,15 +443,14 @@ static void transfer_callback(usb_transfer_t *xfer) {
  * @param ep_address The endpoint address.
  * @param callback The callback function to be called when the transfer is complete.
  * @param length The length of the data to be transferred.
- * @return TransferResult indicating success or specific failure reason
  *
  * @throws None.
  */
-TransferResult USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
+void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
   auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
-    return TRANSFER_ERROR_NO_SLOTS;
+    return;
   }
   trq->callback = callback;
   trq->transfer->callback = transfer_callback;
@@ -461,9 +460,7 @@ TransferResult USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &c
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "Failed to submit transfer, address=%x, length=%d, err=%x", ep_address, length, err);
     this->release_trq(trq);
-    return TRANSFER_ERROR_SUBMIT_FAILED;
   }
-  return TRANSFER_OK;
 }
 
 /**

esphome/components/usb_uart/usb_uart.cpp

@@ -169,98 +169,6 @@ bool USBUartChannel::read_array(uint8_t *data, size_t len) {
   this->parent_->start_input(this);
   return status;
 }
-void USBUartComponent::reset_input_state_(USBUartChannel *channel) {
-  channel->input_retry_count_.store(0);
-  channel->input_started_.store(false);
-}
-
-void USBUartComponent::restart_input_(USBUartChannel *channel) {
-  // Atomically verify it's still started (true) and keep it started
-  // This prevents the race window of toggling true->false->true
-  bool expected = true;
-  if (channel->input_started_.compare_exchange_strong(expected, true)) {
-    // Still started - do the actual restart work without toggling the flag
-    this->do_start_input_(channel);
-  }
-}
-
-void USBUartComponent::input_transfer_callback_(USBUartChannel *channel, const usb_host::TransferStatus &status) {
-  // CALLBACK CONTEXT: This function is executed in USB task via transfer_callback
-  ESP_LOGV(TAG, "Transfer result: length: %u; status %X", status.data_len, status.error_code);
-
-  if (!status.success) {
-    ESP_LOGE(TAG, "Control transfer failed, status=%s", esp_err_to_name(status.error_code));
-    // Transfer failed, slot already released
-    // Reset state so normal operations can restart later
-    this->reset_input_state_(channel);
-    return;
-  }
-
-  if (!channel->dummy_receiver_ && status.data_len > 0) {
-    // Allocate a chunk from the pool
-    UsbDataChunk *chunk = this->chunk_pool_.allocate();
-    if (chunk == nullptr) {
-      // No chunks available - queue is full, data dropped, slot already released
-      this->usb_data_queue_.increment_dropped_count();
-      // Reset state so normal operations can restart later
-      this->reset_input_state_(channel);
-      return;
-    }
-
-    // Copy data to chunk (this is fast, happens in USB task)
-    memcpy(chunk->data, status.data, status.data_len);
-    chunk->length = status.data_len;
-    chunk->channel = channel;
-
-    // Push to lock-free queue for main loop processing
-    // Push always succeeds because pool size == queue size
-    this->usb_data_queue_.push(chunk);
-  }
-
-  // On success, reset retry count and restart input immediately from USB task for performance
-  // The lock-free queue will handle backpressure
-  channel->input_retry_count_.store(0);
-  channel->input_started_.store(false);
-  this->start_input(channel);
-}
-
-void USBUartComponent::do_start_input_(USBUartChannel *channel) {
-  // This function does the actual work of starting input
-  // Caller must ensure input_started_ is already set to true
-  const auto *ep = channel->cdc_dev_.in_ep;
-
-  // input_started_ already set to true by caller
-  auto result = this->transfer_in(
-      ep->bEndpointAddress,
-      [this, channel](const usb_host::TransferStatus &status) { this->input_transfer_callback_(channel, status); },
-      ep->wMaxPacketSize);
-
-  if (result == usb_host::TRANSFER_ERROR_NO_SLOTS) {
-    // No slots available - defer retry to main loop
-    this->defer_input_retry_(channel);
-  } else if (result != usb_host::TRANSFER_OK) {
-    // Other error (submit failed) - don't retry, just reset state
-    // Error already logged by transfer_in()
-    this->reset_input_state_(channel);
-  }
-}
-
-void USBUartComponent::defer_input_retry_(USBUartChannel *channel) {
-  static constexpr uint8_t MAX_INPUT_RETRIES = 10;
-
-  // Atomically increment and get the NEW value (previous + 1)
-  uint8_t new_retry_count = channel->input_retry_count_.fetch_add(1) + 1;
-  if (new_retry_count > MAX_INPUT_RETRIES) {
-    ESP_LOGE(TAG, "Input retry limit reached for channel %d, stopping retries", channel->index_);
-    this->reset_input_state_(channel);
-    return;
-  }
-
-  // Keep input_started_ as true during defer to prevent multiple retries from queueing
-  // The deferred lambda will atomically restart
-  this->defer([this, channel] { this->restart_input_(channel); });
-}
-
 void USBUartComponent::setup() { USBClient::setup(); }
 void USBUartComponent::loop() {
   USBClient::loop();
@@ -306,14 +214,8 @@ void USBUartComponent::dump_config() {
   }
 }
 void USBUartComponent::start_input(USBUartChannel *channel) {
-  if (!channel->initialised_.load())
+  if (!channel->initialised_.load() || channel->input_started_.load())
     return;
-
-  // Atomically check if not started and set to started in one operation
-  bool expected = false;
-  if (!channel->input_started_.compare_exchange_strong(expected, true))
-    return;  // Already started - prevents duplicate transfers from concurrent threads
-
   // THREAD CONTEXT: Called from both USB task and main loop threads
   // - USB task: Immediate restart after successful transfer for continuous data flow
   // - Main loop: Controlled restart after consuming data (backpressure mechanism)
@@ -324,9 +226,45 @@ void USBUartComponent::start_input(USBUartChannel *channel) {
   //
   // The underlying transfer_in() uses lock-free atomic allocation from the
   // TransferRequest pool, making this multi-threaded access safe
+  const auto *ep = channel->cdc_dev_.in_ep;
+  // CALLBACK CONTEXT: This lambda is executed in USB task via transfer_callback
+  auto callback = [this, channel](const usb_host::TransferStatus &status) {
+    ESP_LOGV(TAG, "Transfer result: length: %u; status %X", status.data_len, status.error_code);
+    if (!status.success) {
+      ESP_LOGE(TAG, "Control transfer failed, status=%s", esp_err_to_name(status.error_code));
+      // On failure, don't restart - let next read_array() trigger it
+      channel->input_started_.store(false);
+      return;
+    }
 
-  // Do the actual work (input_started_ already set to true by CAS above)
-  this->do_start_input_(channel);
+    if (!channel->dummy_receiver_ && status.data_len > 0) {
+      // Allocate a chunk from the pool
+      UsbDataChunk *chunk = this->chunk_pool_.allocate();
+      if (chunk == nullptr) {
+        // No chunks available - queue is full or we're out of memory
+        this->usb_data_queue_.increment_dropped_count();
+        // Mark input as not started so we can retry
+        channel->input_started_.store(false);
+        return;
+      }
+
+      // Copy data to chunk (this is fast, happens in USB task)
+      memcpy(chunk->data, status.data, status.data_len);
+      chunk->length = status.data_len;
+      chunk->channel = channel;
+
+      // Push to lock-free queue for main loop processing
+      // Push always succeeds because pool size == queue size
+      this->usb_data_queue_.push(chunk);
+    }
+
+    // On success, restart input immediately from USB task for performance
+    // The lock-free queue will handle backpressure
+    channel->input_started_.store(false);
+    this->start_input(channel);
+  };
+  channel->input_started_.store(true);
+  this->transfer_in(ep->bEndpointAddress, callback, ep->wMaxPacketSize);
 }
 
 void USBUartComponent::start_output(USBUartChannel *channel) {
@@ -432,7 +370,7 @@ void USBUartTypeCdcAcm::enable_channels() {
   for (auto *channel : this->channels_) {
     if (!channel->initialised_.load())
       continue;
-    this->reset_input_state_(channel);
+    channel->input_started_.store(false);
     channel->output_started_.store(false);
     this->start_input(channel);
   }

esphome/components/usb_uart/usb_uart.h

@@ -111,11 +111,10 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   CdcEps cdc_dev_{};
   // Enum (likely 4 bytes)
   UARTParityOptions parity_{UART_CONFIG_PARITY_NONE};
-  // Group atomics together
+  // Group atomics together (each 1 byte)
   std::atomic<bool> input_started_{true};
   std::atomic<bool> output_started_{true};
   std::atomic<bool> initialised_{false};
-  std::atomic<uint8_t> input_retry_count_{0};
   // Group regular bytes together to minimize padding
   const uint8_t index_;
   bool debug_{};
@@ -141,11 +140,6 @@ class USBUartComponent : public usb_host::USBClient {
   EventPool<UsbDataChunk, USB_DATA_QUEUE_SIZE> chunk_pool_;
 
  protected:
-  void defer_input_retry_(USBUartChannel *channel);
-  void reset_input_state_(USBUartChannel *channel);
-  void restart_input_(USBUartChannel *channel);
-  void do_start_input_(USBUartChannel *channel);
-  void input_transfer_callback_(USBUartChannel *channel, const usb_host::TransferStatus &status);
   std::vector<USBUartChannel *> channels_{};
 };
 

esphome/components/valve/__init__.py

@@ -129,11 +129,6 @@ 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,6 +319,9 @@ 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,26 +2195,3 @@ 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/__init__.py

@@ -707,15 +707,6 @@ class EsphomeCore:
     def relative_piolibdeps_path(self, *path: str | Path) -> Path:
         return self.relative_build_path(".piolibdeps", *path)
 
-    @property
-    def platformio_cache_dir(self) -> str:
-        """Get the PlatformIO cache directory path."""
-        # Check if running in Docker/HA addon with custom cache dir
-        if (cache_dir := os.environ.get("PLATFORMIO_CACHE_DIR")) and cache_dir.strip():
-            return cache_dir
-        # Default PlatformIO cache location
-        return os.path.expanduser("~/.platformio/.cache")
-
     @property
     def firmware_bin(self) -> Path:
         if self.is_libretiny:

esphome/core/defines.h

@@ -187,6 +187,7 @@
 #define ESPHOME_ESP32_BLE_GATTS_EVENT_HANDLER_COUNT 1
 #define ESPHOME_ESP32_BLE_BLE_STATUS_EVENT_HANDLER_COUNT 2
 #define USE_ESP32_CAMERA_JPEG_ENCODER
+#define USE_HTTP_REQUEST_RESPONSE
 #define USE_I2C
 #define USE_IMPROV
 #define USE_ESP32_IMPROV_NEXT_URL
@@ -237,6 +238,7 @@
 #define USE_CAPTIVE_PORTAL
 #define USE_ESP8266_PREFERENCES_FLASH
 #define USE_HTTP_REQUEST_ESP8266_HTTPS
+#define USE_HTTP_REQUEST_RESPONSE
 #define USE_I2C
 #define USE_SOCKET_IMPL_LWIP_TCP
 
@@ -257,6 +259,7 @@
 
 #ifdef USE_RP2040
 #define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 0)
+#define USE_HTTP_REQUEST_RESPONSE
 #define USE_I2C
 #define USE_LOGGER_USB_CDC
 #define USE_SOCKET_IMPL_LWIP_TCP
@@ -273,6 +276,7 @@
 #endif
 
 #ifdef USE_HOST
+#define USE_HTTP_REQUEST_RESPONSE
 #define USE_SOCKET_IMPL_BSD_SOCKETS
 #define USE_SOCKET_SELECT_SUPPORT
 #endif

esphome/core/helpers.cpp

@@ -414,8 +414,10 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
-static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
+static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                            "abcdefghijklmnopqrstuvwxyz"
+                                            "0123456789+/";
 
 // Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
@@ -425,8 +427,8 @@ static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqr
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  const void *ptr = memchr(BASE64_CHARS, c, sizeof(BASE64_CHARS));
-  return ptr ? (static_cast<const char *>(ptr) - BASE64_CHARS) : 0;
+  const char *pos = strchr(BASE64_CHARS, c);
+  return pos ? (pos - BASE64_CHARS) : 0;
 }
 
 static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

esphome/core/helpers.h

@@ -143,9 +143,6 @@ template<typename T, size_t N> class StaticVector {
   size_t size() const { return count_; }
   bool empty() const { return count_ == 0; }
 
-  // Direct access to size counter for efficient in-place construction
-  size_t &count() { return count_; }
-
   T &operator[](size_t i) { return data_[i]; }
   const T &operator[](size_t i) const { return data_[i]; }
 

esphome/core/scheduler.h

@@ -94,9 +94,10 @@ class Scheduler {
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
-    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
-    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
+    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
+    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
+    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)

esphome/platformio_api.py

@@ -145,16 +145,7 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    result = run_platformio_cli_run(config, verbose, *args)
-
-    # Run memory analysis if enabled
-    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
-        try:
-            analyze_memory_usage(config)
-        except Exception as e:
-            _LOGGER.warning("Failed to analyze memory usage: %s", e)
-
-    return result
+    return run_platformio_cli_run(config, verbose, *args)
 
 
 def _run_idedata(config):
@@ -403,74 +394,3 @@ class IDEData:
             if path.endswith(".exe")
             else f"{path[:-3]}readelf"
         )
-
-
-def analyze_memory_usage(config: dict[str, Any]) -> None:
-    """Analyze memory usage by component after compilation."""
-    # Lazy import to avoid overhead when not needed
-    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
-    from esphome.analyze_memory.helpers import get_esphome_components
-
-    idedata = get_idedata(config)
-
-    # Get paths to tools
-    elf_path = idedata.firmware_elf_path
-    objdump_path = idedata.objdump_path
-    readelf_path = idedata.readelf_path
-
-    # Debug logging
-    _LOGGER.debug("ELF path from idedata: %s", elf_path)
-
-    # Check if file exists
-    if not Path(elf_path).exists():
-        # Try alternate path
-        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
-        if alt_path.exists():
-            elf_path = str(alt_path)
-            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
-        else:
-            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
-            return
-
-    # Extract external components from config
-    external_components = set()
-
-    # Get the list of built-in ESPHome components
-    builtin_components = get_esphome_components()
-
-    # Special non-component keys that appear in configs
-    NON_COMPONENT_KEYS = {
-        CONF_ESPHOME,
-        "substitutions",
-        "packages",
-        "globals",
-        "<<",
-    }
-
-    # Check all top-level keys in config
-    for key in config:
-        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
-            # This is an external component
-            external_components.add(key)
-
-    _LOGGER.debug("Detected external components: %s", external_components)
-
-    # Create analyzer and run analysis
-    analyzer = MemoryAnalyzerCLI(
-        elf_path, objdump_path, readelf_path, external_components
-    )
-    analyzer.analyze()
-
-    # Generate and print report
-    report = analyzer.generate_report()
-    _LOGGER.info("\n%s", report)
-
-    # Optionally save to file
-    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
-        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
-        if report_file.suffix == ".json":
-            report_file.write_text(analyzer.to_json())
-            _LOGGER.info("Memory report saved to %s", report_file)
-        else:
-            report_file.write_text(report)
-            _LOGGER.info("Memory report saved to %s", report_file)

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.3.0
+aioesphomeapi==42.5.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.1  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.2  # 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/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,12 +43,14 @@ 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,
@@ -65,12 +67,17 @@ 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."""
@@ -686,6 +693,22 @@ 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,
@@ -703,6 +726,7 @@ 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,16 +90,18 @@ 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")
+        file_path: Path to a file (e.g., "esphome/components/wifi/wifi.cpp"
+                                or "tests/components/uart/test.esp32-idf.yaml")
 
     Returns:
-        Component name if path is in components directory, None otherwise
+        Component name if path is in components or tests directory, None otherwise
     """
-    if not file_path.startswith(ESPHOME_COMPONENTS_PATH):
-        return None
-    parts = file_path.split("/")
-    if len(parts) >= 3:
-        return parts[2]
+    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]
     return None
 
 

script/split_components_for_ci.py

@@ -62,6 +62,10 @@ 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/component_tests/packages/test_packages.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from esphome.components.packages import do_packages_pass
+from esphome.components.packages import CONFIG_SCHEMA, do_packages_pass
 from esphome.config import resolve_extend_remove
 from esphome.config_helpers import Extend, Remove
 import esphome.config_validation as cv
@@ -94,6 +94,50 @@ def test_package_invalid_dict(basic_esphome, basic_wifi):
         packages_pass(config)
 
 
+@pytest.mark.parametrize(
+    "package",
+    [
+        {"package1": "github://esphome/non-existant-repo/file1.yml@main"},
+        {"package2": "github://esphome/non-existant-repo/file1.yml"},
+        {"package3": "github://esphome/non-existant-repo/other-folder/file1.yml"},
+        [
+            "github://esphome/non-existant-repo/file1.yml@main",
+            "github://esphome/non-existant-repo/file1.yml",
+            "github://esphome/non-existant-repo/other-folder/file1.yml",
+        ],
+    ],
+)
+def test_package_shorthand(package):
+    CONFIG_SCHEMA(package)
+
+
+@pytest.mark.parametrize(
+    "package",
+    [
+        # not github
+        {"package1": "someplace://esphome/non-existant-repo/file1.yml@main"},
+        # missing repo
+        {"package2": "github://esphome/file1.yml"},
+        # missing file
+        {"package3": "github://esphome/non-existant-repo/@main"},
+        {"a": "invalid string, not shorthand"},
+        "some string",
+        3,
+        False,
+        {"a": 8},
+        ["someplace://esphome/non-existant-repo/file1.yml@main"],
+        ["github://esphome/file1.yml"],
+        ["github://esphome/non-existant-repo/@main"],
+        ["some string"],
+        [True],
+        [3],
+    ],
+)
+def test_package_invalid(package):
+    with pytest.raises(cv.Invalid):
+        CONFIG_SCHEMA(package)
+
+
 def test_package_include(basic_wifi, basic_esphome):
     """
     Tests the simple case where an independent config present in a package is added to the top-level config as is.

tests/component_tests/text/test_text.py

@@ -66,6 +66,5 @@ def test_text_config_lamda_is_set(generate_main):
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
     # Then
-    # Stateless lambda optimization: empty capture list allows function pointer conversion
     assert "it_4->set_template([]() -> esphome::optional<std::string> {" in main_cpp
     assert 'return std::string{"Hello"};' in main_cpp

tests/components/http_request/common.yaml

@@ -4,51 +4,6 @@ wifi:
   ssid: MySSID
   password: password1
 
-esphome:
-  on_boot:
-    then:
-      - http_request.get:
-          url: https://esphome.io
-          request_headers:
-            Content-Type: application/json
-          collect_headers:
-            - age
-          on_error:
-            logger.log: "Request failed"
-          on_response:
-            then:
-              - logger.log:
-                  format: "Response status: %d, Duration: %lu ms, age: %s"
-                  args:
-                    - response->status_code
-                    - (long) response->duration_ms
-                    - response->get_response_header("age").c_str()
-      - http_request.post:
-          url: https://esphome.io
-          request_headers:
-            Content-Type: application/json
-          json:
-            key: value
-      - http_request.send:
-          method: PUT
-          url: https://esphome.io
-          request_headers:
-            Content-Type: application/json
-          body: "Some data"
-
-http_request:
-  useragent: esphome/tagreader
-  timeout: 10s
-  verify_ssl: ${verify_ssl}
-
-script:
-  - id: does_not_compile
-    parameters:
-      api_url: string
-    then:
-      - http_request.get:
-          url: "http://google.com"
-
 ota:
   - platform: http_request
     id: http_request_ota

tests/components/http_request/http_request.yaml

@@ -31,6 +31,20 @@ esphome:
           request_headers:
             Content-Type: application/json
           body: "Some data"
+      - http_request.post:
+          url: https://esphome.io
+          request_headers:
+            Content-Type: application/json
+          json:
+            key: value
+          capture_response: true
+          on_response:
+            then:
+              - logger.log:
+                  format: "Captured response status: %d, Body: %s"
+                  args:
+                    - response->status_code
+                    - body.c_str()
 
 http_request:
   useragent: esphome/tagreader

tests/components/lvgl/common.yaml

@@ -52,6 +52,19 @@ 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
@@ -110,3 +123,21 @@ 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,7 +257,30 @@ 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,6 +2,7 @@ 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,6 +152,14 @@ 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(
@@ -209,6 +217,9 @@ 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,3 +1065,39 @@ 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,6 +261,17 @@ 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

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