Merge branch 'no_batch_events' into integration

esphome/components/api/api_connection.cpp

@@ -1296,8 +1296,8 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 
 #ifdef USE_EVENT
 void APIConnection::send_event(event::Event *event, const char *event_type) {
-  this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
-                          EventResponse::ESTIMATED_SIZE);
+  this->send_message_smart_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
+                            EventResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {

esphome/components/api/api_connection.h

@@ -650,21 +650,30 @@ class APIConnection final : public APIServerConnection {
   }
 #endif
 
+  // Helper to check if a message type should bypass batching
+  // Returns true if:
+  // 1. It's an UpdateStateResponse (always send immediately to handle cases where
+  //    the main loop is blocked, e.g., during OTA updates)
+  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
+  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
+  //    AND batch_delay = 0)
+  inline bool should_send_immediately_(uint8_t message_type) const {
+    return (
+#ifdef USE_UPDATE
+        message_type == UpdateStateResponse::MESSAGE_TYPE ||
+#endif
+#ifdef USE_EVENT
+        message_type == EventResponse::MESSAGE_TYPE ||
+#endif
+        (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0));
+  }
+
   // Helper method to send a message either immediately or via batching
+  // Tries immediate send if should_send_immediately_() returns true and buffer has space
+  // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
                            uint8_t estimated_size) {
-    // Try to send immediately if:
-    // 1. It's an UpdateStateResponse (always send immediately to handle cases where
-    //    the main loop is blocked, e.g., during OTA updates)
-    // 2. OR: We should try to send immediately (should_try_send_immediately = true)
-    //        AND Batch delay is 0 (user has opted in to immediate sending)
-    // 3. AND: Buffer has space available
-    if ((
-#ifdef USE_UPDATE
-            message_type == UpdateStateResponse::MESSAGE_TYPE ||
-#endif
-            (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0)) &&
-        this->helper_->can_write_without_blocking()) {
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
       // Now actually encode and send
       if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
@@ -682,6 +691,27 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
+  // Overload for MessageCreator (used by events which need to capture event_type)
+  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    // Try to send immediately if message type should bypass batching and buffer has space
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
+          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, creator, message_type);
+#endif
+        return true;
+      }
+
+      // If immediate send failed, fall through to batching
+    }
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, std::move(creator), message_type, estimated_size);
+  }
+
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
     this->deferred_batch_.add_item(entity, std::move(creator), message_type, estimated_size);

esphome/components/esp32_ble_tracker/automation.h

@@ -10,7 +10,7 @@ namespace esphome::esp32_ble_tracker {
 class ESPBTAdvertiseTrigger : public Trigger<const ESPBTDevice &>, public ESPBTDeviceListener {
  public:
   explicit ESPBTAdvertiseTrigger(ESP32BLETracker *parent) { parent->register_listener(this); }
-  void set_addresses(const std::vector<uint64_t> &addresses) { this->address_vec_ = addresses; }
+  void set_addresses(std::initializer_list<uint64_t> addresses) { this->address_vec_ = addresses; }
 
   bool parse_device(const ESPBTDevice &device) override {
     uint64_t u64_addr = device.address_uint64();

requirements_test.txt

@@ -5,7 +5,7 @@ pyupgrade==3.21.1  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
 # Unit tests
-pytest==9.0.0
+pytest==9.0.1
 pytest-cov==7.0.0
 pytest-mock==3.15.1
 pytest-asyncio==1.3.0