esphome 2025.5.1__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/nextion/nextion_upload_idf.cpp

@@ -21,7 +21,7 @@ static const char *const TAG = "nextion.upload.idf";
 
 int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &range_start) {
   uint32_t range_size = this->tft_size_ - range_start;
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
   uint32_t range_end = ((upload_first_chunk_sent_ or this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
   ESP_LOGD(TAG, "Range start: %" PRIu32, range_start);
   if (range_size <= 0 or range_end <= range_start) {
@@ -33,20 +33,20 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
 
   char range_header[32];
   sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
-  ESP_LOGV(TAG, "Requesting range: %s", range_header);
+  ESP_LOGV(TAG, "Range: %s", range_header);
   esp_http_client_set_header(http_client, "Range", range_header);
-  ESP_LOGV(TAG, "Opening HTTP connetion");
+  ESP_LOGV(TAG, "Open HTTP");
   esp_err_t err = esp_http_client_open(http_client, 0);
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err));
+    ESP_LOGE(TAG, "HTTP open failed: %s", esp_err_to_name(err));
     return -1;
   }
 
-  ESP_LOGV(TAG, "Fetch content length");
+  ESP_LOGV(TAG, "Fetch length");
   const int chunk_size = esp_http_client_fetch_headers(http_client);
-  ESP_LOGV(TAG, "content_length = %d", chunk_size);
+  ESP_LOGV(TAG, "Length: %d", chunk_size);
   if (chunk_size <= 0) {
-    ESP_LOGE(TAG, "Failed to get chunk's content length: %d", chunk_size);
+    ESP_LOGE(TAG, "Get length failed: %d", chunk_size);
     return -1;
   }
 
@@ -54,7 +54,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
   ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
   uint8_t *buffer = allocator.allocate(4096);
   if (!buffer) {
-    ESP_LOGE(TAG, "Failed to allocate upload buffer");
+    ESP_LOGE(TAG, "Buffer alloc failed");
     return -1;
   }
 
@@ -63,7 +63,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
     App.feed_wdt();
     const uint16_t buffer_size =
         this->content_length_ < 4096 ? this->content_length_ : 4096;  // Limits buffer to the remaining data
-    ESP_LOGV(TAG, "Fetching %" PRIu16 " bytes from HTTP", buffer_size);
+    ESP_LOGV(TAG, "Fetch %" PRIu16 " bytes", buffer_size);
     uint16_t read_len = 0;
     int partial_read_len = 0;
     uint8_t retries = 0;
@@ -84,14 +84,13 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
     }
     if (read_len != buffer_size) {
       // Did not receive the full package within the timeout period
-      ESP_LOGE(TAG, "Failed to read full package, received only %" PRIu16 " of %" PRIu16 " bytes", read_len,
-               buffer_size);
+      ESP_LOGE(TAG, "Read failed: %" PRIu16 "/%" PRIu16 " bytes", read_len, buffer_size);
       // Deallocate buffer
       allocator.deallocate(buffer, 4096);
       buffer = nullptr;
       return -1;
     }
-    ESP_LOGV(TAG, "%d bytes fetched, writing it to UART", read_len);
+    ESP_LOGV(TAG, "Fetched %d bytes", read_len);
     if (read_len > 0) {
       recv_string.clear();
       this->write_array(buffer, buffer_size);
@@ -100,25 +99,23 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
 #ifdef USE_PSRAM
-      ESP_LOGD(
-          TAG,
-          "Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " (DRAM) + %" PRIu32 " (PSRAM) bytes",
-          upload_percentage, this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
-          static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
+      ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 "+%" PRIu32 ")", upload_percentage,
+               this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
+               static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
 #else
-      ESP_LOGD(TAG, "Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " bytes", upload_percentage,
-               this->content_length_, static_cast<uint32_t>(esp_get_free_heap_size()));
+      ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,
+               static_cast<uint32_t>(esp_get_free_heap_size()));
 #endif
       upload_first_chunk_sent_ = true;
       if (recv_string[0] == 0x08 && recv_string.size() == 5) {  // handle partial upload request
-        ESP_LOGD(TAG, "recv_string [%s]",
+        ESP_LOGD(TAG, "Recv: [%s]",
                  format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         uint32_t result = 0;
         for (int j = 0; j < 4; ++j) {
           result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
         }
         if (result > 0) {
-          ESP_LOGI(TAG, "Nextion reported new range %" PRIu32, result);
+          ESP_LOGI(TAG, "New range: %" PRIu32, result);
           this->content_length_ = this->tft_size_ - result;
           range_start = result;
         } else {
@@ -129,7 +126,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
         buffer = nullptr;
         return range_end + 1;
       } else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) {  // 0x05 == "ok"
-        ESP_LOGE(TAG, "Invalid response from Nextion: [%s]",
+        ESP_LOGE(TAG, "Invalid response: [%s]",
                  format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         // Deallocate buffer
         allocator.deallocate(buffer, 4096);
@@ -139,10 +136,10 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
 
       recv_string.clear();
     } else if (read_len == 0) {
-      ESP_LOGV(TAG, "End of HTTP response reached");
+      ESP_LOGV(TAG, "HTTP end");
       break;  // Exit the loop if there is no more data to read
     } else {
-      ESP_LOGE(TAG, "Failed to read from HTTP client, error code: %" PRIu16, read_len);
+      ESP_LOGE(TAG, "HTTP read failed: %" PRIu16, read_len);
       break;  // Exit the loop on error
     }
   }
@@ -154,26 +151,26 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
 }
 
 bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
-  ESP_LOGD(TAG, "Nextion TFT upload requested");
+  ESP_LOGD(TAG, "TFT upload requested");
   ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
   ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
 
   if (this->is_updating_) {
-    ESP_LOGW(TAG, "Currently uploading");
+    ESP_LOGW(TAG, "Upload in progress");
     return false;
   }
 
   if (!network::is_connected()) {
-    ESP_LOGE(TAG, "Network is not connected");
+    ESP_LOGE(TAG, "No network");
     return false;
   }
 
   this->is_updating_ = true;
 
   if (exit_reparse) {
-    ESP_LOGD(TAG, "Exiting Nextion reparse mode");
+    ESP_LOGD(TAG, "Exit reparse mode");
     if (!this->set_protocol_reparse_mode(false)) {
-      ESP_LOGW(TAG, "Failed to request Nextion to exit reparse mode");
+      ESP_LOGW(TAG, "Exit reparse failed");
       return false;
     }
   }
@@ -188,8 +185,8 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client
-  ESP_LOGV(TAG, "Initializing HTTP client");
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Init HTTP client");
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
   esp_http_client_config_t config = {
       .url = this->tft_url_.c_str(),
       .cert_pem = nullptr,
@@ -201,30 +198,30 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   // Initialize the HTTP client with the configuration
   esp_http_client_handle_t http_client = esp_http_client_init(&config);
   if (!http_client) {
-    ESP_LOGE(TAG, "Failed to initialize HTTP client.");
+    ESP_LOGE(TAG, "HTTP init failed");
     return this->upload_end_(false);
   }
 
   esp_err_t err = esp_http_client_set_header(http_client, "Connection", "keep-alive");
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "HTTP set header failed: %s", esp_err_to_name(err));
+    ESP_LOGE(TAG, "Set header failed: %s", esp_err_to_name(err));
     esp_http_client_cleanup(http_client);
     return this->upload_end_(false);
   }
 
   // Perform the HTTP request
-  ESP_LOGV(TAG, "Check if the client could connect");
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Check connection");
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
   err = esp_http_client_perform(http_client);
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "HTTP request failed: %s", esp_err_to_name(err));
+    ESP_LOGE(TAG, "HTTP failed: %s", esp_err_to_name(err));
     esp_http_client_cleanup(http_client);
     return this->upload_end_(false);
   }
 
   // Check the HTTP Status Code
-  ESP_LOGV(TAG, "Check the HTTP Status Code");
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Check status");
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
   int status_code = esp_http_client_get_status_code(http_client);
   if (status_code != 200 && status_code != 206) {
     return this->upload_end_(false);
@@ -232,28 +229,28 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   this->tft_size_ = esp_http_client_get_content_length(http_client);
 
-  ESP_LOGD(TAG, "TFT file size: %zu bytes", this->tft_size_);
+  ESP_LOGD(TAG, "TFT size: %zu bytes", this->tft_size_);
   if (this->tft_size_ < 4096 || this->tft_size_ > 134217728) {
-    ESP_LOGE(TAG, "File size check failed.");
-    ESP_LOGD(TAG, "Close HTTP connection");
+    ESP_LOGE(TAG, "Size check failed");
+    ESP_LOGD(TAG, "Close HTTP");
     esp_http_client_close(http_client);
     esp_http_client_cleanup(http_client);
     ESP_LOGV(TAG, "Connection closed");
     return this->upload_end_(false);
   } else {
-    ESP_LOGV(TAG, "File size check passed. Proceeding...");
+    ESP_LOGV(TAG, "Size check OK");
   }
   this->content_length_ = this->tft_size_;
 
-  ESP_LOGD(TAG, "Uploading Nextion");
+  ESP_LOGD(TAG, "Uploading");
 
   // The Nextion will ignore the upload command if it is sleeping
-  ESP_LOGV(TAG, "Wake-up Nextion");
+  ESP_LOGV(TAG, "Wake-up");
   this->ignore_is_setup_ = true;
   this->send_command_("sleep=0");
   this->send_command_("dim=100");
   vTaskDelay(pdMS_TO_TICKS(250));  // NOLINT
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
 
   App.feed_wdt();
   char command[128];
@@ -263,75 +260,75 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   sprintf(command, "whmi-wris %" PRIu32 ",%" PRIu32 ",1", this->content_length_, baud_rate);
 
   // Clear serial receive buffer
-  ESP_LOGV(TAG, "Clear serial receive buffer");
+  ESP_LOGV(TAG, "Clear RX buffer");
   this->reset_(false);
   vTaskDelay(pdMS_TO_TICKS(250));  // NOLINT
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
 
-  ESP_LOGV(TAG, "Send upload instruction: %s", command);
+  ESP_LOGV(TAG, "Upload cmd: %s", command);
   this->send_command_(command);
 
   if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Changing baud rate from %" PRIu32 " to %" PRIu32 " bps", this->original_baud_rate_, baud_rate);
+    ESP_LOGD(TAG, "Baud: %" PRIu32 "->%" PRIu32, this->original_baud_rate_, baud_rate);
     this->parent_->set_baud_rate(baud_rate);
     this->parent_->load_settings();
   }
 
   std::string response;
-  ESP_LOGV(TAG, "Waiting for upgrade response");
+  ESP_LOGV(TAG, "Wait upload resp");
   this->recv_ret_string_(response, 5000, true);  // This can take some time to return
 
   // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
-  ESP_LOGD(TAG, "Upgrade response is [%s] - %zu byte(s)",
+  ESP_LOGD(TAG, "Upload resp: [%s] %zu B",
            format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str(),
            response.length());
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, esp_get_free_heap_size());
 
   if (response.find(0x05) != std::string::npos) {
-    ESP_LOGV(TAG, "Preparation for TFT upload done");
+    ESP_LOGV(TAG, "Upload prep done");
   } else {
-    ESP_LOGE(TAG, "Preparation for TFT upload failed %d \"%s\"", response[0], response.c_str());
-    ESP_LOGD(TAG, "Close HTTP connection");
+    ESP_LOGE(TAG, "Upload prep failed %d '%s'", response[0], response.c_str());
+    ESP_LOGD(TAG, "Close HTTP");
     esp_http_client_close(http_client);
     esp_http_client_cleanup(http_client);
     ESP_LOGV(TAG, "Connection closed");
     return this->upload_end_(false);
   }
 
-  ESP_LOGV(TAG, "Change the method to GET before starting the download");
+  ESP_LOGV(TAG, "Set method to GET");
   esp_err_t set_method_result = esp_http_client_set_method(http_client, HTTP_METHOD_GET);
   if (set_method_result != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to set HTTP method to GET: %s", esp_err_to_name(set_method_result));
+    ESP_LOGE(TAG, "Set GET failed: %s", esp_err_to_name(set_method_result));
     return this->upload_end_(false);
   }
 
-  ESP_LOGD(TAG, "Uploading TFT to Nextion:");
-  ESP_LOGD(TAG, "  URL: %s", this->tft_url_.c_str());
-  ESP_LOGD(TAG, "  File size: %" PRIu32 " bytes", this->content_length_);
-  ESP_LOGD(TAG, "  Free heap: %" PRIu32, esp_get_free_heap_size());
+  ESP_LOGD(TAG, "Uploading TFT:");
+  ESP_LOGD(TAG, "  URL:  %s", this->tft_url_.c_str());
+  ESP_LOGD(TAG, "  Size: %" PRIu32 " bytes", this->content_length_);
+  ESP_LOGD(TAG, "  Heap: %" PRIu32, esp_get_free_heap_size());
 
   // Proceed with the content download as before
 
-  ESP_LOGV(TAG, "Starting transfer by chunks loop");
+  ESP_LOGV(TAG, "Start chunk transfer");
 
   uint32_t position = 0;
   while (this->content_length_ > 0) {
     int upload_result = upload_by_chunks_(http_client, position);
     if (upload_result < 0) {
-      ESP_LOGE(TAG, "Error uploading TFT to Nextion!");
-      ESP_LOGD(TAG, "Close HTTP connection");
+      ESP_LOGE(TAG, "TFT upload error");
+      ESP_LOGD(TAG, "Close HTTP");
       esp_http_client_close(http_client);
       esp_http_client_cleanup(http_client);
       ESP_LOGV(TAG, "Connection closed");
       return this->upload_end_(false);
     }
     App.feed_wdt();
-    ESP_LOGV(TAG, "Free heap: %" PRIu32 ", Bytes left: %" PRIu32, esp_get_free_heap_size(), this->content_length_);
+    ESP_LOGV(TAG, "Heap: %" PRIu32 " left: %" PRIu32, esp_get_free_heap_size(), this->content_length_);
   }
 
-  ESP_LOGD(TAG, "Successfully uploaded TFT to Nextion!");
+  ESP_LOGD(TAG, "TFT upload complete");
 
-  ESP_LOGD(TAG, "Close HTTP connection");
+  ESP_LOGD(TAG, "Close HTTP");
   esp_http_client_close(http_client);
   esp_http_client_cleanup(http_client);
   ESP_LOGV(TAG, "Connection closed");
@@ -339,23 +336,23 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 }
 
 bool Nextion::upload_end_(bool successful) {
-  ESP_LOGD(TAG, "Nextion TFT upload finished: %s", YESNO(successful));
+  ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
   this->is_updating_ = false;
   this->ignore_is_setup_ = false;
 
   uint32_t baud_rate = this->parent_->get_baud_rate();
   if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Changing baud rate back from %" PRIu32 " to %" PRIu32 " bps", baud_rate, this->original_baud_rate_);
+    ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
     this->parent_->set_baud_rate(this->original_baud_rate_);
     this->parent_->load_settings();
   }
 
   if (successful) {
-    ESP_LOGD(TAG, "Restarting ESPHome");
+    ESP_LOGD(TAG, "Restart");
     delay(1500);  // NOLINT
-    arch_restart();
+    App.safe_reboot();
   } else {
-    ESP_LOGE(TAG, "Nextion TFT upload failed");
+    ESP_LOGE(TAG, "TFT upload failed");
   }
   return successful;
 }

esphome/components/nextion/sensor/nextion_sensor.cpp

@@ -13,7 +13,7 @@ void NextionSensor::process_sensor(const std::string &variable_name, int state)
 
   if (this->wave_chan_id_ == UINT8_MAX && this->variable_name_ == variable_name) {
     this->publish_state(state);
-    ESP_LOGD(TAG, "Processed sensor \"%s\" state %d", variable_name.c_str(), state);
+    ESP_LOGD(TAG, "Sensor: %s=%d", variable_name.c_str(), state);
   }
 }
 
@@ -93,7 +93,7 @@ void NextionSensor::set_state(float state, bool publish, bool send_to_nextion) {
   }
   this->update_component_settings();
 
-  ESP_LOGN(TAG, "Wrote state for sensor \"%s\" state %lf", this->variable_name_.c_str(), published_state);
+  ESP_LOGN(TAG, "Write: %s=%lf", this->variable_name_.c_str(), published_state);
 }
 
 void NextionSensor::wave_update_() {
@@ -105,8 +105,8 @@ void NextionSensor::wave_update_() {
   size_t buffer_to_send =
       this->wave_buffer_.size() < 255 ? this->wave_buffer_.size() : 255;  // ADDT command can only send 255
 
-  ESP_LOGN(TAG, "wave_update send %zu of %zu value(s) to wave nextion component id %d and wave channel id %d",
-           buffer_to_send, this->wave_buffer_.size(), this->component_id_, this->wave_chan_id_);
+  ESP_LOGN(TAG, "Wave update: %zu/%zu vals to comp %d ch %d", buffer_to_send, this->wave_buffer_.size(),
+           this->component_id_, this->wave_chan_id_);
 #endif
 
   this->nextion_->add_addt_command_to_queue(this);

esphome/components/nextion/switch/nextion_switch.cpp

@@ -13,7 +13,7 @@ void NextionSwitch::process_bool(const std::string &variable_name, bool on) {
   if (this->variable_name_ == variable_name) {
     this->publish_state(on);
 
-    ESP_LOGD(TAG, "Processed switch \"%s\" state %s", variable_name.c_str(), state ? "ON" : "OFF");
+    ESP_LOGD(TAG, "Switch: %s=%s", variable_name.c_str(), ONOFF(on));
   }
 }
 
@@ -43,7 +43,7 @@ void NextionSwitch::set_state(bool state, bool publish, bool send_to_nextion) {
 
   this->update_component_settings();
 
-  ESP_LOGN(TAG, "Updated switch \"%s\" state %s", this->variable_name_.c_str(), ONOFF(state));
+  ESP_LOGN(TAG, "Write: %s=%s", this->variable_name_.c_str(), ONOFF(state));
 }
 
 void NextionSwitch::write_state(bool state) { this->set_state(state); }

esphome/components/nextion/text_sensor/nextion_textsensor.cpp

@@ -11,7 +11,7 @@ void NextionTextSensor::process_text(const std::string &variable_name, const std
     return;
   if (this->variable_name_ == variable_name) {
     this->publish_state(text_value);
-    ESP_LOGD(TAG, "Processed text_sensor \"%s\" state \"%s\"", variable_name.c_str(), text_value.c_str());
+    ESP_LOGD(TAG, "Text sensor: %s='%s'", variable_name.c_str(), text_value.c_str());
   }
 }
 
@@ -42,7 +42,7 @@ void NextionTextSensor::set_state(const std::string &state, bool publish, bool s
 
   this->update_component_settings();
 
-  ESP_LOGN(TAG, "Wrote state for text_sensor \"%s\" state \"%s\"", this->variable_name_.c_str(), state.c_str());
+  ESP_LOGN(TAG, "Write: %s='%s'", this->variable_name_.c_str(), state.c_str());
 }
 
 }  // namespace nextion

esphome/components/nfc/nci_message.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <vector>
 

esphome/components/nfc/ndef_record.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <vector>
 

esphome/components/nfc/ndef_record_text.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "ndef_record.h"
 
 #include <vector>

esphome/components/nfc/ndef_record_uri.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "ndef_record.h"
 
 #include <vector>

esphome/components/nfc/nfc.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "ndef_record.h"
 #include "ndef_message.h"
 #include "nfc_tag.h"

esphome/components/nfc/nfc_tag.h

@@ -3,8 +3,8 @@
 #include <memory>
 #include <vector>
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "ndef_message.h"
 
 namespace esphome {

esphome/components/noblex/noblex.cpp

@@ -1,6 +1,6 @@
 #include "noblex.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace noblex {

esphome/components/npi19/npi19.cpp

@@ -1,7 +1,7 @@
 #include "npi19.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace npi19 {
@@ -11,18 +11,16 @@ static const char *const TAG = "npi19";
 static const uint8_t READ_COMMAND = 0xAC;
 
 void NPI19Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up NPI19...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint16_t raw_temperature(0);
   uint16_t raw_pressure(0);
   i2c::ErrorCode err = this->read_(raw_temperature, raw_pressure);
   if (err != i2c::ERROR_OK) {
-    ESP_LOGCONFIG(TAG, "    I2C Communication Failed...");
+    ESP_LOGCONFIG(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
     return;
   }
-
-  ESP_LOGCONFIG(TAG, "    Success...");
 }
 
 void NPI19Component::dump_config() {
@@ -90,7 +88,7 @@ void NPI19Component::update() {
   i2c::ErrorCode err = this->read_(raw_temperature, raw_pressure);
 
   if (err != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "I2C Communication Failed");
+    ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->status_set_warning();
     return;
   }

esphome/components/number/__init__.py

@@ -21,8 +21,10 @@ from esphome.const import (
     CONF_WEB_SERVER,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
+    DEVICE_CLASS_AREA,
     DEVICE_CLASS_ATMOSPHERIC_PRESSURE,
     DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BLOOD_GLUCOSE_CONCENTRATION,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CONDUCTIVITY,
@@ -33,6 +35,7 @@ from esphome.const import (
     DEVICE_CLASS_DURATION,
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_ENERGY_DISTANCE,
     DEVICE_CLASS_ENERGY_STORAGE,
     DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
@@ -54,6 +57,7 @@ from esphome.const import (
     DEVICE_CLASS_PRECIPITATION,
     DEVICE_CLASS_PRECIPITATION_INTENSITY,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_ENERGY,
     DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SOUND_PRESSURE,
@@ -68,6 +72,7 @@ from esphome.const import (
     DEVICE_CLASS_VOLUME_STORAGE,
     DEVICE_CLASS_WATER,
     DEVICE_CLASS_WEIGHT,
+    DEVICE_CLASS_WIND_DIRECTION,
     DEVICE_CLASS_WIND_SPEED,
 )
 from esphome.core import CORE, coroutine_with_priority
@@ -78,8 +83,10 @@ CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
+    DEVICE_CLASS_AREA,
     DEVICE_CLASS_ATMOSPHERIC_PRESSURE,
     DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BLOOD_GLUCOSE_CONCENTRATION,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CONDUCTIVITY,
@@ -90,6 +97,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_DURATION,
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_ENERGY_DISTANCE,
     DEVICE_CLASS_ENERGY_STORAGE,
     DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
@@ -111,6 +119,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_PRECIPITATION,
     DEVICE_CLASS_PRECIPITATION_INTENSITY,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_ENERGY,
     DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SOUND_PRESSURE,
@@ -125,6 +134,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_VOLUME_STORAGE,
     DEVICE_CLASS_WATER,
     DEVICE_CLASS_WEIGHT,
+    DEVICE_CLASS_WIND_DIRECTION,
     DEVICE_CLASS_WIND_SPEED,
 ]
 IS_PLATFORM_COMPONENT = True
@@ -267,6 +277,7 @@ async def register_number(
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_number(var))
+    CORE.register_platform_component("number", var)
     await setup_number_core_(
         var, config, min_value=min_value, max_value=max_value, step=step
     )