esphome 2025.4.1__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/bl0906/constants.h

@@ -45,7 +45,7 @@ static const uint8_t BL0906_WRITE_COMMAND = 0xCA;
 static const uint8_t BL0906_V_RMS = 0x16;
 
 // Total power
-static const uint8_t BL0906_WATT_SUM = 0X2C;
+static const uint8_t BL0906_WATT_SUM = 0x2C;
 
 // Current1~6
 static const uint8_t BL0906_I_1_RMS = 0x0D;  // current_1
@@ -56,29 +56,29 @@ static const uint8_t BL0906_I_5_RMS = 0x13;
 static const uint8_t BL0906_I_6_RMS = 0x14;  // current_6
 
 // Power1~6
-static const uint8_t BL0906_WATT_1 = 0X23;  // power_1
-static const uint8_t BL0906_WATT_2 = 0X24;
-static const uint8_t BL0906_WATT_3 = 0X25;
-static const uint8_t BL0906_WATT_4 = 0X26;
-static const uint8_t BL0906_WATT_5 = 0X29;
-static const uint8_t BL0906_WATT_6 = 0X2A;  // power_6
+static const uint8_t BL0906_WATT_1 = 0x23;  // power_1
+static const uint8_t BL0906_WATT_2 = 0x24;
+static const uint8_t BL0906_WATT_3 = 0x25;
+static const uint8_t BL0906_WATT_4 = 0x26;
+static const uint8_t BL0906_WATT_5 = 0x29;
+static const uint8_t BL0906_WATT_6 = 0x2A;  // power_6
 
 // Active pulse count, unsigned
-static const uint8_t BL0906_CF_1_CNT = 0X30;  // Channel_1
-static const uint8_t BL0906_CF_2_CNT = 0X31;
-static const uint8_t BL0906_CF_3_CNT = 0X32;
-static const uint8_t BL0906_CF_4_CNT = 0X33;
-static const uint8_t BL0906_CF_5_CNT = 0X36;
-static const uint8_t BL0906_CF_6_CNT = 0X37;  // Channel_6
+static const uint8_t BL0906_CF_1_CNT = 0x30;  // Channel_1
+static const uint8_t BL0906_CF_2_CNT = 0x31;
+static const uint8_t BL0906_CF_3_CNT = 0x32;
+static const uint8_t BL0906_CF_4_CNT = 0x33;
+static const uint8_t BL0906_CF_5_CNT = 0x36;
+static const uint8_t BL0906_CF_6_CNT = 0x37;  // Channel_6
 
 // Total active pulse count, unsigned
-static const uint8_t BL0906_CF_SUM_CNT = 0X39;
+static const uint8_t BL0906_CF_SUM_CNT = 0x39;
 
 // Voltage frequency cycle
-static const uint8_t BL0906_FREQUENCY = 0X4E;
+static const uint8_t BL0906_FREQUENCY = 0x4E;
 
 // Internal temperature
-static const uint8_t BL0906_TEMPERATURE = 0X5E;
+static const uint8_t BL0906_TEMPERATURE = 0x5E;
 
 // Calibration register
 // RMS gain adjustment register

esphome/components/ble_client/text_sensor/__init__.py

@@ -4,7 +4,6 @@ from esphome.components import ble_client, esp32_ble_tracker, text_sensor
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
-    CONF_ID,
     CONF_NOTIFY,
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
@@ -32,9 +31,9 @@ BLETextSensorNotifyTrigger = ble_client_ns.class_(
 )
 
 CONFIG_SCHEMA = cv.All(
-    text_sensor.TEXT_SENSOR_SCHEMA.extend(
+    text_sensor.text_sensor_schema(BLETextSensor)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(BLETextSensor),
             cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
             cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
             cv.Optional(CONF_DESCRIPTOR_UUID): esp32_ble_tracker.bt_uuid,
@@ -54,7 +53,7 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await text_sensor.new_text_sensor(config)
     if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
         cg.add(
             var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
@@ -101,7 +100,6 @@ async def to_code(config):
     await cg.register_component(var, config)
     await ble_client.register_ble_node(var, config)
     cg.add(var.set_enable_notify(config[CONF_NOTIFY]))
-    await text_sensor.register_text_sensor(var, config)
     for conf in config.get(CONF_ON_NOTIFY, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await ble_client.register_ble_node(trigger, config)

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -73,9 +73,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       resp.address = this->address_;
       resp.handle = param->read.handle;
       resp.data.reserve(param->read.value_len);
-      for (uint16_t i = 0; i < param->read.value_len; i++) {
-        resp.data.push_back(param->read.value[i]);
-      }
+      // Use bulk insert instead of individual push_backs
+      resp.data.insert(resp.data.end(), param->read.value, param->read.value + param->read.value_len);
       this->proxy_->get_api_connection()->send_bluetooth_gatt_read_response(resp);
       break;
     }
@@ -127,9 +126,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       resp.address = this->address_;
       resp.handle = param->notify.handle;
       resp.data.reserve(param->notify.value_len);
-      for (uint16_t i = 0; i < param->notify.value_len; i++) {
-        resp.data.push_back(param->notify.value[i]);
-      }
+      // Use bulk insert instead of individual push_backs
+      resp.data.insert(resp.data.end(), param->notify.value, param->notify.value + param->notify.value_len);
       this->proxy_->get_api_connection()->send_bluetooth_gatt_notify_data_response(resp);
       break;
     }

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -2,6 +2,7 @@
 
 #include "esphome/core/log.h"
 #include "esphome/core/macros.h"
+#include "esphome/core/application.h"
 
 #ifdef USE_ESP32
 
@@ -25,6 +26,22 @@ std::vector<uint64_t> get_128bit_uuid_vec(esp_bt_uuid_t uuid_source) {
 
 BluetoothProxy::BluetoothProxy() { global_bluetooth_proxy = this; }
 
+void BluetoothProxy::setup() {
+  this->parent_->add_scanner_state_callback([this](esp32_ble_tracker::ScannerState state) {
+    if (this->api_connection_ != nullptr) {
+      this->send_bluetooth_scanner_state_(state);
+    }
+  });
+}
+
+void BluetoothProxy::send_bluetooth_scanner_state_(esp32_ble_tracker::ScannerState state) {
+  api::BluetoothScannerStateResponse resp;
+  resp.state = static_cast<api::enums::BluetoothScannerState>(state);
+  resp.mode = this->parent_->get_scan_active() ? api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_ACTIVE
+                                               : api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_PASSIVE;
+  this->api_connection_->send_bluetooth_scanner_state_response(resp);
+}
+
 bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || this->raw_advertisements_)
     return false;
@@ -35,33 +52,60 @@ bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
   return true;
 }
 
+static constexpr size_t FLUSH_BATCH_SIZE = 8;
+static std::vector<api::BluetoothLERawAdvertisement> &get_batch_buffer() {
+  static std::vector<api::BluetoothLERawAdvertisement> batch_buffer;
+  return batch_buffer;
+}
+
 bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
     return false;
 
-  api::BluetoothLERawAdvertisementsResponse resp;
+  // Get the batch buffer reference
+  auto &batch_buffer = get_batch_buffer();
+
+  // Reserve additional capacity if needed
+  size_t new_size = batch_buffer.size() + count;
+  if (batch_buffer.capacity() < new_size) {
+    batch_buffer.reserve(new_size);
+  }
+
+  // Add new advertisements to the batch buffer
   for (size_t i = 0; i < count; i++) {
     auto &result = advertisements[i];
-    api::BluetoothLERawAdvertisement adv;
+    uint8_t length = result.adv_data_len + result.scan_rsp_len;
+
+    batch_buffer.emplace_back();
+    auto &adv = batch_buffer.back();
     adv.address = esp32_ble::ble_addr_to_uint64(result.bda);
     adv.rssi = result.rssi;
     adv.address_type = result.ble_addr_type;
+    adv.data.assign(&result.ble_adv[0], &result.ble_adv[length]);
 
-    uint8_t length = result.adv_data_len + result.scan_rsp_len;
-    adv.data.reserve(length);
-    for (uint16_t i = 0; i < length; i++) {
-      adv.data.push_back(result.ble_adv[i]);
-    }
-
-    resp.advertisements.push_back(std::move(adv));
-
-    ESP_LOGV(TAG, "Proxying raw packet from %02X:%02X:%02X:%02X:%02X:%02X, length %d. RSSI: %d dB", result.bda[0],
+    ESP_LOGV(TAG, "Queuing raw packet from %02X:%02X:%02X:%02X:%02X:%02X, length %d. RSSI: %d dB", result.bda[0],
              result.bda[1], result.bda[2], result.bda[3], result.bda[4], result.bda[5], length, result.rssi);
   }
-  ESP_LOGV(TAG, "Proxying %d packets", count);
-  this->api_connection_->send_bluetooth_le_raw_advertisements_response(resp);
+
+  // Only send if we've accumulated a good batch size to maximize batching efficiency
+  // https://github.com/esphome/backlog/issues/21
+  if (batch_buffer.size() >= FLUSH_BATCH_SIZE) {
+    this->flush_pending_advertisements();
+  }
+
   return true;
 }
+
+void BluetoothProxy::flush_pending_advertisements() {
+  auto &batch_buffer = get_batch_buffer();
+  if (batch_buffer.empty() || !api::global_api_server->is_connected() || this->api_connection_ == nullptr)
+    return;
+
+  api::BluetoothLERawAdvertisementsResponse resp;
+  resp.advertisements.swap(batch_buffer);
+  this->api_connection_->send_bluetooth_le_raw_advertisements_response(resp);
+}
+
 void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device) {
   api::BluetoothLEAdvertisementResponse resp;
   resp.address = device.address_uint64();
@@ -69,21 +113,34 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
   if (!device.get_name().empty())
     resp.name = device.get_name();
   resp.rssi = device.get_rssi();
-  for (auto uuid : device.get_service_uuids()) {
-    resp.service_uuids.push_back(uuid.to_string());
+
+  // Pre-allocate vectors based on known sizes
+  auto service_uuids = device.get_service_uuids();
+  resp.service_uuids.reserve(service_uuids.size());
+  for (auto &uuid : service_uuids) {
+    resp.service_uuids.emplace_back(uuid.to_string());
   }
-  for (auto &data : device.get_service_datas()) {
-    api::BluetoothServiceData service_data;
+
+  // Pre-allocate service data vector
+  auto service_datas = device.get_service_datas();
+  resp.service_data.reserve(service_datas.size());
+  for (auto &data : service_datas) {
+    resp.service_data.emplace_back();
+    auto &service_data = resp.service_data.back();
     service_data.uuid = data.uuid.to_string();
     service_data.data.assign(data.data.begin(), data.data.end());
-    resp.service_data.push_back(std::move(service_data));
   }
-  for (auto &data : device.get_manufacturer_datas()) {
-    api::BluetoothServiceData manufacturer_data;
+
+  // Pre-allocate manufacturer data vector
+  auto manufacturer_datas = device.get_manufacturer_datas();
+  resp.manufacturer_data.reserve(manufacturer_datas.size());
+  for (auto &data : manufacturer_datas) {
+    resp.manufacturer_data.emplace_back();
+    auto &manufacturer_data = resp.manufacturer_data.back();
     manufacturer_data.uuid = data.uuid.to_string();
     manufacturer_data.data.assign(data.data.begin(), data.data.end());
-    resp.manufacturer_data.push_back(std::move(manufacturer_data));
   }
+
   this->api_connection_->send_bluetooth_le_advertisement(resp);
 }
 
@@ -117,6 +174,18 @@ void BluetoothProxy::loop() {
     }
     return;
   }
+
+  // Flush any pending BLE advertisements that have been accumulated but not yet sent
+  if (this->raw_advertisements_) {
+    static uint32_t last_flush_time = 0;
+    uint32_t now = App.get_loop_component_start_time();
+
+    // Flush accumulated advertisements every 100ms
+    if (now - last_flush_time >= 100) {
+      this->flush_pending_advertisements();
+      last_flush_time = now;
+    }
+  }
   for (auto *connection : this->connections_) {
     if (connection->send_service_ == connection->service_count_) {
       connection->send_service_ = DONE_SENDING_SERVICES;
@@ -145,11 +214,27 @@ void BluetoothProxy::loop() {
       }
       api::BluetoothGATTGetServicesResponse resp;
       resp.address = connection->get_address();
+      resp.services.reserve(1);  // Always one service per response in this implementation
       api::BluetoothGATTService service_resp;
       service_resp.uuid = get_128bit_uuid_vec(service_result.uuid);
       service_resp.handle = service_result.start_handle;
       uint16_t char_offset = 0;
       esp_gattc_char_elem_t char_result;
+      // Get the number of characteristics directly with one call
+      uint16_t total_char_count = 0;
+      esp_gatt_status_t char_count_status = esp_ble_gattc_get_attr_count(
+          connection->get_gattc_if(), connection->get_conn_id(), ESP_GATT_DB_CHARACTERISTIC,
+          service_result.start_handle, service_result.end_handle, 0, &total_char_count);
+
+      if (char_count_status == ESP_GATT_OK && total_char_count > 0) {
+        // Only reserve if we successfully got a count
+        service_resp.characteristics.reserve(total_char_count);
+      } else if (char_count_status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", connection->get_connection_index(),
+                 connection->address_str().c_str(), char_count_status);
+      }
+
+      // Now process characteristics
       while (true) {  // characteristics
         uint16_t char_count = 1;
         esp_gatt_status_t char_status = esp_ble_gattc_get_all_char(
@@ -171,6 +256,23 @@ void BluetoothProxy::loop() {
         characteristic_resp.handle = char_result.char_handle;
         characteristic_resp.properties = char_result.properties;
         char_offset++;
+
+        // Get the number of descriptors directly with one call
+        uint16_t total_desc_count = 0;
+        esp_gatt_status_t desc_count_status =
+            esp_ble_gattc_get_attr_count(connection->get_gattc_if(), connection->get_conn_id(), ESP_GATT_DB_DESCRIPTOR,
+                                         char_result.char_handle, service_result.end_handle, 0, &total_desc_count);
+
+        if (desc_count_status == ESP_GATT_OK && total_desc_count > 0) {
+          // Only reserve if we successfully got a count
+          characteristic_resp.descriptors.reserve(total_desc_count);
+        } else if (desc_count_status != ESP_GATT_OK) {
+          ESP_LOGW(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d",
+                   connection->get_connection_index(), connection->address_str().c_str(), char_result.char_handle,
+                   desc_count_status);
+        }
+
+        // Now process descriptors
         uint16_t desc_offset = 0;
         esp_gattc_descr_elem_t desc_result;
         while (true) {  // descriptors
@@ -453,6 +555,8 @@ void BluetoothProxy::subscribe_api_connection(api::APIConnection *api_connection
   this->api_connection_ = api_connection;
   this->raw_advertisements_ = flags & BluetoothProxySubscriptionFlag::SUBSCRIPTION_RAW_ADVERTISEMENTS;
   this->parent_->recalculate_advertisement_parser_types();
+
+  this->send_bluetooth_scanner_state_(this->parent_->get_scanner_state());
 }
 
 void BluetoothProxy::unsubscribe_api_connection(api::APIConnection *api_connection) {
@@ -525,6 +629,17 @@ void BluetoothProxy::send_device_unpairing(uint64_t address, bool success, esp_e
   this->api_connection_->send_bluetooth_device_unpairing_response(call);
 }
 
+void BluetoothProxy::bluetooth_scanner_set_mode(bool active) {
+  if (this->parent_->get_scan_active() == active) {
+    return;
+  }
+  ESP_LOGD(TAG, "Setting scanner mode to %s", active ? "active" : "passive");
+  this->parent_->set_scan_active(active);
+  this->parent_->stop_scan();
+  this->parent_->set_scan_continuous(
+      true);  // Set this to true to automatically start scanning again when it has cleaned up.
+}
+
 BluetoothProxy *global_bluetooth_proxy = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace bluetooth_proxy

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -41,6 +41,7 @@ enum BluetoothProxyFeature : uint32_t {
   FEATURE_PAIRING = 1 << 3,
   FEATURE_CACHE_CLEARING = 1 << 4,
   FEATURE_RAW_ADVERTISEMENTS = 1 << 5,
+  FEATURE_STATE_AND_MODE = 1 << 6,
 };
 
 enum BluetoothProxySubscriptionFlag : uint32_t {
@@ -53,7 +54,9 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
   bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) override;
   void dump_config() override;
+  void setup() override;
   void loop() override;
+  void flush_pending_advertisements();
   esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;
 
   void register_connection(BluetoothConnection *connection) {
@@ -84,6 +87,8 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   void send_device_unpairing(uint64_t address, bool success, esp_err_t error = ESP_OK);
   void send_device_clear_cache(uint64_t address, bool success, esp_err_t error = ESP_OK);
 
+  void bluetooth_scanner_set_mode(bool active);
+
   static void uint64_to_bd_addr(uint64_t address, esp_bd_addr_t bd_addr) {
     bd_addr[0] = (address >> 40) & 0xff;
     bd_addr[1] = (address >> 32) & 0xff;
@@ -107,6 +112,7 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
     uint32_t flags = 0;
     flags |= BluetoothProxyFeature::FEATURE_PASSIVE_SCAN;
     flags |= BluetoothProxyFeature::FEATURE_RAW_ADVERTISEMENTS;
+    flags |= BluetoothProxyFeature::FEATURE_STATE_AND_MODE;
     if (this->active_) {
       flags |= BluetoothProxyFeature::FEATURE_ACTIVE_CONNECTIONS;
       flags |= BluetoothProxyFeature::FEATURE_REMOTE_CACHING;
@@ -124,6 +130,7 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
 
  protected:
   void send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device);
+  void send_bluetooth_scanner_state_(esp32_ble_tracker::ScannerState state);
 
   BluetoothConnection *get_connection_(uint64_t address, bool reserve);
 

esphome/components/button/__init__.py

@@ -44,7 +44,7 @@ ButtonPressTrigger = button_ns.class_(
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 
-BUTTON_SCHEMA = (
+_BUTTON_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -60,15 +60,13 @@ BUTTON_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def button_schema(
     class_: MockObjClass,
     *,
-    icon: str = _UNDEF,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {cv.GenerateID(): cv.declare_id(class_)}
 
@@ -77,10 +75,15 @@ def button_schema(
         (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
     ]:
-        if default is not _UNDEF:
+        if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
 
-    return BUTTON_SCHEMA.extend(schema)
+    return _BUTTON_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+BUTTON_SCHEMA = button_schema(Button)
+BUTTON_SCHEMA.add_extra(cv.deprecated_schema_constant("button"))
 
 
 async def setup_button_core_(var, config):

esphome/components/canbus/canbus.cpp

@@ -86,6 +86,9 @@ void Canbus::loop() {
       data.push_back(can_message.data[i]);
     }
 
+    this->callback_manager_(can_message.can_id, can_message.use_extended_id, can_message.remote_transmission_request,
+                            data);
+
     // fire all triggers
     for (auto *trigger : this->triggers_) {
       if ((trigger->can_id_ == (can_message.can_id & trigger->can_id_mask_)) &&

esphome/components/canbus/canbus.h

@@ -81,6 +81,20 @@ class Canbus : public Component {
   void set_bitrate(CanSpeed bit_rate) { this->bit_rate_ = bit_rate; }
 
   void add_trigger(CanbusTrigger *trigger);
+  /**
+   * Add a callback to be called when a CAN message is received. All received messages
+   * are passed to the callback without filtering.
+   *
+   * The callback function receives:
+   * - can_id of the received data
+   * - extended_id True if the can_id is an extended id
+   * - rtr If this is a remote transmission request
+   * - data The message data
+   */
+  void add_callback(
+      std::function<void(uint32_t can_id, bool extended_id, bool rtr, const std::vector<uint8_t> &data)> callback) {
+    this->callback_manager_.add(std::move(callback));
+  }
 
  protected:
   template<typename... Ts> friend class CanbusSendAction;
@@ -88,6 +102,8 @@ class Canbus : public Component {
   uint32_t can_id_;
   bool use_extended_id_;
   CanSpeed bit_rate_;
+  CallbackManager<void(uint32_t can_id, bool extended_id, bool rtr, const std::vector<uint8_t> &data)>
+      callback_manager_{};
 
   virtual bool setup_internal();
   virtual Error send_message(struct CanFrame *frame);

esphome/components/ccs811/sensor.py

@@ -32,14 +32,14 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(CCS811Component),
-            cv.Required(CONF_ECO2): sensor.sensor_schema(
+            cv.Optional(CONF_ECO2): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PARTS_PER_MILLION,
                 icon=ICON_MOLECULE_CO2,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_CARBON_DIOXIDE,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
-            cv.Required(CONF_TVOC): sensor.sensor_schema(
+            cv.Optional(CONF_TVOC): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PARTS_PER_BILLION,
                 icon=ICON_RADIATOR,
                 accuracy_decimals=0,
@@ -64,10 +64,13 @@ async def to_code(config):
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
 
-    sens = await sensor.new_sensor(config[CONF_ECO2])
-    cg.add(var.set_co2(sens))
-    sens = await sensor.new_sensor(config[CONF_TVOC])
-    cg.add(var.set_tvoc(sens))
+    if eco2_config := config.get(CONF_ECO2):
+        sens = await sensor.new_sensor(eco2_config)
+        cg.add(var.set_co2(sens))
+
+    if tvoc_config := config.get(CONF_TVOC):
+        sens = await sensor.new_sensor(tvoc_config)
+        cg.add(var.set_tvoc(sens))
 
     if version_config := config.get(CONF_VERSION):
         sens = await text_sensor.new_text_sensor(version_config)

esphome/components/climate/__init__.py

@@ -11,9 +11,11 @@ from esphome.const import (
     CONF_CURRENT_TEMPERATURE_STATE_TOPIC,
     CONF_CUSTOM_FAN_MODE,
     CONF_CUSTOM_PRESET,
+    CONF_ENTITY_CATEGORY,
     CONF_FAN_MODE,
     CONF_FAN_MODE_COMMAND_TOPIC,
     CONF_FAN_MODE_STATE_TOPIC,
+    CONF_ICON,
     CONF_ID,
     CONF_MAX_TEMPERATURE,
     CONF_MIN_TEMPERATURE,
@@ -46,6 +48,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 IS_PLATFORM_COMPONENT = True
@@ -151,12 +154,11 @@ ControlTrigger = climate_ns.class_(
     "ControlTrigger", automation.Trigger.template(ClimateCall.operator("ref"))
 )
 
-CLIMATE_SCHEMA = (
+_CLIMATE_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
         {
-            cv.GenerateID(): cv.declare_id(Climate),
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTClimateComponent),
             cv.Optional(CONF_VISUAL, default={}): cv.Schema(
                 {
@@ -245,6 +247,31 @@ CLIMATE_SCHEMA = (
 )
 
 
+def climate_schema(
+    class_: MockObjClass,
+    *,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {
+        cv.GenerateID(): cv.declare_id(class_),
+    }
+
+    for key, default, validator in [
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _CLIMATE_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+CLIMATE_SCHEMA = climate_schema(Climate)
+CLIMATE_SCHEMA.add_extra(cv.deprecated_schema_constant("climate"))
+
+
 async def setup_climate_core_(var, config):
     await setup_entity(var, config)
 
@@ -419,6 +446,12 @@ async def register_climate(var, config):
     await setup_climate_core_(var, config)
 
 
+async def new_climate(config, *args):
+    var = cg.new_Pvariable(config[CONF_ID], *args)
+    await register_climate(var, config)
+    return var
+
+
 CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
     {
         cv.Required(CONF_ID): cv.use_id(Climate),

esphome/components/climate/climate_mode.h

@@ -20,7 +20,7 @@ enum ClimateMode : uint8_t {
   CLIMATE_MODE_FAN_ONLY = 4,
   /// The climate device is set to dry/humidity mode
   CLIMATE_MODE_DRY = 5,
-  /** The climate device is adjusting the temperatre dynamically.
+  /** The climate device is adjusting the temperature dynamically.
    * For example, the target temperature can be adjusted based on a schedule, or learned behavior.
    * The target temperature can't be adjusted when in this mode.
    */