[wifi] Store credentials in PROGMEM on ESP8266 to reduce RAM usage

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

@@ -416,7 +416,7 @@ jobs:
             }
 
             // Generate review messages
-            function generateReviewMessages(finalLabels, originalLabelCount) {
+            function generateReviewMessages(finalLabels) {
               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 = originalLabelCount > MAX_LABELS;
+                const tooManyLabels = finalLabels.length > 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 ${originalLabelCount} different components/areas.`;
+                  message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${finalLabels.length} different components/areas.`;
                 } else if (tooManyLabels) {
-                  message += `This PR affects ${originalLabelCount} different components/areas.`;
+                  message += `This PR affects ${finalLabels.length} 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, originalLabelCount) {
-              const reviewMessages = generateReviewMessages(finalLabels, originalLabelCount);
+            async function handleReviews(finalLabels) {
+              const reviewMessages = generateReviewMessages(finalLabels);
               const hasReviewableLabels = finalLabels.some(label =>
                 ['too-big', 'needs-codeowners'].includes(label)
               );
@@ -627,7 +627,6 @@ 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'];
@@ -636,7 +635,7 @@ jobs:
             console.log('Computed labels:', finalLabels.join(', '));
 
             // Handle reviews
-            await handleReviews(finalLabels, originalLabelCount);
+            await handleReviews(finalLabels);
 
             // 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@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: generated-proto-files
           path: |

.github/workflows/ci.yml

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

.github/workflows/codeql.yml

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

.github/workflows/release.yml

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

.pre-commit-config.yaml

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

esphome/components/alarm_control_panel/__init__.py

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

esphome/components/api/api.proto

@@ -989,7 +989,7 @@ message ListEntitiesClimateResponse {
 
   bool supports_current_temperature = 5; // Deprecated: use feature_flags
   bool supports_two_point_target_temperature = 6; // Deprecated: use feature_flags
-  repeated ClimateMode supported_modes = 7 [(container_pointer_no_template) = "climate::ClimateModeMask"];
+  repeated ClimateMode supported_modes = 7 [(container_pointer) = "std::set<climate::ClimateMode>"];
   float visual_min_temperature = 8;
   float visual_max_temperature = 9;
   float visual_target_temperature_step = 10;
@@ -998,11 +998,11 @@ message ListEntitiesClimateResponse {
   // Deprecated in API version 1.5
   bool legacy_supports_away = 11 [deprecated=true];
   bool supports_action = 12; // Deprecated: use feature_flags
-  repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
-  repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::vector"];
-  repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer) = "std::vector"];
+  repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer) = "std::set<climate::ClimateFanMode>"];
+  repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer) = "std::set<climate::ClimateSwingMode>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::set"];
+  repeated ClimatePreset supported_presets = 16 [(container_pointer) = "std::set<climate::ClimatePreset>"];
+  repeated string supported_custom_presets = 17 [(container_pointer) = "std::set"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;
@@ -1143,7 +1143,7 @@ message ListEntitiesSelectResponse {
   reserved 4; // Deprecated: was string unique_id
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
-  repeated string options = 6 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string options = 6 [(container_pointer) = "std::vector"];
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];

esphome/components/api/api_connection.cpp

@@ -1,5 +1,3 @@
-// random comment
-
 #include "api_connection.h"
 #ifdef USE_API
 #ifdef USE_API_NOISE
@@ -671,18 +669,18 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   msg.supports_action = traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION);
   // Current feature flags and other supported parameters
   msg.feature_flags = traits.get_feature_flags();
-  msg.supported_modes = &traits.get_supported_modes();
+  msg.supported_modes = &traits.get_supported_modes_for_api_();
   msg.visual_min_temperature = traits.get_visual_min_temperature();
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_target_temperature_step = traits.get_visual_target_temperature_step();
   msg.visual_current_temperature_step = traits.get_visual_current_temperature_step();
   msg.visual_min_humidity = traits.get_visual_min_humidity();
   msg.visual_max_humidity = traits.get_visual_max_humidity();
-  msg.supported_fan_modes = &traits.get_supported_fan_modes();
-  msg.supported_custom_fan_modes = &traits.get_supported_custom_fan_modes();
-  msg.supported_presets = &traits.get_supported_presets();
-  msg.supported_custom_presets = &traits.get_supported_custom_presets();
-  msg.supported_swing_modes = &traits.get_supported_swing_modes();
+  msg.supported_fan_modes = &traits.get_supported_fan_modes_for_api_();
+  msg.supported_custom_fan_modes = &traits.get_supported_custom_fan_modes_for_api_();
+  msg.supported_presets = &traits.get_supported_presets_for_api_();
+  msg.supported_custom_presets = &traits.get_supported_custom_presets_for_api_();
+  msg.supported_swing_modes = &traits.get_supported_swing_modes_for_api_();
   return fill_and_encode_entity_info(climate, msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }

esphome/components/api/api_pb2.cpp

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

esphome/components/api/api_pb2.h

@@ -1377,16 +1377,16 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
 #endif
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
-  const climate::ClimateModeMask *supported_modes{};
+  const std::set<climate::ClimateMode> *supported_modes{};
   float visual_min_temperature{0.0f};
   float visual_max_temperature{0.0f};
   float visual_target_temperature_step{0.0f};
   bool supports_action{false};
-  const climate::ClimateFanModeMask *supported_fan_modes{};
-  const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const std::vector<std::string> *supported_custom_fan_modes{};
-  const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<std::string> *supported_custom_presets{};
+  const std::set<climate::ClimateFanMode> *supported_fan_modes{};
+  const std::set<climate::ClimateSwingMode> *supported_swing_modes{};
+  const std::set<std::string> *supported_custom_fan_modes{};
+  const std::set<climate::ClimatePreset> *supported_presets{};
+  const std::set<std::string> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};
@@ -1534,7 +1534,7 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_select_response"; }
 #endif
-  const FixedVector<const char *> *options{};
+  const std::vector<std::string> *options{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

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

esphome/components/bedjet/bedjet_const.h

@@ -99,8 +99,9 @@ enum BedjetCommand : uint8_t {
 
 static const uint8_t BEDJET_FAN_SPEED_COUNT = 20;
 
-static constexpr const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
+static const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
 static const std::string BEDJET_FAN_STEP_NAME_STRINGS[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
+static const std::set<std::string> BEDJET_FAN_STEP_NAMES_SET BEDJET_FAN_STEP_NAMES_;
 
 }  // namespace bedjet
 }  // namespace esphome

esphome/components/bedjet/climate/bedjet_climate.h

@@ -43,7 +43,7 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
     });
 
     // It would be better if we had a slider for the fan modes.
-    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES);
+    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES_SET);
     traits.set_supported_presets({
         // If we support NONE, then have to decide what happens if the user switches to it (turn off?)
         // climate::CLIMATE_PRESET_NONE,

esphome/components/binary_sensor/__init__.py

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

esphome/components/ble_client/automation.h

@@ -96,11 +96,8 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   BLEClientWriteAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
-    this->construct_simple_value_();
   }
 
-  ~BLEClientWriteAction() { this->destroy_simple_value_(); }
-
   void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
   void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
@@ -109,18 +106,14 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
 
-  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->destroy_simple_value_();
-    this->value_.template_func = func;
-    this->has_simple_value_ = false;
+  void set_value_template(std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->value_template_ = std::move(func);
+    has_simple_value_ = false;
   }
 
   void set_value_simple(const std::vector<uint8_t> &value) {
-    if (!this->has_simple_value_) {
-      this->construct_simple_value_();
-    }
-    this->value_.simple = value;
-    this->has_simple_value_ = true;
+    this->value_simple_ = value;
+    has_simple_value_ = true;
   }
 
   void play(Ts... x) override {}
@@ -128,7 +121,7 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void play_complex(Ts... x) override {
     this->num_running_++;
     this->var_ = std::make_tuple(x...);
-    auto value = this->has_simple_value_ ? this->value_.simple : this->value_.template_func(x...);
+    auto value = this->has_simple_value_ ? this->value_simple_ : this->value_template_(x...);
     // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
     if (!write(value))
       this->play_next_(x...);
@@ -201,22 +194,10 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   }
 
  private:
-  void construct_simple_value_() { new (&this->value_.simple) std::vector<uint8_t>(); }
-
-  void destroy_simple_value_() {
-    if (this->has_simple_value_) {
-      this->value_.simple.~vector();
-    }
-  }
-
   BLEClient *ble_client_;
   bool has_simple_value_ = true;
-  union Value {
-    std::vector<uint8_t> simple;
-    std::vector<uint8_t> (*template_func)(Ts...);
-    Value() {}   // trivial constructor
-    ~Value() {}  // trivial destructor - we manage lifetime via discriminator
-  } value_;
+  std::vector<uint8_t> value_simple_;
+  std::function<std::vector<uint8_t>(Ts...)> value_template_{};
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;
   std::tuple<Ts...> var_{};
@@ -232,9 +213,9 @@ template<typename... Ts> class BLEClientPasskeyReplyAction : public Action<Ts...
   void play(Ts... x) override {
     uint32_t passkey;
     if (has_simple_value_) {
-      passkey = this->value_.simple;
+      passkey = this->value_simple_;
     } else {
-      passkey = this->value_.template_func(x...);
+      passkey = this->value_template_(x...);
     }
     if (passkey > 999999)
       return;
@@ -243,23 +224,21 @@ template<typename... Ts> class BLEClientPasskeyReplyAction : public Action<Ts...
     esp_ble_passkey_reply(remote_bda, true, passkey);
   }
 
-  void set_value_template(uint32_t (*func)(Ts...)) {
-    this->value_.template_func = func;
-    this->has_simple_value_ = false;
+  void set_value_template(std::function<uint32_t(Ts...)> func) {
+    this->value_template_ = std::move(func);
+    has_simple_value_ = false;
   }
 
   void set_value_simple(const uint32_t &value) {
-    this->value_.simple = value;
-    this->has_simple_value_ = true;
+    this->value_simple_ = value;
+    has_simple_value_ = true;
   }
 
  private:
   BLEClient *parent_{nullptr};
   bool has_simple_value_ = true;
-  union {
-    uint32_t simple;
-    uint32_t (*template_func)(Ts...);
-  } value_{.simple = 0};
+  uint32_t value_simple_{0};
+  std::function<uint32_t(Ts...)> value_template_{};
 };
 
 template<typename... Ts> class BLEClientNumericComparisonReplyAction : public Action<Ts...> {
@@ -270,29 +249,27 @@ template<typename... Ts> class BLEClientNumericComparisonReplyAction : public Ac
     esp_bd_addr_t remote_bda;
     memcpy(remote_bda, parent_->get_remote_bda(), sizeof(esp_bd_addr_t));
     if (has_simple_value_) {
-      esp_ble_confirm_reply(remote_bda, this->value_.simple);
+      esp_ble_confirm_reply(remote_bda, this->value_simple_);
     } else {
-      esp_ble_confirm_reply(remote_bda, this->value_.template_func(x...));
+      esp_ble_confirm_reply(remote_bda, this->value_template_(x...));
     }
   }
 
-  void set_value_template(bool (*func)(Ts...)) {
-    this->value_.template_func = func;
-    this->has_simple_value_ = false;
+  void set_value_template(std::function<bool(Ts...)> func) {
+    this->value_template_ = std::move(func);
+    has_simple_value_ = false;
   }
 
   void set_value_simple(const bool &value) {
-    this->value_.simple = value;
-    this->has_simple_value_ = true;
+    this->value_simple_ = value;
+    has_simple_value_ = true;
   }
 
  private:
   BLEClient *parent_{nullptr};
   bool has_simple_value_ = true;
-  union {
-    bool simple;
-    bool (*template_func)(Ts...);
-  } value_{.simple = false};
+  bool value_simple_{false};
+  std::function<bool(Ts...)> value_template_{};
 };
 
 template<typename... Ts> class BLEClientRemoveBondAction : public Action<Ts...> {

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -117,9 +117,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
 }
 
 float BLESensor::parse_data_(uint8_t *value, uint16_t value_len) {
-  if (this->has_data_to_value_) {
+  if (this->data_to_value_func_.has_value()) {
     std::vector<uint8_t> data(value, value + value_len);
-    return this->data_to_value_func_(data);
+    return (*this->data_to_value_func_)(data);
   } else {
     return value[0];
   }

esphome/components/ble_client/sensor/ble_sensor.h

@@ -15,6 +15,8 @@ namespace ble_client {
 
 namespace espbt = esphome::esp32_ble_tracker;
 
+using data_to_value_t = std::function<float(std::vector<uint8_t>)>;
+
 class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClientNode {
  public:
   void loop() override;
@@ -31,17 +33,13 @@ class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClie
   void set_descr_uuid16(uint16_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
   void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-  void set_data_to_value(float (*lambda)(const std::vector<uint8_t> &)) {
-    this->data_to_value_func_ = lambda;
-    this->has_data_to_value_ = true;
-  }
+  void set_data_to_value(data_to_value_t &&lambda) { this->data_to_value_func_ = lambda; }
   void set_enable_notify(bool notify) { this->notify_ = notify; }
   uint16_t handle;
 
  protected:
   float parse_data_(uint8_t *value, uint16_t value_len);
-  bool has_data_to_value_{false};
-  float (*data_to_value_func_)(const std::vector<uint8_t> &){};
+  optional<data_to_value_t> data_to_value_func_{};
   bool notify_;
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;

esphome/components/button/__init__.py

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

esphome/components/climate/__init__.py

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

esphome/components/climate/climate.cpp

@@ -385,7 +385,7 @@ void Climate::save_state_() {
   if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
-    // std::vector maintains insertion order
+    // std::set has consistent order (lexicographic for strings)
     size_t i = 0;
     for (const auto &mode : supported) {
       if (mode == custom_fan_mode) {
@@ -402,7 +402,7 @@ void Climate::save_state_() {
   if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
-    // std::vector maintains insertion order
+    // std::set has consistent order (lexicographic for strings)
     size_t i = 0;
     for (const auto &preset : supported) {
       if (preset == custom_preset) {

esphome/components/climate/climate_mode.h

@@ -7,7 +7,6 @@ namespace esphome {
 namespace climate {
 
 /// Enum for all modes a climate device can be in.
-/// NOTE: If adding values, update ClimateModeMask in climate_traits.h to use the new last value
 enum ClimateMode : uint8_t {
   /// The climate device is off
   CLIMATE_MODE_OFF = 0,
@@ -25,7 +24,7 @@ enum ClimateMode : uint8_t {
    * For example, the target temperature can be adjusted based on a schedule, or learned behavior.
    * The target temperature can't be adjusted when in this mode.
    */
-  CLIMATE_MODE_AUTO = 6  // Update ClimateModeMask in climate_traits.h if adding values after this
+  CLIMATE_MODE_AUTO = 6
 };
 
 /// Enum for the current action of the climate device. Values match those of ClimateMode.
@@ -44,7 +43,6 @@ enum ClimateAction : uint8_t {
   CLIMATE_ACTION_FAN = 6,
 };
 
-/// NOTE: If adding values, update ClimateFanModeMask in climate_traits.h to use the new last value
 enum ClimateFanMode : uint8_t {
   /// The fan mode is set to On
   CLIMATE_FAN_ON = 0,
@@ -65,11 +63,10 @@ enum ClimateFanMode : uint8_t {
   /// The fan mode is set to Diffuse
   CLIMATE_FAN_DIFFUSE = 8,
   /// The fan mode is set to Quiet
-  CLIMATE_FAN_QUIET = 9,  // Update ClimateFanModeMask in climate_traits.h if adding values after this
+  CLIMATE_FAN_QUIET = 9,
 };
 
 /// Enum for all modes a climate swing can be in
-/// NOTE: If adding values, update ClimateSwingModeMask in climate_traits.h to use the new last value
 enum ClimateSwingMode : uint8_t {
   /// The swing mode is set to Off
   CLIMATE_SWING_OFF = 0,
@@ -78,11 +75,10 @@ enum ClimateSwingMode : uint8_t {
   /// The fan mode is set to Vertical
   CLIMATE_SWING_VERTICAL = 2,
   /// The fan mode is set to Horizontal
-  CLIMATE_SWING_HORIZONTAL = 3,  // Update ClimateSwingModeMask in climate_traits.h if adding values after this
+  CLIMATE_SWING_HORIZONTAL = 3,
 };
 
 /// Enum for all preset modes
-/// NOTE: If adding values, update ClimatePresetMask in climate_traits.h to use the new last value
 enum ClimatePreset : uint8_t {
   /// No preset is active
   CLIMATE_PRESET_NONE = 0,
@@ -99,7 +95,7 @@ enum ClimatePreset : uint8_t {
   /// Device is prepared for sleep
   CLIMATE_PRESET_SLEEP = 6,
   /// Device is reacting to activity (e.g., movement sensors)
-  CLIMATE_PRESET_ACTIVITY = 7,  // Update ClimatePresetMask in climate_traits.h if adding values after this
+  CLIMATE_PRESET_ACTIVITY = 7,
 };
 
 enum ClimateFeature : uint32_t {

esphome/components/climate/climate_traits.h

@@ -1,33 +1,19 @@
 #pragma once
 
-#include <vector>
+#include <set>
 #include "climate_mode.h"
-#include "esphome/core/finite_set_mask.h"
 #include "esphome/core/helpers.h"
 
 namespace esphome {
+
+#ifdef USE_API
+namespace api {
+class APIConnection;
+}  // namespace api
+#endif
+
 namespace climate {
 
-// Type aliases for climate enum bitmasks
-// These replace std::set<EnumType> to eliminate red-black tree overhead
-// For contiguous enums starting at 0, DefaultBitPolicy provides 1:1 mapping (enum value = bit position)
-// Bitmask size is automatically calculated from the last enum value
-using ClimateModeMask = FiniteSetMask<ClimateMode, DefaultBitPolicy<ClimateMode, CLIMATE_MODE_AUTO + 1>>;
-using ClimateFanModeMask = FiniteSetMask<ClimateFanMode, DefaultBitPolicy<ClimateFanMode, CLIMATE_FAN_QUIET + 1>>;
-using ClimateSwingModeMask =
-    FiniteSetMask<ClimateSwingMode, DefaultBitPolicy<ClimateSwingMode, CLIMATE_SWING_HORIZONTAL + 1>>;
-using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimatePreset, CLIMATE_PRESET_ACTIVITY + 1>>;
-
-// Lightweight linear search for small vectors (1-20 items)
-// Avoids std::find template overhead
-template<typename T> inline bool vector_contains(const std::vector<T> &vec, const T &value) {
-  for (const auto &item : vec) {
-    if (item == value)
-      return true;
-  }
-  return false;
-}
-
 /** This class contains all static data for climate devices.
  *
  * All climate devices must support these features:
@@ -121,60 +107,48 @@ class ClimateTraits {
     }
   }
 
-  void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
+  void set_supported_modes(std::set<ClimateMode> modes) { this->supported_modes_ = std::move(modes); }
   void add_supported_mode(ClimateMode mode) { this->supported_modes_.insert(mode); }
   bool supports_mode(ClimateMode mode) const { return this->supported_modes_.count(mode); }
-  const ClimateModeMask &get_supported_modes() const { return this->supported_modes_; }
+  const std::set<ClimateMode> &get_supported_modes() const { return this->supported_modes_; }
 
-  void set_supported_fan_modes(ClimateFanModeMask modes) { this->supported_fan_modes_ = modes; }
+  void set_supported_fan_modes(std::set<ClimateFanMode> modes) { this->supported_fan_modes_ = std::move(modes); }
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
-  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.push_back(mode); }
+  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.insert(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
     return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
-  const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
+  const std::set<ClimateFanMode> &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  void set_supported_custom_fan_modes(std::vector<std::string> supported_custom_fan_modes) {
+  void set_supported_custom_fan_modes(std::set<std::string> supported_custom_fan_modes) {
     this->supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
   }
-  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) {
-    this->supported_custom_fan_modes_ = modes;
-  }
-  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
-    this->supported_custom_fan_modes_.assign(modes, modes + N);
-  }
-  const std::vector<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
+  const std::set<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
   bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
-    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
+    return this->supported_custom_fan_modes_.count(custom_fan_mode);
   }
 
-  void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
+  void set_supported_presets(std::set<ClimatePreset> presets) { this->supported_presets_ = std::move(presets); }
   void add_supported_preset(ClimatePreset preset) { this->supported_presets_.insert(preset); }
-  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.push_back(preset); }
+  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.insert(preset); }
   bool supports_preset(ClimatePreset preset) const { return this->supported_presets_.count(preset); }
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
-  const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
+  const std::set<climate::ClimatePreset> &get_supported_presets() const { return this->supported_presets_; }
 
-  void set_supported_custom_presets(std::vector<std::string> supported_custom_presets) {
+  void set_supported_custom_presets(std::set<std::string> supported_custom_presets) {
     this->supported_custom_presets_ = std::move(supported_custom_presets);
   }
-  void set_supported_custom_presets(std::initializer_list<std::string> presets) {
-    this->supported_custom_presets_ = presets;
-  }
-  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
-    this->supported_custom_presets_.assign(presets, presets + N);
-  }
-  const std::vector<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
+  const std::set<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
   bool supports_custom_preset(const std::string &custom_preset) const {
-    return vector_contains(this->supported_custom_presets_, custom_preset);
+    return this->supported_custom_presets_.count(custom_preset);
   }
 
-  void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
+  void set_supported_swing_modes(std::set<ClimateSwingMode> modes) { this->supported_swing_modes_ = std::move(modes); }
   void add_supported_swing_mode(ClimateSwingMode mode) { this->supported_swing_modes_.insert(mode); }
   bool supports_swing_mode(ClimateSwingMode swing_mode) const { return this->supported_swing_modes_.count(swing_mode); }
   bool get_supports_swing_modes() const { return !this->supported_swing_modes_.empty(); }
-  const ClimateSwingModeMask &get_supported_swing_modes() const { return this->supported_swing_modes_; }
+  const std::set<ClimateSwingMode> &get_supported_swing_modes() const { return this->supported_swing_modes_; }
 
   float get_visual_min_temperature() const { return this->visual_min_temperature_; }
   void set_visual_min_temperature(float visual_min_temperature) {
@@ -205,6 +179,23 @@ class ClimateTraits {
   void set_visual_max_humidity(float visual_max_humidity) { this->visual_max_humidity_ = visual_max_humidity; }
 
  protected:
+#ifdef USE_API
+  // The API connection is a friend class to access internal methods
+  friend class api::APIConnection;
+  // These methods return references to internal data structures.
+  // They are used by the API to avoid copying data when encoding messages.
+  // Warning: Do not use these methods outside of the API connection code.
+  // They return references to internal data that can be invalidated.
+  const std::set<ClimateMode> &get_supported_modes_for_api_() const { return this->supported_modes_; }
+  const std::set<ClimateFanMode> &get_supported_fan_modes_for_api_() const { return this->supported_fan_modes_; }
+  const std::set<std::string> &get_supported_custom_fan_modes_for_api_() const {
+    return this->supported_custom_fan_modes_;
+  }
+  const std::set<climate::ClimatePreset> &get_supported_presets_for_api_() const { return this->supported_presets_; }
+  const std::set<std::string> &get_supported_custom_presets_for_api_() const { return this->supported_custom_presets_; }
+  const std::set<ClimateSwingMode> &get_supported_swing_modes_for_api_() const { return this->supported_swing_modes_; }
+#endif
+
   void set_mode_support_(climate::ClimateMode mode, bool supported) {
     if (supported) {
       this->supported_modes_.insert(mode);
@@ -235,12 +226,12 @@ class ClimateTraits {
   float visual_min_humidity_{30};
   float visual_max_humidity_{99};
 
-  climate::ClimateModeMask supported_modes_{climate::CLIMATE_MODE_OFF};
-  climate::ClimateFanModeMask supported_fan_modes_;
-  climate::ClimateSwingModeMask supported_swing_modes_;
-  climate::ClimatePresetMask supported_presets_;
-  std::vector<std::string> supported_custom_fan_modes_;
-  std::vector<std::string> supported_custom_presets_;
+  std::set<climate::ClimateMode> supported_modes_ = {climate::CLIMATE_MODE_OFF};
+  std::set<climate::ClimateFanMode> supported_fan_modes_;
+  std::set<climate::ClimateSwingMode> supported_swing_modes_;
+  std::set<climate::ClimatePreset> supported_presets_;
+  std::set<std::string> supported_custom_fan_modes_;
+  std::set<std::string> supported_custom_presets_;
 };
 
 }  // namespace climate

esphome/components/climate_ir/__init__.py

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

esphome/components/climate_ir/climate_ir.h

@@ -24,18 +24,16 @@ class ClimateIR : public Component,
                   public remote_base::RemoteTransmittable {
  public:
   ClimateIR(float minimum_temperature, float maximum_temperature, float temperature_step = 1.0f,
-            bool supports_dry = false, bool supports_fan_only = false,
-            climate::ClimateFanModeMask fan_modes = climate::ClimateFanModeMask(),
-            climate::ClimateSwingModeMask swing_modes = climate::ClimateSwingModeMask(),
-            climate::ClimatePresetMask presets = climate::ClimatePresetMask()) {
+            bool supports_dry = false, bool supports_fan_only = false, std::set<climate::ClimateFanMode> fan_modes = {},
+            std::set<climate::ClimateSwingMode> swing_modes = {}, std::set<climate::ClimatePreset> presets = {}) {
     this->minimum_temperature_ = minimum_temperature;
     this->maximum_temperature_ = maximum_temperature;
     this->temperature_step_ = temperature_step;
     this->supports_dry_ = supports_dry;
     this->supports_fan_only_ = supports_fan_only;
-    this->fan_modes_ = fan_modes;
-    this->swing_modes_ = swing_modes;
-    this->presets_ = presets;
+    this->fan_modes_ = std::move(fan_modes);
+    this->swing_modes_ = std::move(swing_modes);
+    this->presets_ = std::move(presets);
   }
 
   void setup() override;
@@ -62,9 +60,9 @@ class ClimateIR : public Component,
   bool supports_heat_{true};
   bool supports_dry_{false};
   bool supports_fan_only_{false};
-  climate::ClimateFanModeMask fan_modes_{};
-  climate::ClimateSwingModeMask swing_modes_{};
-  climate::ClimatePresetMask presets_{};
+  std::set<climate::ClimateFanMode> fan_modes_ = {};
+  std::set<climate::ClimateSwingMode> swing_modes_ = {};
+  std::set<climate::ClimatePreset> presets_ = {};
 
   sensor::Sensor *sensor_{nullptr};
 };

esphome/components/cover/__init__.py

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

esphome/components/esp32_ble_server/__init__.py

@@ -461,9 +461,7 @@ async def parse_value(value_config, args):
     if isinstance(value, str):
         value = list(value.encode(value_config[CONF_STRING_ENCODING]))
     if isinstance(value, list):
-        # Generate initializer list {1, 2, 3} instead of std::vector<uint8_t>({1, 2, 3})
-        # This calls the set_value(std::initializer_list<uint8_t>) overload
-        return cg.ArrayInitializer(*value)
+        return cg.std_vector.template(cg.uint8)(value)
     val = cg.RawExpression(f"{value_config[CONF_TYPE]}({cg.safe_exp(value)})")
     return ByteBuffer_ns.wrap(val, value_config[CONF_ENDIANNESS])
 

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -35,18 +35,13 @@ BLECharacteristic::BLECharacteristic(const ESPBTUUID uuid, uint32_t properties)
 
 void BLECharacteristic::set_value(ByteBuffer buffer) { this->set_value(buffer.get_data()); }
 
-void BLECharacteristic::set_value(std::vector<uint8_t> &&buffer) {
+void BLECharacteristic::set_value(const std::vector<uint8_t> &buffer) {
   xSemaphoreTake(this->set_value_lock_, 0L);
-  this->value_ = std::move(buffer);
+  this->value_ = buffer;
   xSemaphoreGive(this->set_value_lock_);
 }
-
-void BLECharacteristic::set_value(std::initializer_list<uint8_t> data) {
-  this->set_value(std::vector<uint8_t>(data));  // Delegate to move overload
-}
-
 void BLECharacteristic::set_value(const std::string &buffer) {
-  this->set_value(std::vector<uint8_t>(buffer.begin(), buffer.end()));  // Delegate to move overload
+  this->set_value(std::vector<uint8_t>(buffer.begin(), buffer.end()));
 }
 
 void BLECharacteristic::notify() {

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -33,8 +33,7 @@ class BLECharacteristic {
   ~BLECharacteristic();
 
   void set_value(ByteBuffer buffer);
-  void set_value(std::vector<uint8_t> &&buffer);
-  void set_value(std::initializer_list<uint8_t> data);
+  void set_value(const std::vector<uint8_t> &buffer);
   void set_value(const std::string &buffer);
 
   void set_broadcast_property(bool value);

esphome/components/esp32_ble_server/ble_descriptor.cpp

@@ -46,17 +46,15 @@ void BLEDescriptor::do_create(BLECharacteristic *characteristic) {
   this->state_ = CREATING;
 }
 
-void BLEDescriptor::set_value(std::vector<uint8_t> &&buffer) { this->set_value_impl_(buffer.data(), buffer.size()); }
+void BLEDescriptor::set_value(std::vector<uint8_t> buffer) {
+  size_t length = buffer.size();
 
-void BLEDescriptor::set_value(std::initializer_list<uint8_t> data) { this->set_value_impl_(data.begin(), data.size()); }
-
-void BLEDescriptor::set_value_impl_(const uint8_t *data, size_t length) {
   if (length > this->value_.attr_max_len) {
     ESP_LOGE(TAG, "Size %d too large, must be no bigger than %d", length, this->value_.attr_max_len);
     return;
   }
   this->value_.attr_len = length;
-  memcpy(this->value_.attr_value, data, length);
+  memcpy(this->value_.attr_value, buffer.data(), length);
 }
 
 void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,

esphome/components/esp32_ble_server/ble_descriptor.h

@@ -27,8 +27,7 @@ class BLEDescriptor {
   void do_create(BLECharacteristic *characteristic);
   ESPBTUUID get_uuid() const { return this->uuid_; }
 
-  void set_value(std::vector<uint8_t> &&buffer);
-  void set_value(std::initializer_list<uint8_t> data);
+  void set_value(std::vector<uint8_t> buffer);
   void set_value(ByteBuffer buffer) { this->set_value(buffer.get_data()); }
 
   void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
@@ -43,8 +42,6 @@ class BLEDescriptor {
   }
 
  protected:
-  void set_value_impl_(const uint8_t *data, size_t length);
-
   BLECharacteristic *characteristic_{nullptr};
   ESPBTUUID uuid_;
   uint16_t handle_{0xFFFF};

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -270,8 +270,8 @@ void ESP32ImprovComponent::set_error_(improv::Error error) {
   }
 }
 
-void ESP32ImprovComponent::send_response_(std::vector<uint8_t> &&response) {
-  this->rpc_response_->set_value(std::move(response));
+void ESP32ImprovComponent::send_response_(std::vector<uint8_t> &response) {
+  this->rpc_response_->set_value(ByteBuffer::wrap(response));
   if (this->state_ != improv::STATE_STOPPED)
     this->rpc_response_->notify();
 }
@@ -409,8 +409,10 @@ void ESP32ImprovComponent::check_wifi_connection_() {
       }
     }
 #endif
-    this->send_response_(improv::build_rpc_response(improv::WIFI_SETTINGS,
-                                                    std::vector<std::string>(url_strings, url_strings + url_count)));
+    // Pass to build_rpc_response using vector constructor from iterators to avoid extra copies
+    std::vector<uint8_t> data = improv::build_rpc_response(
+        improv::WIFI_SETTINGS, std::vector<std::string>(url_strings, url_strings + url_count));
+    this->send_response_(data);
   } else if (this->is_active() && this->state_ != improv::STATE_PROVISIONED) {
     ESP_LOGD(TAG, "WiFi provisioned externally");
   }

esphome/components/esp32_improv/esp32_improv_component.h

@@ -109,7 +109,7 @@ class ESP32ImprovComponent : public Component, public improv_base::ImprovBase {
   void set_state_(improv::State state, bool update_advertising = true);
   void set_error_(improv::Error error);
   improv::State get_initial_state_() const;
-  void send_response_(std::vector<uint8_t> &&response);
+  void send_response_(std::vector<uint8_t> &response);
   void process_incoming_data_();
   void on_wifi_connect_timeout_();
   void check_wifi_connection_();

esphome/components/event/__init__.py

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

esphome/components/fan/__init__.py

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

esphome/components/fan/fan.h

@@ -60,6 +60,8 @@ 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/haier/haier_base.cpp

@@ -171,7 +171,7 @@ void HaierClimateBase::toggle_power() {
       PendingAction({ActionRequest::TOGGLE_POWER, esphome::optional<haier_protocol::HaierMessage>()});
 }
 
-void HaierClimateBase::set_supported_swing_modes(climate::ClimateSwingModeMask modes) {
+void HaierClimateBase::set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
   this->traits_.set_supported_swing_modes(modes);
   if (!modes.empty())
     this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);
@@ -179,13 +179,13 @@ void HaierClimateBase::set_supported_swing_modes(climate::ClimateSwingModeMask m
 
 void HaierClimateBase::set_answer_timeout(uint32_t timeout) { this->haier_protocol_.set_answer_timeout(timeout); }
 
-void HaierClimateBase::set_supported_modes(climate::ClimateModeMask modes) {
+void HaierClimateBase::set_supported_modes(const std::set<climate::ClimateMode> &modes) {
   this->traits_.set_supported_modes(modes);
   this->traits_.add_supported_mode(climate::CLIMATE_MODE_OFF);        // Always available
   this->traits_.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);  // Always available
 }
 
-void HaierClimateBase::set_supported_presets(climate::ClimatePresetMask presets) {
+void HaierClimateBase::set_supported_presets(const std::set<climate::ClimatePreset> &presets) {
   this->traits_.set_supported_presets(presets);
   if (!presets.empty())
     this->traits_.add_supported_preset(climate::CLIMATE_PRESET_NONE);

esphome/components/haier/haier_base.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <chrono>
+#include <set>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
@@ -59,9 +60,9 @@ class HaierClimateBase : public esphome::Component,
   void send_power_off_command();
   void toggle_power();
   void reset_protocol() { this->reset_protocol_request_ = true; };
-  void set_supported_modes(esphome::climate::ClimateModeMask modes);
-  void set_supported_swing_modes(esphome::climate::ClimateSwingModeMask modes);
-  void set_supported_presets(esphome::climate::ClimatePresetMask presets);
+  void set_supported_modes(const std::set<esphome::climate::ClimateMode> &modes);
+  void set_supported_swing_modes(const std::set<esphome::climate::ClimateSwingMode> &modes);
+  void set_supported_presets(const std::set<esphome::climate::ClimatePreset> &presets);
   bool valid_connection() const { return this->protocol_phase_ >= ProtocolPhases::IDLE; };
   size_t available() noexcept override { return esphome::uart::UARTDevice::available(); };
   size_t read_array(uint8_t *data, size_t len) noexcept override {

esphome/components/haier/hon_climate.cpp

@@ -1033,9 +1033,9 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
   {
     // Swing mode
     ClimateSwingMode old_swing_mode = this->swing_mode;
-    const auto &swing_modes = traits_.get_supported_swing_modes();
-    bool vertical_swing_supported = swing_modes.count(CLIMATE_SWING_VERTICAL);
-    bool horizontal_swing_supported = swing_modes.count(CLIMATE_SWING_HORIZONTAL);
+    const std::set<ClimateSwingMode> &swing_modes = traits_.get_supported_swing_modes();
+    bool vertical_swing_supported = swing_modes.find(CLIMATE_SWING_VERTICAL) != swing_modes.end();
+    bool horizontal_swing_supported = swing_modes.find(CLIMATE_SWING_HORIZONTAL) != swing_modes.end();
     if (horizontal_swing_supported &&
         (packet.control.horizontal_swing_mode == (uint8_t) hon_protocol::HorizontalSwingMode::AUTO)) {
       if (vertical_swing_supported &&
@@ -1218,13 +1218,13 @@ void HonClimate::fill_control_messages_queue_() {
                                                 (uint8_t) hon_protocol::DataParameters::QUIET_MODE,
                                             quiet_mode_buf, 2);
     }
-    if ((fast_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_BOOST)) {
+    if ((fast_mode_buf[1] != 0xFF) && ((presets.find(climate::ClimatePreset::CLIMATE_PRESET_BOOST) != presets.end()))) {
       this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                             (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                 (uint8_t) hon_protocol::DataParameters::FAST_MODE,
                                             fast_mode_buf, 2);
     }
-    if ((away_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_AWAY)) {
+    if ((away_mode_buf[1] != 0xFF) && ((presets.find(climate::ClimatePreset::CLIMATE_PRESET_AWAY) != presets.end()))) {
       this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                             (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                 (uint8_t) hon_protocol::DataParameters::TEN_DEGREE,

esphome/components/heatpumpir/heatpumpir.h

@@ -97,11 +97,12 @@ const float TEMP_MAX = 100;  // Celsius
 class HeatpumpIRClimate : public climate_ir::ClimateIR {
  public:
   HeatpumpIRClimate()
-      : climate_ir::ClimateIR(TEMP_MIN, TEMP_MAX, 1.0f, true, true,
-                              {climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
-                               climate::CLIMATE_FAN_AUTO},
-                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
-                               climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}) {}
+      : climate_ir::ClimateIR(
+            TEMP_MIN, TEMP_MAX, 1.0f, true, true,
+            std::set<climate::ClimateFanMode>{climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                                              climate::CLIMATE_FAN_HIGH, climate::CLIMATE_FAN_AUTO},
+            std::set<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
+                                                climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}) {}
   void setup() override;
   void set_protocol(Protocol protocol) { this->protocol_ = protocol; }
   void set_horizontal_default(HorizontalDirection horizontal_direction) {

esphome/components/http_request/__init__.py

@@ -12,6 +12,7 @@ from esphome.const import (
     CONF_ON_ERROR,
     CONF_ON_RESPONSE,
     CONF_TIMEOUT,
+    CONF_TRIGGER_ID,
     CONF_URL,
     CONF_WATCHDOG_TIMEOUT,
     PLATFORM_HOST,
@@ -215,8 +216,16 @@ 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(single=True),
-        cv.Optional(CONF_ON_ERROR): automation.validate_automation(single=True),
+        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_MAX_RESPONSE_BUFFER_SIZE, default="1kB"): cv.validate_bytes,
     }
 )
@@ -271,12 +280,7 @@ 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]))
-
-    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_capture_response(config[CONF_CAPTURE_RESPONSE]))
     cg.add(var.set_max_response_buffer_size(config[CONF_MAX_RESPONSE_BUFFER_SIZE]))
 
     if CONF_BODY in config:
@@ -299,26 +303,21 @@ 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))
 
-    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)
+    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)
 
     return var
 

esphome/components/http_request/http_request.h

@@ -124,7 +124,7 @@ class HttpRequestComponent : public Component {
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 
   void set_useragent(const char *useragent) { this->useragent_ = useragent; }
-  void set_timeout(uint32_t timeout) { this->timeout_ = timeout; }
+  void set_timeout(uint16_t timeout) { this->timeout_ = timeout; }
   void set_watchdog_timeout(uint32_t watchdog_timeout) { this->watchdog_timeout_ = watchdog_timeout; }
   uint32_t get_watchdog_timeout() const { return this->watchdog_timeout_; }
   void set_follow_redirects(bool follow_redirects) { this->follow_redirects_ = follow_redirects; }
@@ -173,7 +173,7 @@ class HttpRequestComponent : public Component {
   const char *useragent_{nullptr};
   bool follow_redirects_{};
   uint16_t redirect_limit_{};
-  uint32_t timeout_{4500};
+  uint16_t timeout_{4500};
   uint32_t watchdog_timeout_{0};
 };
 
@@ -183,9 +183,7 @@ 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});
@@ -197,14 +195,9 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
 
   void set_json(std::function<void(Ts..., JsonObject)> json_func) { this->json_func_ = json_func; }
 
-#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_response_trigger(HttpRequestResponseTrigger *trigger) { this->response_triggers_.push_back(trigger); }
 
-  Trigger<Ts...> *get_error_trigger() const { return this->error_trigger_; }
+  void register_error_trigger(Trigger<> *trigger) { this->error_triggers_.push_back(trigger); }
 
   void set_max_response_buffer_size(size_t max_response_buffer_size) {
     this->max_response_buffer_size_ = max_response_buffer_size;
@@ -235,20 +228,17 @@ 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) {
-      std::apply([this](Ts... captured_args_inner) { this->error_trigger_->trigger(captured_args_inner...); },
-                 captured_args);
+      for (auto *trigger : this->error_triggers_)
+        trigger->trigger();
       return;
     }
 
     size_t content_length = container->content_length;
     size_t max_length = std::min(content_length, this->max_response_buffer_size_);
 
-#ifdef USE_HTTP_REQUEST_RESPONSE
+    std::string response_body;
     if (this->capture_response_.value(x...)) {
-      std::string response_body;
       RAMAllocator<uint8_t> allocator;
       uint8_t *buf = allocator.allocate(max_length);
       if (buf != nullptr) {
@@ -263,17 +253,19 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
         response_body.assign((char *) buf, read_index);
         allocator.deallocate(buf, max_length);
       }
-      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);
+    }
+
+    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);
+      }
     }
     container->end();
   }
@@ -291,13 +283,8 @@ 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};
-#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...>();
+  std::vector<HttpRequestResponseTrigger *> response_triggers_{};
+  std::vector<Trigger<> *> error_triggers_{};
 
   size_t max_response_buffer_size_{SIZE_MAX};
 };

esphome/components/image/image.cpp

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

esphome/components/lock/__init__.py

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

esphome/components/logger/__init__.py

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

esphome/components/lvgl/lv_validation.py

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

esphome/components/lvgl/lvcode.py

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

esphome/components/lvgl/lvgl_esphome.h

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

esphome/components/lvgl/select/lvgl_select.h

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

esphome/components/lvgl/sensor/__init__.py

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

esphome/components/lvgl/widgets/canvas.py

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

esphome/components/media_player/__init__.py

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

esphome/components/midea/air_conditioner.h

@@ -19,9 +19,6 @@ using climate::ClimateTraits;
 using climate::ClimateMode;
 using climate::ClimateSwingMode;
 using climate::ClimateFanMode;
-using climate::ClimateModeMask;
-using climate::ClimateSwingModeMask;
-using climate::ClimatePresetMask;
 
 class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>, public climate::Climate {
  public:
@@ -43,20 +40,20 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void do_power_on() { this->base_.setPowerState(true); }
   void do_power_off() { this->base_.setPowerState(false); }
   void do_power_toggle() { this->base_.setPowerState(this->mode == ClimateMode::CLIMATE_MODE_OFF); }
-  void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
-  void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
-  void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(const std::vector<std::string> &presets) { this->supported_custom_presets_ = presets; }
-  void set_custom_fan_modes(const std::vector<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
+  void set_supported_modes(const std::set<ClimateMode> &modes) { this->supported_modes_ = modes; }
+  void set_supported_swing_modes(const std::set<ClimateSwingMode> &modes) { this->supported_swing_modes_ = modes; }
+  void set_supported_presets(const std::set<ClimatePreset> &presets) { this->supported_presets_ = presets; }
+  void set_custom_presets(const std::set<std::string> &presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(const std::set<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
   ClimateTraits traits() override;
-  ClimateModeMask supported_modes_{};
-  ClimateSwingModeMask supported_swing_modes_{};
-  ClimatePresetMask supported_presets_{};
-  std::vector<std::string> supported_custom_presets_{};
-  std::vector<std::string> supported_custom_fan_modes_{};
+  std::set<ClimateMode> supported_modes_{};
+  std::set<ClimateSwingMode> supported_swing_modes_{};
+  std::set<ClimatePreset> supported_presets_{};
+  std::set<std::string> supported_custom_presets_{};
+  std::set<std::string> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/mipi/__init__.py

@@ -384,18 +384,6 @@ 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,7 +46,6 @@ from esphome.const import (
     CONF_DATA_RATE,
     CONF_DC_PIN,
     CONF_DIMENSIONS,
-    CONF_DISABLED,
     CONF_ENABLE_PIN,
     CONF_GREEN,
     CONF_HSYNC_PIN,
@@ -118,16 +117,16 @@ def data_pin_set(length):
 
 def model_schema(config):
     model = MODELS[config[CONF_MODEL].upper()]
-    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),
-    )
+    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")
+
     # RPI model does not use an init sequence, indicates with empty list
     if model.initsequence is None:
         # Custom model requires an init sequence
@@ -136,16 +135,12 @@ def model_schema(config):
     else:
         iseqconf = cv.Optional(CONF_INIT_SEQUENCE)
         uses_spi = CONF_INIT_SEQUENCE in config or len(model.initsequence) != 0
-    # 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
-    )
+    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
+    )
     pixel_modes = (PIXEL_MODE_16BIT, PIXEL_MODE_18BIT, "16", "18")
     schema = display.FULL_DISPLAY_SCHEMA.extend(
         {
@@ -162,7 +157,7 @@ def model_schema(config):
             model.option(CONF_PIXEL_MODE, PIXEL_MODE_16BIT): cv.one_of(
                 *pixel_modes, lower=True
             ),
-            cv.Optional(CONF_TRANSFORM): transform,
+            model.option(CONF_TRANSFORM, cv.UNDEFINED): 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,
@@ -275,6 +270,7 @@ 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,6 +131,19 @@ 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]
@@ -139,7 +152,7 @@ def model_schema(config):
             {
                 cv.Required(CONF_MIRROR_X): cv.boolean,
                 cv.Required(CONF_MIRROR_Y): cv.boolean,
-                **model.swap_xy_schema(),
+                **swap_xy_schema(model),
             }
         ),
         cv.one_of(CONF_DISABLED, lower=True),

esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h

@@ -33,8 +33,8 @@ class ModbusBinarySensor : public Component, public binary_sensor::BinarySensor,
 
   void dump_config() override;
 
-  using transform_func_t = optional<bool> (*)(ModbusBinarySensor *, bool, const std::vector<uint8_t> &);
-  void set_template(transform_func_t f) { this->transform_func_ = f; }
+  using transform_func_t = std::function<optional<bool>(ModbusBinarySensor *, bool, const std::vector<uint8_t> &)>;
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
 
  protected:
   optional<transform_func_t> transform_func_{nullopt};

esphome/components/modbus_controller/number/modbus_number.h

@@ -31,10 +31,10 @@ class ModbusNumber : public number::Number, public Component, public SensorItem
   void set_parent(ModbusController *parent) { this->parent_ = parent; }
   void set_write_multiply(float factor) { this->multiply_by_ = factor; }
 
-  using transform_func_t = optional<float> (*)(ModbusNumber *, float, const std::vector<uint8_t> &);
-  using write_transform_func_t = optional<float> (*)(ModbusNumber *, float, std::vector<uint16_t> &);
-  void set_template(transform_func_t f) { this->transform_func_ = f; }
-  void set_write_template(write_transform_func_t f) { this->write_transform_func_ = f; }
+  using transform_func_t = std::function<optional<float>(ModbusNumber *, float, const std::vector<uint8_t> &)>;
+  using write_transform_func_t = std::function<optional<float>(ModbusNumber *, float, std::vector<uint16_t> &)>;
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
   void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:

esphome/components/modbus_controller/output/modbus_output.h

@@ -29,8 +29,8 @@ class ModbusFloatOutput : public output::FloatOutput, public Component, public S
   // Do nothing
   void parse_and_publish(const std::vector<uint8_t> &data) override{};
 
-  using write_transform_func_t = optional<float> (*)(ModbusFloatOutput *, float, std::vector<uint16_t> &);
-  void set_write_template(write_transform_func_t f) { this->write_transform_func_ = f; }
+  using write_transform_func_t = std::function<optional<float>(ModbusFloatOutput *, float, std::vector<uint16_t> &)>;
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
   void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:
@@ -60,8 +60,8 @@ class ModbusBinaryOutput : public output::BinaryOutput, public Component, public
   // Do nothing
   void parse_and_publish(const std::vector<uint8_t> &data) override{};
 
-  using write_transform_func_t = optional<bool> (*)(ModbusBinaryOutput *, bool, std::vector<uint8_t> &);
-  void set_write_template(write_transform_func_t f) { this->write_transform_func_ = f; }
+  using write_transform_func_t = std::function<optional<bool>(ModbusBinaryOutput *, bool, std::vector<uint8_t> &)>;
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
   void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:

esphome/components/modbus_controller/select/modbus_select.cpp

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

esphome/components/modbus_controller/select/modbus_select.h

@@ -26,15 +26,16 @@ class ModbusSelect : public Component, public select::Select, public SensorItem
     this->mapping_ = std::move(mapping);
   }
 
-  using transform_func_t = optional<std::string> (*)(ModbusSelect *const, int64_t, const std::vector<uint8_t> &);
-  using write_transform_func_t = optional<int64_t> (*)(ModbusSelect *const, const std::string &, int64_t,
-                                                       std::vector<uint16_t> &);
+  using transform_func_t =
+      std::function<optional<std::string>(ModbusSelect *const, int64_t, const std::vector<uint8_t> &)>;
+  using write_transform_func_t =
+      std::function<optional<int64_t>(ModbusSelect *const, const std::string &, int64_t, std::vector<uint16_t> &)>;
 
   void set_parent(ModbusController *const parent) { this->parent_ = parent; }
   void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_template(transform_func_t f) { this->transform_func_ = f; }
-  void set_write_template(write_transform_func_t f) { this->write_transform_func_ = f; }
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
 
   void dump_config() override;
   void parse_and_publish(const std::vector<uint8_t> &data) override;

esphome/components/modbus_controller/sensor/modbus_sensor.h

@@ -25,9 +25,9 @@ class ModbusSensor : public Component, public sensor::Sensor, public SensorItem
 
   void parse_and_publish(const std::vector<uint8_t> &data) override;
   void dump_config() override;
-  using transform_func_t = optional<float> (*)(ModbusSensor *, float, const std::vector<uint8_t> &);
+  using transform_func_t = std::function<optional<float>(ModbusSensor *, float, const std::vector<uint8_t> &)>;
 
-  void set_template(transform_func_t f) { this->transform_func_ = f; }
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
 
  protected:
   optional<transform_func_t> transform_func_{nullopt};

esphome/components/modbus_controller/switch/modbus_switch.h

@@ -34,10 +34,10 @@ class ModbusSwitch : public Component, public switch_::Switch, public SensorItem
   void parse_and_publish(const std::vector<uint8_t> &data) override;
   void set_parent(ModbusController *parent) { this->parent_ = parent; }
 
-  using transform_func_t = optional<bool> (*)(ModbusSwitch *, bool, const std::vector<uint8_t> &);
-  using write_transform_func_t = optional<bool> (*)(ModbusSwitch *, bool, std::vector<uint8_t> &);
-  void set_template(transform_func_t f) { this->publish_transform_func_ = f; }
-  void set_write_template(write_transform_func_t f) { this->write_transform_func_ = f; }
+  using transform_func_t = std::function<optional<bool>(ModbusSwitch *, bool, const std::vector<uint8_t> &)>;
+  using write_transform_func_t = std::function<optional<bool>(ModbusSwitch *, bool, std::vector<uint8_t> &)>;
+  void set_template(transform_func_t &&f) { this->publish_transform_func_ = f; }
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
   void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:

esphome/components/modbus_controller/text_sensor/modbus_textsensor.h

@@ -30,8 +30,9 @@ class ModbusTextSensor : public Component, public text_sensor::TextSensor, publi
   void dump_config() override;
 
   void parse_and_publish(const std::vector<uint8_t> &data) override;
-  using transform_func_t = optional<std::string> (*)(ModbusTextSensor *, std::string, const std::vector<uint8_t> &);
-  void set_template(transform_func_t f) { this->transform_func_ = f; }
+  using transform_func_t =
+      std::function<optional<std::string>(ModbusTextSensor *, std::string, const std::vector<uint8_t> &)>;
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
 
  protected:
   optional<transform_func_t> transform_func_{nullopt};

esphome/components/number/__init__.py

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

esphome/components/packages/__init__.py

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

esphome/components/remote_base/__init__.py

@@ -17,7 +17,6 @@ from esphome.const import (
     CONF_FAMILY,
     CONF_GROUP,
     CONF_ID,
-    CONF_INDEX,
     CONF_INVERTED,
     CONF_LEVEL,
     CONF_MAGNITUDE,
@@ -617,49 +616,6 @@ async def dooya_action(var, config, args):
     cg.add(var.set_check(template_))
 
 
-# Dyson
-DysonData, DysonBinarySensor, DysonTrigger, DysonAction, DysonDumper = declare_protocol(
-    "Dyson"
-)
-DYSON_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_CODE): cv.hex_uint16_t,
-        cv.Optional(CONF_INDEX, default=0xFF): cv.hex_uint8_t,
-    }
-)
-
-
-@register_binary_sensor("dyson", DysonBinarySensor, DYSON_SCHEMA)
-def dyson_binary_sensor(var, config):
-    cg.add(
-        var.set_data(
-            cg.StructInitializer(
-                DysonData,
-                ("code", config[CONF_CODE]),
-                ("index", config[CONF_INDEX]),
-            )
-        )
-    )
-
-
-@register_trigger("dyson", DysonTrigger, DysonData)
-def dyson_trigger(var, config):
-    pass
-
-
-@register_dumper("dyson", DysonDumper)
-def dyson_dumper(var, config):
-    pass
-
-
-@register_action("dyson", DysonAction, DYSON_SCHEMA)
-async def dyson_action(var, config, args):
-    template_ = await cg.templatable(config[CONF_CODE], args, cg.uint16)
-    cg.add(var.set_code(template_))
-    template_ = await cg.templatable(config[CONF_INDEX], args, cg.uint8)
-    cg.add(var.set_index(template_))
-
-
 # JVC
 JVCData, JVCBinarySensor, JVCTrigger, JVCAction, JVCDumper = declare_protocol("JVC")
 JVC_SCHEMA = cv.Schema({cv.Required(CONF_DATA): cv.hex_uint32_t})

esphome/components/remote_base/dyson_protocol.cpp

@@ -1,71 +0,0 @@
-#include "dyson_protocol.h"
-#include "esphome/core/log.h"
-
-#include <cinttypes>
-
-namespace esphome {
-namespace remote_base {
-
-static const char *const TAG = "remote.dyson";
-
-// pulsewidth [µs]
-constexpr uint32_t PW_MARK_US = 780;
-constexpr uint32_t PW_SHORT_US = 720;
-constexpr uint32_t PW_LONG_US = 1500;
-constexpr uint32_t PW_START_US = 2280;
-
-// MSB of 15 bit dyson code
-constexpr uint16_t MSB_DYSON = (1 << 14);
-
-// required symbols in transmit buffer = (start_symbol + 15 data_symbols)
-constexpr uint32_t N_SYMBOLS_REQ = 2u * (1 + 15);
-
-void DysonProtocol::encode(RemoteTransmitData *dst, const DysonData &data) {
-  uint32_t raw_code = (data.code << 2) + (data.index & 3);
-  dst->set_carrier_frequency(36000);
-  dst->reserve(N_SYMBOLS_REQ + 1);
-  dst->item(PW_START_US, PW_SHORT_US);
-  for (uint16_t mask = MSB_DYSON; mask != 0; mask >>= 1) {
-    if (mask == (mask & raw_code)) {
-      dst->item(PW_MARK_US, PW_LONG_US);
-    } else {
-      dst->item(PW_MARK_US, PW_SHORT_US);
-    }
-  }
-  dst->mark(PW_MARK_US);  // final carrier pulse
-}
-
-optional<DysonData> DysonProtocol::decode(RemoteReceiveData src) {
-  uint32_t n_received = static_cast<uint32_t>(src.size());
-  uint16_t raw_code = 0;
-  DysonData data{
-      .code = 0,
-      .index = 0,
-  };
-  if (n_received < N_SYMBOLS_REQ)
-    return {};  // invalid frame length
-  if (!src.expect_item(PW_START_US, PW_SHORT_US))
-    return {};  // start not found
-  for (uint16_t mask = MSB_DYSON; mask != 0; mask >>= 1) {
-    if (src.expect_item(PW_MARK_US, PW_SHORT_US)) {
-      raw_code &= ~mask;  // zero detected
-    } else if (src.expect_item(PW_MARK_US, PW_LONG_US)) {
-      raw_code |= mask;  // one detected
-    } else {
-      return {};  // invalid data item
-    }
-  }
-  data.code = raw_code >> 2;          // extract button code
-  data.index = raw_code & 3;          // extract rolling index
-  if (src.expect_mark(PW_MARK_US)) {  // check total length
-    return data;
-  }
-  return {};  // frame not complete
-}
-
-void DysonProtocol::dump(const DysonData &data) {
-  ESP_LOGI(TAG, "Dyson: code=0x%x rolling index=%d", data.code, data.index);
-}
-
-}  // namespace remote_base
-}  // namespace esphome

esphome/components/remote_base/dyson_protocol.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "remote_base.h"
-
-#include <cinttypes>
-
-namespace esphome {
-namespace remote_base {
-
-static constexpr uint8_t IGNORE_INDEX = 0xFF;
-
-struct DysonData {
-  uint16_t code;  // the button, e.g. power, swing, fan++, ...
-  uint8_t index;  // the rolling index counter
-  bool operator==(const DysonData &rhs) const {
-    if (IGNORE_INDEX == index || IGNORE_INDEX == rhs.index) {
-      return code == rhs.code;
-    }
-    return code == rhs.code && index == rhs.index;
-  }
-};
-
-class DysonProtocol : public RemoteProtocol<DysonData> {
- public:
-  void encode(RemoteTransmitData *dst, const DysonData &data) override;
-  optional<DysonData> decode(RemoteReceiveData src) override;
-  void dump(const DysonData &data) override;
-};
-
-DECLARE_REMOTE_PROTOCOL(Dyson)
-
-template<typename... Ts> class DysonAction : public RemoteTransmitterActionBase<Ts...> {
- public:
-  TEMPLATABLE_VALUE(uint16_t, code)
-  TEMPLATABLE_VALUE(uint8_t, index)
-
-  void encode(RemoteTransmitData *dst, Ts... x) override {
-    DysonData data{};
-    data.code = this->code_.value(x...);
-    data.index = this->index_.value(x...);
-    DysonProtocol().encode(dst, data);
-  }
-};
-
-}  // namespace remote_base
-}  // namespace esphome

esphome/components/remote_transmitter/__init__.py

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

esphome/components/remote_transmitter/remote_transmitter.h

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

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

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

esphome/components/select/__init__.py

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

esphome/components/select/select.cpp

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

esphome/components/select/select.h

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

esphome/components/select/select_traits.cpp

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

esphome/components/select/select_traits.h

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

esphome/components/sensor/__init__.py

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

esphome/components/switch/__init__.py

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

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -25,20 +25,6 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
   this->sensor_data_.push_back(sd);
   this->sensor_map_[sensor].store_index = this->next_store_index_++;
 };
-
-static const LogString *sensor_type_to_string(AlarmSensorType type) {
-  switch (type) {
-    case ALARM_SENSOR_TYPE_INSTANT:
-      return LOG_STR("instant");
-    case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
-      return LOG_STR("delayed_follower");
-    case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
-      return LOG_STR("instant_always");
-    case ALARM_SENSOR_TYPE_DELAYED:
-    default:
-      return LOG_STR("delayed");
-  }
-}
 #endif
 
 void TemplateAlarmControlPanel::dump_config() {
@@ -60,31 +46,53 @@ void TemplateAlarmControlPanel::dump_config() {
                 "  Supported Features: %" PRIu32,
                 (this->pending_time_ / 1000), (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (auto sensor_info : this->sensor_map_) {
+    ESP_LOGCONFIG(TAG, "  Binary Sensor:");
     ESP_LOGCONFIG(TAG,
-                  "  Binary Sensor:\n"
                   "    Name: %s\n"
-                  "    Type: %s\n"
                   "    Armed home bypass: %s\n"
                   "    Armed night bypass: %s\n"
                   "    Auto bypass: %s\n"
                   "    Chime mode: %s",
-                  sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(info.type)),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_CHIME));
+                  sensor_info.first->get_name().c_str(),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME));
+    const char *sensor_type;
+    switch (sensor_info.second.type) {
+      case ALARM_SENSOR_TYPE_INSTANT:
+        sensor_type = "instant";
+        break;
+      case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
+        sensor_type = "delayed_follower";
+        break;
+      case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
+        sensor_type = "instant_always";
+        break;
+      case ALARM_SENSOR_TYPE_DELAYED:
+      default:
+        sensor_type = "delayed";
+    }
+    ESP_LOGCONFIG(TAG, "    Sensor type: %s", sensor_type);
   }
 #endif
 }
 
 void TemplateAlarmControlPanel::setup() {
-  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);
+  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->desired_state_ = this->current_state_;
@@ -111,83 +119,86 @@ void TemplateAlarmControlPanel::loop() {
     this->publish_state(ACP_STATE_TRIGGERED);
     return;
   }
-  auto next_state = this->current_state_;
+  auto future_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_) {
-    next_state = this->desired_state_;
+    future_state = this->desired_state_;
   }
 
-  bool delayed_sensor_faulted = false;
-  bool instant_sensor_faulted = false;
+  bool delayed_sensor_not_ready = false;
+  bool instant_sensor_not_ready = false;
 
 #ifdef USE_BINARY_SENSOR
-  // Test all of the sensors regardless of the alarm panel state
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  // Test all of the sensors in the list regardless of the alarm panel state
+  for (auto sensor_info : this->sensor_map_) {
     // Check for chime zones
-    if (info.flags & BINARY_SENSOR_MODE_CHIME) {
+    if ((sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME)) {
       // Look for the transition from closed to open
-      if ((!this->sensor_data_[info.store_index].last_chime_state) && (sensor->state)) {
+      if ((!this->sensor_data_[sensor_info.second.store_index].last_chime_state) && (sensor_info.first->state)) {
         // Must be disarmed to chime
         if (this->current_state_ == ACP_STATE_DISARMED) {
           this->chime_callback_.call();
         }
       }
       // Record the sensor state change
-      this->sensor_data_[info.store_index].last_chime_state = sensor->state;
+      this->sensor_data_[sensor_info.second.store_index].last_chime_state = sensor_info.first->state;
     }
-    // Check for faulted sensors
-    if (sensor->state) {
+    // Check for triggered sensors
+    if (sensor_info.first->state) {  // Sensor triggered?
       // Skip if auto bypassed
       if (std::count(this->bypassed_sensor_indicies_.begin(), this->bypassed_sensor_indicies_.end(),
-                     info.store_index) == 1) {
+                     sensor_info.second.store_index) == 1) {
         continue;
       }
       // Skip if bypass armed home
-      if ((this->current_state_ == ACP_STATE_ARMED_HOME) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
+      if (this->current_state_ == ACP_STATE_ARMED_HOME &&
+          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
         continue;
       }
       // Skip if bypass armed night
-      if ((this->current_state_ == ACP_STATE_ARMED_NIGHT) && (info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
+      if (this->current_state_ == ACP_STATE_ARMED_NIGHT &&
+          (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT)) {
         continue;
       }
 
-      switch (info.type) {
-        case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
-          next_state = ACP_STATE_TRIGGERED;
-          [[fallthrough]];
+      switch (sensor_info.second.type) {
         case ALARM_SENSOR_TYPE_INSTANT:
-          instant_sensor_faulted = true;
+          instant_sensor_not_ready = true;
+          break;
+        case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
+          instant_sensor_not_ready = true;
+          future_state = ACP_STATE_TRIGGERED;
           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_faulted = true;
+            delayed_sensor_not_ready = true;
           } else {
-            instant_sensor_faulted = true;
+            instant_sensor_not_ready = true;
           }
           break;
         case ALARM_SENSOR_TYPE_DELAYED:
         default:
-          delayed_sensor_faulted = true;
+          delayed_sensor_not_ready = true;
       }
     }
   }
-  // Update all sensors ready flag
-  bool sensors_ready = !(instant_sensor_faulted || delayed_sensor_faulted);
+  // Update all sensors not ready flag
+  this->sensors_ready_ = ((!instant_sensor_not_ready) && (!delayed_sensor_not_ready));
 
   // Call the ready state change callback if there was a change
-  if (this->sensors_ready_ != sensors_ready) {
-    this->sensors_ready_ = sensors_ready;
+  if (this->sensors_ready_ != this->sensors_ready_last_) {
     this->ready_callback_.call();
+    this->sensors_ready_last_ = this->sensors_ready_;
   }
 
 #endif
-  if (this->is_state_armed(next_state) && (!this->sensors_ready_)) {
+  if (this->is_state_armed(future_state) && (!this->sensors_ready_)) {
     // Instant sensors
-    if (instant_sensor_faulted) {
+    if (instant_sensor_not_ready) {
       this->publish_state(ACP_STATE_TRIGGERED);
-    } else if (delayed_sensor_faulted) {
+    } else if (delayed_sensor_not_ready) {
       // Delayed sensors
       if ((this->pending_time_ > 0) && (this->current_state_ != ACP_STATE_TRIGGERED)) {
         this->publish_state(ACP_STATE_PENDING);
@@ -195,8 +206,8 @@ void TemplateAlarmControlPanel::loop() {
         this->publish_state(ACP_STATE_TRIGGERED);
       }
     }
-  } else if (next_state != this->current_state_) {
-    this->publish_state(next_state);
+  } else if (future_state != this->current_state_) {
+    this->publish_state(future_state);
   }
 }
 
@@ -223,6 +234,8 @@ 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) {
@@ -244,11 +257,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
-    // 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);
+  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);
     }
   }
 #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 { return !this->codes_.empty(); }
+  bool get_requires_code() const override;
   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,8 +66,7 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
   /** Add a binary_sensor to the alarm_panel.
    *
    * @param sensor The BinarySensor instance.
-   * @param flags The OR of BinarySensorFlags for the sensor.
-   * @param type The sensor type which determines its triggering behaviour.
+   * @param ignore_when_home if this should be ignored when armed_home mode
    */
   void add_sensor(binary_sensor::BinarySensor *sensor, uint16_t flags = 0,
                   AlarmSensorType type = ALARM_SENSOR_TYPE_DELAYED);
@@ -122,7 +121,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 alarm specific info
+  // This maps a binary sensor to its type and attribute bits
   std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
   // a list of automatically bypassed sensors
   std::vector<uint8_t> bypassed_sensor_indicies_;
@@ -148,6 +147,7 @@ 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/select/template_select.cpp

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

esphome/components/text/__init__.py

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

esphome/components/text_sensor/__init__.py

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

esphome/components/thermostat/thermostat_climate.h

@@ -40,10 +40,6 @@ enum OnBootRestoreFrom : uint8_t {
 };
 
 struct ThermostatClimateTimer {
-  ThermostatClimateTimer() = default;
-  ThermostatClimateTimer(bool active, uint32_t time, uint32_t started, std::function<void()> func)
-      : active(active), time(time), started(started), func(std::move(func)) {}
-
   bool active;
   uint32_t time;
   uint32_t started;

esphome/components/toshiba/toshiba.cpp

@@ -405,7 +405,7 @@ void ToshibaClimate::setup() {
   this->swing_modes_ = this->toshiba_swing_modes_();
 
   // Ensure swing mode is always initialized to a valid value
-  if (this->swing_modes_.empty() || !this->swing_modes_.count(this->swing_mode)) {
+  if (this->swing_modes_.empty() || this->swing_modes_.find(this->swing_mode) == this->swing_modes_.end()) {
     // No swing support for this model or current swing mode not supported, reset to OFF
     this->swing_mode = climate::CLIMATE_SWING_OFF;
   }

esphome/components/toshiba/toshiba.h

@@ -71,10 +71,10 @@ class ToshibaClimate : public climate_ir::ClimateIR {
       return TOSHIBA_RAS_2819T_TEMP_C_MAX;
     return TOSHIBA_GENERIC_TEMP_C_MAX;  // Default to GENERIC for unknown models
   }
-  climate::ClimateSwingModeMask toshiba_swing_modes_() {
+  std::set<climate::ClimateSwingMode> toshiba_swing_modes_() {
     return (this->model_ == MODEL_GENERIC)
-               ? climate::ClimateSwingModeMask()
-               : climate::ClimateSwingModeMask{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL};
+               ? std::set<climate::ClimateSwingMode>{}
+               : std::set<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL};
   }
   void encode_(remote_base::RemoteTransmitData *data, const uint8_t *message, uint8_t nbytes, uint8_t repeat);
   bool decode_(remote_base::RemoteReceiveData *data, uint8_t *message, uint8_t nbytes);

esphome/components/tuya/climate/tuya_climate.cpp

@@ -312,12 +312,18 @@ climate::ClimateTraits TuyaClimate::traits() {
     traits.add_supported_preset(climate::CLIMATE_PRESET_NONE);
   }
   if (this->swing_vertical_id_.has_value() && this->swing_horizontal_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH,
-                                      climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_HORIZONTAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {
+        climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH, climate::CLIMATE_SWING_VERTICAL,
+        climate::CLIMATE_SWING_HORIZONTAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   } else if (this->swing_vertical_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {climate::CLIMATE_SWING_OFF,
+                                                                 climate::CLIMATE_SWING_VERTICAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   } else if (this->swing_horizontal_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {climate::CLIMATE_SWING_OFF,
+                                                                 climate::CLIMATE_SWING_HORIZONTAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   }
 
   if (fan_speed_id_) {

esphome/components/tuya/select/tuya_select.cpp

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

esphome/components/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(cg.ArrayInitializer(*data)))
+        cg.add(var.set_data_static(data))
     return var
 
 

esphome/components/uart/automation.h

@@ -14,12 +14,8 @@ template<typename... Ts> class UARTWriteAction : public Action<Ts...>, public Pa
     this->data_func_ = func;
     this->static_ = false;
   }
-  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);
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = 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(cg.ArrayInitializer(*data)))
+    cg.add(var.set_data(data))

esphome/components/uart/button/uart_button.h

@@ -11,8 +11,7 @@ namespace uart {
 
 class UARTButton : public button::Button, public UARTDevice, public Component {
  public:
-  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 set_data(const std::vector<uint8_t> &data) { this->data_ = 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(cg.ArrayInitializer(*data_on)))
+            cg.add(var.set_data_on(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(cg.ArrayInitializer(*data_off)))
+            cg.add(var.set_data_off(data_off))
     else:
         data = config[CONF_DATA]
         if isinstance(data, bytes):
             data = [HexInt(x) for x in data]
-        cg.add(var.set_data_on(cg.ArrayInitializer(*data)))
+        cg.add(var.set_data_on(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,10 +14,8 @@ class UARTSwitch : public switch_::Switch, public UARTDevice, public Component {
  public:
   void loop() override;
 
-  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_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_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,58 +46,40 @@ 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) &&
-           !shouldFallbackToSoftwareSerial()) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX)) {
     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) &&
-           !shouldFallbackToSoftwareSerial()) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL1_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL1_RX)) {
     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) &&
-           !shouldFallbackToSoftwareSerial()) {
+  else if ((tx_pin == -1 || tx_pin == PIN_SERIAL2_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL2_RX)) {
     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,6 +84,11 @@ def update_schema(
     return _UPDATE_SCHEMA.extend(schema)
 
 
+# Remove before 2025.11.0
+UPDATE_SCHEMA = update_schema()
+UPDATE_SCHEMA.add_extra(cv.deprecated_schema_constant("update"))
+
+
 async def setup_update_core_(var, config):
     await setup_entity(var, config, "update")
 

esphome/components/valve/__init__.py

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

esphome/components/wifi/__init__.py

@@ -140,17 +140,21 @@ EAP_AUTH_SCHEMA = cv.All(
     cv.has_at_least_one_key(CONF_IDENTITY, CONF_CERTIFICATE),
 )
 
+CONF_AP_TIMEOUT = "ap_timeout"
+CONF_SSID_DATA_ID = "ssid_data_id"
+CONF_PASSWORD_DATA_ID = "password_data_id"
+
 WIFI_NETWORK_BASE = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(WiFiAP),
+        cv.GenerateID(CONF_SSID_DATA_ID): cv.declare_id(cg.uint8),
+        cv.GenerateID(CONF_PASSWORD_DATA_ID): cv.declare_id(cg.uint8),
         cv.Optional(CONF_SSID): cv.ssid,
         cv.Optional(CONF_PASSWORD): validate_password,
         cv.Optional(CONF_CHANNEL): validate_channel,
         cv.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
     }
 )
-
-CONF_AP_TIMEOUT = "ap_timeout"
 WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend(
     {
         cv.Optional(
@@ -352,9 +356,23 @@ def manual_ip(config):
 
 def wifi_network(config, ap, static_ip):
     if CONF_SSID in config:
-        cg.add(ap.set_ssid(config[CONF_SSID]))
+        ssid = config[CONF_SSID]
+        if CORE.is_esp8266:
+            # On ESP8266, store SSID in PROGMEM to save RAM
+            prog_arr = cg.progmem_array(config[CONF_SSID_DATA_ID], ssid)
+            cg.add(ap.set_ssid_flash(prog_arr))
+        else:
+            # On ESP32/RP2040, string literals are already in rodata (flash)
+            cg.add(ap.set_ssid_flash(ssid))
     if CONF_PASSWORD in config:
-        cg.add(ap.set_password(config[CONF_PASSWORD]))
+        password = config[CONF_PASSWORD]
+        if CORE.is_esp8266:
+            # On ESP8266, store password in PROGMEM to save RAM
+            prog_arr = cg.progmem_array(config[CONF_PASSWORD_DATA_ID], password)
+            cg.add(ap.set_password_flash(prog_arr))
+        else:
+            # On ESP32/RP2040, string literals are already in rodata (flash)
+            cg.add(ap.set_password_flash(password))
     if CONF_EAP in config:
         cg.add(ap.set_eap(eap_auth(config[CONF_EAP])))
         cg.add_define("USE_WIFI_WPA2_EAP")