esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/smt100/smt100.cpp

@@ -16,7 +16,7 @@ void SMT100Component::loop() {
   while (this->available() != 0) {
     if (readline_(read(), buffer, MAX_LINE_LENGTH) > 0) {
       int counts = (int) strtol((strtok(buffer, ",")), nullptr, 10);
-      float dielectric_constant = (float) strtod((strtok(nullptr, ",")), nullptr);
+      float permittivity = (float) strtod((strtok(nullptr, ",")), nullptr);
       float moisture = (float) strtod((strtok(nullptr, ",")), nullptr);
       float temperature = (float) strtod((strtok(nullptr, ",")), nullptr);
       float voltage = (float) strtod((strtok(nullptr, ",")), nullptr);
@@ -25,8 +25,8 @@ void SMT100Component::loop() {
         counts_sensor_->publish_state(counts);
       }
 
-      if (this->dielectric_constant_sensor_ != nullptr) {
-        dielectric_constant_sensor_->publish_state(dielectric_constant);
+      if (this->permittivity_sensor_ != nullptr) {
+        permittivity_sensor_->publish_state(permittivity);
       }
 
       if (this->moisture_sensor_ != nullptr) {
@@ -49,8 +49,8 @@ float SMT100Component::get_setup_priority() const { return setup_priority::DATA;
 void SMT100Component::dump_config() {
   ESP_LOGCONFIG(TAG, "SMT100:");
 
-  LOG_SENSOR(TAG, "Counts", this->temperature_sensor_);
-  LOG_SENSOR(TAG, "Dielectric Constant", this->temperature_sensor_);
+  LOG_SENSOR(TAG, "Counts", this->counts_sensor_);
+  LOG_SENSOR(TAG, "Permittivity", this->permittivity_sensor_);
   LOG_SENSOR(TAG, "Temperature", this->temperature_sensor_);
   LOG_SENSOR(TAG, "Moisture", this->moisture_sensor_);
   LOG_UPDATE_INTERVAL(this);

esphome/components/smt100/smt100.h

@@ -20,8 +20,8 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
   float get_setup_priority() const override;
 
   void set_counts_sensor(sensor::Sensor *counts_sensor) { this->counts_sensor_ = counts_sensor; }
-  void set_dielectric_constant_sensor(sensor::Sensor *dielectric_constant_sensor) {
-    this->dielectric_constant_sensor_ = dielectric_constant_sensor;
+  void set_permittivity_sensor(sensor::Sensor *permittivity_sensor) {
+    this->permittivity_sensor_ = permittivity_sensor;
   }
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
   void set_moisture_sensor(sensor::Sensor *moisture_sensor) { this->moisture_sensor_ = moisture_sensor; }
@@ -31,7 +31,7 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
   int readline_(int readch, char *buffer, int len);
 
   sensor::Sensor *counts_sensor_{nullptr};
-  sensor::Sensor *dielectric_constant_sensor_{nullptr};
+  sensor::Sensor *permittivity_sensor_{nullptr};
   sensor::Sensor *moisture_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *voltage_sensor_{nullptr};

esphome/components/sn74hc595/__init__.py

@@ -95,7 +95,7 @@ SN74HC595_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=2047),
     modes=[CONF_OUTPUT],
     mode_validator=_validate_output_mode,
-    invertable=True,
+    invertible=True,
 ).extend(
     {
         cv.Required(CONF_SN74HC595): cv.use_id(SN74HC595Component),

esphome/components/sn74hc595/sn74hc595.cpp

@@ -1,5 +1,6 @@
 #include "sn74hc595.h"
 #include "esphome/core/log.h"
+#include <ranges>
 
 namespace esphome {
 namespace sn74hc595 {
@@ -55,9 +56,9 @@ void SN74HC595Component::digital_write_(uint16_t pin, bool value) {
 }
 
 void SN74HC595GPIOComponent::write_gpio() {
-  for (auto byte = this->output_bytes_.rbegin(); byte != this->output_bytes_.rend(); byte++) {
+  for (uint8_t &output_byte : std::ranges::reverse_view(this->output_bytes_)) {
     for (int8_t i = 7; i >= 0; i--) {
-      bool bit = (*byte >> i) & 1;
+      bool bit = (output_byte >> i) & 1;
       this->data_pin_->digital_write(bit);
       this->clock_pin_->digital_write(true);
       this->clock_pin_->digital_write(false);
@@ -68,9 +69,9 @@ void SN74HC595GPIOComponent::write_gpio() {
 
 #ifdef USE_SPI
 void SN74HC595SPIComponent::write_gpio() {
-  for (auto byte = this->output_bytes_.rbegin(); byte != this->output_bytes_.rend(); byte++) {
+  for (uint8_t &output_byte : std::ranges::reverse_view(this->output_bytes_)) {
     this->enable();
-    this->transfer_byte(*byte);
+    this->transfer_byte(output_byte);
     this->disable();
   }
   SN74HC595Component::write_gpio();

esphome/components/sntp/sntp_component.cpp

@@ -1,7 +1,7 @@
 #include "sntp_component.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 #include "esp_sntp.h"
 #elif USE_ESP8266
 #include "sntp.h"
@@ -16,7 +16,7 @@ static const char *const TAG = "sntp";
 
 void SNTPComponent::setup() {
   ESP_LOGCONFIG(TAG, "Running setup");
-#if defined(USE_ESP_IDF)
+#if defined(USE_ESP32)
   if (esp_sntp_enabled()) {
     esp_sntp_stop();
   }
@@ -46,7 +46,7 @@ void SNTPComponent::dump_config() {
   }
 }
 void SNTPComponent::update() {
-#if !defined(USE_ESP_IDF)
+#if !defined(USE_ESP32)
   // force resync
   if (sntp_enabled()) {
     sntp_stop();
@@ -67,6 +67,12 @@ void SNTPComponent::loop() {
            time.minute, time.second);
   this->time_sync_callback_.call();
   this->has_time_ = true;
+
+#ifdef USE_ESP_IDF
+  // On ESP-IDF, time sync is permanent and update() doesn't force resync
+  // Time is now synchronized, no need to check anymore
+  this->disable_loop();
+#endif
 }
 
 }  // namespace sntp

esphome/components/sntp/time.py

@@ -7,6 +7,7 @@ from esphome.const import (
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
+    PLATFORM_LN882X,
     PLATFORM_RP2040,
     PLATFORM_RTL87XX,
 )
@@ -33,6 +34,7 @@ CONFIG_SCHEMA = cv.All(
             PLATFORM_ESP8266,
             PLATFORM_RP2040,
             PLATFORM_BK72XX,
+            PLATFORM_LN882X,
             PLATFORM_RTL87XX,
         ]
     ),

esphome/components/socket/__init__.py

@@ -1,5 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.core import CORE
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -16,6 +17,7 @@ CONFIG_SCHEMA = cv.Schema(
             esp32=IMPLEMENTATION_BSD_SOCKETS,
             rp2040=IMPLEMENTATION_LWIP_TCP,
             bk72xx=IMPLEMENTATION_LWIP_SOCKETS,
+            ln882x=IMPLEMENTATION_LWIP_SOCKETS,
             rtl87xx=IMPLEMENTATION_LWIP_SOCKETS,
             host=IMPLEMENTATION_BSD_SOCKETS,
         ): cv.one_of(
@@ -39,3 +41,18 @@ async def to_code(config):
     elif impl == IMPLEMENTATION_BSD_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
         cg.add_define("USE_SOCKET_SELECT_SUPPORT")
+
+
+def FILTER_SOURCE_FILES() -> list[str]:
+    """Return list of socket implementation files that aren't selected by the user."""
+    impl = CORE.config["socket"][CONF_IMPLEMENTATION]
+
+    # Build list of files to exclude based on selected implementation
+    excluded = []
+    if impl != IMPLEMENTATION_LWIP_TCP:
+        excluded.append("lwip_raw_tcp_impl.cpp")
+    if impl != IMPLEMENTATION_BSD_SOCKETS:
+        excluded.append("bsd_sockets_impl.cpp")
+    if impl != IMPLEMENTATION_LWIP_SOCKETS:
+        excluded.append("lwip_sockets_impl.cpp")
+    return excluded

esphome/components/spi/__init__.py

@@ -13,6 +13,7 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CLK_PIN,
@@ -31,6 +32,7 @@ from esphome.const import (
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PLATFORM_RP2040,
+    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
@@ -79,6 +81,7 @@ CONF_SPI_MODE = "spi_mode"
 CONF_FORCE_SW = "force_sw"
 CONF_INTERFACE = "interface"
 CONF_INTERFACE_INDEX = "interface_index"
+CONF_RELEASE_DEVICE = "release_device"
 TYPE_SINGLE = "single"
 TYPE_QUAD = "quad"
 TYPE_OCTAL = "octal"
@@ -378,6 +381,7 @@ def spi_device_schema(
         cv.Optional(CONF_SPI_MODE, default=default_mode): cv.enum(
             SPI_MODE_OPTIONS, upper=True
         ),
+        cv.Optional(CONF_RELEASE_DEVICE): cv.All(cv.boolean, cv.only_with_esp_idf),
     }
     if cs_pin_required:
         schema[cv.Required(CONF_CS_PIN)] = pins.gpio_output_pin_schema
@@ -389,13 +393,15 @@ def spi_device_schema(
 async def register_spi_device(var, config):
     parent = await cg.get_variable(config[CONF_SPI_ID])
     cg.add(var.set_spi_parent(parent))
-    if CONF_CS_PIN in config:
-        pin = await cg.gpio_pin_expression(config[CONF_CS_PIN])
+    if cs_pin := config.get(CONF_CS_PIN):
+        pin = await cg.gpio_pin_expression(cs_pin)
         cg.add(var.set_cs_pin(pin))
-    if CONF_DATA_RATE in config:
-        cg.add(var.set_data_rate(config[CONF_DATA_RATE]))
-    if CONF_SPI_MODE in config:
-        cg.add(var.set_mode(config[CONF_SPI_MODE]))
+    if data_rate := config.get(CONF_DATA_RATE):
+        cg.add(var.set_data_rate(data_rate))
+    if spi_mode := config.get(CONF_SPI_MODE):
+        cg.add(var.set_mode(spi_mode))
+    if release_device := config.get(CONF_RELEASE_DEVICE):
+        cg.add(var.set_release_device(release_device))
 
 
 def final_validate_device_schema(name: str, *, require_mosi: bool, require_miso: bool):
@@ -419,3 +425,18 @@ def final_validate_device_schema(name: str, *, require_mosi: bool, require_miso:
         {cv.Required(CONF_SPI_ID): fv.id_declaration_match_schema(hub_schema)},
         extra=cv.ALLOW_EXTRA,
     )
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "spi_arduino.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP8266_ARDUINO,
+            PlatformFramework.RP2040_ARDUINO,
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+        "spi_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
+    }
+)

esphome/components/spi/spi.cpp

@@ -16,12 +16,13 @@ bool SPIDelegate::is_ready() { return true; }
 GPIOPin *const NullPin::NULL_PIN = new NullPin();  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 SPIDelegate *SPIComponent::register_device(SPIClient *device, SPIMode mode, SPIBitOrder bit_order, uint32_t data_rate,
-                                           GPIOPin *cs_pin) {
+                                           GPIOPin *cs_pin, bool release_device, bool write_only) {
   if (this->devices_.count(device) != 0) {
     ESP_LOGE(TAG, "Device already registered");
     return this->devices_[device];
   }
-  SPIDelegate *delegate = this->spi_bus_->get_delegate(data_rate, bit_order, mode, cs_pin);  // NOLINT
+  SPIDelegate *delegate =
+      this->spi_bus_->get_delegate(data_rate, bit_order, mode, cs_pin, release_device, write_only);  // NOLINT
   this->devices_[device] = delegate;
   return delegate;
 }

esphome/components/spi/spi.h

@@ -317,7 +317,8 @@ class SPIBus {
 
   SPIBus(GPIOPin *clk, GPIOPin *sdo, GPIOPin *sdi) : clk_pin_(clk), sdo_pin_(sdo), sdi_pin_(sdi) {}
 
-  virtual SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin) {
+  virtual SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin,
+                                    bool release_device, bool write_only) {
     return new SPIDelegateBitBash(data_rate, bit_order, mode, cs_pin, this->clk_pin_, this->sdo_pin_, this->sdi_pin_);
   }
 
@@ -334,7 +335,7 @@ class SPIClient;
 class SPIComponent : public Component {
  public:
   SPIDelegate *register_device(SPIClient *device, SPIMode mode, SPIBitOrder bit_order, uint32_t data_rate,
-                               GPIOPin *cs_pin);
+                               GPIOPin *cs_pin, bool release_device, bool write_only);
   void unregister_device(SPIClient *device);
 
   void set_clk(GPIOPin *clk) { this->clk_pin_ = clk; }
@@ -390,7 +391,8 @@ class SPIClient {
 
   virtual void spi_setup() {
     esph_log_d("spi_device", "mode %u, data_rate %ukHz", (unsigned) this->mode_, (unsigned) (this->data_rate_ / 1000));
-    this->delegate_ = this->parent_->register_device(this, this->mode_, this->bit_order_, this->data_rate_, this->cs_);
+    this->delegate_ = this->parent_->register_device(this, this->mode_, this->bit_order_, this->data_rate_, this->cs_,
+                                                     this->release_device_, this->write_only_);
   }
 
   virtual void spi_teardown() {
@@ -399,6 +401,8 @@ class SPIClient {
   }
 
   bool spi_is_ready() { return this->delegate_->is_ready(); }
+  void set_release_device(bool release) { this->release_device_ = release; }
+  void set_write_only(bool write_only) { this->write_only_ = write_only; }
 
  protected:
   SPIBitOrder bit_order_{BIT_ORDER_MSB_FIRST};
@@ -406,6 +410,8 @@ class SPIClient {
   uint32_t data_rate_{1000000};
   SPIComponent *parent_{nullptr};
   GPIOPin *cs_{nullptr};
+  bool release_device_{false};
+  bool write_only_{false};
   SPIDelegate *delegate_{SPIDelegate::NULL_DELEGATE};
 };
 

esphome/components/spi/spi_arduino.cpp

@@ -43,10 +43,7 @@ class SPIDelegateHw : public SPIDelegate {
       return;
     }
 #ifdef USE_RP2040
-    // avoid overwriting the supplied buffer. Use vector for automatic deallocation
-    auto rxbuf = std::vector<uint8_t>(length);
-    memcpy(rxbuf.data(), ptr, length);
-    this->channel_->transfer((void *) rxbuf.data(), length);
+    this->channel_->transfer(ptr, nullptr, length);
 #elif defined(USE_ESP8266)
     // ESP8266 SPI library requires the pointer to be word aligned, but the data may not be
     // so we need to copy the data to a temporary buffer
@@ -89,7 +86,8 @@ class SPIBusHw : public SPIBus {
 #endif
   }
 
-  SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin) override {
+  SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin,
+                            bool release_device, bool write_only) override {
     return new SPIDelegateHw(this->channel_, data_rate, bit_order, mode, cs_pin);
   }
 

esphome/components/spi/spi_esp_idf.cpp

@@ -11,34 +11,26 @@ static const size_t MAX_TRANSFER_SIZE = 4092;  // dictated by ESP-IDF API.
 class SPIDelegateHw : public SPIDelegate {
  public:
   SPIDelegateHw(SPIInterface channel, uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin,
-                bool write_only)
-      : SPIDelegate(data_rate, bit_order, mode, cs_pin), channel_(channel), write_only_(write_only) {
-    spi_device_interface_config_t config = {};
-    config.mode = static_cast<uint8_t>(mode);
-    config.clock_speed_hz = static_cast<int>(data_rate);
-    config.spics_io_num = -1;
-    config.flags = 0;
-    config.queue_size = 1;
-    config.pre_cb = nullptr;
-    config.post_cb = nullptr;
-    if (bit_order == BIT_ORDER_LSB_FIRST)
-      config.flags |= SPI_DEVICE_BIT_LSBFIRST;
-    if (write_only)
-      config.flags |= SPI_DEVICE_HALFDUPLEX | SPI_DEVICE_NO_DUMMY;
-    esp_err_t const err = spi_bus_add_device(channel, &config, &this->handle_);
-    if (err != ESP_OK)
-      ESP_LOGE(TAG, "Add device failed - err %X", err);
+                bool release_device, bool write_only)
+      : SPIDelegate(data_rate, bit_order, mode, cs_pin),
+        channel_(channel),
+        release_device_(release_device),
+        write_only_(write_only) {
+    if (!this->release_device_)
+      add_device_();
   }
 
   bool is_ready() override { return this->handle_ != nullptr; }
 
   void begin_transaction() override {
+    if (this->release_device_)
+      this->add_device_();
     if (this->is_ready()) {
       if (spi_device_acquire_bus(this->handle_, portMAX_DELAY) != ESP_OK)
         ESP_LOGE(TAG, "Failed to acquire SPI bus");
       SPIDelegate::begin_transaction();
     } else {
-      ESP_LOGW(TAG, "spi_setup called before initialisation");
+      ESP_LOGW(TAG, "SPI device not ready, cannot begin transaction");
     }
   }
 
@@ -46,6 +38,10 @@ class SPIDelegateHw : public SPIDelegate {
     if (this->is_ready()) {
       SPIDelegate::end_transaction();
       spi_device_release_bus(this->handle_);
+      if (this->release_device_) {
+        spi_bus_remove_device(this->handle_);
+        this->handle_ = nullptr;  // reset handle to indicate no device is registered
+      }
     }
   }
 
@@ -189,8 +185,30 @@ class SPIDelegateHw : public SPIDelegate {
   void read_array(uint8_t *ptr, size_t length) override { this->transfer(nullptr, ptr, length); }
 
  protected:
+  bool add_device_() {
+    spi_device_interface_config_t config = {};
+    config.mode = static_cast<uint8_t>(this->mode_);
+    config.clock_speed_hz = static_cast<int>(this->data_rate_);
+    config.spics_io_num = -1;
+    config.flags = 0;
+    config.queue_size = 1;
+    config.pre_cb = nullptr;
+    config.post_cb = nullptr;
+    if (this->bit_order_ == BIT_ORDER_LSB_FIRST)
+      config.flags |= SPI_DEVICE_BIT_LSBFIRST;
+    if (this->write_only_)
+      config.flags |= SPI_DEVICE_HALFDUPLEX | SPI_DEVICE_NO_DUMMY;
+    esp_err_t const err = spi_bus_add_device(this->channel_, &config, &this->handle_);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Add device failed - err %X", err);
+      return false;
+    }
+    return true;
+  }
+
   SPIInterface channel_{};
   spi_device_handle_t handle_{};
+  bool release_device_{false};
   bool write_only_{false};
 };
 
@@ -231,9 +249,10 @@ class SPIBusHw : public SPIBus {
       ESP_LOGE(TAG, "Bus init failed - err %X", err);
   }
 
-  SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin) override {
-    return new SPIDelegateHw(this->channel_, data_rate, bit_order, mode, cs_pin,
-                             Utility::get_pin_no(this->sdi_pin_) == -1);
+  SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin,
+                            bool release_device, bool write_only) override {
+    return new SPIDelegateHw(this->channel_, data_rate, bit_order, mode, cs_pin, release_device,
+                             write_only || Utility::get_pin_no(this->sdi_pin_) == -1);
   }
 
  protected:

esphome/components/spi_led_strip/spi_led_strip.cpp

@@ -5,7 +5,7 @@ namespace spi_led_strip {
 
 SpiLedStrip::SpiLedStrip(uint16_t num_leds) {
   this->num_leds_ = num_leds;
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   this->buffer_size_ = num_leds * 4 + 8;
   this->buf_ = allocator.allocate(this->buffer_size_);
   if (this->buf_ == nullptr) {

esphome/components/sps30/sps30.h

@@ -26,7 +26,6 @@ class SPS30Component : public PollingComponent, public sensirion_common::Sensiri
   void setup() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   bool start_fan_cleaning();
 

esphome/components/ssd1306_base/ssd1306_base.cpp

@@ -224,7 +224,7 @@ bool SSD1306::is_sh1106_() const {
 }
 bool SSD1306::is_sh1107_() const { return this->model_ == SH1107_MODEL_128_64 || this->model_ == SH1107_MODEL_128_128; }
 bool SSD1306::is_ssd1305_() const {
-  return this->model_ == SSD1305_MODEL_128_64 || this->model_ == SSD1305_MODEL_128_64;
+  return this->model_ == SSD1305_MODEL_128_64 || this->model_ == SSD1305_MODEL_128_32;
 }
 void SSD1306::update() {
   this->do_update_();

esphome/components/st7701s/st7701s.cpp

@@ -12,10 +12,8 @@ void ST7701S::setup() {
 
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;
-#if ESP_IDF_VERSION_MAJOR >= 5
   config.bounce_buffer_size_px = this->width_ * 10;
   config.num_fbs = 1;
-#endif  // ESP_IDF_VERSION_MAJOR
   config.timings.h_res = this->width_;
   config.timings.v_res = this->height_;
   config.timings.hsync_pulse_width = this->hsync_pulse_width_;
@@ -48,10 +46,8 @@ void ST7701S::setup() {
 }
 
 void ST7701S::loop() {
-#if ESP_IDF_VERSION_MAJOR >= 5
   if (this->handle_ != nullptr)
     esp_lcd_rgb_panel_restart(this->handle_);
-#endif  // ESP_IDF_VERSION_MAJOR
 }
 
 void ST7701S::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,

esphome/components/status/status_binary_sensor.h

@@ -13,8 +13,6 @@ class StatusBinarySensor : public binary_sensor::BinarySensor, public Component
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   bool is_status_binary_sensor() const override { return true; }
 };