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

esphome/components/ble_client/automation.h

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

esphome/components/ble_client/sensor/ble_sensor.cpp

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

esphome/components/ble_client/sensor/ble_sensor.h

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

esphome/components/esp32_ble_server/__init__.py

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

esphome/components/esp32_ble_server/ble_characteristic.cpp

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

esphome/components/esp32_ble_server/ble_characteristic.h

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

esphome/components/esp32_ble_server/ble_descriptor.cpp

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

esphome/components/esp32_ble_server/ble_descriptor.h

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

esphome/components/esp32_improv/esp32_improv_component.cpp

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

esphome/components/esp32_improv/esp32_improv_component.h

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

esphome/components/http_request/http_request.h

@@ -124,7 +124,7 @@ class HttpRequestComponent : public Component {
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 
   void set_useragent(const char *useragent) { this->useragent_ = useragent; }
-  void set_timeout(uint32_t timeout) { this->timeout_ = timeout; }
+  void set_timeout(uint16_t timeout) { this->timeout_ = timeout; }
   void set_watchdog_timeout(uint32_t watchdog_timeout) { this->watchdog_timeout_ = watchdog_timeout; }
   uint32_t get_watchdog_timeout() const { return this->watchdog_timeout_; }
   void set_follow_redirects(bool follow_redirects) { this->follow_redirects_ = follow_redirects; }
@@ -173,7 +173,7 @@ class HttpRequestComponent : public Component {
   const char *useragent_{nullptr};
   bool follow_redirects_{};
   uint16_t redirect_limit_{};
-  uint32_t timeout_{4500};
+  uint16_t timeout_{4500};
   uint32_t watchdog_timeout_{0};
 };
 

esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h

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

esphome/components/modbus_controller/number/modbus_number.h

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

esphome/components/modbus_controller/output/modbus_output.h

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

esphome/components/modbus_controller/select/modbus_select.h

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

esphome/components/modbus_controller/sensor/modbus_sensor.h

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

esphome/components/modbus_controller/switch/modbus_switch.h

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

esphome/components/modbus_controller/text_sensor/modbus_textsensor.h

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

esphome/components/remote_base/__init__.py

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

esphome/components/remote_base/dyson_protocol.cpp

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

esphome/components/remote_base/dyson_protocol.h

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

esphome/components/wifi/__init__.py

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

esphome/components/wifi/wifi_component.cpp

@@ -888,19 +888,68 @@ void WiFiComponent::save_fast_connect_settings_() {
 }
 #endif
 
-void WiFiAP::set_ssid(const std::string &ssid) { this->ssid_ = ssid; }
+void WiFiAP::set_ssid(const std::string &ssid) {
+  this->ssid_storage_ = ssid;
+  this->ssid_ = this->ssid_storage_->c_str();
+}
 void WiFiAP::set_bssid(bssid_t bssid) { this->bssid_ = bssid; }
 void WiFiAP::set_bssid(optional<bssid_t> bssid) { this->bssid_ = bssid; }
-void WiFiAP::set_password(const std::string &password) { this->password_ = password; }
+void WiFiAP::set_password(const std::string &password) {
+  this->password_storage_ = password;
+  this->password_ = this->password_storage_->c_str();
+}
+#ifdef USE_ESP8266
+void WiFiAP::set_ssid_flash(const uint8_t *ssid) {
+  this->ssid_storage_.reset();
+  this->ssid_ = reinterpret_cast<const char *>(ssid);
+}
+void WiFiAP::set_password_flash(const uint8_t *password) {
+  this->password_storage_.reset();
+  this->password_ = reinterpret_cast<const char *>(password);
+}
+#else
+void WiFiAP::set_ssid_flash(const char *ssid) {
+  this->ssid_storage_.reset();
+  this->ssid_ = ssid;
+}
+void WiFiAP::set_password_flash(const char *password) {
+  this->password_storage_.reset();
+  this->password_ = password;
+}
+#endif
 #ifdef USE_WIFI_WPA2_EAP
 void WiFiAP::set_eap(optional<EAPAuth> eap_auth) { this->eap_ = std::move(eap_auth); }
 #endif
 void WiFiAP::set_channel(optional<uint8_t> channel) { this->channel_ = channel; }
 void WiFiAP::set_manual_ip(optional<ManualIP> manual_ip) { this->manual_ip_ = manual_ip; }
 void WiFiAP::set_hidden(bool hidden) { this->hidden_ = hidden; }
-const std::string &WiFiAP::get_ssid() const { return this->ssid_; }
+std::string WiFiAP::get_ssid() const {
+#ifdef USE_ESP8266
+  if (!this->ssid_storage_.has_value()) {
+    // Flash storage - read from PROGMEM
+    size_t len = strlen_P(this->ssid_);
+    std::string result;
+    result.resize(len);
+    memcpy_P(&result[0], this->ssid_, len);
+    return result;
+  }
+#endif
+  return std::string(this->ssid_);
+}
 const optional<bssid_t> &WiFiAP::get_bssid() const { return this->bssid_; }
-const std::string &WiFiAP::get_password() const { return this->password_; }
+std::string WiFiAP::get_password() const {
+#ifdef USE_ESP8266
+  if (!this->password_storage_.has_value()) {
+    // Flash storage - read from PROGMEM
+    size_t len = strlen_P(this->password_);
+    std::string result;
+    result.resize(len);
+    memcpy_P(&result[0], this->password_, len);
+    return result;
+  }
+#endif
+  return std::string(this->password_);
+}
 #ifdef USE_WIFI_WPA2_EAP
 const optional<EAPAuth> &WiFiAP::get_eap() const { return this->eap_; }
 #endif

esphome/components/wifi/wifi_component.h

@@ -135,6 +135,18 @@ class WiFiAP {
   void set_bssid(bssid_t bssid);
   void set_bssid(optional<bssid_t> bssid);
   void set_password(const std::string &password);
+  /// Set SSID from flash string (PROGMEM on ESP8266, rodata on ESP32)
+#ifdef USE_ESP8266
+  void set_ssid_flash(const uint8_t *ssid);
+#else
+  void set_ssid_flash(const char *ssid);
+#endif
+  /// Set password from flash string (PROGMEM on ESP8266, rodata on ESP32)
+#ifdef USE_ESP8266
+  void set_password_flash(const uint8_t *password);
+#else
+  void set_password_flash(const char *password);
+#endif
 #ifdef USE_WIFI_WPA2_EAP
   void set_eap(optional<EAPAuth> eap_auth);
 #endif  // USE_WIFI_WPA2_EAP
@@ -142,9 +154,9 @@ class WiFiAP {
   void set_priority(float priority) { priority_ = priority; }
   void set_manual_ip(optional<ManualIP> manual_ip);
   void set_hidden(bool hidden);
-  const std::string &get_ssid() const;
+  std::string get_ssid() const;
   const optional<bssid_t> &get_bssid() const;
-  const std::string &get_password() const;
+  std::string get_password() const;
 #ifdef USE_WIFI_WPA2_EAP
   const optional<EAPAuth> &get_eap() const;
 #endif  // USE_WIFI_WPA2_EAP
@@ -154,8 +166,10 @@ class WiFiAP {
   bool get_hidden() const;
 
  protected:
-  std::string ssid_;
-  std::string password_;
+  const char *ssid_{nullptr};
+  const char *password_{nullptr};
+  optional<std::string> ssid_storage_;
+  optional<std::string> password_storage_;
   optional<bssid_t> bssid_;
 #ifdef USE_WIFI_WPA2_EAP
   optional<EAPAuth> eap_;

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -236,16 +236,25 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
 
   struct station_config conf {};
   memset(&conf, 0, sizeof(conf));
-  if (ap.get_ssid().size() > sizeof(conf.ssid)) {
+
+  std::string ssid = ap.get_ssid();
+  std::string password = ap.get_password();
+
+  size_t ssid_len = ssid.length();
+  size_t password_len = password.length();
+
+  if (ssid_len > sizeof(conf.ssid)) {
     ESP_LOGE(TAG, "SSID too long");
     return false;
   }
-  if (ap.get_password().size() > sizeof(conf.password)) {
+
+  if (password_len > sizeof(conf.password)) {
     ESP_LOGE(TAG, "Password too long");
     return false;
   }
-  memcpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), ap.get_ssid().size());
-  memcpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), ap.get_password().size());
+
+  memcpy(conf.ssid, ssid.c_str(), ssid_len);
+  memcpy(conf.password, password.c_str(), password_len);
 
   if (ap.get_bssid().has_value()) {
     conf.bssid_set = 1;
@@ -791,27 +800,35 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     return false;
 
   struct softap_config conf {};
-  if (ap.get_ssid().size() > sizeof(conf.ssid)) {
+
+  std::string ssid = ap.get_ssid();
+  std::string password = ap.get_password();
+
+  size_t ssid_len = ssid.length();
+  size_t password_len = password.length();
+
+  if (ssid_len > sizeof(conf.ssid)) {
     ESP_LOGE(TAG, "AP SSID too long");
     return false;
   }
-  memcpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), ap.get_ssid().size());
-  conf.ssid_len = static_cast<uint8>(ap.get_ssid().size());
+
+  memcpy(conf.ssid, ssid.c_str(), ssid_len);
+  conf.ssid_len = static_cast<uint8>(ssid_len);
   conf.channel = ap.get_channel().value_or(1);
   conf.ssid_hidden = ap.get_hidden();
   conf.max_connection = 5;
   conf.beacon_interval = 100;
 
-  if (ap.get_password().empty()) {
+  if (password_len == 0) {
     conf.authmode = AUTH_OPEN;
     *conf.password = 0;
   } else {
     conf.authmode = AUTH_WPA2_PSK;
-    if (ap.get_password().size() > sizeof(conf.password)) {
+    if (password_len > sizeof(conf.password)) {
       ESP_LOGE(TAG, "AP password too long");
       return false;
     }
-    memcpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), ap.get_password().size());
+    memcpy(conf.password, password.c_str(), password_len);
   }
 
   ETS_UART_INTR_DISABLE();

script/determine-jobs.py

@@ -48,6 +48,7 @@ import sys
 from typing import Any
 
 from helpers import (
+    BASE_BUS_COMPONENTS,
     CPP_FILE_EXTENSIONS,
     PYTHON_FILE_EXTENSIONS,
     changed_files,
@@ -452,7 +453,7 @@ def detect_memory_impact_config(
     # Get actually changed files (not dependencies)
     files = changed_files(branch)
 
-    # Find all changed components (excluding core)
+    # Find all changed components (excluding core and base bus components)
     # Also collect platform hints from platform-specific filenames
     changed_component_set: set[str] = set()
     has_core_cpp_changes = False
@@ -461,13 +462,13 @@ def detect_memory_impact_config(
     for file in files:
         component = get_component_from_path(file)
         if component:
-            # Add all changed components, including base bus components
-            # Base bus components (uart, i2c, spi, etc.) should still be analyzed
-            # when directly changed, even though they're also used as dependencies
-            changed_component_set.add(component)
-            # Check if this is a platform-specific file
-            if platform_hint := _detect_platform_hint_from_filename(file):
-                platform_hints.append(platform_hint)
+            # Skip base bus components as they're used across many builds
+            if component not in BASE_BUS_COMPONENTS:
+                changed_component_set.add(component)
+                # Check if this is a platform-specific file
+                platform_hint = _detect_platform_hint_from_filename(file)
+                if platform_hint:
+                    platform_hints.append(platform_hint)
         elif file.startswith("esphome/") and file.endswith(CPP_FILE_EXTENSIONS):
             # Core ESPHome C++ files changed (not component-specific)
             # Only C++ files affect memory usage

script/helpers.py

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

tests/components/ble_client/common.yaml

@@ -3,52 +3,3 @@ esp32_ble_tracker:
 ble_client:
   - mac_address: 01:02:03:04:05:06
     id: test_blec
-    on_connect:
-      - ble_client.ble_write:
-          id: test_blec
-          service_uuid: "abcd1234-abcd-1234-abcd-abcd12345678"
-          characteristic_uuid: "abcd1235-abcd-1234-abcd-abcd12345678"
-          value: !lambda |-
-            return std::vector<uint8_t>{0x01, 0x02, 0x03};
-      - ble_client.ble_write:
-          id: test_blec
-          service_uuid: "abcd1234-abcd-1234-abcd-abcd12345678"
-          characteristic_uuid: "abcd1235-abcd-1234-abcd-abcd12345678"
-          value: [0x04, 0x05, 0x06]
-    on_passkey_request:
-      - ble_client.passkey_reply:
-          id: test_blec
-          passkey: !lambda |-
-            return 123456;
-      - ble_client.passkey_reply:
-          id: test_blec
-          passkey: 654321
-    on_numeric_comparison_request:
-      - ble_client.numeric_comparison_reply:
-          id: test_blec
-          accept: !lambda |-
-            return true;
-      - ble_client.numeric_comparison_reply:
-          id: test_blec
-          accept: false
-
-sensor:
-  - platform: ble_client
-    ble_client_id: test_blec
-    type: characteristic
-    id: test_sensor_lambda
-    name: "BLE Sensor with Lambda"
-    service_uuid: "abcd1234-abcd-1234-abcd-abcd12345678"
-    characteristic_uuid: "abcd1236-abcd-1234-abcd-abcd12345678"
-    lambda: |-
-      if (x.size() >= 2) {
-        return (float)(x[0] | (x[1] << 8)) / 100.0;
-      }
-      return NAN;
-  - platform: ble_client
-    ble_client_id: test_blec
-    type: characteristic
-    id: test_sensor_no_lambda
-    name: "BLE Sensor without Lambda"
-    service_uuid: "abcd1234-abcd-1234-abcd-abcd12345678"
-    characteristic_uuid: "abcd1237-abcd-1234-abcd-abcd12345678"

tests/components/modbus/common.yaml

@@ -1,5 +1,3 @@
-# comment
-
 modbus:
   id: mod_bus1
   flow_control_pin: ${flow_control_pin}

tests/components/modbus_controller/common.yaml

@@ -56,14 +56,6 @@ binary_sensor:
     register_type: read
     address: 0x3200
     bitmask: 0x80
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_binary_sensor2
-    name: Test Binary Sensor with Lambda
-    register_type: read
-    address: 0x3201
-    lambda: |-
-      return x;
 
 number:
   - platform: modbus_controller
@@ -73,16 +65,6 @@ number:
     address: 0x9001
     value_type: U_WORD
     multiply: 1.0
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_number2
-    name: Test Number with Lambda
-    address: 0x9002
-    value_type: U_WORD
-    lambda: |-
-      return x * 2.0;
-    write_lambda: |-
-      return x / 2.0;
 
 output:
   - platform: modbus_controller
@@ -92,14 +74,6 @@ output:
     register_type: holding
     value_type: U_WORD
     multiply: 1000
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_output2
-    address: 2049
-    register_type: holding
-    value_type: U_WORD
-    write_lambda: |-
-      return x * 100.0;
 
 select:
   - platform: modbus_controller
@@ -113,34 +87,6 @@ select:
       "One": 1
       "Two": 2
       "Three": 3
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_select2
-    name: Test Select with Lambda
-    address: 1001
-    value_type: U_WORD
-    optionsmap:
-      "Off": 0
-      "On": 1
-      "Two": 2
-    lambda: |-
-      ESP_LOGD("Reg1001", "Received value %lld", x);
-      if (x > 1) {
-        return std::string("Two");
-      } else if (x == 1) {
-        return std::string("On");
-      }
-      return std::string("Off");
-    write_lambda: |-
-      ESP_LOGD("Reg1001", "Set option to %s (%lld)", x.c_str(), value);
-      if (x == "On") {
-        return 1;
-      }
-      if (x == "Two") {
-        payload.push_back(0x0002);
-        return 0;
-      }
-      return value;
 
 sensor:
   - platform: modbus_controller
@@ -151,15 +97,6 @@ sensor:
     address: 0x9001
     unit_of_measurement: "AH"
     value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_sensor2
-    name: Test Sensor with Lambda
-    register_type: holding
-    address: 0x9002
-    value_type: U_WORD
-    lambda: |-
-      return x / 10.0;
 
 switch:
   - platform: modbus_controller
@@ -169,16 +106,6 @@ switch:
     register_type: coil
     address: 0x15
     bitmask: 1
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_switch2
-    name: Test Switch with Lambda
-    register_type: coil
-    address: 0x16
-    lambda: |-
-      return !x;
-    write_lambda: |-
-      return !x;
 
 text_sensor:
   - platform: modbus_controller
@@ -190,13 +117,3 @@ text_sensor:
     register_count: 3
     raw_encode: HEXBYTES
     response_size: 6
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller1
-    id: modbus_text_sensor2
-    name: Test Text Sensor with Lambda
-    register_type: holding
-    address: 0x9014
-    register_count: 2
-    response_size: 4
-    lambda: |-
-      return "Modified: " + x;

tests/components/remote_receiver/common-actions.yaml

@@ -48,11 +48,6 @@ on_drayton:
     - logger.log:
         format: "on_drayton: %u %u %u"
         args: ["x.address", "x.channel", "x.command"]
-on_dyson:
-  then:
-    - logger.log:
-        format: "on_dyson: %u %u"
-        args: ["x.code", "x.index"]
 on_gobox:
   then:
     - logger.log:

tests/components/remote_transmitter/common-buttons.yaml

@@ -6,13 +6,6 @@ button:
       remote_transmitter.transmit_beo4:
         source: 0x01
         command: 0x0C
-  - platform: template
-    name: Dyson fan up
-    id: dyson_fan_up
-    on_press:
-      remote_transmitter.transmit_dyson:
-        code: 0x1215
-        index: 0x0
   - platform: template
     name: JVC Off
     id: living_room_lights_on

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

@@ -19,41 +19,3 @@ uart:
 
 packet_transport:
   - platform: uart
-
-switch:
-  # Test uart switch with single state (array)
-  - platform: uart
-    name: "UART Switch Single Array"
-    uart_id: uart_uart
-    data: [0x01, 0x02, 0x03]
-  # Test uart switch with single state (string)
-  - platform: uart
-    name: "UART Switch Single String"
-    uart_id: uart_uart
-    data: "ON"
-  # Test uart switch with turn_on/turn_off (arrays)
-  - platform: uart
-    name: "UART Switch Dual Array"
-    uart_id: uart_uart
-    data:
-      turn_on: [0xA0, 0xA1, 0xA2]
-      turn_off: [0xB0, 0xB1, 0xB2]
-  # Test uart switch with turn_on/turn_off (strings)
-  - platform: uart
-    name: "UART Switch Dual String"
-    uart_id: uart_uart
-    data:
-      turn_on: "TURN_ON"
-      turn_off: "TURN_OFF"
-
-button:
-  # Test uart button with array data
-  - platform: uart
-    name: "UART Button Array"
-    uart_id: uart_uart
-    data: [0xFF, 0xEE, 0xDD]
-  # Test uart button with string data
-  - platform: uart
-    name: "UART Button String"
-    uart_id: uart_uart
-    data: "BUTTON_PRESS"

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

@@ -13,21 +13,3 @@ uart:
     rx_buffer_size: 512
     parity: EVEN
     stop_bits: 2
-
-switch:
-  - platform: uart
-    name: "UART Switch Array"
-    uart_id: uart_uart
-    data: [0x01, 0x02, 0x03]
-  - platform: uart
-    name: "UART Switch Dual"
-    uart_id: uart_uart
-    data:
-      turn_on: [0xA0, 0xA1]
-      turn_off: [0xB0, 0xB1]
-
-button:
-  - platform: uart
-    name: "UART Button"
-    uart_id: uart_uart
-    data: [0xFF, 0xEE]

tests/script/test_determine_jobs.py

@@ -849,47 +849,39 @@ def test_detect_memory_impact_config_no_components_with_tests(tmp_path: Path) ->
     assert result["should_run"] == "false"
 
 
-def test_detect_memory_impact_config_includes_base_bus_components(
-    tmp_path: Path,
-) -> None:
-    """Test that base bus components (i2c, spi, uart) are included when directly changed.
-
-    Base bus components should be analyzed for memory impact when they are directly
-    changed, even though they are often used as dependencies. This ensures that
-    optimizations to base components (like using move semantics or initializer_list)
-    are properly measured.
-    """
+def test_detect_memory_impact_config_skips_base_bus_components(tmp_path: Path) -> None:
+    """Test that base bus components (i2c, spi, uart) are skipped."""
     # Create test directory structure
     tests_dir = tmp_path / "tests" / "components"
 
-    # uart component (base bus component that should be included)
-    uart_dir = tests_dir / "uart"
-    uart_dir.mkdir(parents=True)
-    (uart_dir / "test.esp32-idf.yaml").write_text("test: uart")
+    # i2c component (should be skipped as it's a base bus component)
+    i2c_dir = tests_dir / "i2c"
+    i2c_dir.mkdir(parents=True)
+    (i2c_dir / "test.esp32-idf.yaml").write_text("test: i2c")
 
-    # wifi component (regular component)
+    # wifi component (should not be skipped)
     wifi_dir = tests_dir / "wifi"
     wifi_dir.mkdir(parents=True)
     (wifi_dir / "test.esp32-idf.yaml").write_text("test: wifi")
 
-    # Mock changed_files to return both uart and wifi
+    # Mock changed_files to return both i2c and wifi
     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/components/uart/automation.h",  # Header file with inline code
+            "esphome/components/i2c/i2c.cpp",
             "esphome/components/wifi/wifi.cpp",
         ]
         determine_jobs._component_has_tests.cache_clear()
 
         result = determine_jobs.detect_memory_impact_config()
 
-    # Should include both uart and wifi
+    # Should only include wifi, not i2c
     assert result["should_run"] == "true"
-    assert set(result["components"]) == {"uart", "wifi"}
-    assert result["platform"] == "esp32-idf"  # Common platform
+    assert result["components"] == ["wifi"]
+    assert "i2c" not in result["components"]
 
 
 def test_detect_memory_impact_config_with_variant_tests(tmp_path: Path) -> None:

tests/script/test_helpers.py

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