[core] Fix crash when config keys contain periods during platform detection

Co-authored-by: J. Nick Koston <nick@koston.org>
Co-authored-by: Keith Burzinski <kbx81x@gmail.com>

.github/workflows/ci-memory-impact-comment.yml

@@ -28,20 +28,23 @@ jobs:
         run: |
           # Get PR details by searching for PR with matching head SHA
           # The workflow_run.pull_requests field is often empty for forks
+          # Use paginate to handle repos with many open PRs
           head_sha="${{ github.event.workflow_run.head_sha }}"
-          pr_data=$(gh api "/repos/${{ github.repository }}/commits/$head_sha/pulls" \
-            --jq '.[0] | {number: .number, base_ref: .base.ref}')
-          if [ -z "$pr_data" ] || [ "$pr_data" == "null" ]; then
+          pr_data=$(gh api --paginate "/repos/${{ github.repository }}/pulls" \
+            --jq ".[] | select(.head.sha == \"$head_sha\") | {number: .number, base_ref: .base.ref}" \
+            | head -n 1)
+
+          if [ -z "$pr_data" ]; then
             echo "No PR found for SHA $head_sha, skipping"
-            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "skip=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi
 
           pr_number=$(echo "$pr_data" | jq -r '.number')
           base_ref=$(echo "$pr_data" | jq -r '.base_ref')
 
-          echo "pr_number=$pr_number" >> $GITHUB_OUTPUT
-          echo "base_ref=$base_ref" >> $GITHUB_OUTPUT
+          echo "pr_number=$pr_number" >> "$GITHUB_OUTPUT"
+          echo "base_ref=$base_ref" >> "$GITHUB_OUTPUT"
           echo "Found PR #$pr_number targeting base branch: $base_ref"
 
       - name: Check out code from base repository
@@ -87,9 +90,9 @@ jobs:
         if: steps.pr.outputs.skip != 'true'
         run: |
           if [ -f ./memory-analysis/memory-analysis-target.json ] && [ -f ./memory-analysis/memory-analysis-pr.json ]; then
-            echo "found=true" >> $GITHUB_OUTPUT
+            echo "found=true" >> "$GITHUB_OUTPUT"
           else
-            echo "found=false" >> $GITHUB_OUTPUT
+            echo "found=false" >> "$GITHUB_OUTPUT"
             echo "Memory analysis artifacts not found, skipping comment"
           fi
 

.github/workflows/ci.yml

@@ -432,21 +432,6 @@ jobs:
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
-
-      - name: Cache platformio
-        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ~/.platformio
-          key: platformio-test-${{ hashFiles('platformio.ini') }}
-
-      - name: Cache platformio
-        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ~/.platformio
-          key: platformio-test-${{ hashFiles('platformio.ini') }}
-
       - name: Validate and compile components with intelligent grouping
         run: |
           . venv/bin/activate

esphome/__main__.py

@@ -62,6 +62,40 @@ from esphome.util import (
 
 _LOGGER = logging.getLogger(__name__)
 
+# Special non-component keys that appear in configs
+_NON_COMPONENT_KEYS = frozenset(
+    {
+        CONF_ESPHOME,
+        "substitutions",
+        "packages",
+        "globals",
+        "external_components",
+        "<<",
+    }
+)
+
+
+def detect_external_components(config: ConfigType) -> set[str]:
+    """Detect external/custom components in the configuration.
+
+    External components are those that appear in the config but are not
+    part of ESPHome's built-in components and are not special config keys.
+
+    Args:
+        config: The ESPHome configuration dictionary
+
+    Returns:
+        A set of external component names
+    """
+    from esphome.analyze_memory.helpers import get_esphome_components
+
+    builtin_components = get_esphome_components()
+    return {
+        key
+        for key in config
+        if key not in builtin_components and key not in _NON_COMPONENT_KEYS
+    }
+
 
 class ArgsProtocol(Protocol):
     device: list[str] | None
@@ -892,6 +926,54 @@ def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
     return 0
 
 
+def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
+    """Analyze memory usage by component.
+
+    This command compiles the configuration and performs memory analysis.
+    Compilation is fast if sources haven't changed (just relinking).
+    """
+    from esphome import platformio_api
+    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
+
+    # Always compile to ensure fresh data (fast if no changes - just relinks)
+    exit_code = write_cpp(config)
+    if exit_code != 0:
+        return exit_code
+    exit_code = compile_program(args, config)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info("Successfully compiled program.")
+
+    # Get idedata for analysis
+    idedata = platformio_api.get_idedata(config)
+    if idedata is None:
+        _LOGGER.error("Failed to get IDE data for memory analysis")
+        return 1
+
+    firmware_elf = Path(idedata.firmware_elf_path)
+
+    # Extract external components from config
+    external_components = detect_external_components(config)
+    _LOGGER.debug("Detected external components: %s", external_components)
+
+    # Perform memory analysis
+    _LOGGER.info("Analyzing memory usage...")
+    analyzer = MemoryAnalyzerCLI(
+        str(firmware_elf),
+        idedata.objdump_path,
+        idedata.readelf_path,
+        external_components,
+    )
+    analyzer.analyze()
+
+    # Generate and display report
+    report = analyzer.generate_report()
+    print()
+    print(report)
+
+    return 0
+
+
 def command_rename(args: ArgsProtocol, config: ConfigType) -> int | None:
     new_name = args.name
     for c in new_name:
@@ -1007,6 +1089,7 @@ POST_CONFIG_ACTIONS = {
     "idedata": command_idedata,
     "rename": command_rename,
     "discover": command_discover,
+    "analyze-memory": command_analyze_memory,
 }
 
 SIMPLE_CONFIG_ACTIONS = [
@@ -1292,6 +1375,14 @@ def parse_args(argv):
     )
     parser_rename.add_argument("name", help="The new name for the device.", type=str)
 
+    parser_analyze_memory = subparsers.add_parser(
+        "analyze-memory",
+        help="Analyze memory usage by component.",
+    )
+    parser_analyze_memory.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+
     # Keep backward compatibility with the old command line format of
     # esphome <config> <command>.
     #

esphome/components/anova/anova.h

@@ -28,7 +28,7 @@ class Anova : public climate::Climate, public esphome::ble_client::BLEClientNode
   void dump_config() override;
   climate::ClimateTraits traits() override {
     auto traits = climate::ClimateTraits();
-    traits.set_supports_current_temperature(true);
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
     traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::ClimateMode::CLIMATE_MODE_HEAT});
     traits.set_visual_min_temperature(25.0);
     traits.set_visual_max_temperature(100.0);

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -6,6 +6,9 @@ namespace bang_bang {
 
 static const char *const TAG = "bang_bang.climate";
 
+BangBangClimate::BangBangClimate()
+    : idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
+
 void BangBangClimate::setup() {
   this->sensor_->add_on_state_callback([this](float state) {
     this->current_temperature = state;
@@ -31,53 +34,63 @@ void BangBangClimate::setup() {
     restore->to_call(this).perform();
   } else {
     // restore from defaults, change_away handles those for us
-    if (supports_cool_ && supports_heat_) {
+    if (this->supports_cool_ && this->supports_heat_) {
       this->mode = climate::CLIMATE_MODE_HEAT_COOL;
-    } else if (supports_cool_) {
+    } else if (this->supports_cool_) {
       this->mode = climate::CLIMATE_MODE_COOL;
-    } else if (supports_heat_) {
+    } else if (this->supports_heat_) {
       this->mode = climate::CLIMATE_MODE_HEAT;
     }
     this->change_away_(false);
   }
 }
+
 void BangBangClimate::control(const climate::ClimateCall &call) {
-  if (call.get_mode().has_value())
+  if (call.get_mode().has_value()) {
     this->mode = *call.get_mode();
-  if (call.get_target_temperature_low().has_value())
+  }
+  if (call.get_target_temperature_low().has_value()) {
     this->target_temperature_low = *call.get_target_temperature_low();
-  if (call.get_target_temperature_high().has_value())
+  }
+  if (call.get_target_temperature_high().has_value()) {
     this->target_temperature_high = *call.get_target_temperature_high();
-  if (call.get_preset().has_value())
+  }
+  if (call.get_preset().has_value()) {
     this->change_away_(*call.get_preset() == climate::CLIMATE_PRESET_AWAY);
+  }
 
   this->compute_state_();
   this->publish_state();
 }
+
 climate::ClimateTraits BangBangClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(true);
-  if (this->humidity_sensor_ != nullptr)
-    traits.set_supports_current_humidity(true);
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE |
+                           climate::CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE | climate::CLIMATE_SUPPORTS_ACTION);
+  if (this->humidity_sensor_ != nullptr) {
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY);
+  }
   traits.set_supported_modes({
       climate::CLIMATE_MODE_OFF,
   });
-  if (supports_cool_)
+  if (this->supports_cool_) {
     traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
-  if (supports_heat_)
+  }
+  if (this->supports_heat_) {
     traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
-  if (supports_cool_ && supports_heat_)
+  }
+  if (this->supports_cool_ && this->supports_heat_) {
     traits.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);
-  traits.set_supports_two_point_target_temperature(true);
-  if (supports_away_) {
+  }
+  if (this->supports_away_) {
     traits.set_supported_presets({
         climate::CLIMATE_PRESET_HOME,
         climate::CLIMATE_PRESET_AWAY,
     });
   }
-  traits.set_supports_action(true);
   return traits;
 }
+
 void BangBangClimate::compute_state_() {
   if (this->mode == climate::CLIMATE_MODE_OFF) {
     this->switch_to_action_(climate::CLIMATE_ACTION_OFF);
@@ -122,6 +135,7 @@ void BangBangClimate::compute_state_() {
 
   this->switch_to_action_(target_action);
 }
+
 void BangBangClimate::switch_to_action_(climate::ClimateAction action) {
   if (action == this->action) {
     // already in target mode
@@ -166,6 +180,7 @@ void BangBangClimate::switch_to_action_(climate::ClimateAction action) {
   this->prev_trigger_ = trig;
   this->publish_state();
 }
+
 void BangBangClimate::change_away_(bool away) {
   if (!away) {
     this->target_temperature_low = this->normal_config_.default_temperature_low;
@@ -176,22 +191,26 @@ void BangBangClimate::change_away_(bool away) {
   }
   this->preset = away ? climate::CLIMATE_PRESET_AWAY : climate::CLIMATE_PRESET_HOME;
 }
+
 void BangBangClimate::set_normal_config(const BangBangClimateTargetTempConfig &normal_config) {
   this->normal_config_ = normal_config;
 }
+
 void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &away_config) {
   this->supports_away_ = true;
   this->away_config_ = away_config;
 }
-BangBangClimate::BangBangClimate()
-    : idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
+
 void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
 void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
+
 Trigger<> *BangBangClimate::get_idle_trigger() const { return this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger_; }
-void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
 Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger_; }
+
+void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+
 void BangBangClimate::dump_config() {
   LOG_CLIMATE("", "Bang Bang Climate", this);
   ESP_LOGCONFIG(TAG,

esphome/components/bang_bang/bang_bang_climate.h

@@ -25,14 +25,15 @@ class BangBangClimate : public climate::Climate, public Component {
 
   void set_sensor(sensor::Sensor *sensor);
   void set_humidity_sensor(sensor::Sensor *humidity_sensor);
-  Trigger<> *get_idle_trigger() const;
-  Trigger<> *get_cool_trigger() const;
   void set_supports_cool(bool supports_cool);
-  Trigger<> *get_heat_trigger() const;
   void set_supports_heat(bool supports_heat);
   void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
   void set_away_config(const BangBangClimateTargetTempConfig &away_config);
 
+  Trigger<> *get_idle_trigger() const;
+  Trigger<> *get_cool_trigger() const;
+  Trigger<> *get_heat_trigger() const;
+
  protected:
   /// Override control to change settings of the climate device.
   void control(const climate::ClimateCall &call) override;
@@ -56,16 +57,10 @@ class BangBangClimate : public climate::Climate, public Component {
    *
    * In idle mode, the controller is assumed to have both heating and cooling disabled.
    */
-  Trigger<> *idle_trigger_;
+  Trigger<> *idle_trigger_{nullptr};
   /** The trigger to call when the controller should switch to cooling mode.
    */
-  Trigger<> *cool_trigger_;
-  /** Whether the controller supports cooling.
-   *
-   * A false value for this attribute means that the controller has no cooling action
-   * (for example a thermostat, where only heating and not-heating is possible).
-   */
-  bool supports_cool_{false};
+  Trigger<> *cool_trigger_{nullptr};
   /** The trigger to call when the controller should switch to heating mode.
    *
    * A null value for this attribute means that the controller has no heating action
@@ -73,15 +68,23 @@ class BangBangClimate : public climate::Climate, public Component {
    * (blinds open) is possible.
    */
   Trigger<> *heat_trigger_{nullptr};
-  bool supports_heat_{false};
   /** A reference to the trigger that was previously active.
    *
    * This is so that the previous trigger can be stopped before enabling a new one.
    */
   Trigger<> *prev_trigger_{nullptr};
 
-  BangBangClimateTargetTempConfig normal_config_{};
+  /** Whether the controller supports cooling/heating
+   *
+   * A false value for this attribute means that the controller has no respective action
+   * (for example a thermostat, where only heating and not-heating is possible).
+   */
+  bool supports_cool_{false};
+  bool supports_heat_{false};
+
   bool supports_away_{false};
+
+  BangBangClimateTargetTempConfig normal_config_{};
   BangBangClimateTargetTempConfig away_config_{};
 };
 

esphome/components/bedjet/climate/bedjet_climate.h

@@ -33,8 +33,7 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
 
   climate::ClimateTraits traits() override {
     auto traits = climate::ClimateTraits();
-    traits.set_supports_action(true);
-    traits.set_supports_current_temperature(true);
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_ACTION | climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
     traits.set_supported_modes({
         climate::CLIMATE_MODE_OFF,
         climate::CLIMATE_MODE_HEAT,

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -77,6 +77,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -79,6 +79,9 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }

esphome/components/climate/climate.cpp

@@ -6,6 +6,42 @@ namespace climate {
 
 static const char *const TAG = "climate";
 
+// Memory-efficient lookup tables
+struct StringToUint8 {
+  const char *str;
+  const uint8_t value;
+};
+
+constexpr StringToUint8 CLIMATE_MODES_BY_STR[] = {
+    {"OFF", CLIMATE_MODE_OFF},
+    {"AUTO", CLIMATE_MODE_AUTO},
+    {"COOL", CLIMATE_MODE_COOL},
+    {"HEAT", CLIMATE_MODE_HEAT},
+    {"FAN_ONLY", CLIMATE_MODE_FAN_ONLY},
+    {"DRY", CLIMATE_MODE_DRY},
+    {"HEAT_COOL", CLIMATE_MODE_HEAT_COOL},
+};
+
+constexpr StringToUint8 CLIMATE_FAN_MODES_BY_STR[] = {
+    {"ON", CLIMATE_FAN_ON},         {"OFF", CLIMATE_FAN_OFF},       {"AUTO", CLIMATE_FAN_AUTO},
+    {"LOW", CLIMATE_FAN_LOW},       {"MEDIUM", CLIMATE_FAN_MEDIUM}, {"HIGH", CLIMATE_FAN_HIGH},
+    {"MIDDLE", CLIMATE_FAN_MIDDLE}, {"FOCUS", CLIMATE_FAN_FOCUS},   {"DIFFUSE", CLIMATE_FAN_DIFFUSE},
+    {"QUIET", CLIMATE_FAN_QUIET},
+};
+
+constexpr StringToUint8 CLIMATE_PRESETS_BY_STR[] = {
+    {"ECO", CLIMATE_PRESET_ECO},           {"AWAY", CLIMATE_PRESET_AWAY}, {"BOOST", CLIMATE_PRESET_BOOST},
+    {"COMFORT", CLIMATE_PRESET_COMFORT},   {"HOME", CLIMATE_PRESET_HOME}, {"SLEEP", CLIMATE_PRESET_SLEEP},
+    {"ACTIVITY", CLIMATE_PRESET_ACTIVITY}, {"NONE", CLIMATE_PRESET_NONE},
+};
+
+constexpr StringToUint8 CLIMATE_SWING_MODES_BY_STR[] = {
+    {"OFF", CLIMATE_SWING_OFF},
+    {"BOTH", CLIMATE_SWING_BOTH},
+    {"VERTICAL", CLIMATE_SWING_VERTICAL},
+    {"HORIZONTAL", CLIMATE_SWING_HORIZONTAL},
+};
+
 void ClimateCall::perform() {
   this->parent_->control_callback_.call(*this);
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
@@ -50,47 +86,46 @@ void ClimateCall::perform() {
   }
   this->parent_->control(*this);
 }
+
 void ClimateCall::validate_() {
   auto traits = this->parent_->get_traits();
   if (this->mode_.has_value()) {
     auto mode = *this->mode_;
     if (!traits.supports_mode(mode)) {
-      ESP_LOGW(TAG, "  Mode %s is not supported by this device!", LOG_STR_ARG(climate_mode_to_string(mode)));
+      ESP_LOGW(TAG, "  Mode %s not supported", LOG_STR_ARG(climate_mode_to_string(mode)));
       this->mode_.reset();
     }
   }
   if (this->custom_fan_mode_.has_value()) {
     auto custom_fan_mode = *this->custom_fan_mode_;
     if (!traits.supports_custom_fan_mode(custom_fan_mode)) {
-      ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!", custom_fan_mode.c_str());
+      ESP_LOGW(TAG, "  Fan Mode %s not supported", custom_fan_mode.c_str());
       this->custom_fan_mode_.reset();
     }
   } else if (this->fan_mode_.has_value()) {
     auto fan_mode = *this->fan_mode_;
     if (!traits.supports_fan_mode(fan_mode)) {
-      ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!",
-               LOG_STR_ARG(climate_fan_mode_to_string(fan_mode)));
+      ESP_LOGW(TAG, "  Fan Mode %s not supported", LOG_STR_ARG(climate_fan_mode_to_string(fan_mode)));
       this->fan_mode_.reset();
     }
   }
   if (this->custom_preset_.has_value()) {
     auto custom_preset = *this->custom_preset_;
     if (!traits.supports_custom_preset(custom_preset)) {
-      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", custom_preset.c_str());
+      ESP_LOGW(TAG, "  Preset %s not supported", custom_preset.c_str());
       this->custom_preset_.reset();
     }
   } else if (this->preset_.has_value()) {
     auto preset = *this->preset_;
     if (!traits.supports_preset(preset)) {
-      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", LOG_STR_ARG(climate_preset_to_string(preset)));
+      ESP_LOGW(TAG, "  Preset %s not supported", LOG_STR_ARG(climate_preset_to_string(preset)));
       this->preset_.reset();
     }
   }
   if (this->swing_mode_.has_value()) {
     auto swing_mode = *this->swing_mode_;
     if (!traits.supports_swing_mode(swing_mode)) {
-      ESP_LOGW(TAG, "  Swing Mode %s is not supported by this device!",
-               LOG_STR_ARG(climate_swing_mode_to_string(swing_mode)));
+      ESP_LOGW(TAG, "  Swing Mode %s not supported", LOG_STR_ARG(climate_swing_mode_to_string(swing_mode)));
       this->swing_mode_.reset();
     }
   }
@@ -99,159 +134,127 @@ void ClimateCall::validate_() {
     if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                  CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
       ESP_LOGW(TAG, "  Cannot set target temperature for climate device "
-                    "with two-point target temperature!");
+                    "with two-point target temperature");
       this->target_temperature_.reset();
     } else if (std::isnan(target)) {
-      ESP_LOGW(TAG, "  Target temperature must not be NAN!");
+      ESP_LOGW(TAG, "  Target temperature must not be NAN");
       this->target_temperature_.reset();
     }
   }
   if (this->target_temperature_low_.has_value() || this->target_temperature_high_.has_value()) {
     if (!traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                   CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
-      ESP_LOGW(TAG, "  Cannot set low/high target temperature for this device!");
+      ESP_LOGW(TAG, "  Cannot set low/high target temperature");
       this->target_temperature_low_.reset();
       this->target_temperature_high_.reset();
     }
   }
   if (this->target_temperature_low_.has_value() && std::isnan(*this->target_temperature_low_)) {
-    ESP_LOGW(TAG, "  Target temperature low must not be NAN!");
+    ESP_LOGW(TAG, "  Target temperature low must not be NAN");
     this->target_temperature_low_.reset();
   }
   if (this->target_temperature_high_.has_value() && std::isnan(*this->target_temperature_high_)) {
-    ESP_LOGW(TAG, "  Target temperature low must not be NAN!");
+    ESP_LOGW(TAG, "  Target temperature high must not be NAN");
     this->target_temperature_high_.reset();
   }
   if (this->target_temperature_low_.has_value() && this->target_temperature_high_.has_value()) {
     float low = *this->target_temperature_low_;
     float high = *this->target_temperature_high_;
     if (low > high) {
-      ESP_LOGW(TAG, "  Target temperature low %.2f must be smaller than target temperature high %.2f!", low, high);
+      ESP_LOGW(TAG, "  Target temperature low %.2f must be less than target temperature high %.2f", low, high);
       this->target_temperature_low_.reset();
       this->target_temperature_high_.reset();
     }
   }
 }
+
 ClimateCall &ClimateCall::set_mode(ClimateMode mode) {
   this->mode_ = mode;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_mode(const std::string &mode) {
-  if (str_equals_case_insensitive(mode, "OFF")) {
-    this->set_mode(CLIMATE_MODE_OFF);
-  } else if (str_equals_case_insensitive(mode, "AUTO")) {
-    this->set_mode(CLIMATE_MODE_AUTO);
-  } else if (str_equals_case_insensitive(mode, "COOL")) {
-    this->set_mode(CLIMATE_MODE_COOL);
-  } else if (str_equals_case_insensitive(mode, "HEAT")) {
-    this->set_mode(CLIMATE_MODE_HEAT);
-  } else if (str_equals_case_insensitive(mode, "FAN_ONLY")) {
-    this->set_mode(CLIMATE_MODE_FAN_ONLY);
-  } else if (str_equals_case_insensitive(mode, "DRY")) {
-    this->set_mode(CLIMATE_MODE_DRY);
-  } else if (str_equals_case_insensitive(mode, "HEAT_COOL")) {
-    this->set_mode(CLIMATE_MODE_HEAT_COOL);
-  } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized mode %s", this->parent_->get_name().c_str(), mode.c_str());
+  for (const auto &mode_entry : CLIMATE_MODES_BY_STR) {
+    if (str_equals_case_insensitive(mode, mode_entry.str)) {
+      this->set_mode(static_cast<ClimateMode>(mode_entry.value));
+      return *this;
+    }
   }
+  ESP_LOGW(TAG, "'%s' - Unrecognized mode %s", this->parent_->get_name().c_str(), mode.c_str());
   return *this;
 }
+
 ClimateCall &ClimateCall::set_fan_mode(ClimateFanMode fan_mode) {
   this->fan_mode_ = fan_mode;
   this->custom_fan_mode_.reset();
   return *this;
 }
+
 ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
-  if (str_equals_case_insensitive(fan_mode, "ON")) {
-    this->set_fan_mode(CLIMATE_FAN_ON);
-  } else if (str_equals_case_insensitive(fan_mode, "OFF")) {
-    this->set_fan_mode(CLIMATE_FAN_OFF);
-  } else if (str_equals_case_insensitive(fan_mode, "AUTO")) {
-    this->set_fan_mode(CLIMATE_FAN_AUTO);
-  } else if (str_equals_case_insensitive(fan_mode, "LOW")) {
-    this->set_fan_mode(CLIMATE_FAN_LOW);
-  } else if (str_equals_case_insensitive(fan_mode, "MEDIUM")) {
-    this->set_fan_mode(CLIMATE_FAN_MEDIUM);
-  } else if (str_equals_case_insensitive(fan_mode, "HIGH")) {
-    this->set_fan_mode(CLIMATE_FAN_HIGH);
-  } else if (str_equals_case_insensitive(fan_mode, "MIDDLE")) {
-    this->set_fan_mode(CLIMATE_FAN_MIDDLE);
-  } else if (str_equals_case_insensitive(fan_mode, "FOCUS")) {
-    this->set_fan_mode(CLIMATE_FAN_FOCUS);
-  } else if (str_equals_case_insensitive(fan_mode, "DIFFUSE")) {
-    this->set_fan_mode(CLIMATE_FAN_DIFFUSE);
-  } else if (str_equals_case_insensitive(fan_mode, "QUIET")) {
-    this->set_fan_mode(CLIMATE_FAN_QUIET);
-  } else {
-    if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
-      this->custom_fan_mode_ = fan_mode;
-      this->fan_mode_.reset();
-    } else {
-      ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
+  for (const auto &mode_entry : CLIMATE_FAN_MODES_BY_STR) {
+    if (str_equals_case_insensitive(fan_mode, mode_entry.str)) {
+      this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
+      return *this;
     }
   }
+  if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
+    this->custom_fan_mode_ = fan_mode;
+    this->fan_mode_.reset();
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
+  }
   return *this;
 }
+
 ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
   if (fan_mode.has_value()) {
     this->set_fan_mode(fan_mode.value());
   }
   return *this;
 }
+
 ClimateCall &ClimateCall::set_preset(ClimatePreset preset) {
   this->preset_ = preset;
   this->custom_preset_.reset();
   return *this;
 }
+
 ClimateCall &ClimateCall::set_preset(const std::string &preset) {
-  if (str_equals_case_insensitive(preset, "ECO")) {
-    this->set_preset(CLIMATE_PRESET_ECO);
-  } else if (str_equals_case_insensitive(preset, "AWAY")) {
-    this->set_preset(CLIMATE_PRESET_AWAY);
-  } else if (str_equals_case_insensitive(preset, "BOOST")) {
-    this->set_preset(CLIMATE_PRESET_BOOST);
-  } else if (str_equals_case_insensitive(preset, "COMFORT")) {
-    this->set_preset(CLIMATE_PRESET_COMFORT);
-  } else if (str_equals_case_insensitive(preset, "HOME")) {
-    this->set_preset(CLIMATE_PRESET_HOME);
-  } else if (str_equals_case_insensitive(preset, "SLEEP")) {
-    this->set_preset(CLIMATE_PRESET_SLEEP);
-  } else if (str_equals_case_insensitive(preset, "ACTIVITY")) {
-    this->set_preset(CLIMATE_PRESET_ACTIVITY);
-  } else if (str_equals_case_insensitive(preset, "NONE")) {
-    this->set_preset(CLIMATE_PRESET_NONE);
-  } else {
-    if (this->parent_->get_traits().supports_custom_preset(preset)) {
-      this->custom_preset_ = preset;
-      this->preset_.reset();
-    } else {
-      ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), preset.c_str());
+  for (const auto &preset_entry : CLIMATE_PRESETS_BY_STR) {
+    if (str_equals_case_insensitive(preset, preset_entry.str)) {
+      this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
+      return *this;
     }
   }
+  if (this->parent_->get_traits().supports_custom_preset(preset)) {
+    this->custom_preset_ = preset;
+    this->preset_.reset();
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), preset.c_str());
+  }
   return *this;
 }
+
 ClimateCall &ClimateCall::set_preset(optional<std::string> preset) {
   if (preset.has_value()) {
     this->set_preset(preset.value());
   }
   return *this;
 }
+
 ClimateCall &ClimateCall::set_swing_mode(ClimateSwingMode swing_mode) {
   this->swing_mode_ = swing_mode;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_swing_mode(const std::string &swing_mode) {
-  if (str_equals_case_insensitive(swing_mode, "OFF")) {
-    this->set_swing_mode(CLIMATE_SWING_OFF);
-  } else if (str_equals_case_insensitive(swing_mode, "BOTH")) {
-    this->set_swing_mode(CLIMATE_SWING_BOTH);
-  } else if (str_equals_case_insensitive(swing_mode, "VERTICAL")) {
-    this->set_swing_mode(CLIMATE_SWING_VERTICAL);
-  } else if (str_equals_case_insensitive(swing_mode, "HORIZONTAL")) {
-    this->set_swing_mode(CLIMATE_SWING_HORIZONTAL);
-  } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized swing mode %s", this->parent_->get_name().c_str(), swing_mode.c_str());
+  for (const auto &mode_entry : CLIMATE_SWING_MODES_BY_STR) {
+    if (str_equals_case_insensitive(swing_mode, mode_entry.str)) {
+      this->set_swing_mode(static_cast<ClimateSwingMode>(mode_entry.value));
+      return *this;
+    }
   }
+  ESP_LOGW(TAG, "'%s' - Unrecognized swing mode %s", this->parent_->get_name().c_str(), swing_mode.c_str());
   return *this;
 }
 
@@ -259,59 +262,71 @@ ClimateCall &ClimateCall::set_target_temperature(float target_temperature) {
   this->target_temperature_ = target_temperature;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_temperature_low(float target_temperature_low) {
   this->target_temperature_low_ = target_temperature_low;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_temperature_high(float target_temperature_high) {
   this->target_temperature_high_ = target_temperature_high;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_humidity(float target_humidity) {
   this->target_humidity_ = target_humidity;
   return *this;
 }
 
-const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_; }
 const optional<float> &ClimateCall::get_target_temperature() const { return this->target_temperature_; }
 const optional<float> &ClimateCall::get_target_temperature_low() const { return this->target_temperature_low_; }
 const optional<float> &ClimateCall::get_target_temperature_high() const { return this->target_temperature_high_; }
 const optional<float> &ClimateCall::get_target_humidity() const { return this->target_humidity_; }
+
+const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_; }
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
-const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
-const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
-const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
 const optional<ClimateSwingMode> &ClimateCall::get_swing_mode() const { return this->swing_mode_; }
+const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
+const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
+const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
+
 ClimateCall &ClimateCall::set_target_temperature_high(optional<float> target_temperature_high) {
   this->target_temperature_high_ = target_temperature_high;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_temperature_low(optional<float> target_temperature_low) {
   this->target_temperature_low_ = target_temperature_low;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_temperature(optional<float> target_temperature) {
   this->target_temperature_ = target_temperature;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_target_humidity(optional<float> target_humidity) {
   this->target_humidity_ = target_humidity;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_mode(optional<ClimateMode> mode) {
   this->mode_ = mode;
   return *this;
 }
+
 ClimateCall &ClimateCall::set_fan_mode(optional<ClimateFanMode> fan_mode) {
   this->fan_mode_ = fan_mode;
   this->custom_fan_mode_.reset();
   return *this;
 }
+
 ClimateCall &ClimateCall::set_preset(optional<ClimatePreset> preset) {
   this->preset_ = preset;
   this->custom_preset_.reset();
   return *this;
 }
+
 ClimateCall &ClimateCall::set_swing_mode(optional<ClimateSwingMode> swing_mode) {
   this->swing_mode_ = swing_mode;
   return *this;
@@ -336,6 +351,7 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
     return {};
   return recovered;
 }
+
 void Climate::save_state_() {
 #if (defined(USE_ESP_IDF) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
     !defined(CLANG_TIDY)
@@ -398,6 +414,7 @@ void Climate::save_state_() {
 
   this->rtc_.save(&state);
 }
+
 void Climate::publish_state() {
   ESP_LOGD(TAG, "'%s' - Sending state:", this->name_.c_str());
   auto traits = this->get_traits();
@@ -469,16 +486,20 @@ ClimateTraits Climate::get_traits() {
 void Climate::set_visual_min_temperature_override(float visual_min_temperature_override) {
   this->visual_min_temperature_override_ = visual_min_temperature_override;
 }
+
 void Climate::set_visual_max_temperature_override(float visual_max_temperature_override) {
   this->visual_max_temperature_override_ = visual_max_temperature_override;
 }
+
 void Climate::set_visual_temperature_step_override(float target, float current) {
   this->visual_target_temperature_step_override_ = target;
   this->visual_current_temperature_step_override_ = current;
 }
+
 void Climate::set_visual_min_humidity_override(float visual_min_humidity_override) {
   this->visual_min_humidity_override_ = visual_min_humidity_override;
 }
+
 void Climate::set_visual_max_humidity_override(float visual_max_humidity_override) {
   this->visual_max_humidity_override_ = visual_max_humidity_override;
 }
@@ -510,6 +531,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   }
   return call;
 }
+
 void ClimateDeviceRestoreState::apply(Climate *climate) {
   auto traits = climate->get_traits();
   climate->mode = this->mode;
@@ -579,68 +601,68 @@ void Climate::dump_traits_(const char *tag) {
   auto traits = this->get_traits();
   ESP_LOGCONFIG(tag, "ClimateTraits:");
   ESP_LOGCONFIG(tag,
-                "  [x] Visual settings:\n"
-                "      - Min temperature: %.1f\n"
-                "      - Max temperature: %.1f\n"
-                "      - Temperature step:\n"
-                "          Target: %.1f",
+                "  Visual settings:\n"
+                "  - Min temperature: %.1f\n"
+                "  - Max temperature: %.1f\n"
+                "  - Temperature step:\n"
+                "      Target: %.1f",
                 traits.get_visual_min_temperature(), traits.get_visual_max_temperature(),
                 traits.get_visual_target_temperature_step());
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE)) {
-    ESP_LOGCONFIG(tag, "          Current: %.1f", traits.get_visual_current_temperature_step());
+    ESP_LOGCONFIG(tag, "      Current: %.1f", traits.get_visual_current_temperature_step());
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY |
                                climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY)) {
     ESP_LOGCONFIG(tag,
-                  "      - Min humidity: %.0f\n"
-                  "      - Max humidity: %.0f",
+                  "  - Min humidity: %.0f\n"
+                  "  - Max humidity: %.0f",
                   traits.get_visual_min_humidity(), traits.get_visual_max_humidity());
   }
   if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
-    ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");
+    ESP_LOGCONFIG(tag, "  Supports two-point target temperature");
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE)) {
-    ESP_LOGCONFIG(tag, "  [x] Supports current temperature");
+    ESP_LOGCONFIG(tag, "  Supports current temperature");
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY)) {
-    ESP_LOGCONFIG(tag, "  [x] Supports target humidity");
+    ESP_LOGCONFIG(tag, "  Supports target humidity");
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY)) {
-    ESP_LOGCONFIG(tag, "  [x] Supports current humidity");
+    ESP_LOGCONFIG(tag, "  Supports current humidity");
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    ESP_LOGCONFIG(tag, "  [x] Supports action");
+    ESP_LOGCONFIG(tag, "  Supports action");
   }
   if (!traits.get_supported_modes().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported modes:");
+    ESP_LOGCONFIG(tag, "  Supported modes:");
     for (ClimateMode m : traits.get_supported_modes())
-      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_mode_to_string(m)));
+      ESP_LOGCONFIG(tag, "  - %s", LOG_STR_ARG(climate_mode_to_string(m)));
   }
   if (!traits.get_supported_fan_modes().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported fan modes:");
+    ESP_LOGCONFIG(tag, "  Supported fan modes:");
     for (ClimateFanMode m : traits.get_supported_fan_modes())
-      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_fan_mode_to_string(m)));
+      ESP_LOGCONFIG(tag, "  - %s", LOG_STR_ARG(climate_fan_mode_to_string(m)));
   }
   if (!traits.get_supported_custom_fan_modes().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported custom fan modes:");
+    ESP_LOGCONFIG(tag, "  Supported custom fan modes:");
     for (const std::string &s : traits.get_supported_custom_fan_modes())
-      ESP_LOGCONFIG(tag, "      - %s", s.c_str());
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_presets().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported presets:");
+    ESP_LOGCONFIG(tag, "  Supported presets:");
     for (ClimatePreset p : traits.get_supported_presets())
-      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_preset_to_string(p)));
+      ESP_LOGCONFIG(tag, "  - %s", LOG_STR_ARG(climate_preset_to_string(p)));
   }
   if (!traits.get_supported_custom_presets().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported custom presets:");
+    ESP_LOGCONFIG(tag, "  Supported custom presets:");
     for (const std::string &s : traits.get_supported_custom_presets())
-      ESP_LOGCONFIG(tag, "      - %s", s.c_str());
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_swing_modes().empty()) {
-    ESP_LOGCONFIG(tag, "  [x] Supported swing modes:");
+    ESP_LOGCONFIG(tag, "  Supported swing modes:");
     for (ClimateSwingMode m : traits.get_supported_swing_modes())
-      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_swing_mode_to_string(m)));
+      ESP_LOGCONFIG(tag, "  - %s", LOG_STR_ARG(climate_swing_mode_to_string(m)));
   }
 }
 

esphome/components/climate/climate.h

@@ -93,30 +93,31 @@ class ClimateCall {
 
   void perform();
 
-  const optional<ClimateMode> &get_mode() const;
   const optional<float> &get_target_temperature() const;
   const optional<float> &get_target_temperature_low() const;
   const optional<float> &get_target_temperature_high() const;
   const optional<float> &get_target_humidity() const;
+
+  const optional<ClimateMode> &get_mode() const;
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
-  const optional<std::string> &get_custom_fan_mode() const;
   const optional<ClimatePreset> &get_preset() const;
+  const optional<std::string> &get_custom_fan_mode() const;
   const optional<std::string> &get_custom_preset() const;
 
  protected:
   void validate_();
 
   Climate *const parent_;
-  optional<ClimateMode> mode_;
   optional<float> target_temperature_;
   optional<float> target_temperature_low_;
   optional<float> target_temperature_high_;
   optional<float> target_humidity_;
+  optional<ClimateMode> mode_;
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
-  optional<std::string> custom_fan_mode_;
   optional<ClimatePreset> preset_;
+  optional<std::string> custom_fan_mode_;
   optional<std::string> custom_preset_;
 };
 
@@ -169,47 +170,6 @@ class Climate : public EntityBase {
  public:
   Climate() {}
 
-  /// The active mode of the climate device.
-  ClimateMode mode{CLIMATE_MODE_OFF};
-
-  /// The active state of the climate device.
-  ClimateAction action{CLIMATE_ACTION_OFF};
-
-  /// The current temperature of the climate device, as reported from the integration.
-  float current_temperature{NAN};
-
-  /// The current humidity of the climate device, as reported from the integration.
-  float current_humidity{NAN};
-
-  union {
-    /// The target temperature of the climate device.
-    float target_temperature;
-    struct {
-      /// The minimum target temperature of the climate device, for climate devices with split target temperature.
-      float target_temperature_low{NAN};
-      /// The maximum target temperature of the climate device, for climate devices with split target temperature.
-      float target_temperature_high{NAN};
-    };
-  };
-
-  /// The target humidity of the climate device.
-  float target_humidity;
-
-  /// The active fan mode of the climate device.
-  optional<ClimateFanMode> fan_mode;
-
-  /// The active swing mode of the climate device.
-  ClimateSwingMode swing_mode;
-
-  /// The active custom fan mode of the climate device.
-  optional<std::string> custom_fan_mode;
-
-  /// The active preset of the climate device.
-  optional<ClimatePreset> preset;
-
-  /// The active custom preset mode of the climate device.
-  optional<std::string> custom_preset;
-
   /** Add a callback for the climate device state, each time the state of the climate device is updated
    * (using publish_state), this callback will be called.
    *
@@ -251,6 +211,47 @@ class Climate : public EntityBase {
   void set_visual_min_humidity_override(float visual_min_humidity_override);
   void set_visual_max_humidity_override(float visual_max_humidity_override);
 
+  /// The current temperature of the climate device, as reported from the integration.
+  float current_temperature{NAN};
+
+  /// The current humidity of the climate device, as reported from the integration.
+  float current_humidity{NAN};
+
+  union {
+    /// The target temperature of the climate device.
+    float target_temperature;
+    struct {
+      /// The minimum target temperature of the climate device, for climate devices with split target temperature.
+      float target_temperature_low{NAN};
+      /// The maximum target temperature of the climate device, for climate devices with split target temperature.
+      float target_temperature_high{NAN};
+    };
+  };
+
+  /// The target humidity of the climate device.
+  float target_humidity;
+
+  /// The active fan mode of the climate device.
+  optional<ClimateFanMode> fan_mode;
+
+  /// The active preset of the climate device.
+  optional<ClimatePreset> preset;
+
+  /// The active custom fan mode of the climate device.
+  optional<std::string> custom_fan_mode;
+
+  /// The active custom preset mode of the climate device.
+  optional<std::string> custom_preset;
+
+  /// The active mode of the climate device.
+  ClimateMode mode{CLIMATE_MODE_OFF};
+
+  /// The active state of the climate device.
+  ClimateAction action{CLIMATE_ACTION_OFF};
+
+  /// The active swing mode of the climate device.
+  ClimateSwingMode swing_mode{CLIMATE_SWING_OFF};
+
  protected:
   friend ClimateCall;
 

esphome/components/climate_ir/climate_ir.cpp

@@ -8,7 +8,10 @@ static const char *const TAG = "climate_ir";
 
 climate::ClimateTraits ClimateIR::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(this->sensor_ != nullptr);
+  if (this->sensor_ != nullptr) {
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
+  }
+
   traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL});
   if (this->supports_cool_)
     traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
@@ -19,7 +22,6 @@ climate::ClimateTraits ClimateIR::traits() {
   if (this->supports_fan_only_)
     traits.add_supported_mode(climate::CLIMATE_MODE_FAN_ONLY);
 
-  traits.set_supports_two_point_target_temperature(false);
   traits.set_visual_min_temperature(this->minimum_temperature_);
   traits.set_visual_max_temperature(this->maximum_temperature_);
   traits.set_visual_temperature_step(this->temperature_step_);

esphome/components/cover/cover.cpp

@@ -1,6 +1,6 @@
 #include "cover.h"
-#include "esphome/core/log.h"
 #include <strings.h>
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace cover {
@@ -144,21 +144,7 @@ CoverCall &CoverCall::set_stop(bool stop) {
 bool CoverCall::get_stop() const { return this->stop_; }
 
 CoverCall Cover::make_call() { return {this}; }
-void Cover::open() {
-  auto call = this->make_call();
-  call.set_command_open();
-  call.perform();
-}
-void Cover::close() {
-  auto call = this->make_call();
-  call.set_command_close();
-  call.perform();
-}
-void Cover::stop() {
-  auto call = this->make_call();
-  call.set_command_stop();
-  call.perform();
-}
+
 void Cover::add_on_state_callback(std::function<void()> &&f) { this->state_callback_.add(std::move(f)); }
 void Cover::publish_state(bool save) {
   this->position = clamp(this->position, 0.0f, 1.0f);

esphome/components/cover/cover.h

@@ -4,6 +4,7 @@
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
+
 #include "cover_traits.h"
 
 namespace esphome {
@@ -125,25 +126,6 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
 
   /// Construct a new cover call used to control the cover.
   CoverCall make_call();
-  /** Open the cover.
-   *
-   * This is a legacy method and may be removed later, please use `.make_call()` instead.
-   */
-  ESPDEPRECATED("open() is deprecated, use make_call().set_command_open().perform() instead.", "2021.9")
-  void open();
-  /** Close the cover.
-   *
-   * This is a legacy method and may be removed later, please use `.make_call()` instead.
-   */
-  ESPDEPRECATED("close() is deprecated, use make_call().set_command_close().perform() instead.", "2021.9")
-  void close();
-  /** Stop the cover.
-   *
-   * This is a legacy method and may be removed later, please use `.make_call()` instead.
-   * As per solution from issue #2885 the call should include perform()
-   */
-  ESPDEPRECATED("stop() is deprecated, use make_call().set_command_stop().perform() instead.", "2021.9")
-  void stop();
 
   void add_on_state_callback(std::function<void()> &&f);
 

esphome/components/daikin_arc/daikin_arc.cpp

@@ -241,9 +241,7 @@ uint8_t DaikinArcClimate::humidity_() {
 
 climate::ClimateTraits DaikinArcClimate::traits() {
   climate::ClimateTraits traits = climate_ir::ClimateIR::traits();
-  traits.set_supports_current_temperature(true);
-  traits.set_supports_current_humidity(false);
-  traits.set_supports_target_humidity(true);
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE | climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY);
   traits.set_visual_min_humidity(38);
   traits.set_visual_max_humidity(52);
   return traits;

esphome/components/demo/demo_climate.h

@@ -82,16 +82,14 @@ class DemoClimate : public climate::Climate, public Component {
     climate::ClimateTraits traits{};
     switch (type_) {
       case DemoClimateType::TYPE_1:
-        traits.set_supports_current_temperature(true);
+        traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE | climate::CLIMATE_SUPPORTS_ACTION);
         traits.set_supported_modes({
             climate::CLIMATE_MODE_OFF,
             climate::CLIMATE_MODE_HEAT,
         });
-        traits.set_supports_action(true);
         traits.set_visual_temperature_step(0.5);
         break;
       case DemoClimateType::TYPE_2:
-        traits.set_supports_current_temperature(false);
         traits.set_supported_modes({
             climate::CLIMATE_MODE_OFF,
             climate::CLIMATE_MODE_HEAT,
@@ -100,7 +98,7 @@ class DemoClimate : public climate::Climate, public Component {
             climate::CLIMATE_MODE_DRY,
             climate::CLIMATE_MODE_FAN_ONLY,
         });
-        traits.set_supports_action(true);
+        traits.add_feature_flags(climate::CLIMATE_SUPPORTS_ACTION);
         traits.set_supported_fan_modes({
             climate::CLIMATE_FAN_ON,
             climate::CLIMATE_FAN_OFF,
@@ -123,8 +121,8 @@ class DemoClimate : public climate::Climate, public Component {
         traits.set_supported_custom_presets({"My Preset"});
         break;
       case DemoClimateType::TYPE_3:
-        traits.set_supports_current_temperature(true);
-        traits.set_supports_two_point_target_temperature(true);
+        traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE |
+                                 climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE);
         traits.set_supported_modes({
             climate::CLIMATE_MODE_OFF,
             climate::CLIMATE_MODE_COOL,

esphome/components/epaper_spi/epaper_spi.cpp

@@ -103,7 +103,7 @@ bool EPaperBase::is_idle_() {
   if (this->busy_pin_ == nullptr) {
     return true;
   }
-  return !this->busy_pin_->digital_read();
+  return this->busy_pin_->digital_read();
 }
 
 void EPaperBase::reset() {

esphome/components/esp32/__init__.py

@@ -779,6 +779,16 @@ async def to_code(config):
         Path(__file__).parent / "post_build.py.script",
     )
 
+    # In testing mode, add IRAM fix script to allow linking grouped component tests
+    # Similar to ESP8266's approach but for ESP-IDF
+    if CORE.testing_mode:
+        cg.add_build_flag("-DESPHOME_TESTING_MODE")
+        add_extra_script(
+            "pre",
+            "iram_fix.py",
+            Path(__file__).parent / "iram_fix.py.script",
+        )
+
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_platformio_option("framework", "espidf")
         cg.add_build_flag("-DUSE_ESP_IDF")
@@ -805,6 +815,7 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_AUTOSTART_ARDUINO", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
+        add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 
     cg.add_build_flag("-Wno-nonnull-compare")
 

esphome/components/esp32/iram_fix.py.script

@@ -0,0 +1,71 @@
+import os
+import re
+
+# pylint: disable=E0602
+Import("env")  # noqa
+
+# IRAM size for testing mode (2MB - large enough to accommodate grouped tests)
+TESTING_IRAM_SIZE = 0x200000
+
+
+def patch_idf_linker_script(source, target, env):
+    """Patch ESP-IDF linker script to increase IRAM size for testing mode."""
+    # Check if we're in testing mode by looking for the define
+    build_flags = env.get("BUILD_FLAGS", [])
+    testing_mode = any("-DESPHOME_TESTING_MODE" in flag for flag in build_flags)
+
+    if not testing_mode:
+        return
+
+    # For ESP-IDF, the linker scripts are generated in the build directory
+    build_dir = env.subst("$BUILD_DIR")
+
+    # The memory.ld file is directly in the build directory
+    memory_ld = os.path.join(build_dir, "memory.ld")
+
+    if not os.path.exists(memory_ld):
+        print(f"ESPHome: Warning - could not find linker script at {memory_ld}")
+        return
+
+    try:
+        with open(memory_ld, "r") as f:
+            content = f.read()
+    except OSError as e:
+        print(f"ESPHome: Error reading linker script: {e}")
+        return
+
+    # Check if this file contains iram0_0_seg
+    if 'iram0_0_seg' not in content:
+        print(f"ESPHome: Warning - iram0_0_seg not found in {memory_ld}")
+        return
+
+    # Look for iram0_0_seg definition and increase its length
+    # ESP-IDF format can be:
+    #   iram0_0_seg (RX) : org = 0x40080000, len = 0x20000 + 0x0
+    # or more complex with nested parentheses:
+    #   iram0_0_seg (RX) : org = (0x40370000 + 0x4000), len = (((0x403CB700 - (0x40378000 - 0x3FC88000)) - 0x3FC88000) + 0x8000 - 0x4000)
+    # We want to change len to TESTING_IRAM_SIZE for testing
+
+    # Use a more robust approach: find the line and manually parse it
+    lines = content.split('\n')
+    for i, line in enumerate(lines):
+        if 'iram0_0_seg' in line and 'len' in line:
+            # Find the position of "len = " and replace everything after it until the end of the statement
+            match = re.search(r'(iram0_0_seg\s*\([^)]*\)\s*:\s*org\s*=\s*(?:\([^)]+\)|0x[0-9a-fA-F]+)\s*,\s*len\s*=\s*)(.+?)(\s*)$', line)
+            if match:
+                lines[i] = f"{match.group(1)}{TESTING_IRAM_SIZE:#x}{match.group(3)}"
+                break
+
+    updated = '\n'.join(lines)
+
+    if updated != content:
+        with open(memory_ld, "w") as f:
+            f.write(updated)
+        print(f"ESPHome: Patched IRAM size to {TESTING_IRAM_SIZE:#x} in {memory_ld} for testing mode")
+    else:
+        print(f"ESPHome: Warning - could not patch iram0_0_seg in {memory_ld}")
+
+
+# Hook into the build process before linking
+# For ESP-IDF, we need to run this after the linker scripts are generated
+env.AddPreAction("$BUILD_DIR/${PROGNAME}.elf", patch_idf_linker_script)

esphome/components/esp32_improv/__init__.py

@@ -1,11 +1,11 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import binary_sensor, esp32_ble, output
+from esphome.components import binary_sensor, esp32_ble, improv_base, output
 from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_ON_STATE, CONF_TRIGGER_ID
 
-AUTO_LOAD = ["esp32_ble_server"]
+AUTO_LOAD = ["esp32_ble_server", "improv_base"]
 CODEOWNERS = ["@jesserockz"]
 DEPENDENCIES = ["wifi", "esp32"]
 
@@ -20,6 +20,7 @@ CONF_ON_STOP = "on_stop"
 CONF_STATUS_INDICATOR = "status_indicator"
 CONF_WIFI_TIMEOUT = "wifi_timeout"
 
+
 improv_ns = cg.esphome_ns.namespace("improv")
 Error = improv_ns.enum("Error")
 State = improv_ns.enum("State")
@@ -43,55 +44,63 @@ ESP32ImprovStoppedTrigger = esp32_improv_ns.class_(
 )
 
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(ESP32ImprovComponent),
-        cv.Required(CONF_AUTHORIZER): cv.Any(
-            cv.none, cv.use_id(binary_sensor.BinarySensor)
-        ),
-        cv.Optional(CONF_STATUS_INDICATOR): cv.use_id(output.BinaryOutput),
-        cv.Optional(
-            CONF_IDENTIFY_DURATION, default="10s"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(
-            CONF_AUTHORIZED_DURATION, default="1min"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(
-            CONF_WIFI_TIMEOUT, default="1min"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_ON_PROVISIONED): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    ESP32ImprovProvisionedTrigger
-                ),
-            }
-        ),
-        cv.Optional(CONF_ON_PROVISIONING): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    ESP32ImprovProvisioningTrigger
-                ),
-            }
-        ),
-        cv.Optional(CONF_ON_START): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ESP32ImprovStartTrigger),
-            }
-        ),
-        cv.Optional(CONF_ON_STATE): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ESP32ImprovStateTrigger),
-            }
-        ),
-        cv.Optional(CONF_ON_STOP): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    ESP32ImprovStoppedTrigger
-                ),
-            }
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ESP32ImprovComponent),
+            cv.Required(CONF_AUTHORIZER): cv.Any(
+                cv.none, cv.use_id(binary_sensor.BinarySensor)
+            ),
+            cv.Optional(CONF_STATUS_INDICATOR): cv.use_id(output.BinaryOutput),
+            cv.Optional(
+                CONF_IDENTIFY_DURATION, default="10s"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_AUTHORIZED_DURATION, default="1min"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_WIFI_TIMEOUT, default="1min"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_ON_PROVISIONED): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        ESP32ImprovProvisionedTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_PROVISIONING): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        ESP32ImprovProvisioningTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_START): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        ESP32ImprovStartTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_STATE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        ESP32ImprovStateTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_STOP): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        ESP32ImprovStoppedTrigger
+                    ),
+                }
+            ),
+        }
+    )
+    .extend(improv_base.IMPROV_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
@@ -102,7 +111,8 @@ async def to_code(config):
     await cg.register_component(var, config)
 
     cg.add_define("USE_IMPROV")
-    cg.add_library("improv/Improv", "1.2.4")
+
+    await improv_base.setup_improv_core(var, config)
 
     cg.add(var.set_identify_duration(config[CONF_IDENTIFY_DURATION]))
     cg.add(var.set_authorized_duration(config[CONF_AUTHORIZED_DURATION]))

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -1,10 +1,10 @@
 #include "esp32_improv_component.h"
 
+#include "esphome/components/bytebuffer/bytebuffer.h"
 #include "esphome/components/esp32_ble/ble.h"
 #include "esphome/components/esp32_ble_server/ble_2902.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
-#include "esphome/components/bytebuffer/bytebuffer.h"
 
 #ifdef USE_ESP32
 
@@ -384,7 +384,16 @@ void ESP32ImprovComponent::check_wifi_connection_() {
     this->connecting_sta_ = {};
     this->cancel_timeout("wifi-connect-timeout");
 
-    std::vector<std::string> urls = {ESPHOME_MY_LINK};
+    std::vector<std::string> urls;
+
+    // Add next_url if configured (should be first per Improv BLE spec)
+    std::string next_url = this->get_formatted_next_url_();
+    if (!next_url.empty()) {
+      urls.push_back(next_url);
+    }
+
+    // Add default URLs for backward compatibility
+    urls.emplace_back(ESPHOME_MY_LINK);
 #ifdef USE_WEBSERVER
     for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
       if (ip.is_ip4()) {

esphome/components/esp32_improv/esp32_improv_component.h

@@ -7,6 +7,7 @@
 
 #include "esphome/components/esp32_ble_server/ble_characteristic.h"
 #include "esphome/components/esp32_ble_server/ble_server.h"
+#include "esphome/components/improv_base/improv_base.h"
 #include "esphome/components/wifi/wifi_component.h"
 
 #ifdef USE_ESP32_IMPROV_STATE_CALLBACK
@@ -32,7 +33,7 @@ namespace esp32_improv {
 
 using namespace esp32_ble_server;
 
-class ESP32ImprovComponent : public Component {
+class ESP32ImprovComponent : public Component, public improv_base::ImprovBase {
  public:
   ESP32ImprovComponent();
   void dump_config() override;

esphome/components/fan/__init__.py

@@ -38,7 +38,6 @@ IS_PLATFORM_COMPONENT = True
 
 fan_ns = cg.esphome_ns.namespace("fan")
 Fan = fan_ns.class_("Fan", cg.EntityBase)
-FanState = fan_ns.class_("Fan", Fan, cg.Component)
 
 FanDirection = fan_ns.enum("FanDirection", is_class=True)
 FAN_DIRECTION_ENUM = {

esphome/components/fan/automation.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/core/automation.h"
-#include "fan_state.h"
+#include "esphome/core/component.h"
+#include "fan.h"
 
 namespace esphome {
 namespace fan {

esphome/components/fan/fan_state.cpp

@@ -1,16 +0,0 @@
-#include "fan_state.h"
-
-namespace esphome {
-namespace fan {
-
-static const char *const TAG = "fan";
-
-void FanState::setup() {
-  auto restore = this->restore_state_();
-  if (restore)
-    restore->to_call(*this).perform();
-}
-float FanState::get_setup_priority() const { return setup_priority::DATA - 1.0f; }
-
-}  // namespace fan
-}  // namespace esphome

esphome/components/fan/fan_state.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "fan.h"
-
-namespace esphome {
-namespace fan {
-
-enum ESPDEPRECATED("LegacyFanDirection members are deprecated, use FanDirection instead.",
-                   "2022.2") LegacyFanDirection {
-  FAN_DIRECTION_FORWARD = 0,
-  FAN_DIRECTION_REVERSE = 1
-};
-
-class ESPDEPRECATED("FanState is deprecated, use Fan instead.", "2022.2") FanState : public Fan, public Component {
- public:
-  FanState() = default;
-
-  /// Get the traits of this fan.
-  FanTraits get_traits() override { return this->traits_; }
-  /// Set the traits of this fan (i.e. what features it supports).
-  void set_traits(const FanTraits &traits) { this->traits_ = traits; }
-
-  void setup() override;
-  float get_setup_priority() const override;
-
- protected:
-  void control(const FanCall &call) override { this->publish_state(); }
-
-  FanTraits traits_{};
-};
-
-}  // namespace fan
-}  // namespace esphome

esphome/components/haier/haier_base.cpp

@@ -65,7 +65,7 @@ HaierClimateBase::HaierClimateBase()
       {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH});
   this->traits_.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH,
                                            climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_HORIZONTAL});
-  this->traits_.set_supports_current_temperature(true);
+  this->traits_.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
 }
 
 HaierClimateBase::~HaierClimateBase() {}

esphome/components/improv_base/improv_base.cpp

@@ -10,27 +10,36 @@ std::string ImprovBase::get_formatted_next_url_() {
   if (this->next_url_.empty()) {
     return "";
   }
-  std::string copy = this->next_url_;
-  // Device name
-  std::size_t pos = this->next_url_.find("{{device_name}}");
-  if (pos != std::string::npos) {
-    const std::string &device_name = App.get_name();
-    copy.replace(pos, 15, device_name);
+
+  std::string formatted_url = this->next_url_;
+
+  // Replace all occurrences of {{device_name}}
+  const std::string device_name_placeholder = "{{device_name}}";
+  const std::string &device_name = App.get_name();
+  size_t pos = 0;
+  while ((pos = formatted_url.find(device_name_placeholder, pos)) != std::string::npos) {
+    formatted_url.replace(pos, device_name_placeholder.length(), device_name);
+    pos += device_name.length();
   }
 
-  // Ip address
-  pos = this->next_url_.find("{{ip_address}}");
-  if (pos != std::string::npos) {
-    for (auto &ip : network::get_ip_addresses()) {
-      if (ip.is_ip4()) {
-        std::string ipa = ip.str();
-        copy.replace(pos, 14, ipa);
-        break;
-      }
+  // Replace all occurrences of {{ip_address}}
+  const std::string ip_address_placeholder = "{{ip_address}}";
+  std::string ip_address_str;
+  for (auto &ip : network::get_ip_addresses()) {
+    if (ip.is_ip4()) {
+      ip_address_str = ip.str();
+      break;
     }
   }
+  pos = 0;
+  while ((pos = formatted_url.find(ip_address_placeholder, pos)) != std::string::npos) {
+    formatted_url.replace(pos, ip_address_placeholder.length(), ip_address_str);
+    pos += ip_address_str.length();
+  }
 
-  return copy;
+  // Note: {{esphome_version}} is replaced at code generation time in Python
+
+  return formatted_url;
 }
 
 }  // namespace improv_base

esphome/components/midea/air_conditioner.cpp

@@ -77,7 +77,7 @@ void AirConditioner::control(const ClimateCall &call) {
 
 ClimateTraits AirConditioner::traits() {
   auto traits = ClimateTraits();
-  traits.set_supports_current_temperature(true);
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
   traits.set_visual_min_temperature(17);
   traits.set_visual_max_temperature(30);
   traits.set_visual_temperature_step(0.5);

esphome/components/mipi_rgb/models/waveshare.py

@@ -30,6 +30,19 @@ wave_4_3 = DriverChip(
         "blue": [14, 38, 18, 17, 10],
     },
 )
+
+wave_4_3.extend(
+    "WAVESHARE-5-1024X600",
+    width=1024,
+    height=600,
+    hsync_back_porch=145,
+    hsync_front_porch=170,
+    hsync_pulse_width=30,
+    vsync_back_porch=23,
+    vsync_front_porch=12,
+    vsync_pulse_width=2,
+)
+
 wave_4_3.extend(
     "ESP32-S3-TOUCH-LCD-7-800X480",
     enable_pin=[{"ch422g": None, "number": 2}, {"ch422g": None, "number": 6}],

esphome/components/mitsubishi/mitsubishi.cpp

@@ -52,8 +52,9 @@ const uint8_t MITSUBISHI_BYTE16 = 0x00;
 
 climate::ClimateTraits MitsubishiClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(this->sensor_ != nullptr);
-  traits.set_supports_action(false);
+  if (this->sensor_ != nullptr) {
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
+  }
   traits.set_visual_min_temperature(MITSUBISHI_TEMP_MIN);
   traits.set_visual_max_temperature(MITSUBISHI_TEMP_MAX);
   traits.set_visual_temperature_step(1.0f);

esphome/components/mqtt/mqtt_fan.h

@@ -5,7 +5,7 @@
 #ifdef USE_MQTT
 #ifdef USE_FAN
 
-#include "esphome/components/fan/fan_state.h"
+#include "esphome/components/fan/fan.h"
 #include "mqtt_component.h"
 
 namespace esphome {

esphome/components/mqtt/mqtt_light.cpp

@@ -69,6 +69,12 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
   if (traits.supports_color_capability(ColorCapability::BRIGHTNESS))
     root["brightness"] = true;
 
+  if (traits.supports_color_mode(ColorMode::COLOR_TEMPERATURE) ||
+      traits.supports_color_mode(ColorMode::COLD_WARM_WHITE)) {
+    root[MQTT_MIN_MIREDS] = traits.get_min_mireds();
+    root[MQTT_MAX_MIREDS] = traits.get_max_mireds();
+  }
+
   if (this->state_->supports_effects()) {
     root["effect"] = true;
     JsonArray effect_list = root[MQTT_EFFECT_LIST].to<JsonArray>();

esphome/components/pid/pid_climate.cpp

@@ -54,11 +54,10 @@ void PIDClimate::control(const climate::ClimateCall &call) {
 }
 climate::ClimateTraits PIDClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(true);
-  traits.set_supports_two_point_target_temperature(false);
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE | climate::CLIMATE_SUPPORTS_ACTION);
 
   if (this->humidity_sensor_ != nullptr)
-    traits.set_supports_current_humidity(true);
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY);
 
   traits.set_supported_modes({climate::CLIMATE_MODE_OFF});
   if (supports_cool_())
@@ -68,7 +67,6 @@ climate::ClimateTraits PIDClimate::traits() {
   if (supports_heat_() && supports_cool_())
     traits.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);
 
-  traits.set_supports_action(true);
   return traits;
 }
 void PIDClimate::dump_config() {

esphome/components/substitutions/__init__.py

@@ -6,7 +6,7 @@ import esphome.config_validation as cv
 from esphome.const import CONF_SUBSTITUTIONS, VALID_SUBSTITUTIONS_CHARACTERS
 from esphome.yaml_util import ESPHomeDataBase, ESPLiteralValue, make_data_base
 
-from .jinja import Jinja, JinjaStr, TemplateError, TemplateRuntimeError, has_jinja
+from .jinja import Jinja, JinjaError, JinjaStr, has_jinja
 
 CODEOWNERS = ["@esphome/core"]
 _LOGGER = logging.getLogger(__name__)
@@ -57,17 +57,12 @@ def _expand_jinja(value, orig_value, path, jinja, ignore_missing):
                     "->".join(str(x) for x in path),
                     err.message,
                 )
-        except (
-            TemplateError,
-            TemplateRuntimeError,
-            RuntimeError,
-            ArithmeticError,
-            AttributeError,
-            TypeError,
-        ) as err:
+        except JinjaError as err:
             raise cv.Invalid(
-                f"{type(err).__name__} Error evaluating jinja expression '{value}': {str(err)}."
-                f" See {'->'.join(str(x) for x in path)}",
+                f"{err.error_name()} Error evaluating jinja expression '{value}': {str(err.parent())}."
+                f"\nEvaluation stack: (most recent evaluation last)\n{err.stack_trace_str()}"
+                f"\nRelevant context:\n{err.context_trace_str()}"
+                f"\nSee {'->'.join(str(x) for x in path)}",
                 path,
             )
     return value

esphome/components/substitutions/jinja.py

@@ -6,6 +6,8 @@ import re
 import jinja2 as jinja
 from jinja2.sandbox import SandboxedEnvironment
 
+from esphome.yaml_util import ESPLiteralValue
+
 TemplateError = jinja.TemplateError
 TemplateSyntaxError = jinja.TemplateSyntaxError
 TemplateRuntimeError = jinja.TemplateRuntimeError
@@ -26,18 +28,20 @@ def has_jinja(st):
     return detect_jinja_re.search(st) is not None
 
 
-# SAFE_GLOBAL_FUNCTIONS defines a allowlist of built-in functions that are considered safe to expose
+# SAFE_GLOBALS defines a allowlist of built-in functions or modules that are considered safe to expose
 # in Jinja templates or other sandboxed evaluation contexts. Only functions that do not allow
 # arbitrary code execution, file access, or other security risks are included.
 #
 # The following functions are considered safe:
+#   - math: The entire math module is injected, allowing access to mathematical functions like sin, cos, sqrt, etc.
 #   - ord: Converts a character to its Unicode code point integer.
 #   - chr: Converts an integer to its corresponding Unicode character.
 #   - len: Returns the length of a sequence or collection.
 #
 # These functions were chosen because they are pure, have no side effects, and do not provide access
 # to the file system, environment, or other potentially sensitive resources.
-SAFE_GLOBAL_FUNCTIONS = {
+SAFE_GLOBALS = {
+    "math": math,  # Inject entire math module
     "ord": ord,
     "chr": chr,
     "len": len,
@@ -56,22 +60,62 @@ class JinjaStr(str):
     later in the main substitutions pass.
     """
 
+    Undefined = object()
+
     def __new__(cls, value: str, upvalues=None):
-        obj = super().__new__(cls, value)
-        obj.upvalues = upvalues or {}
+        if isinstance(value, JinjaStr):
+            base = str(value)
+            merged = {**value.upvalues, **(upvalues or {})}
+        else:
+            base = value
+            merged = dict(upvalues or {})
+        obj = super().__new__(cls, base)
+        obj.upvalues = merged
+        obj.result = JinjaStr.Undefined
         return obj
 
-    def __init__(self, value: str, upvalues=None):
-        self.upvalues = upvalues or {}
+
+class JinjaError(Exception):
+    def __init__(self, context_trace: dict, expr: str):
+        self.context_trace = context_trace
+        self.eval_stack = [expr]
+
+    def parent(self):
+        return self.__context__
+
+    def error_name(self):
+        return type(self.parent()).__name__
+
+    def context_trace_str(self):
+        return "\n".join(
+            f"  {k} = {repr(v)} ({type(v).__name__})"
+            for k, v in self.context_trace.items()
+        )
+
+    def stack_trace_str(self):
+        return "\n".join(
+            f" {len(self.eval_stack) - i}: {expr}{i == 0 and ' <-- ' + self.error_name() or ''}"
+            for i, expr in enumerate(self.eval_stack)
+        )
 
 
-class Jinja:
+class TrackerContext(jinja.runtime.Context):
+    def resolve_or_missing(self, key):
+        val = super().resolve_or_missing(key)
+        if isinstance(val, JinjaStr):
+            self.environment.context_trace[key] = val
+            val, _ = self.environment.expand(val)
+        self.environment.context_trace[key] = val
+        return val
+
+
+class Jinja(SandboxedEnvironment):
     """
     Wraps a Jinja environment
     """
 
     def __init__(self, context_vars):
-        self.env = SandboxedEnvironment(
+        super().__init__(
             trim_blocks=True,
             lstrip_blocks=True,
             block_start_string="<%",
@@ -82,13 +126,20 @@ class Jinja:
             variable_end_string="}",
             undefined=jinja.StrictUndefined,
         )
-        self.env.add_extension("jinja2.ext.do")
-        self.env.globals["math"] = math  # Inject entire math module
+        self.context_class = TrackerContext
+        self.add_extension("jinja2.ext.do")
+        self.context_trace = {}
         self.context_vars = {**context_vars}
-        self.env.globals = {
-            **self.env.globals,
+        for k, v in self.context_vars.items():
+            if isinstance(v, ESPLiteralValue):
+                continue
+            if isinstance(v, str) and not isinstance(v, JinjaStr) and has_jinja(v):
+                self.context_vars[k] = JinjaStr(v, self.context_vars)
+
+        self.globals = {
+            **self.globals,
             **self.context_vars,
-            **SAFE_GLOBAL_FUNCTIONS,
+            **SAFE_GLOBALS,
         }
 
     def safe_eval(self, expr):
@@ -110,23 +161,43 @@ class Jinja:
         result = None
         override_vars = {}
         if isinstance(content_str, JinjaStr):
+            if content_str.result is not JinjaStr.Undefined:
+                return content_str.result, None
             # If `value` is already a JinjaStr, it means we are trying to evaluate it again
             # in a parent pass.
             # Hopefully, all required variables are visible now.
             override_vars = content_str.upvalues
+
+        old_trace = self.context_trace
+        self.context_trace = {}
         try:
-            template = self.env.from_string(content_str)
+            template = self.from_string(content_str)
             result = self.safe_eval(template.render(override_vars))
             if isinstance(result, Undefined):
-                # This happens when the expression is simply an undefined variable. Jinja does not
-                # raise an exception, instead we get "Undefined".
-                # Trigger an UndefinedError exception so we skip to below.
-                print("" + result)
+                print("" + result)  # force a UndefinedError exception
         except (TemplateSyntaxError, UndefinedError) as err:
             # `content_str` contains a Jinja expression that refers to a variable that is undefined
             # in this scope. Perhaps it refers to a root substitution that is not visible yet.
-            # Therefore, return the original `content_str` as a JinjaStr, which contains the variables
+            # Therefore, return `content_str` as a JinjaStr, which contains the variables
             # that are actually visible to it at this point to postpone evaluation.
             return JinjaStr(content_str, {**self.context_vars, **override_vars}), err
+        except JinjaError as err:
+            err.context_trace = {**self.context_trace, **err.context_trace}
+            err.eval_stack.append(content_str)
+            raise err
+        except (
+            TemplateError,
+            TemplateRuntimeError,
+            RuntimeError,
+            ArithmeticError,
+            AttributeError,
+            TypeError,
+        ) as err:
+            raise JinjaError(self.context_trace, content_str) from err
+        finally:
+            self.context_trace = old_trace
+
+        if isinstance(content_str, JinjaStr):
+            content_str.result = result
 
         return result, None

esphome/components/tuya/climate/tuya_climate.cpp

@@ -283,8 +283,11 @@ void TuyaClimate::control_fan_mode_(const climate::ClimateCall &call) {
 
 climate::ClimateTraits TuyaClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_action(true);
-  traits.set_supports_current_temperature(this->current_temperature_id_.has_value());
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_ACTION);
+  if (this->current_temperature_id_.has_value()) {
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
+  }
+
   if (supports_heat_)
     traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
   if (supports_cool_)

esphome/components/uponor_smatrix/__init__.py

@@ -17,6 +17,12 @@ UponorSmatrixDevice = uponor_smatrix_ns.class_(
     "UponorSmatrixDevice", cg.Parented.template(UponorSmatrixComponent)
 )
 
+
+device_address = cv.All(
+    cv.hex_int,
+    cv.Range(min=0x1000000, max=0xFFFFFFFF, msg="Expected a 32 bit device address"),
+)
+
 CONF_UPONOR_SMATRIX_ID = "uponor_smatrix_id"
 CONF_TIME_DEVICE_ADDRESS = "time_device_address"
 
@@ -24,9 +30,12 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(UponorSmatrixComponent),
-            cv.Optional(CONF_ADDRESS): cv.hex_uint16_t,
+            cv.Optional(CONF_ADDRESS): cv.invalid(
+                f"The '{CONF_ADDRESS}' option has been removed. "
+                "Use full 32 bit addresses in the device definitions instead."
+            ),
             cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
-            cv.Optional(CONF_TIME_DEVICE_ADDRESS): cv.hex_uint16_t,
+            cv.Optional(CONF_TIME_DEVICE_ADDRESS): device_address,
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -47,7 +56,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 UPONOR_SMATRIX_DEVICE_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_UPONOR_SMATRIX_ID): cv.use_id(UponorSmatrixComponent),
-        cv.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        cv.Required(CONF_ADDRESS): device_address,
     }
 )
 
@@ -58,17 +67,15 @@ async def to_code(config):
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
 
-    if address := config.get(CONF_ADDRESS):
-        cg.add(var.set_system_address(address))
     if time_id := config.get(CONF_TIME_ID):
         time_ = await cg.get_variable(time_id)
         cg.add(var.set_time_id(time_))
-    if time_device_address := config.get(CONF_TIME_DEVICE_ADDRESS):
-        cg.add(var.set_time_device_address(time_device_address))
+        if time_device_address := config.get(CONF_TIME_DEVICE_ADDRESS):
+            cg.add(var.set_time_device_address(time_device_address))
 
 
 async def register_uponor_smatrix_device(var, config):
     parent = await cg.get_variable(config[CONF_UPONOR_SMATRIX_ID])
     cg.add(var.set_parent(parent))
-    cg.add(var.set_device_address(config[CONF_ADDRESS]))
+    cg.add(var.set_address(config[CONF_ADDRESS]))
     cg.add(parent.register_device(var))

esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "uponor_smatrix.climate";
 
 void UponorSmatrixClimate::dump_config() {
   LOG_CLIMATE("", "Uponor Smatrix Climate", this);
-  ESP_LOGCONFIG(TAG, "  Device address: 0x%04X", this->address_);
+  ESP_LOGCONFIG(TAG, "  Device address: 0x%08X", this->address_);
 }
 
 void UponorSmatrixClimate::loop() {
@@ -30,10 +30,9 @@ void UponorSmatrixClimate::loop() {
 
 climate::ClimateTraits UponorSmatrixClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(true);
-  traits.set_supports_current_humidity(true);
+  traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE | climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY |
+                           climate::CLIMATE_SUPPORTS_ACTION);
   traits.set_supported_modes({climate::CLIMATE_MODE_HEAT});
-  traits.set_supports_action(true);
   traits.set_supported_presets({climate::CLIMATE_PRESET_ECO});
   traits.set_visual_min_temperature(this->min_temperature_);
   traits.set_visual_max_temperature(this->max_temperature_);

esphome/components/uponor_smatrix/sensor/uponor_smatrix_sensor.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "uponor_smatrix.sensor";
 void UponorSmatrixSensor::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Uponor Smatrix Sensor\n"
-                "  Device address: 0x%04X",
+                "  Device address: 0x%08X",
                 this->address_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "External Temperature", this->external_temperature_sensor_);

esphome/components/uponor_smatrix/uponor_smatrix.cpp

@@ -18,11 +18,10 @@ void UponorSmatrixComponent::setup() {
 
 void UponorSmatrixComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Uponor Smatrix");
-  ESP_LOGCONFIG(TAG, "  System address: 0x%04X", this->address_);
 #ifdef USE_TIME
   if (this->time_id_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Time synchronization: YES");
-    ESP_LOGCONFIG(TAG, "  Time master device address: 0x%04X", this->time_device_address_);
+    ESP_LOGCONFIG(TAG, "  Time master device address: 0x%08X", this->time_device_address_);
   }
 #endif
 
@@ -31,7 +30,7 @@ void UponorSmatrixComponent::dump_config() {
   if (!this->unknown_devices_.empty()) {
     ESP_LOGCONFIG(TAG, "  Detected unknown device addresses:");
     for (auto device_address : this->unknown_devices_) {
-      ESP_LOGCONFIG(TAG, "    0x%04X", device_address);
+      ESP_LOGCONFIG(TAG, "    0x%08X", device_address);
     }
   }
 }
@@ -89,8 +88,7 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
     return false;
   }
 
-  uint16_t system_address = encode_uint16(packet[0], packet[1]);
-  uint16_t device_address = encode_uint16(packet[2], packet[3]);
+  uint32_t device_address = encode_uint32(packet[0], packet[1], packet[2], packet[3]);
   uint16_t crc = encode_uint16(packet[packet_len - 1], packet[packet_len - 2]);
 
   uint16_t computed_crc = crc16(packet, packet_len - 2);
@@ -99,24 +97,14 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
     return false;
   }
 
-  ESP_LOGV(TAG, "Received packet: sys=%04X, dev=%04X, data=%s, crc=%04X", system_address, device_address,
+  ESP_LOGV(TAG, "Received packet: addr=%08X, data=%s, crc=%04X", device_address,
            format_hex(&packet[4], packet_len - 6).c_str(), crc);
 
-  // Detect or check system address
-  if (this->address_ == 0) {
-    ESP_LOGI(TAG, "Using detected system address 0x%04X", system_address);
-    this->address_ = system_address;
-  } else if (this->address_ != system_address) {
-    // This should never happen except if the system address was set or detected incorrectly, so warn the user.
-    ESP_LOGW(TAG, "Received packet from unknown system address 0x%04X", system_address);
-    return true;
-  }
-
   // Handle packet
   size_t data_len = (packet_len - 6) / 3;
   if (data_len == 0) {
     if (packet[4] == UPONOR_ID_REQUEST)
-      ESP_LOGVV(TAG, "Ignoring request packet for device 0x%04X", device_address);
+      ESP_LOGVV(TAG, "Ignoring request packet for device 0x%08X", device_address);
     return true;
   }
 
@@ -141,7 +129,7 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
       if (data[i].id == UPONOR_ID_DATETIME1)
         found_time = true;
       if (found_temperature && found_time) {
-        ESP_LOGI(TAG, "Using detected time device address 0x%04X", device_address);
+        ESP_LOGI(TAG, "Using detected time device address 0x%08X", device_address);
         this->time_device_address_ = device_address;
         break;
       }
@@ -160,7 +148,7 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
 
   // Log unknown device addresses
   if (!found && !this->unknown_devices_.count(device_address)) {
-    ESP_LOGI(TAG, "Received packet for unknown device address 0x%04X ", device_address);
+    ESP_LOGI(TAG, "Received packet for unknown device address 0x%08X ", device_address);
     this->unknown_devices_.insert(device_address);
   }
 
@@ -168,16 +156,16 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
   return true;
 }
 
-bool UponorSmatrixComponent::send(uint16_t device_address, const UponorSmatrixData *data, size_t data_len) {
-  if (this->address_ == 0 || device_address == 0 || data == nullptr || data_len == 0)
+bool UponorSmatrixComponent::send(uint32_t device_address, const UponorSmatrixData *data, size_t data_len) {
+  if (device_address == 0 || data == nullptr || data_len == 0)
     return false;
 
   // Assemble packet for send queue. All fields are big-endian except for the little-endian checksum.
   std::vector<uint8_t> packet;
   packet.reserve(6 + 3 * data_len);
 
-  packet.push_back(this->address_ >> 8);
-  packet.push_back(this->address_ >> 0);
+  packet.push_back(device_address >> 24);
+  packet.push_back(device_address >> 16);
   packet.push_back(device_address >> 8);
   packet.push_back(device_address >> 0);
 

esphome/components/uponor_smatrix/uponor_smatrix.h

@@ -71,23 +71,21 @@ class UponorSmatrixComponent : public uart::UARTDevice, public Component {
   void dump_config() override;
   void loop() override;
 
-  void set_system_address(uint16_t address) { this->address_ = address; }
   void register_device(UponorSmatrixDevice *device) { this->devices_.push_back(device); }
 
-  bool send(uint16_t device_address, const UponorSmatrixData *data, size_t data_len);
+  bool send(uint32_t device_address, const UponorSmatrixData *data, size_t data_len);
 
 #ifdef USE_TIME
   void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
-  void set_time_device_address(uint16_t address) { this->time_device_address_ = address; }
+  void set_time_device_address(uint32_t address) { this->time_device_address_ = address; }
   void send_time() { this->send_time_requested_ = true; }
 #endif
 
  protected:
   bool parse_byte_(uint8_t byte);
 
-  uint16_t address_;
   std::vector<UponorSmatrixDevice *> devices_;
-  std::set<uint16_t> unknown_devices_;
+  std::set<uint32_t> unknown_devices_;
 
   std::vector<uint8_t> rx_buffer_;
   std::queue<std::vector<uint8_t>> tx_queue_;
@@ -96,7 +94,7 @@ class UponorSmatrixComponent : public uart::UARTDevice, public Component {
 
 #ifdef USE_TIME
   time::RealTimeClock *time_id_{nullptr};
-  uint16_t time_device_address_;
+  uint32_t time_device_address_;
   bool send_time_requested_;
   bool do_send_time_();
 #endif
@@ -104,7 +102,7 @@ class UponorSmatrixComponent : public uart::UARTDevice, public Component {
 
 class UponorSmatrixDevice : public Parented<UponorSmatrixComponent> {
  public:
-  void set_device_address(uint16_t address) { this->address_ = address; }
+  void set_address(uint32_t address) { this->address_ = address; }
 
   virtual void on_device_data(const UponorSmatrixData *data, size_t data_len) = 0;
   bool send(const UponorSmatrixData *data, size_t data_len) {
@@ -113,7 +111,7 @@ class UponorSmatrixDevice : public Parented<UponorSmatrixComponent> {
 
  protected:
   friend UponorSmatrixComponent;
-  uint16_t address_;
+  uint32_t address_;
 };
 
 inline float raw_to_celsius(uint16_t raw) {

esphome/components/yashima/yashima.cpp

@@ -81,7 +81,9 @@ const uint32_t YASHIMA_CARRIER_FREQUENCY = 38000;
 
 climate::ClimateTraits YashimaClimate::traits() {
   auto traits = climate::ClimateTraits();
-  traits.set_supports_current_temperature(this->sensor_ != nullptr);
+  if (this->sensor_ != nullptr) {
+    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
+  }
 
   traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL});
   if (supports_cool_)
@@ -89,7 +91,6 @@ climate::ClimateTraits YashimaClimate::traits() {
   if (supports_heat_)
     traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
 
-  traits.set_supports_two_point_target_temperature(false);
   traits.set_visual_min_temperature(YASHIMA_TEMP_MIN);
   traits.set_visual_max_temperature(YASHIMA_TEMP_MAX);
   traits.set_visual_temperature_step(1);

esphome/core/__init__.py

@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_COMMENT,
     CONF_ESPHOME,
     CONF_ETHERNET,
+    CONF_OPENTHREAD,
     CONF_PORT,
     CONF_USE_ADDRESS,
     CONF_WEB_SERVER,
@@ -641,6 +642,9 @@ class EsphomeCore:
         if CONF_ETHERNET in self.config:
             return self.config[CONF_ETHERNET][CONF_USE_ADDRESS]
 
+        if CONF_OPENTHREAD in self.config:
+            return f"{self.name}.local"
+
         return None
 
     @property

esphome/core/application.h

@@ -39,7 +39,7 @@
 #include "esphome/components/text_sensor/text_sensor.h"
 #endif
 #ifdef USE_FAN
-#include "esphome/components/fan/fan_state.h"
+#include "esphome/components/fan/fan.h"
 #endif
 #ifdef USE_CLIMATE
 #include "esphome/components/climate/climate.h"

esphome/core/config.py

@@ -318,7 +318,8 @@ def preload_core_config(config, result) -> str:
     target_platforms = []
 
     for domain in config:
-        if domain.startswith("."):
+        # Skip package keys which may contain periods (e.g., "ratgdo.esphome")
+        if "." in domain:
             continue
         if _is_target_platform(domain):
             target_platforms += [domain]

esphome/core/controller.h

@@ -5,7 +5,7 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
 #ifdef USE_FAN
-#include "esphome/components/fan/fan_state.h"
+#include "esphome/components/fan/fan.h"
 #endif
 #ifdef USE_LIGHT
 #include "esphome/components/light/light_state.h"

esphome/core/defines.h

@@ -273,6 +273,8 @@
 
 #ifdef USE_NRF52
 #define USE_NRF52_DFU
+#define USE_SOFTDEVICE_ID 7
+#define USE_SOFTDEVICE_VERSION 1
 #endif
 
 // Disabled feature flags

esphome/github_cache.py

@@ -1,362 +0,0 @@
-"""GitHub download cache for ESPHome.
-
-This module provides caching functionality for GitHub release downloads
-to avoid redundant network I/O when switching between platforms.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-from pathlib import Path
-import shutil
-import time
-import urllib.error
-import urllib.request
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class GitHubCache:
-    """Manages caching of GitHub release downloads."""
-
-    # Cache expiration time in seconds (30 days)
-    CACHE_EXPIRATION_SECONDS = 30 * 24 * 60 * 60
-
-    def __init__(self, cache_dir: Path | None = None):
-        """Initialize the cache manager.
-
-        Args:
-            cache_dir: Directory to store cached files.
-                      Defaults to ~/.esphome_cache/github
-        """
-        if cache_dir is None:
-            cache_dir = Path.home() / ".esphome_cache" / "github"
-        self.cache_dir = cache_dir
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.metadata_file = self.cache_dir / "cache_metadata.json"
-        # Prune old files on initialization
-        try:
-            self._prune_old_files()
-        except Exception as e:
-            _LOGGER.debug("Failed to prune old cache files: %s", e)
-
-    def _load_metadata(self) -> dict:
-        """Load cache metadata from disk."""
-        if self.metadata_file.exists():
-            try:
-                with open(self.metadata_file) as f:
-                    return json.load(f)
-            except (OSError, ValueError, json.JSONDecodeError):
-                return {}
-        return {}
-
-    def _save_metadata(self, metadata: dict) -> None:
-        """Save cache metadata to disk."""
-        try:
-            with open(self.metadata_file, "w") as f:
-                json.dump(metadata, f, indent=2)
-        except OSError as e:
-            _LOGGER.debug("Failed to save cache metadata: %s", e)
-
-    @staticmethod
-    def is_github_url(url: str) -> bool:
-        """Check if URL is a GitHub release download."""
-        return "github.com" in url.lower() and url.endswith(".zip")
-
-    def _get_cache_key(self, url: str) -> str:
-        """Get cache key (hash) for a URL."""
-        return hashlib.sha256(url.encode()).hexdigest()
-
-    def _get_cache_path(self, url: str) -> Path:
-        """Get cache file path for a URL."""
-        cache_key = self._get_cache_key(url)
-        ext = Path(url.split("?")[0]).suffix
-        return self.cache_dir / f"{cache_key}{ext}"
-
-    def _check_if_modified(
-        self,
-        url: str,
-        last_modified: str | None = None,
-        etag: str | None = None,
-    ) -> bool:
-        """Check if a URL has been modified using HTTP 304.
-
-        Args:
-            url: URL to check
-            last_modified: Last-Modified header from previous response
-            etag: ETag header from previous response
-
-        Returns:
-            True if modified, False if not modified (or offline/unreachable)
-        """
-        if not last_modified and not etag:
-            # No cache headers available, assume modified
-            return True
-
-        try:
-            request = urllib.request.Request(url)
-            request.get_method = lambda: "HEAD"
-
-            if last_modified:
-                request.add_header("If-Modified-Since", last_modified)
-            if etag:
-                request.add_header("If-None-Match", etag)
-
-            try:
-                urllib.request.urlopen(request, timeout=10)
-                # 200 OK = file was modified
-                return True
-            except urllib.error.HTTPError as e:
-                if e.code == 304:
-                    # Not modified
-                    _LOGGER.debug("File not modified (HTTP 304): %s", url)
-                    return False
-                # Other errors, assume modified to be safe
-                return True
-        except (OSError, urllib.error.URLError):
-            # If check fails (offline/network error), assume not modified (use cache)
-            _LOGGER.info("Cannot reach server (offline?), using cached file: %s", url)
-            return False
-
-    def get_cached_path(self, url: str, check_updates: bool = True) -> Path | None:
-        """Get path to cached file if available and valid.
-
-        Args:
-            url: URL to check
-            check_updates: Whether to check for updates using HTTP 304
-
-        Returns:
-            Path to cached file if valid, None if needs download
-        """
-        if not self.is_github_url(url):
-            return None
-
-        cache_path = self._get_cache_path(url)
-        if not cache_path.exists():
-            return None
-
-        # Load metadata
-        metadata = self._load_metadata()
-        cache_key = self._get_cache_key(url)
-
-        # Check if file should be re-downloaded
-        should_redownload = False
-        if check_updates and cache_key in metadata:
-            last_modified = metadata[cache_key].get("last_modified")
-            etag = metadata[cache_key].get("etag")
-            if self._check_if_modified(url, last_modified, etag):
-                # File was modified, need to re-download
-                _LOGGER.debug("Cached file is outdated: %s", url)
-                should_redownload = True
-
-        if should_redownload:
-            return None
-
-        # File is valid, update cached_at timestamp to keep it fresh
-        if cache_key in metadata:
-            metadata[cache_key]["cached_at"] = time.time()
-            self._save_metadata(metadata)
-
-        # Log appropriate message
-        if not check_updates:
-            _LOGGER.debug("Using cached file (no update check): %s", url)
-        elif cache_key not in metadata:
-            _LOGGER.debug("Using cached file (no metadata): %s", url)
-        else:
-            _LOGGER.debug("Using cached file: %s", url)
-
-        return cache_path
-
-    def save_to_cache(self, url: str, source_path: Path) -> None:
-        """Save a downloaded file to cache.
-
-        Args:
-            url: URL the file was downloaded from
-            source_path: Path to the downloaded file
-        """
-        if not self.is_github_url(url):
-            return
-
-        try:
-            cache_path = self._get_cache_path(url)
-            # Only copy if source and destination are different
-            if source_path.resolve() != cache_path.resolve():
-                shutil.copy2(source_path, cache_path)
-
-            # Try to get HTTP headers for caching
-            last_modified = None
-            etag = None
-            try:
-                request = urllib.request.Request(url)
-                request.get_method = lambda: "HEAD"
-                response = urllib.request.urlopen(request, timeout=10)
-                last_modified = response.headers.get("Last-Modified")
-                etag = response.headers.get("ETag")
-            except (OSError, urllib.error.URLError):
-                pass
-
-            # Update metadata
-            metadata = self._load_metadata()
-            cache_key = self._get_cache_key(url)
-
-            metadata[cache_key] = {
-                "url": url,
-                "size": cache_path.stat().st_size,
-                "cached_at": time.time(),
-                "last_modified": last_modified,
-                "etag": etag,
-            }
-            self._save_metadata(metadata)
-
-            _LOGGER.debug("Saved to cache: %s", url)
-
-        except OSError as e:
-            _LOGGER.debug("Failed to save to cache: %s", e)
-
-    def copy_from_cache(self, url: str, destination: Path) -> bool:
-        """Copy a cached file to destination.
-
-        Args:
-            url: URL of the cached file
-            destination: Where to copy the file
-
-        Returns:
-            True if successful, False otherwise
-        """
-        cached_path = self.get_cached_path(url, check_updates=True)
-        if not cached_path:
-            return False
-
-        try:
-            shutil.copy2(cached_path, destination)
-            _LOGGER.info("Using cached download for %s", url)
-            return True
-        except OSError as e:
-            _LOGGER.warning("Failed to use cache: %s", e)
-            return False
-
-    def cache_size(self) -> int:
-        """Get total size of cached files in bytes."""
-        total = 0
-        try:
-            for file_path in self.cache_dir.glob("*"):
-                if file_path.is_file() and file_path != self.metadata_file:
-                    total += file_path.stat().st_size
-        except OSError:
-            pass
-        return total
-
-    def list_cached(self) -> list[dict]:
-        """List all cached files with metadata."""
-        cached_files = []
-        metadata = self._load_metadata()
-
-        for cache_key, meta in metadata.items():
-            cache_path = (
-                self.cache_dir / f"{cache_key}{Path(meta['url'].split('?')[0]).suffix}"
-            )
-            if cache_path.exists():
-                cached_files.append(
-                    {
-                        "url": meta["url"],
-                        "path": cache_path,
-                        "size": meta["size"],
-                        "cached_at": meta.get("cached_at"),
-                        "last_modified": meta.get("last_modified"),
-                        "etag": meta.get("etag"),
-                    }
-                )
-
-        return cached_files
-
-    def clear_cache(self) -> None:
-        """Clear all cached files."""
-        try:
-            for file_path in self.cache_dir.glob("*"):
-                if file_path.is_file():
-                    file_path.unlink()
-            _LOGGER.info("Cache cleared: %s", self.cache_dir)
-        except OSError as e:
-            _LOGGER.warning("Failed to clear cache: %s", e)
-
-    def _prune_old_files(self) -> None:
-        """Remove cache files older than CACHE_EXPIRATION_SECONDS."""
-        current_time = time.time()
-        metadata = self._load_metadata()
-        removed_count = 0
-        removed_size = 0
-
-        # Check each file in metadata
-        for cache_key, meta in list(metadata.items()):
-            cached_at = meta.get("cached_at", 0)
-            age_seconds = current_time - cached_at
-
-            if age_seconds > self.CACHE_EXPIRATION_SECONDS:
-                # File is too old, remove it
-                cache_path = (
-                    self.cache_dir
-                    / f"{cache_key}{Path(meta['url'].split('?')[0]).suffix}"
-                )
-                if cache_path.exists():
-                    file_size = cache_path.stat().st_size
-                    cache_path.unlink()
-                    removed_size += file_size
-                    removed_count += 1
-                    _LOGGER.debug(
-                        "Pruned old cache file (age: %.1f days): %s",
-                        age_seconds / (24 * 60 * 60),
-                        meta["url"],
-                    )
-
-                # Remove from metadata
-                del metadata[cache_key]
-
-        # Also check for orphaned files (files without metadata)
-        for file_path in self.cache_dir.glob("*.zip"):
-            if file_path == self.metadata_file:
-                continue
-
-            # Check if file is in metadata
-            found_in_metadata = False
-            for cache_key in metadata:
-                if file_path.name.startswith(cache_key):
-                    found_in_metadata = True
-                    break
-
-            if not found_in_metadata:
-                # Orphaned file - check age by modification time
-                file_age = current_time - file_path.stat().st_mtime
-                if file_age > self.CACHE_EXPIRATION_SECONDS:
-                    file_size = file_path.stat().st_size
-                    file_path.unlink()
-                    removed_size += file_size
-                    removed_count += 1
-                    _LOGGER.debug(
-                        "Pruned orphaned cache file (age: %.1f days): %s",
-                        file_age / (24 * 60 * 60),
-                        file_path.name,
-                    )
-
-        # Save updated metadata if anything was removed
-        if removed_count > 0:
-            self._save_metadata(metadata)
-            removed_mb = removed_size / (1024 * 1024)
-            _LOGGER.info(
-                "Pruned %d old cache file(s), freed %.2f MB",
-                removed_count,
-                removed_mb,
-            )
-
-
-# Global cache instance
-_cache: GitHubCache | None = None
-
-
-def get_cache() -> GitHubCache:
-    """Get the global GitHub cache instance."""
-    global _cache  # noqa: PLW0603
-    if _cache is None:
-        _cache = GitHubCache()
-    return _cache

esphome/platformio_api.py

@@ -5,6 +5,7 @@ import os
 from pathlib import Path
 import re
 import subprocess
+from typing import Any
 
 from esphome.const import CONF_COMPILE_PROCESS_LIMIT, CONF_ESPHOME, KEY_CORE
 from esphome.core import CORE, EsphomeError
@@ -43,168 +44,32 @@ def patch_structhash():
 
 
 def patch_file_downloader():
-    """Patch PlatformIO's FileDownloader to add caching and retry on PackageException errors.
+    """Patch PlatformIO's FileDownloader to retry on PackageException errors."""
+    from platformio.package.download import FileDownloader
+    from platformio.package.exception import PackageException
 
-    This function attempts to patch PlatformIO's internal download mechanism.
-    If patching fails (due to API changes), it gracefully falls back to no caching.
-    """
-    try:
-        from platformio.package.download import FileDownloader
-        from platformio.package.exception import PackageException
-    except ImportError as e:
-        _LOGGER.debug("Could not import PlatformIO modules for patching: %s", e)
-        return
+    original_init = FileDownloader.__init__
 
-    # Import our cache module
-    from esphome.github_cache import GitHubCache
+    def patched_init(self, *args: Any, **kwargs: Any) -> None:
+        max_retries = 3
 
-    _LOGGER.debug("Applying GitHub download cache patch...")
-
-    # Verify the classes have the expected methods before patching
-    if not hasattr(FileDownloader, "__init__") or not hasattr(FileDownloader, "start"):
-        _LOGGER.warning(
-            "PlatformIO FileDownloader API has changed, skipping cache patch"
-        )
-        return
-
-    try:
-        original_init = FileDownloader.__init__
-        original_start = FileDownloader.start
-
-        # Initialize cache in .platformio directory so it benefits from GitHub Actions cache
-        platformio_dir = Path.home() / ".platformio"
-        cache_dir = platformio_dir / "esphome_download_cache"
-        cache_dir_existed = cache_dir.exists()
-        cache = GitHubCache(cache_dir=cache_dir)
-        if not cache_dir_existed:
-            _LOGGER.info("Created GitHub download cache at: %s", cache.cache_dir)
-    except Exception as e:
-        _LOGGER.warning("Failed to initialize GitHub download cache: %s", e)
-        return
-
-    def patched_init(self, *args, **kwargs):
-        """Patched init that checks cache before making HTTP connection."""
-        try:
-            # Extract URL from args (first positional argument)
-            url = args[0] if args else kwargs.get("url")
-            dest_dir = args[1] if len(args) > 1 else kwargs.get("dest_dir")
-
-            # Debug: Log all downloads
-            _LOGGER.debug("[GitHub Cache] Download request for: %s", url)
-
-            # Store URL for later use (original FileDownloader doesn't store it)
-            self._esphome_cache_url = url if cache.is_github_url(url) else None
-
-            # Check cache for GitHub URLs BEFORE making HTTP request
-            if self._esphome_cache_url:
-                _LOGGER.debug("[GitHub Cache] This is a GitHub URL, checking cache...")
-                self._esphome_use_cache = cache.get_cached_path(url, check_updates=True)
-                if self._esphome_use_cache:
-                    _LOGGER.info(
-                        "Found %s in cache, will restore instead of downloading",
-                        Path(url.split("?")[0]).name,
-                    )
-                    _LOGGER.debug(
-                        "[GitHub Cache] Found in cache: %s", self._esphome_use_cache
+        for attempt in range(max_retries):
+            try:
+                return original_init(self, *args, **kwargs)
+            except PackageException as e:
+                if attempt < max_retries - 1:
+                    _LOGGER.warning(
+                        "Package download failed: %s. Retrying... (attempt %d/%d)",
+                        str(e),
+                        attempt + 1,
+                        max_retries,
                     )
                 else:
-                    _LOGGER.debug(
-                        "[GitHub Cache] Not in cache, will download and cache"
-                    )
-            else:
-                self._esphome_use_cache = None
-                if url and str(url).startswith("http"):
-                    _LOGGER.debug("[GitHub Cache] Not a GitHub URL, skipping cache")
+                    # Final attempt - re-raise
+                    raise
+        return None
 
-            # Only make HTTP connection if we don't have cached file
-            if self._esphome_use_cache:
-                # Skip HTTP connection, we'll handle this in start()
-                # Set minimal attributes to satisfy FileDownloader
-                # Create a mock session that can be safely closed in __del__
-                class MockSession:
-                    def close(self):
-                        pass
-
-                self._http_session = MockSession()
-                self._http_response = None
-                self._fname = Path(url.split("?")[0]).name
-                self._destination = self._fname
-                if dest_dir:
-                    from os.path import join
-
-                    self._destination = join(dest_dir, self._fname)
-                # Note: Actual restoration logged in patched_start
-                return None  # Don't call original_init
-
-            # Normal initialization with retry logic
-            max_retries = 3
-            for attempt in range(max_retries):
-                try:
-                    return original_init(self, *args, **kwargs)
-                except PackageException as e:
-                    if attempt < max_retries - 1:
-                        _LOGGER.warning(
-                            "Package download failed: %s. Retrying... (attempt %d/%d)",
-                            str(e),
-                            attempt + 1,
-                            max_retries,
-                        )
-                    else:
-                        # Final attempt - re-raise
-                        raise
-            return None
-        except Exception as e:
-            # If anything goes wrong in our cache logic, fall back to normal download
-            _LOGGER.debug("Cache check failed, falling back to normal download: %s", e)
-            self._esphome_cache_url = None
-            self._esphome_use_cache = None
-            return original_init(self, *args, **kwargs)
-
-    def patched_start(self, *args, **kwargs):
-        """Patched start that uses cache when available."""
-        try:
-            import shutil
-
-            # Get the cache URL and path that were set in __init__
-            cache_url = getattr(self, "_esphome_cache_url", None)
-            cached_file = getattr(self, "_esphome_use_cache", None)
-
-            # If we're using cache, copy file instead of downloading
-            if cached_file:
-                try:
-                    shutil.copy2(cached_file, self._destination)
-                    _LOGGER.info(
-                        "Restored %s from cache (avoided download)",
-                        Path(cached_file).name,
-                    )
-                    return True
-                except OSError as e:
-                    _LOGGER.warning("Failed to copy from cache: %s", e)
-                    # Fall through to re-download
-
-            # Perform normal download
-            result = original_start(self, *args, **kwargs)
-
-            # Save to cache if it was a GitHub URL
-            if cache_url:
-                try:
-                    cache.save_to_cache(cache_url, Path(self._destination))
-                except OSError as e:
-                    _LOGGER.debug("Failed to save to cache: %s", e)
-
-            return result
-        except Exception as e:
-            # If anything goes wrong, fall back to normal download
-            _LOGGER.debug("Cache restoration failed, using normal download: %s", e)
-            return original_start(self, *args, **kwargs)
-
-    # Apply the patches
-    try:
-        FileDownloader.__init__ = patched_init
-        FileDownloader.start = patched_start
-        _LOGGER.debug("GitHub download cache patch applied successfully")
-    except Exception as e:
-        _LOGGER.warning("Failed to apply GitHub download cache patch: %s", e)
+    FileDownloader.__init__ = patched_init
 
 
 IGNORE_LIB_WARNINGS = f"(?:{'|'.join(['Hash', 'Update'])})"
@@ -222,8 +87,6 @@ FILTER_PLATFORMIO_LINES = [
     r"Memory Usage -> https://bit.ly/pio-memory-usage",
     r"Found: https://platformio.org/lib/show/.*",
     r"Using cache: .*",
-    # Don't filter our cache messages - let users see when cache is being used
-    # r"Using cached download for .*",
     r"Installing dependencies",
     r"Library Manager: Already installed, built-in library",
     r"Building in .* mode",

script/cache_platformio_downloads.py

@@ -1,164 +0,0 @@
-#!/usr/bin/env python3
-"""
-Pre-cache PlatformIO GitHub Downloads
-
-This script extracts GitHub URLs from platformio.ini and pre-caches them
-to avoid redundant downloads when switching between ESP8266 and ESP32 builds.
-
-Usage:
-    python3 script/cache_platformio_downloads.py [platformio.ini]
-"""
-
-import argparse
-import configparser
-from pathlib import Path
-import re
-import sys
-
-# Import the cache manager
-sys.path.insert(0, str(Path(__file__).parent.parent))
-from esphome.github_cache import GitHubCache
-
-
-def extract_github_urls(platformio_ini: Path) -> list[str]:
-    """Extract all GitHub URLs from platformio.ini.
-
-    Args:
-        platformio_ini: Path to platformio.ini file
-
-    Returns:
-        List of GitHub URLs found
-    """
-    config = configparser.ConfigParser(inline_comment_prefixes=(";",))
-    config.read(platformio_ini)
-
-    urls = []
-    github_pattern = re.compile(r"https://github\.com/[^\s;]+\.zip")
-
-    for section in config.sections():
-        conf = config[section]
-
-        # Check platform
-        if "platform" in conf:
-            platform_value = conf["platform"]
-            matches = github_pattern.findall(platform_value)
-            urls.extend(matches)
-
-        # Check platform_packages
-        if "platform_packages" in conf:
-            for line in conf["platform_packages"].splitlines():
-                line = line.strip()
-                if not line or line.startswith("#"):
-                    continue
-                matches = github_pattern.findall(line)
-                urls.extend(matches)
-
-    # Remove duplicates while preserving order using dict
-    return list(dict.fromkeys(urls))
-
-
-def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Pre-cache PlatformIO GitHub downloads",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-This script scans platformio.ini for GitHub URLs and pre-caches them.
-This avoids redundant downloads when switching between platforms (e.g., ESP8266 and ESP32).
-
-Examples:
-  # Cache downloads from default platformio.ini
-  %(prog)s
-
-  # Cache downloads from specific file
-  %(prog)s custom_platformio.ini
-
-  # Show what would be cached without downloading
-  %(prog)s --dry-run
-        """,
-    )
-
-    parser.add_argument(
-        "platformio_ini",
-        nargs="?",
-        default="platformio.ini",
-        help="Path to platformio.ini (default: platformio.ini)",
-    )
-
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Show what would be cached without downloading",
-    )
-
-    parser.add_argument(
-        "--cache-dir",
-        type=Path,
-        help="Cache directory (default: ~/.platformio/esphome_download_cache)",
-    )
-
-    parser.add_argument(
-        "--force",
-        action="store_true",
-        help="Force re-download even if cached",
-    )
-
-    args = parser.parse_args()
-
-    platformio_ini = Path(args.platformio_ini)
-
-    if not platformio_ini.exists():
-        print(f"Error: {platformio_ini} not found", file=sys.stderr)
-        return 1
-
-    # Extract URLs
-    print(f"Scanning {platformio_ini} for GitHub URLs...")
-    urls = extract_github_urls(platformio_ini)
-
-    if not urls:
-        print("No GitHub URLs found in platformio.ini")
-        return 0
-
-    print(f"Found {len(urls)} unique GitHub URL(s):")
-    for url in urls:
-        print(f"  - {url}")
-    print()
-
-    if args.dry_run:
-        print("Dry run - not downloading")
-        return 0
-
-    # Initialize cache (use PlatformIO directory by default)
-    cache_dir = args.cache_dir
-    if cache_dir is None:
-        cache_dir = Path.home() / ".platformio" / "esphome_download_cache"
-    cache = GitHubCache(cache_dir)
-
-    # Cache each URL
-    success_count = 0
-    for i, url in enumerate(urls, 1):
-        print(f"[{i}/{len(urls)}] Checking {url}")
-        try:
-            # Use the download_with_progress from github_download_cache CLI
-            from script.github_download_cache import download_with_progress
-
-            download_with_progress(cache, url, force=args.force, check_updates=True)
-            success_count += 1
-            print()
-        except Exception as e:
-            print(f"Error caching {url}: {e}", file=sys.stderr)
-            print()
-
-    # Show cache stats
-    total_size = cache.cache_size()
-    size_mb = total_size / (1024 * 1024)
-    print("\nCache summary:")
-    print(f"  Successfully cached: {success_count}/{len(urls)}")
-    print(f"  Total cache size: {size_mb:.2f} MB")
-    print(f"  Cache location: {cache.cache_dir}")
-
-    return 0 if success_count == len(urls) else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

script/determine-jobs.py

@@ -273,6 +273,9 @@ def detect_memory_impact_config(
     building a merged configuration with all changed components (like
     test_build_components.py does) to get comprehensive memory analysis.
 
+    For core C++ file changes without component changes, runs a fallback
+    analysis using a representative component to measure the impact.
+
     Args:
         branch: Branch to compare against
 
@@ -289,7 +292,7 @@ def detect_memory_impact_config(
 
     # Find all changed components (excluding core and base bus components)
     changed_component_set: set[str] = set()
-    has_core_changes = False
+    has_core_cpp_changes = False
 
     for file in files:
         component = get_component_from_path(file)
@@ -297,22 +300,23 @@ def detect_memory_impact_config(
             # Skip base bus components as they're used across many builds
             if component not in BASE_BUS_COMPONENTS:
                 changed_component_set.add(component)
-        elif file.startswith("esphome/"):
-            # Core ESPHome files changed (not component-specific)
-            has_core_changes = True
+        elif file.startswith("esphome/") and file.endswith(CPP_FILE_EXTENSIONS):
+            # Core ESPHome C++ files changed (not component-specific)
+            # Only C++ files affect memory usage
+            has_core_cpp_changes = True
 
-    # If no components changed but core changed, test representative component
+    # If no components changed but core C++ changed, test representative component
     force_fallback_platform = False
-    if not changed_component_set and has_core_changes:
+    if not changed_component_set and has_core_cpp_changes:
         print(
-            f"Memory impact: No components changed, but core files changed. "
+            f"Memory impact: No components changed, but core C++ files changed. "
             f"Testing {MEMORY_IMPACT_FALLBACK_COMPONENT} component on {MEMORY_IMPACT_FALLBACK_PLATFORM}.",
             file=sys.stderr,
         )
         changed_component_set.add(MEMORY_IMPACT_FALLBACK_COMPONENT)
         force_fallback_platform = True  # Use fallback platform (most representative)
     elif not changed_component_set:
-        # No components and no core changes
+        # No components and no core C++ changes
         return {"should_run": "false"}
 
     # Find components that have tests and collect their supported platforms

script/github_download_cache.py

@@ -1,195 +0,0 @@
-#!/usr/bin/env python3
-"""
-GitHub Download Cache CLI
-
-This script provides a command-line interface to the GitHub download cache.
-The actual caching logic is in esphome/github_cache.py.
-
-Usage:
-    python3 script/github_download_cache.py download URL
-    python3 script/github_download_cache.py list
-    python3 script/github_download_cache.py stats
-    python3 script/github_download_cache.py clear
-"""
-
-import argparse
-from pathlib import Path
-import sys
-import urllib.request
-
-# Add parent directory to path to import esphome modules
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from esphome.github_cache import GitHubCache
-
-
-def download_with_progress(
-    cache: GitHubCache, url: str, force: bool = False, check_updates: bool = True
-) -> Path:
-    """Download a URL with progress indicator and caching.
-
-    Args:
-        cache: GitHubCache instance
-        url: URL to download
-        force: Force re-download even if cached
-        check_updates: Check for updates using HTTP 304
-
-    Returns:
-        Path to cached file
-    """
-    # If force, skip cache check
-    if not force:
-        cached_path = cache.get_cached_path(url, check_updates=check_updates)
-        if cached_path:
-            print(f"Using cached file for {url}")
-            print(f"  Cache: {cached_path}")
-            return cached_path
-
-    # Need to download
-    print(f"Downloading {url}")
-    cache_path = cache._get_cache_path(url)
-    print(f"  Cache: {cache_path}")
-
-    # Download with progress
-    temp_path = cache_path.with_suffix(cache_path.suffix + ".tmp")
-
-    try:
-        with urllib.request.urlopen(url) as response:
-            total_size = int(response.headers.get("Content-Length", 0))
-            downloaded = 0
-
-            with open(temp_path, "wb") as f:
-                while True:
-                    chunk = response.read(8192)
-                    if not chunk:
-                        break
-                    f.write(chunk)
-                    downloaded += len(chunk)
-
-                    if total_size > 0:
-                        percent = (downloaded / total_size) * 100
-                        print(f"\r  Progress: {percent:.1f}%", end="", flush=True)
-
-            print()  # New line after progress
-
-        # Move to final location
-        temp_path.replace(cache_path)
-
-        # Let cache handle metadata
-        cache.save_to_cache(url, cache_path)
-
-        return cache_path
-
-    except (OSError, urllib.error.URLError) as e:
-        if temp_path.exists():
-            temp_path.unlink()
-        raise RuntimeError(f"Failed to download {url}: {e}") from e
-
-
-def main():
-    """CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="GitHub Download Cache Manager",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Download and cache a URL
-  %(prog)s download https://github.com/pioarduino/registry/releases/download/0.0.1/esptoolpy-v5.1.0.zip
-
-  # List cached files
-  %(prog)s list
-
-  # Show cache statistics
-  %(prog)s stats
-
-  # Clear cache
-  %(prog)s clear
-        """,
-    )
-
-    parser.add_argument(
-        "--cache-dir",
-        type=Path,
-        help="Cache directory (default: ~/.platformio/esphome_download_cache)",
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
-
-    # Download command
-    download_parser = subparsers.add_parser("download", help="Download and cache a URL")
-    download_parser.add_argument("url", help="URL to download")
-    download_parser.add_argument(
-        "--force", action="store_true", help="Force re-download even if cached"
-    )
-    download_parser.add_argument(
-        "--no-check-updates",
-        action="store_true",
-        help="Skip checking for updates (don't use HTTP 304)",
-    )
-
-    # List command
-    subparsers.add_parser("list", help="List cached files")
-
-    # Stats command
-    subparsers.add_parser("stats", help="Show cache statistics")
-
-    # Clear command
-    subparsers.add_parser("clear", help="Clear all cached files")
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        return 1
-
-    # Use PlatformIO cache directory by default
-    if args.cache_dir is None:
-        args.cache_dir = Path.home() / ".platformio" / "esphome_download_cache"
-
-    cache = GitHubCache(args.cache_dir)
-
-    if args.command == "download":
-        try:
-            check_updates = not args.no_check_updates
-            cache_path = download_with_progress(
-                cache, args.url, force=args.force, check_updates=check_updates
-            )
-            print(f"\nCached at: {cache_path}")
-            return 0
-        except Exception as e:
-            print(f"Error: {e}", file=sys.stderr)
-            return 1
-
-    elif args.command == "list":
-        cached = cache.list_cached()
-        if not cached:
-            print("No cached files")
-            return 0
-
-        print(f"Cached files ({len(cached)}):")
-        for item in cached:
-            size_mb = item["size"] / (1024 * 1024)
-            print(f"  {item['url']}")
-            print(f"    Size: {size_mb:.2f} MB")
-            print(f"    Path: {item['path']}")
-        return 0
-
-    elif args.command == "stats":
-        total_size = cache.cache_size()
-        cached_count = len(cache.list_cached())
-        size_mb = total_size / (1024 * 1024)
-
-        print(f"Cache directory: {cache.cache_dir}")
-        print(f"Cached files: {cached_count}")
-        print(f"Total size: {size_mb:.2f} MB")
-        return 0
-
-    elif args.command == "clear":
-        cache.clear_cache()
-        return 0
-
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

script/platformio_download_wrapper.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-"""
-PlatformIO Download Wrapper with Caching
-
-This script can be used as a wrapper around PlatformIO downloads to add caching.
-It intercepts download operations and uses the GitHub download cache.
-
-This is designed to be called from PlatformIO's extra_scripts if needed.
-"""
-
-from pathlib import Path
-import sys
-
-# Import the cache manager
-sys.path.insert(0, str(Path(__file__).parent))
-from github_download_cache import GitHubDownloadCache
-
-
-def is_github_url(url: str) -> bool:
-    """Check if a URL is a GitHub URL."""
-    return "github.com" in url.lower()
-
-
-def cached_download_handler(source, target, env):
-    """PlatformIO download handler that uses caching for GitHub URLs.
-
-    This function can be registered as a custom download handler in PlatformIO.
-
-    Args:
-        source: Source URL
-        target: Target file path
-        env: SCons environment
-    """
-    import shutil
-    import urllib.request
-
-    url = str(source[0])
-    target_path = Path(str(target[0]))
-
-    # Only cache GitHub URLs
-    if not is_github_url(url):
-        # Fall back to default download
-        print(f"Downloading (no cache): {url}")
-        with (
-            urllib.request.urlopen(url) as response,
-            open(target_path, "wb") as out_file,
-        ):
-            shutil.copyfileobj(response, out_file)
-        return
-
-    # Use cache for GitHub URLs
-    cache = GitHubDownloadCache()
-    print(f"Downloading with cache: {url}")
-
-    try:
-        cached_path = cache.download_with_cache(url, check_updates=True)
-
-        # Copy from cache to target
-        shutil.copy2(cached_path, target_path)
-        print(f"  Copied to: {target_path}")
-
-    except Exception as e:
-        print(f"Cache download failed, using direct download: {e}")
-        # Fall back to direct download
-        with (
-            urllib.request.urlopen(url) as response,
-            open(target_path, "wb") as out_file,
-        ):
-            shutil.copyfileobj(response, out_file)
-
-
-def setup_platformio_caching():
-    """Setup PlatformIO to use cached downloads.
-
-    This should be called from an extra_scripts file in platformio.ini.
-
-    Example extra_scripts file (e.g., platformio_hooks.py):
-        Import("env")
-        from script.platformio_download_wrapper import setup_platformio_caching
-        setup_platformio_caching()
-    """
-    try:
-        from SCons.Script import DefaultEnvironment
-
-        DefaultEnvironment()
-
-        # Register custom download handler
-        # Note: This may not work with all PlatformIO versions
-        # as the download mechanism is internal
-        print("Note: Direct download interception is not fully supported.")
-        print("Please use the cache_platformio_downloads.py script instead.")
-
-    except ImportError:
-        print("Warning: SCons not available, cannot setup download caching")
-
-
-if __name__ == "__main__":
-    # CLI mode - can be used to manually download a URL with caching
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Download a URL with caching")
-    parser.add_argument("url", help="URL to download")
-    parser.add_argument("target", help="Target file path")
-    parser.add_argument("--cache-dir", type=Path, help="Cache directory")
-
-    args = parser.parse_args()
-
-    cache = GitHubDownloadCache(args.cache_dir)
-    target_path = Path(args.target)
-
-    try:
-        if is_github_url(args.url):
-            print(f"Downloading with cache: {args.url}")
-            cached_path = cache.download_with_cache(args.url)
-
-            # Copy to target
-            import shutil
-
-            target_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(cached_path, target_path)
-            print(f"Copied to: {target_path}")
-        else:
-            print(f"Downloading directly (not a GitHub URL): {args.url}")
-            import shutil
-            import urllib.request
-
-            target_path.parent.mkdir(parents=True, exist_ok=True)
-            with (
-                urllib.request.urlopen(args.url) as response,
-                open(target_path, "wb") as out_file,
-            ):
-                shutil.copyfileobj(response, out_file)
-
-        sys.exit(0)
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)

tests/components/climate/common.yaml

@@ -0,0 +1,31 @@
+switch:
+  - platform: template
+    id: climate_heater_switch
+    optimistic: true
+  - platform: template
+    id: climate_cooler_switch
+    optimistic: true
+
+sensor:
+  - platform: template
+    id: climate_temperature_sensor
+    lambda: |-
+      return 21.5;
+    update_interval: 60s
+
+climate:
+  - platform: bang_bang
+    id: climate_test_climate
+    name: Test Climate
+    sensor: climate_temperature_sensor
+    default_target_temperature_low: 18°C
+    default_target_temperature_high: 24°C
+    idle_action:
+      - switch.turn_off: climate_heater_switch
+      - switch.turn_off: climate_cooler_switch
+    cool_action:
+      - switch.turn_on: climate_cooler_switch
+      - switch.turn_off: climate_heater_switch
+    heat_action:
+      - switch.turn_on: climate_heater_switch
+      - switch.turn_off: climate_cooler_switch

tests/components/climate/test.esp8266-ard.yaml

@@ -0,0 +1 @@
+<<: !include common.yaml

tests/components/esp32_improv/common.yaml

@@ -16,3 +16,4 @@ esp32_improv:
   authorizer: io0_button
   authorized_duration: 1min
   status_indicator: built_in_led
+  next_url: "https://example.com/setup?device={{device_name}}&ip={{ip_address}}&version={{esphome_version}}"

tests/components/uponor_smatrix/common.yaml

@@ -11,18 +11,17 @@ time:
       - 192.168.178.1
 
 uponor_smatrix:
-  address: 0x110B
   time_id: sntp_time
-  time_device_address: 0xDE13
+  time_device_address: 0x110BDE13
 
 climate:
   - platform: uponor_smatrix
-    address: 0xDE13
+    address: 0x110BDE13
     name: Thermostat Living Room
 
 sensor:
   - platform: uponor_smatrix
-    address: 0xDE13
+    address: 0x110BDE13
     humidity:
       name: Thermostat Humidity Living Room
     temperature:

tests/integration/test_oversized_payloads.py

@@ -281,8 +281,12 @@ async def test_noise_corrupt_encrypted_frame(
         # Check for signs that the process exited/crashed
         if "Segmentation fault" in line or "core dumped" in line:
             process_exited = True
-        # Check for the expected warning about decryption failure
+        # Check for the expected log about decryption failure
+        # This can appear as either a VV-level log from noise or a W-level log from connection
         if (
+            "[VV][api.noise" in line
+            and "noise_cipherstate_decrypt failed: MAC_FAILURE" in line
+        ) or (
             "[W][api.connection" in line
             and "Reading failed CIPHERSTATE_DECRYPT_FAILED" in line
         ):
@@ -322,9 +326,9 @@ async def test_noise_corrupt_encrypted_frame(
         assert not process_exited, (
             "ESPHome process should not crash on corrupt encrypted frames"
         )
-        # Verify we saw the expected warning message
+        # Verify we saw the expected log message about decryption failure
         assert cipherstate_failed, (
-            "Expected to see warning about CIPHERSTATE_DECRYPT_FAILED"
+            "Expected to see log about noise_cipherstate_decrypt failure or CIPHERSTATE_DECRYPT_FAILED"
         )
 
         # Verify we can still reconnect after handling the corrupt frame

tests/script/test_determine_jobs.py

@@ -545,7 +545,7 @@ def test_detect_memory_impact_config_with_common_platform(tmp_path: Path) -> Non
 
 
 def test_detect_memory_impact_config_core_only_changes(tmp_path: Path) -> None:
-    """Test memory impact detection with core-only changes (no component changes)."""
+    """Test memory impact detection with core C++ changes (no component changes)."""
     # Create test directory structure with fallback component
     tests_dir = tmp_path / "tests" / "components"
 
@@ -554,7 +554,7 @@ def test_detect_memory_impact_config_core_only_changes(tmp_path: Path) -> None:
     api_dir.mkdir(parents=True)
     (api_dir / "test.esp32-idf.yaml").write_text("test: api")
 
-    # Mock changed_files to return only core files (no component files)
+    # Mock changed_files to return only core C++ files (no component files)
     with (
         patch.object(determine_jobs, "root_path", str(tmp_path)),
         patch.object(helpers, "root_path", str(tmp_path)),
@@ -574,6 +574,35 @@ def test_detect_memory_impact_config_core_only_changes(tmp_path: Path) -> None:
     assert result["use_merged_config"] == "true"
 
 
+def test_detect_memory_impact_config_core_python_only_changes(tmp_path: Path) -> None:
+    """Test that Python-only core changes don't trigger memory impact analysis."""
+    # Create test directory structure with fallback component
+    tests_dir = tmp_path / "tests" / "components"
+
+    # api component (fallback component) with esp32-idf test
+    api_dir = tests_dir / "api"
+    api_dir.mkdir(parents=True)
+    (api_dir / "test.esp32-idf.yaml").write_text("test: api")
+
+    # Mock changed_files to return only core Python files (no C++ files)
+    with (
+        patch.object(determine_jobs, "root_path", str(tmp_path)),
+        patch.object(helpers, "root_path", str(tmp_path)),
+        patch.object(determine_jobs, "changed_files") as mock_changed_files,
+    ):
+        mock_changed_files.return_value = [
+            "esphome/__main__.py",
+            "esphome/config.py",
+            "esphome/core/config.py",
+        ]
+        determine_jobs._component_has_tests.cache_clear()
+
+        result = determine_jobs.detect_memory_impact_config()
+
+    # Python-only changes should NOT trigger memory impact analysis
+    assert result["should_run"] == "false"
+
+
 def test_detect_memory_impact_config_no_common_platform(tmp_path: Path) -> None:
     """Test memory impact detection when components have no common platform."""
     # Create test directory structure

tests/unit_tests/core/test_config.py

@@ -476,6 +476,55 @@ def test_preload_core_config_multiple_platforms(setup_core: Path) -> None:
             preload_core_config(config, result)
 
 
+def test_preload_core_config_skips_package_keys_with_periods(setup_core: Path) -> None:
+    """Test preload_core_config skips package keys containing periods.
+
+    Package keys can contain periods (e.g., "ratgdo.esphome") and should be
+    skipped when searching for target platforms to avoid triggering the
+    assertion in get_component() that component names cannot contain periods.
+
+    Regression test for: https://github.com/esphome/esphome/issues/11182
+    """
+    config = {
+        CONF_ESPHOME: {
+            CONF_NAME: "test_device",
+        },
+        "esp32": {},
+        # Package key with period should be ignored
+        "ratgdo.esphome": "github://ratgdo/esphome-ratgdo/v32disco_secplusv1.yaml",
+    }
+    result = {}
+
+    # Should not raise AssertionError from get_component()
+    platform = preload_core_config(config, result)
+
+    assert platform == "esp32"
+    assert CORE.name == "test_device"
+
+
+def test_preload_core_config_skips_keys_starting_with_period(setup_core: Path) -> None:
+    """Test preload_core_config skips keys starting with period.
+
+    Keys starting with "." are special ESPHome internal keys and should be
+    skipped when searching for target platforms.
+    """
+    config = {
+        CONF_ESPHOME: {
+            CONF_NAME: "test_device",
+        },
+        "esp8266": {},
+        # Internal key starting with period should be ignored
+        ".platformio_options": {"board_build.flash_mode": "dout"},
+    }
+    result = {}
+
+    # Should not raise any errors
+    platform = preload_core_config(config, result)
+
+    assert platform == "esp8266"
+    assert CORE.name == "test_device"
+
+
 def test_include_file_header(tmp_path: Path, mock_copy_file_if_changed: Mock) -> None:
     """Test include_file adds include statement for header files."""
     src_file = tmp_path / "source.h"

tests/unit_tests/fixtures/substitutions/02-expressions.approved.yaml

@@ -8,6 +8,7 @@ substitutions:
   area: 25
   numberOne: 1
   var1: 79
+  double_width: 14
 test_list:
   - The area is 56
   - 56
@@ -25,3 +26,4 @@ test_list:
   - ord("a") = 97
   - chr(97) = a
   - len([1,2,3]) = 3
+  - width = 7, double_width = 14

tests/unit_tests/fixtures/substitutions/02-expressions.input.yaml

@@ -8,6 +8,7 @@ substitutions:
   area: 25
   numberOne: 1
   var1: 79
+  double_width: ${width * 2}
 
 test_list:
   - "The area is ${width * height}"
@@ -23,3 +24,4 @@ test_list:
   - ord("a") = ${ ord("a") }
   - chr(97) = ${ chr(97) }
   - len([1,2,3]) = ${ len([1,2,3]) }
+  - width = ${width}, double_width = ${double_width}

tests/unit_tests/test_core.py

@@ -570,6 +570,13 @@ class TestEsphomeCore:
 
         assert target.address == "4.3.2.1"
 
+    def test_address__openthread(self, target):
+        target.name = "test-device"
+        target.config = {}
+        target.config[const.CONF_OPENTHREAD] = {}
+
+        assert target.address == "test-device.local"
+
     def test_is_esp32(self, target):
         target.data[const.KEY_CORE] = {const.KEY_TARGET_PLATFORM: "esp32"}
 

tests/unit_tests/test_main.py

@@ -17,10 +17,12 @@ from esphome import platformio_api
 from esphome.__main__ import (
     Purpose,
     choose_upload_log_host,
+    command_analyze_memory,
     command_clean_all,
     command_rename,
     command_update_all,
     command_wizard,
+    detect_external_components,
     get_port_type,
     has_ip_address,
     has_mqtt,
@@ -226,13 +228,47 @@ def mock_run_external_process() -> Generator[Mock]:
 
 
 @pytest.fixture
-def mock_run_external_command() -> Generator[Mock]:
-    """Mock run_external_command for testing."""
+def mock_run_external_command_main() -> Generator[Mock]:
+    """Mock run_external_command in __main__ module (different from platformio_api)."""
     with patch("esphome.__main__.run_external_command") as mock:
         mock.return_value = 0  # Default to success
         yield mock
 
 
+@pytest.fixture
+def mock_write_cpp() -> Generator[Mock]:
+    """Mock write_cpp for testing."""
+    with patch("esphome.__main__.write_cpp") as mock:
+        mock.return_value = 0  # Default to success
+        yield mock
+
+
+@pytest.fixture
+def mock_compile_program() -> Generator[Mock]:
+    """Mock compile_program for testing."""
+    with patch("esphome.__main__.compile_program") as mock:
+        mock.return_value = 0  # Default to success
+        yield mock
+
+
+@pytest.fixture
+def mock_get_esphome_components() -> Generator[Mock]:
+    """Mock get_esphome_components for testing."""
+    with patch("esphome.analyze_memory.helpers.get_esphome_components") as mock:
+        mock.return_value = {"logger", "api", "ota"}
+        yield mock
+
+
+@pytest.fixture
+def mock_memory_analyzer_cli() -> Generator[Mock]:
+    """Mock MemoryAnalyzerCLI for testing."""
+    with patch("esphome.analyze_memory.cli.MemoryAnalyzerCLI") as mock_class:
+        mock_analyzer = MagicMock()
+        mock_analyzer.generate_report.return_value = "Mock Memory Report"
+        mock_class.return_value = mock_analyzer
+        yield mock_class
+
+
 def test_choose_upload_log_host_with_string_default() -> None:
     """Test with a single string default device."""
     setup_core()
@@ -839,7 +875,7 @@ def test_upload_program_serial_esp8266_with_file(
 
 def test_upload_using_esptool_path_conversion(
     tmp_path: Path,
-    mock_run_external_command: Mock,
+    mock_run_external_command_main: Mock,
     mock_get_idedata: Mock,
 ) -> None:
     """Test upload_using_esptool properly converts Path objects to strings for esptool.
@@ -875,10 +911,10 @@ def test_upload_using_esptool_path_conversion(
     assert result == 0
 
     # Verify that run_external_command was called
-    assert mock_run_external_command.call_count == 1
+    assert mock_run_external_command_main.call_count == 1
 
     # Get the actual call arguments
-    call_args = mock_run_external_command.call_args[0]
+    call_args = mock_run_external_command_main.call_args[0]
 
     # The first argument should be esptool.main function,
     # followed by the command arguments
@@ -917,7 +953,7 @@ def test_upload_using_esptool_path_conversion(
 
 def test_upload_using_esptool_with_file_path(
     tmp_path: Path,
-    mock_run_external_command: Mock,
+    mock_run_external_command_main: Mock,
 ) -> None:
     """Test upload_using_esptool with a custom file that's a Path object."""
     setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test")
@@ -934,10 +970,10 @@ def test_upload_using_esptool_with_file_path(
     assert result == 0
 
     # Verify that run_external_command was called
-    mock_run_external_command.assert_called_once()
+    mock_run_external_command_main.assert_called_once()
 
     # Get the actual call arguments
-    call_args = mock_run_external_command.call_args[0]
+    call_args = mock_run_external_command_main.call_args[0]
     cmd_list = list(call_args[1:])  # Skip the esptool.main function
 
     # Find the firmware path in the command
@@ -2273,3 +2309,226 @@ def test_show_logs_api_mqtt_timeout_fallback(
 
     # Verify run_logs was called with only the static IP (MQTT failed)
     mock_run_logs.assert_called_once_with(CORE.config, ["192.168.1.100"])
+
+
+def test_detect_external_components_no_external(
+    mock_get_esphome_components: Mock,
+) -> None:
+    """Test detect_external_components with no external components."""
+    config = {
+        CONF_ESPHOME: {CONF_NAME: "test_device"},
+        "logger": {},
+        "api": {},
+    }
+
+    result = detect_external_components(config)
+
+    assert result == set()
+    mock_get_esphome_components.assert_called_once()
+
+
+def test_detect_external_components_with_external(
+    mock_get_esphome_components: Mock,
+) -> None:
+    """Test detect_external_components detects external components."""
+    config = {
+        CONF_ESPHOME: {CONF_NAME: "test_device"},
+        "logger": {},  # Built-in
+        "api": {},  # Built-in
+        "my_custom_sensor": {},  # External
+        "another_custom": {},  # External
+        "external_components": [],  # Special key, not a component
+        "substitutions": {},  # Special key, not a component
+    }
+
+    result = detect_external_components(config)
+
+    assert result == {"my_custom_sensor", "another_custom"}
+    mock_get_esphome_components.assert_called_once()
+
+
+def test_detect_external_components_filters_special_keys(
+    mock_get_esphome_components: Mock,
+) -> None:
+    """Test detect_external_components filters out special config keys."""
+    config = {
+        CONF_ESPHOME: {CONF_NAME: "test_device"},
+        "substitutions": {"key": "value"},
+        "packages": {},
+        "globals": [],
+        "external_components": [],
+        "<<": {},  # YAML merge key
+    }
+
+    result = detect_external_components(config)
+
+    assert result == set()
+    mock_get_esphome_components.assert_called_once()
+
+
+def test_command_analyze_memory_success(
+    tmp_path: Path,
+    capfd: CaptureFixture[str],
+    mock_write_cpp: Mock,
+    mock_compile_program: Mock,
+    mock_get_idedata: Mock,
+    mock_get_esphome_components: Mock,
+    mock_memory_analyzer_cli: Mock,
+) -> None:
+    """Test command_analyze_memory with successful compilation and analysis."""
+    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
+
+    # Create firmware.elf file
+    firmware_path = (
+        tmp_path / ".esphome" / "build" / "test_device" / ".pioenvs" / "test_device"
+    )
+    firmware_path.mkdir(parents=True, exist_ok=True)
+    firmware_elf = firmware_path / "firmware.elf"
+    firmware_elf.write_text("mock elf file")
+
+    # Mock idedata
+    mock_idedata_obj = MagicMock(spec=platformio_api.IDEData)
+    mock_idedata_obj.firmware_elf_path = str(firmware_elf)
+    mock_idedata_obj.objdump_path = "/path/to/objdump"
+    mock_idedata_obj.readelf_path = "/path/to/readelf"
+    mock_get_idedata.return_value = mock_idedata_obj
+
+    config = {
+        CONF_ESPHOME: {CONF_NAME: "test_device"},
+        "logger": {},
+    }
+
+    args = MockArgs()
+
+    result = command_analyze_memory(args, config)
+
+    assert result == 0
+
+    # Verify compilation was done
+    mock_write_cpp.assert_called_once_with(config)
+    mock_compile_program.assert_called_once_with(args, config)
+
+    # Verify analyzer was created with correct parameters
+    mock_memory_analyzer_cli.assert_called_once_with(
+        str(firmware_elf),
+        "/path/to/objdump",
+        "/path/to/readelf",
+        set(),  # No external components
+    )
+
+    # Verify analysis was run
+    mock_analyzer = mock_memory_analyzer_cli.return_value
+    mock_analyzer.analyze.assert_called_once()
+    mock_analyzer.generate_report.assert_called_once()
+
+    # Verify report was printed
+    captured = capfd.readouterr()
+    assert "Mock Memory Report" in captured.out
+
+
+def test_command_analyze_memory_with_external_components(
+    tmp_path: Path,
+    mock_write_cpp: Mock,
+    mock_compile_program: Mock,
+    mock_get_idedata: Mock,
+    mock_get_esphome_components: Mock,
+    mock_memory_analyzer_cli: Mock,
+) -> None:
+    """Test command_analyze_memory detects external components."""
+    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
+
+    # Create firmware.elf file
+    firmware_path = (
+        tmp_path / ".esphome" / "build" / "test_device" / ".pioenvs" / "test_device"
+    )
+    firmware_path.mkdir(parents=True, exist_ok=True)
+    firmware_elf = firmware_path / "firmware.elf"
+    firmware_elf.write_text("mock elf file")
+
+    # Mock idedata
+    mock_idedata_obj = MagicMock(spec=platformio_api.IDEData)
+    mock_idedata_obj.firmware_elf_path = str(firmware_elf)
+    mock_idedata_obj.objdump_path = "/path/to/objdump"
+    mock_idedata_obj.readelf_path = "/path/to/readelf"
+    mock_get_idedata.return_value = mock_idedata_obj
+
+    config = {
+        CONF_ESPHOME: {CONF_NAME: "test_device"},
+        "logger": {},
+        "my_custom_component": {"param": "value"},  # External component
+        "external_components": [{"source": "github://user/repo"}],  # Not a component
+    }
+
+    args = MockArgs()
+
+    result = command_analyze_memory(args, config)
+
+    assert result == 0
+
+    # Verify analyzer was created with external components detected
+    mock_memory_analyzer_cli.assert_called_once_with(
+        str(firmware_elf),
+        "/path/to/objdump",
+        "/path/to/readelf",
+        {"my_custom_component"},  # External component detected
+    )
+
+
+def test_command_analyze_memory_write_cpp_fails(
+    tmp_path: Path,
+    mock_write_cpp: Mock,
+) -> None:
+    """Test command_analyze_memory when write_cpp fails."""
+    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
+
+    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
+    args = MockArgs()
+
+    mock_write_cpp.return_value = 1  # Failure
+
+    result = command_analyze_memory(args, config)
+
+    assert result == 1
+    mock_write_cpp.assert_called_once_with(config)
+
+
+def test_command_analyze_memory_compile_fails(
+    tmp_path: Path,
+    mock_write_cpp: Mock,
+    mock_compile_program: Mock,
+) -> None:
+    """Test command_analyze_memory when compilation fails."""
+    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
+
+    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
+    args = MockArgs()
+
+    mock_compile_program.return_value = 1  # Compilation failed
+
+    result = command_analyze_memory(args, config)
+
+    assert result == 1
+    mock_write_cpp.assert_called_once_with(config)
+    mock_compile_program.assert_called_once_with(args, config)
+
+
+def test_command_analyze_memory_no_idedata(
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+    mock_write_cpp: Mock,
+    mock_compile_program: Mock,
+    mock_get_idedata: Mock,
+) -> None:
+    """Test command_analyze_memory when idedata cannot be retrieved."""
+    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
+
+    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
+    args = MockArgs()
+
+    mock_get_idedata.return_value = None  # Failed to get idedata
+
+    with caplog.at_level(logging.ERROR):
+        result = command_analyze_memory(args, config)
+
+    assert result == 1
+    assert "Failed to get IDE data for memory analysis" in caplog.text