esphome 2025.8.4__py3-none-any.whl → 2025.9.0b2__py3-none-any.whl

esphome/components/aht10/aht10.cpp

@@ -96,7 +96,7 @@ void AHT10Component::read_data_() {
     ESP_LOGD(TAG, "Read attempt %d at %ums", this->read_count_, (unsigned) (millis() - this->start_time_));
   }
   if (this->read(data, 6) != i2c::ERROR_OK) {
-    this->status_set_warning("Read failed, will retry");
+    this->status_set_warning(LOG_STR("Read failed, will retry"));
     this->restart_read_();
     return;
   }
@@ -113,7 +113,7 @@ void AHT10Component::read_data_() {
     } else {
       ESP_LOGD(TAG, "Invalid humidity, retrying");
       if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-        this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+        this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
       }
       this->restart_read_();
       return;
@@ -144,7 +144,7 @@ void AHT10Component::update() {
     return;
   this->start_time_ = millis();
   if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
     return;
   }
   this->restart_read_();

esphome/components/airthings_ble/__init__.py

@@ -18,6 +18,6 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield esp32_ble_tracker.register_ble_device(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)

esphome/components/alarm_control_panel/__init__.py

@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -345,6 +345,6 @@ async def alarm_control_panel_is_armed_to_code(
     return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(alarm_control_panel_ns.using)

esphome/components/am2315c/am2315c.cpp

@@ -29,22 +29,6 @@ namespace am2315c {
 
 static const char *const TAG = "am2315c";
 
-uint8_t AM2315C::crc8_(uint8_t *data, uint8_t len) {
-  uint8_t crc = 0xFF;
-  while (len--) {
-    crc ^= *data++;
-    for (uint8_t i = 0; i < 8; i++) {
-      if (crc & 0x80) {
-        crc <<= 1;
-        crc ^= 0x31;
-      } else {
-        crc <<= 1;
-      }
-    }
-  }
-  return crc;
-}
-
 bool AM2315C::reset_register_(uint8_t reg) {
   //  code based on demo code sent by www.aosong.com
   //  no further documentation.
@@ -86,7 +70,7 @@ bool AM2315C::convert_(uint8_t *data, float &humidity, float &temperature) {
   humidity = raw * 9.5367431640625e-5;
   raw = ((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5];
   temperature = raw * 1.9073486328125e-4 - 50;
-  return this->crc8_(data, 6) == data[6];
+  return crc8(data, 6, 0xFF, 0x31, true) == data[6];
 }
 
 void AM2315C::setup() {

esphome/components/am2315c/am2315c.h

@@ -21,9 +21,9 @@
 // SOFTWARE.
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
 
 namespace esphome {
 namespace am2315c {
@@ -39,7 +39,6 @@ class AM2315C : public PollingComponent, public i2c::I2CDevice {
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
 
  protected:
-  uint8_t crc8_(uint8_t *data, uint8_t len);
   bool convert_(uint8_t *data, float &humidity, float &temperature);
   bool reset_register_(uint8_t reg);
 

esphome/components/api/__init__.py

@@ -24,7 +24,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_VARIABLES,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 DOMAIN = "api"
 DEPENDENCIES = ["network"]
@@ -134,7 +134,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(40.0)
+@coroutine_with_priority(CoroPriority.WEB)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/api/api_connection.cpp

@@ -42,6 +42,8 @@ static constexpr uint8_t MAX_PING_RETRIES = 60;
 static constexpr uint16_t PING_RETRY_INTERVAL = 1000;
 static constexpr uint32_t KEEPALIVE_DISCONNECT_TIMEOUT = (KEEPALIVE_TIMEOUT_MS * 5) / 2;
 
+static constexpr auto ESPHOME_VERSION_REF = StringRef::from_lit(ESPHOME_VERSION);
+
 static const char *const TAG = "api.connection";
 #ifdef USE_CAMERA
 static const int CAMERA_STOP_STREAM = 5000;
@@ -112,7 +114,7 @@ void APIConnection::start() {
   APIError err = this->helper_->init();
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_("Helper init failed", err);
+    this->log_warning_(LOG_STR("Helper init failed"), err);
     return;
   }
   this->client_info_.peername = helper_->getpeername();
@@ -159,7 +161,7 @@ void APIConnection::loop() {
         break;
       } else if (err != APIError::OK) {
         on_fatal_error();
-        this->log_warning_("Reading failed", err);
+        this->log_warning_(LOG_STR("Reading failed"), err);
         return;
       } else {
         this->last_traffic_ = now;
@@ -289,16 +291,26 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint8_t mess
     return 0;  // Doesn't fit
   }
 
-  // Allocate buffer space - pass payload size, allocation functions add header/footer space
-  ProtoWriteBuffer buffer = is_single ? conn->allocate_single_message_buffer(calculated_size)
-                                      : conn->allocate_batch_message_buffer(calculated_size);
-
   // Get buffer size after allocation (which includes header padding)
   std::vector<uint8_t> &shared_buf = conn->parent_->get_shared_buffer_ref();
-  size_t size_before_encode = shared_buf.size();
+
+  if (is_single || conn->flags_.batch_first_message) {
+    // Single message or first batch message
+    conn->prepare_first_message_buffer(shared_buf, header_padding, total_calculated_size);
+    if (conn->flags_.batch_first_message) {
+      conn->flags_.batch_first_message = false;
+    }
+  } else {
+    // Batch message second or later
+    // Add padding for previous message footer + this message header
+    size_t current_size = shared_buf.size();
+    shared_buf.reserve(current_size + total_calculated_size);
+    shared_buf.resize(current_size + footer_size + header_padding);
+  }
 
   // Encode directly into buffer
-  msg.encode(buffer);
+  size_t size_before_encode = shared_buf.size();
+  msg.encode({&shared_buf});
 
   // Calculate actual encoded size (not including header that was already added)
   size_t actual_payload_size = shared_buf.size() - size_before_encode;
@@ -1060,16 +1072,16 @@ void APIConnection::camera_image(const CameraImageRequest &msg) {
 
 #ifdef USE_HOMEASSISTANT_TIME
 void APIConnection::on_get_time_response(const GetTimeResponse &value) {
-  if (homeassistant::global_homeassistant_time != nullptr)
+  if (homeassistant::global_homeassistant_time != nullptr) {
     homeassistant::global_homeassistant_time->set_epoch_time(value.epoch_seconds);
-}
+#ifdef USE_TIME_TIMEZONE
+    if (!value.timezone.empty() && value.timezone != homeassistant::global_homeassistant_time->get_timezone()) {
+      homeassistant::global_homeassistant_time->set_timezone(value.timezone);
+    }
 #endif
-
-bool APIConnection::send_get_time_response(const GetTimeRequest &msg) {
-  GetTimeResponse resp;
-  resp.epoch_seconds = ::time(nullptr);
-  return this->send_message(resp, GetTimeResponse::MESSAGE_TYPE);
+  }
 }
+#endif
 
 #ifdef USE_BLUETOOTH_PROXY
 void APIConnection::subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) {
@@ -1360,9 +1372,8 @@ bool APIConnection::send_hello_response(const HelloRequest &msg) {
   HelloResponse resp;
   resp.api_version_major = 1;
   resp.api_version_minor = 12;
-  // Temporary string for concatenation - will be valid during send_message call
-  std::string server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
-  resp.set_server_info(StringRef(server_info));
+  // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
+  resp.set_server_info(ESPHOME_VERSION_REF);
   resp.set_name(StringRef(App.get_name()));
 
 #ifdef USE_API_PASSWORD
@@ -1409,8 +1420,6 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   std::string mac_address = get_mac_address_pretty();
   resp.set_mac_address(StringRef(mac_address));
 
-  // Compile-time StringRef constants
-  static constexpr auto ESPHOME_VERSION_REF = StringRef::from_lit(ESPHOME_VERSION);
   resp.set_esphome_version(ESPHOME_VERSION_REF);
 
   resp.set_compilation_time(App.get_compilation_time_ref());
@@ -1555,7 +1564,7 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
     return false;
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_("Packet write failed", err);
+    this->log_warning_(LOG_STR("Packet write failed"), err);
     return false;
   }
   // Do not set last_traffic_ on send
@@ -1616,14 +1625,6 @@ bool APIConnection::schedule_batch_() {
   return true;
 }
 
-ProtoWriteBuffer APIConnection::allocate_single_message_buffer(uint16_t size) { return this->create_buffer(size); }
-
-ProtoWriteBuffer APIConnection::allocate_batch_message_buffer(uint16_t size) {
-  ProtoWriteBuffer result = this->prepare_message_buffer(size, this->flags_.batch_first_message);
-  this->flags_.batch_first_message = false;
-  return result;
-}
-
 void APIConnection::process_batch_() {
   // Ensure PacketInfo remains trivially destructible for our placement new approach
   static_assert(std::is_trivially_destructible<PacketInfo>::value,
@@ -1731,7 +1732,7 @@ void APIConnection::process_batch_() {
     }
     remaining_size -= payload_size;
     // Calculate where the next message's header padding will start
-    // Current buffer size + footer space (that prepare_message_buffer will add for this message)
+    // Current buffer size + footer space for this message
     current_offset = shared_buf.size() + footer_size;
   }
 
@@ -1750,7 +1751,7 @@ void APIConnection::process_batch_() {
                                                        std::span<const PacketInfo>(packet_info, packet_count));
   if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
     on_fatal_error();
-    this->log_warning_("Batch write failed", err);
+    this->log_warning_(LOG_STR("Batch write failed"), err);
   }
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1828,11 +1829,14 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
-void APIConnection::log_warning_(const char *message, APIError err) {
-  ESP_LOGW(TAG, "%s: %s %s errno=%d", this->get_client_combined_info().c_str(), message, api_error_to_str(err), errno);
+void APIConnection::log_warning_(const LogString *message, APIError err) {
+  ESP_LOGW(TAG, "%s: %s %s errno=%d", this->get_client_combined_info().c_str(), LOG_STR_ARG(message),
+           LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 
-void APIConnection::log_socket_operation_failed_(APIError err) { this->log_warning_("Socket operation failed", err); }
+void APIConnection::log_socket_operation_failed_(APIError err) {
+  this->log_warning_(LOG_STR("Socket operation failed"), err);
+}
 
 }  // namespace esphome::api
 #endif

esphome/components/api/api_connection.h

@@ -44,7 +44,7 @@ static constexpr size_t MAX_PACKETS_PER_BATCH = 64;  // ESP32 has 8KB+ stack, HO
 static constexpr size_t MAX_PACKETS_PER_BATCH = 32;  // ESP8266/RP2040/etc have smaller stacks
 #endif
 
-class APIConnection : public APIServerConnection {
+class APIConnection final : public APIServerConnection {
  public:
   friend class APIServer;
   friend class ListEntitiesIterator;
@@ -219,7 +219,6 @@ class APIConnection : public APIServerConnection {
 #ifdef USE_API_HOMEASSISTANT_STATES
   void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) override;
 #endif
-  bool send_get_time_response(const GetTimeRequest &msg) override;
 #ifdef USE_API_SERVICES
   void execute_service(const ExecuteServiceRequest &msg) override;
 #endif
@@ -252,44 +251,21 @@ class APIConnection : public APIServerConnection {
 
     // Get header padding size - used for both reserve and insert
     uint8_t header_padding = this->helper_->frame_header_padding();
-
     // Get shared buffer from parent server
     std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
+    this->prepare_first_message_buffer(shared_buf, header_padding,
+                                       reserve_size + header_padding + this->helper_->frame_footer_size());
+    return {&shared_buf};
+  }
+
+  void prepare_first_message_buffer(std::vector<uint8_t> &shared_buf, size_t header_padding, size_t total_size) {
     shared_buf.clear();
     // Reserve space for header padding + message + footer
     // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext)
     // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext)
-    shared_buf.reserve(reserve_size + header_padding + this->helper_->frame_footer_size());
+    shared_buf.reserve(total_size);
     // Resize to add header padding so message encoding starts at the correct position
     shared_buf.resize(header_padding);
-    return {&shared_buf};
-  }
-
-  // Prepare buffer for next message in batch
-  ProtoWriteBuffer prepare_message_buffer(uint16_t message_size, bool is_first_message) {
-    // Get reference to shared buffer (it maintains state between batch messages)
-    std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
-
-    if (is_first_message) {
-      shared_buf.clear();
-    }
-
-    size_t current_size = shared_buf.size();
-
-    // Calculate padding to add:
-    // - First message: just header padding
-    // - Subsequent messages: footer for previous message + header padding for this message
-    size_t padding_to_add = is_first_message
-                                ? this->helper_->frame_header_padding()
-                                : this->helper_->frame_header_padding() + this->helper_->frame_footer_size();
-
-    // Reserve space for padding + message
-    shared_buf.reserve(current_size + padding_to_add + message_size);
-
-    // Resize to add the padding bytes
-    shared_buf.resize(current_size + padding_to_add);
-
-    return {&shared_buf};
   }
 
   bool try_to_clear_buffer(bool log_out_of_space);
@@ -297,10 +273,6 @@ class APIConnection : public APIServerConnection {
 
   std::string get_client_combined_info() const { return this->client_info_.get_combined_info(); }
 
-  // Buffer allocator methods for batch processing
-  ProtoWriteBuffer allocate_single_message_buffer(uint16_t size);
-  ProtoWriteBuffer allocate_batch_message_buffer(uint16_t size);
-
  protected:
   // Helper function to handle authentication completion
   void complete_authentication_();
@@ -328,9 +300,17 @@ class APIConnection : public APIServerConnection {
                                               APIConnection *conn, uint32_t remaining_size, bool is_single) {
     // Set common fields that are shared by all entity types
     msg.key = entity->get_object_id_hash();
-    // IMPORTANT: get_object_id() may return a temporary std::string
-    std::string object_id = entity->get_object_id();
-    msg.set_object_id(StringRef(object_id));
+    // Try to use static reference first to avoid allocation
+    StringRef static_ref = entity->get_object_id_ref_for_api_();
+    // Store dynamic string outside the if-else to maintain lifetime
+    std::string object_id;
+    if (!static_ref.empty()) {
+      msg.set_object_id(static_ref);
+    } else {
+      // Dynamic case - need to allocate
+      object_id = entity->get_object_id();
+      msg.set_object_id(StringRef(object_id));
+    }
 
     if (entity->has_own_name()) {
       msg.set_name(entity->get_name());
@@ -751,7 +731,7 @@ class APIConnection : public APIServerConnection {
   }
 
   // Helper function to log API errors with errno
-  void log_warning_(const char *message, APIError err);
+  void log_warning_(const LogString *message, APIError err);
   // Specific helper for duplicated error message
   void log_socket_operation_failed_(APIError err);
 };

esphome/components/api/api_frame_helper.cpp

@@ -23,59 +23,59 @@ static const char *const TAG = "api.frame_helper";
 #define LOG_PACKET_SENDING(data, len) ((void) 0)
 #endif
 
-const char *api_error_to_str(APIError err) {
+const LogString *api_error_to_logstr(APIError err) {
   // not using switch to ensure compiler doesn't try to build a big table out of it
   if (err == APIError::OK) {
-    return "OK";
+    return LOG_STR("OK");
   } else if (err == APIError::WOULD_BLOCK) {
-    return "WOULD_BLOCK";
+    return LOG_STR("WOULD_BLOCK");
   } else if (err == APIError::BAD_INDICATOR) {
-    return "BAD_INDICATOR";
+    return LOG_STR("BAD_INDICATOR");
   } else if (err == APIError::BAD_DATA_PACKET) {
-    return "BAD_DATA_PACKET";
+    return LOG_STR("BAD_DATA_PACKET");
   } else if (err == APIError::TCP_NODELAY_FAILED) {
-    return "TCP_NODELAY_FAILED";
+    return LOG_STR("TCP_NODELAY_FAILED");
   } else if (err == APIError::TCP_NONBLOCKING_FAILED) {
-    return "TCP_NONBLOCKING_FAILED";
+    return LOG_STR("TCP_NONBLOCKING_FAILED");
   } else if (err == APIError::CLOSE_FAILED) {
-    return "CLOSE_FAILED";
+    return LOG_STR("CLOSE_FAILED");
   } else if (err == APIError::SHUTDOWN_FAILED) {
-    return "SHUTDOWN_FAILED";
+    return LOG_STR("SHUTDOWN_FAILED");
   } else if (err == APIError::BAD_STATE) {
-    return "BAD_STATE";
+    return LOG_STR("BAD_STATE");
   } else if (err == APIError::BAD_ARG) {
-    return "BAD_ARG";
+    return LOG_STR("BAD_ARG");
   } else if (err == APIError::SOCKET_READ_FAILED) {
-    return "SOCKET_READ_FAILED";
+    return LOG_STR("SOCKET_READ_FAILED");
   } else if (err == APIError::SOCKET_WRITE_FAILED) {
-    return "SOCKET_WRITE_FAILED";
+    return LOG_STR("SOCKET_WRITE_FAILED");
   } else if (err == APIError::OUT_OF_MEMORY) {
-    return "OUT_OF_MEMORY";
+    return LOG_STR("OUT_OF_MEMORY");
   } else if (err == APIError::CONNECTION_CLOSED) {
-    return "CONNECTION_CLOSED";
+    return LOG_STR("CONNECTION_CLOSED");
   }
 #ifdef USE_API_NOISE
   else if (err == APIError::BAD_HANDSHAKE_PACKET_LEN) {
-    return "BAD_HANDSHAKE_PACKET_LEN";
+    return LOG_STR("BAD_HANDSHAKE_PACKET_LEN");
   } else if (err == APIError::HANDSHAKESTATE_READ_FAILED) {
-    return "HANDSHAKESTATE_READ_FAILED";
+    return LOG_STR("HANDSHAKESTATE_READ_FAILED");
   } else if (err == APIError::HANDSHAKESTATE_WRITE_FAILED) {
-    return "HANDSHAKESTATE_WRITE_FAILED";
+    return LOG_STR("HANDSHAKESTATE_WRITE_FAILED");
   } else if (err == APIError::HANDSHAKESTATE_BAD_STATE) {
-    return "HANDSHAKESTATE_BAD_STATE";
+    return LOG_STR("HANDSHAKESTATE_BAD_STATE");
   } else if (err == APIError::CIPHERSTATE_DECRYPT_FAILED) {
-    return "CIPHERSTATE_DECRYPT_FAILED";
+    return LOG_STR("CIPHERSTATE_DECRYPT_FAILED");
   } else if (err == APIError::CIPHERSTATE_ENCRYPT_FAILED) {
-    return "CIPHERSTATE_ENCRYPT_FAILED";
+    return LOG_STR("CIPHERSTATE_ENCRYPT_FAILED");
   } else if (err == APIError::HANDSHAKESTATE_SETUP_FAILED) {
-    return "HANDSHAKESTATE_SETUP_FAILED";
+    return LOG_STR("HANDSHAKESTATE_SETUP_FAILED");
   } else if (err == APIError::HANDSHAKESTATE_SPLIT_FAILED) {
-    return "HANDSHAKESTATE_SPLIT_FAILED";
+    return LOG_STR("HANDSHAKESTATE_SPLIT_FAILED");
   } else if (err == APIError::BAD_HANDSHAKE_ERROR_BYTE) {
-    return "BAD_HANDSHAKE_ERROR_BYTE";
+    return LOG_STR("BAD_HANDSHAKE_ERROR_BYTE");
   }
 #endif
-  return "UNKNOWN";
+  return LOG_STR("UNKNOWN");
 }
 
 // Default implementation for loop - handles sending buffered data

esphome/components/api/api_frame_helper.h

@@ -66,7 +66,7 @@ enum class APIError : uint16_t {
 #endif
 };
 
-const char *api_error_to_str(APIError err);
+const LogString *api_error_to_logstr(APIError err);
 
 class APIFrameHelper {
  public:
@@ -104,9 +104,9 @@ class APIFrameHelper {
   // The buffer contains all messages with appropriate padding before each
   virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) = 0;
   // Get the frame header padding required by this protocol
-  virtual uint8_t frame_header_padding() = 0;
+  uint8_t frame_header_padding() const { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
-  virtual uint8_t frame_footer_size() = 0;
+  uint8_t frame_footer_size() const { return frame_footer_size_; }
   // Check if socket has data ready to read
   bool is_socket_ready() const { return socket_ != nullptr && socket_->ready(); }