esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/espnow/espnow_packet.h

@@ -0,0 +1,166 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include "espnow_err.h"
+
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <esp_err.h>
+#include <esp_idf_version.h>
+#include <esp_now.h>
+
+namespace esphome::espnow {
+
+static const uint8_t ESPNOW_BROADCAST_ADDR[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+static const uint8_t ESPNOW_MULTICAST_ADDR[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE};
+
+struct WifiPacketRxControl {
+  int8_t rssi;         // Received Signal Strength Indicator (RSSI) of packet, unit: dBm
+  uint32_t timestamp;  // Timestamp in microseconds when the packet was received, precise only if modem sleep or
+                       // light sleep is not enabled
+};
+
+struct ESPNowRecvInfo {
+  uint8_t src_addr[ESP_NOW_ETH_ALEN]; /**< Source address of ESPNOW packet */
+  uint8_t des_addr[ESP_NOW_ETH_ALEN]; /**< Destination address of ESPNOW packet */
+  wifi_pkt_rx_ctrl_t *rx_ctrl;        /**< Rx control info of ESPNOW packet */
+};
+
+using send_callback_t = std::function<void(esp_err_t)>;
+
+class ESPNowPacket {
+ public:
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  enum esp_now_packet_type_t : uint8_t {
+    RECEIVED,
+    SENT,
+  };
+
+  // Constructor for received data
+  ESPNowPacket(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
+    this->init_received_data_(info, data, size);
+  };
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
+  // Constructor for sent data
+  ESPNowPacket(const esp_now_send_info_t *info, esp_now_send_status_t status) {
+    this->init_sent_data_(info->src_addr, status);
+  }
+#else
+  // Constructor for sent data
+  ESPNowPacket(const uint8_t *mac_addr, esp_now_send_status_t status) { this->init_sent_data_(mac_addr, status); }
+#endif
+
+  // Default constructor for pre-allocation in pool
+  ESPNowPacket() {}
+
+  void release() {}
+
+  void load_received_data(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
+    this->type_ = RECEIVED;
+    this->init_received_data_(info, data, size);
+  }
+
+  void load_sent_data(const uint8_t *mac_addr, esp_now_send_status_t status) {
+    this->type_ = SENT;
+    this->init_sent_data_(mac_addr, status);
+  }
+
+  // Disable copy to prevent double-delete
+  ESPNowPacket(const ESPNowPacket &) = delete;
+  ESPNowPacket &operator=(const ESPNowPacket &) = delete;
+
+  union {
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    struct received_data {
+      ESPNowRecvInfo info;                 // Information about the received packet
+      uint8_t data[ESP_NOW_MAX_DATA_LEN];  // Data received in the packet
+      uint8_t size;                        // Size of the received data
+      WifiPacketRxControl rx_ctrl;         // Status of the received packet
+    } receive;
+
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    struct sent_data {
+      uint8_t address[ESP_NOW_ETH_ALEN];
+      esp_now_send_status_t status;
+    } sent;
+  } packet_;
+
+  esp_now_packet_type_t type_;
+
+  esp_now_packet_type_t type() const { return this->type_; }
+  const ESPNowRecvInfo &get_receive_info() const { return this->packet_.receive.info; }
+
+ private:
+  void init_received_data_(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
+    memcpy(this->packet_.receive.info.src_addr, info->src_addr, ESP_NOW_ETH_ALEN);
+    memcpy(this->packet_.receive.info.des_addr, info->des_addr, ESP_NOW_ETH_ALEN);
+    memcpy(this->packet_.receive.data, data, size);
+    this->packet_.receive.size = size;
+
+    this->packet_.receive.rx_ctrl.rssi = info->rx_ctrl->rssi;
+    this->packet_.receive.rx_ctrl.timestamp = info->rx_ctrl->timestamp;
+
+    this->packet_.receive.info.rx_ctrl = reinterpret_cast<wifi_pkt_rx_ctrl_t *>(&this->packet_.receive.rx_ctrl);
+  }
+
+  void init_sent_data_(const uint8_t *mac_addr, esp_now_send_status_t status) {
+    memcpy(this->packet_.sent.address, mac_addr, ESP_NOW_ETH_ALEN);
+    this->packet_.sent.status = status;
+  }
+};
+
+class ESPNowSendPacket {
+ public:
+  ESPNowSendPacket(const uint8_t *peer_address, const uint8_t *payload, size_t size, const send_callback_t &&callback)
+      : callback_(callback) {
+    this->init_data_(peer_address, payload, size);
+  }
+  ESPNowSendPacket(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
+    this->init_data_(peer_address, payload, size);
+  }
+
+  // Default constructor for pre-allocation in pool
+  ESPNowSendPacket() {}
+
+  void release() {}
+
+  // Disable copy to prevent double-delete
+  ESPNowSendPacket(const ESPNowSendPacket &) = delete;
+  ESPNowSendPacket &operator=(const ESPNowSendPacket &) = delete;
+
+  void load_data(const uint8_t *peer_address, const uint8_t *payload, size_t size, const send_callback_t &callback) {
+    this->init_data_(peer_address, payload, size);
+    this->callback_ = callback;
+  }
+
+  void load_data(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
+    this->init_data_(peer_address, payload, size);
+    this->callback_ = nullptr;  // Reset callback
+  }
+
+  uint8_t address_[ESP_NOW_ETH_ALEN]{0};   // MAC address of the peer to send the packet to
+  uint8_t data_[ESP_NOW_MAX_DATA_LEN]{0};  // Data to send
+  uint8_t size_{0};                        // Size of the data to send, must be <= ESP_NOW_MAX_DATA_LEN
+  send_callback_t callback_{nullptr};      // Callback to call when the send operation is complete
+
+ private:
+  void init_data_(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
+    memcpy(this->address_, peer_address, ESP_NOW_ETH_ALEN);
+    if (size > ESP_NOW_MAX_DATA_LEN) {
+      this->size_ = 0;
+      return;
+    }
+    this->size_ = size;
+    memcpy(this->data_, payload, this->size_);
+  }
+};
+
+}  // namespace esphome::espnow
+
+#endif  // USE_ESP32

esphome/components/ethernet/__init__.py

@@ -112,7 +112,7 @@ def _is_framework_spi_polling_mode_supported():
             return True
         if cv.Version(5, 3, 0) > framework_version >= cv.Version(5, 2, 1):
             return True
-        if cv.Version(5, 2, 0) > framework_version >= cv.Version(5, 1, 4):
+        if cv.Version(5, 2, 0) > framework_version >= cv.Version(5, 1, 4):  # noqa: SIM103
             return True
         return False
     if CORE.using_arduino:
@@ -342,5 +342,11 @@ async def to_code(config):
 
     cg.add_define("USE_ETHERNET")
 
+    # Disable WiFi when using Ethernet to save memory
+    if CORE.using_esp_idf:
+        add_idf_sdkconfig_option("CONFIG_ESP_WIFI_ENABLED", False)
+        # Also disable WiFi/BT coexistence since WiFi is disabled
+        add_idf_sdkconfig_option("CONFIG_SW_COEXIST_ENABLE", False)
+
     if CORE.using_arduino:
         cg.add_library("WiFi", None)

esphome/components/ethernet/esp_eth_phy_jl1101.c

@@ -25,6 +25,9 @@
 #include "driver/gpio.h"
 #include "esp_rom_gpio.h"
 #include "esp_rom_sys.h"
+#include "esp_idf_version.h"
+
+#if defined(USE_ARDUINO) || ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
 
 static const char *TAG = "jl1101";
 #define PHY_CHECK(a, str, goto_tag, ...) \
@@ -336,4 +339,6 @@ esp_eth_phy_t *esp_eth_phy_new_jl1101(const eth_phy_config_t *config) {
 err:
   return NULL;
 }
+
+#endif /* USE_ARDUINO */
 #endif /* USE_ESP32 */

esphome/components/ethernet/ethernet_component.cpp

@@ -54,7 +54,6 @@ EthernetComponent *global_eth_component;  // NOLINT(cppcoreguidelines-avoid-non-
 EthernetComponent::EthernetComponent() { global_eth_component = this; }
 
 void EthernetComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (esp_reset_reason() != ESP_RST_DEEPSLEEP) {
     // Delay here to allow power to stabilise before Ethernet is initialized.
     delay(300);  // NOLINT

esphome/components/ethernet/ethernet_component.h

@@ -11,6 +11,7 @@
 #include "esp_eth_mac.h"
 #include "esp_netif.h"
 #include "esp_mac.h"
+#include "esp_idf_version.h"
 
 namespace esphome {
 namespace ethernet {
@@ -153,7 +154,10 @@ class EthernetComponent : public Component {
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern EthernetComponent *global_eth_component;
+
+#if defined(USE_ARDUINO) || ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
 extern "C" esp_eth_phy_t *esp_eth_phy_new_jl1101(const eth_phy_config_t *config);
+#endif
 
 }  // namespace ethernet
 }  // namespace esphome

esphome/components/ethernet_info/ethernet_info_text_sensor.h

@@ -29,7 +29,6 @@ class IPAddressEthernetInfo : public PollingComponent, public text_sensor::TextS
   }
 
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo"; }
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
 
@@ -52,7 +51,6 @@ class DNSAddressEthernetInfo : public PollingComponent, public text_sensor::Text
     }
   }
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo-dns"; }
   void dump_config() override;
 
  protected:
@@ -63,7 +61,6 @@ class MACAddressEthernetInfo : public Component, public text_sensor::TextSensor
  public:
   void setup() override { this->publish_state(ethernet::global_eth_component->get_eth_mac_address_pretty()); }
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo-mac"; }
   void dump_config() override;
 };
 

esphome/components/event/__init__.py

@@ -145,5 +145,4 @@ async def event_fire_to_code(config, action_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_EVENT")
     cg.add_global(event_ns.using)

esphome/components/factory_reset/__init__.py

@@ -1,5 +1,97 @@
+from esphome.automation import Trigger, build_automation, validate_automation
 import esphome.codegen as cg
+from esphome.components.esp8266 import CONF_RESTORE_FROM_FLASH, KEY_ESP8266
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_TRIGGER_ID,
+    PLATFORM_BK72XX,
+    PLATFORM_ESP32,
+    PLATFORM_ESP8266,
+    PLATFORM_LN882X,
+    PLATFORM_RTL87XX,
+)
+from esphome.core import CORE
+from esphome.final_validate import full_config
 
 CODEOWNERS = ["@anatoly-savchenkov"]
 
 factory_reset_ns = cg.esphome_ns.namespace("factory_reset")
+FactoryResetComponent = factory_reset_ns.class_("FactoryResetComponent", cg.Component)
+FastBootTrigger = factory_reset_ns.class_("FastBootTrigger", Trigger, cg.Component)
+
+CONF_MAX_DELAY = "max_delay"
+CONF_RESETS_REQUIRED = "resets_required"
+CONF_ON_INCREMENT = "on_increment"
+
+
+def _validate(config):
+    if CONF_RESETS_REQUIRED in config:
+        return cv.only_on(
+            [
+                PLATFORM_BK72XX,
+                PLATFORM_ESP32,
+                PLATFORM_ESP8266,
+                PLATFORM_LN882X,
+                PLATFORM_RTL87XX,
+            ]
+        )(config)
+
+    if CONF_ON_INCREMENT in config:
+        raise cv.Invalid(
+            f"'{CONF_ON_INCREMENT}' requires a value for '{CONF_RESETS_REQUIRED}'"
+        )
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(FactoryResetComponent),
+            cv.Optional(CONF_MAX_DELAY, default="10s"): cv.All(
+                cv.positive_time_period_seconds,
+                cv.Range(min=cv.TimePeriod(milliseconds=1000)),
+            ),
+            cv.Optional(CONF_RESETS_REQUIRED): cv.positive_not_null_int,
+            cv.Optional(CONF_ON_INCREMENT): validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FastBootTrigger),
+                }
+            ),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    _validate,
+)
+
+
+def _final_validate(config):
+    if CORE.is_esp8266 and CONF_RESETS_REQUIRED in config:
+        fconfig = full_config.get()
+        if not fconfig.get_config_for_path([KEY_ESP8266, CONF_RESTORE_FROM_FLASH]):
+            raise cv.Invalid(
+                "'resets_required' needs 'restore_from_flash' to be enabled in the  'esp8266' configuration"
+            )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    if reset_count := config.get(CONF_RESETS_REQUIRED):
+        var = cg.new_Pvariable(
+            config[CONF_ID],
+            reset_count,
+            config[CONF_MAX_DELAY].total_milliseconds,
+        )
+        await cg.register_component(var, config)
+        for conf in config.get(CONF_ON_INCREMENT, []):
+            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+            await build_automation(
+                trigger,
+                [
+                    (cg.uint8, "x"),
+                    (cg.uint8, "target"),
+                ],
+                conf,
+            )

esphome/components/factory_reset/factory_reset.cpp

@@ -0,0 +1,76 @@
+#include "factory_reset.h"
+
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+
+#if !defined(USE_RP2040) && !defined(USE_HOST)
+
+namespace esphome {
+namespace factory_reset {
+
+static const char *const TAG = "factory_reset";
+static const uint32_t POWER_CYCLES_KEY = 0xFA5C0DE;
+
+static bool was_power_cycled() {
+#ifdef USE_ESP32
+  return esp_reset_reason() == ESP_RST_POWERON;
+#endif
+#ifdef USE_ESP8266
+  auto reset_reason = EspClass::getResetReason();
+  return strcasecmp(reset_reason.c_str(), "power On") == 0 || strcasecmp(reset_reason.c_str(), "external system") == 0;
+#endif
+#ifdef USE_LIBRETINY
+  auto reason = lt_get_reboot_reason();
+  return reason == REBOOT_REASON_POWER || reason == REBOOT_REASON_HARDWARE;
+#endif
+}
+
+void FactoryResetComponent::dump_config() {
+  uint8_t count = 0;
+  this->flash_.load(&count);
+  ESP_LOGCONFIG(TAG, "Factory Reset by Reset:");
+  ESP_LOGCONFIG(TAG,
+                "  Max interval between resets %" PRIu32 " seconds\n"
+                "  Current count: %u\n"
+                "  Factory reset after %u resets",
+                this->max_interval_ / 1000, count, this->required_count_);
+}
+
+void FactoryResetComponent::save_(uint8_t count) {
+  this->flash_.save(&count);
+  global_preferences->sync();
+  this->defer([count, this] { this->increment_callback_.call(count, this->required_count_); });
+}
+
+void FactoryResetComponent::setup() {
+  this->flash_ = global_preferences->make_preference<uint8_t>(POWER_CYCLES_KEY, true);
+  if (was_power_cycled()) {
+    uint8_t count = 0;
+    this->flash_.load(&count);
+    // this is a power on reset or external system reset
+    count++;
+    if (count == this->required_count_) {
+      ESP_LOGW(TAG, "Reset count reached, factory resetting");
+      global_preferences->reset();
+      // delay to allow log to be sent
+      delay(100);         // NOLINT
+      App.safe_reboot();  // should not return
+    }
+    this->save_(count);
+    ESP_LOGD(TAG, "Power on reset detected, incremented count to %u", count);
+    this->set_timeout(this->max_interval_, [this]() {
+      ESP_LOGD(TAG, "No reset in the last %" PRIu32 " seconds, resetting count", this->max_interval_ / 1000);
+      this->save_(0);  // reset count
+    });
+  } else {
+    this->save_(0);  // reset count if not a power cycle
+  }
+}
+
+}  // namespace factory_reset
+}  // namespace esphome
+
+#endif  // !defined(USE_RP2040) && !defined(USE_HOST)

esphome/components/factory_reset/factory_reset.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/preferences.h"
+#if !defined(USE_RP2040) && !defined(USE_HOST)
+
+#ifdef USE_ESP32
+#include <esp_system.h>
+#endif
+
+namespace esphome {
+namespace factory_reset {
+class FactoryResetComponent : public Component {
+ public:
+  FactoryResetComponent(uint8_t required_count, uint32_t max_interval)
+      : required_count_(required_count), max_interval_(max_interval) {}
+
+  void dump_config() override;
+  void setup() override;
+  void add_increment_callback(std::function<void(uint8_t, uint8_t)> &&callback) {
+    this->increment_callback_.add(std::move(callback));
+  }
+
+ protected:
+  ~FactoryResetComponent() = default;
+  void save_(uint8_t count);
+  ESPPreferenceObject flash_{};  // saves the number of fast power cycles
+  uint8_t required_count_;       // The number of boot attempts before fast boot is enabled
+  uint32_t max_interval_;        // max interval between power cycles
+  CallbackManager<void(uint8_t, uint8_t)> increment_callback_{};
+};
+
+class FastBootTrigger : public Trigger<uint8_t, uint8_t> {
+ public:
+  explicit FastBootTrigger(FactoryResetComponent *parent) {
+    parent->add_increment_callback([this](uint8_t current, uint8_t target) { this->trigger(current, target); });
+  }
+};
+}  // namespace factory_reset
+}  // namespace esphome
+
+#endif  // !defined(USE_RP2040) && !defined(USE_HOST)

esphome/components/fan/__init__.py

@@ -400,5 +400,4 @@ async def fan_is_on_off_to_code(config, condition_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_FAN")
     cg.add_global(fan_ns.using)

esphome/components/fan/fan_traits.h

@@ -4,6 +4,13 @@
 #pragma once
 
 namespace esphome {
+
+#ifdef USE_API
+namespace api {
+class APIConnection;
+}  // namespace api
+#endif
+
 namespace fan {
 
 class FanTraits {
@@ -36,6 +43,15 @@ class FanTraits {
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
  protected:
+#ifdef USE_API
+  // The API connection is a friend class to access internal methods
+  friend class api::APIConnection;
+  // This method returns a reference to the internal preset modes set.
+  // It is used by the API to avoid copying data when encoding messages.
+  // Warning: Do not use this method outside of the API connection code.
+  // It returns a reference to internal data that can be invalidated.
+  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
+#endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};

esphome/components/fastled_base/fastled_light.cpp

@@ -9,7 +9,6 @@ namespace fastled_base {
 static const char *const TAG = "fastled";
 
 void FastLEDLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->controller_->init();
   this->controller_->setLeds(this->leds_, this->num_leds_);
   this->effect_data_ = new uint8_t[this->num_leds_];  // NOLINT

esphome/components/fastled_spi/light.py

@@ -55,9 +55,7 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     var = await fastled_base.new_fastled_light(config)
 
-    rgb_order = cg.RawExpression(
-        config[CONF_RGB_ORDER] if CONF_RGB_ORDER in config else "RGB"
-    )
+    rgb_order = cg.RawExpression(config.get(CONF_RGB_ORDER, "RGB"))
     data_rate = None
 
     if CONF_DATA_RATE in config:

esphome/components/fingerprint_grow/fingerprint_grow.cpp

@@ -57,8 +57,6 @@ void FingerprintGrowComponent::update() {
 }
 
 void FingerprintGrowComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   this->has_sensing_pin_ = (this->sensing_pin_ != nullptr);
   this->has_power_pin_ = (this->sensor_power_pin_ != nullptr);
 

esphome/components/font/__init__.py

@@ -15,6 +15,7 @@ from freetype import (
     FT_LOAD_RENDER,
     FT_LOAD_TARGET_MONO,
     Face,
+    FT_Exception,
     ft_pixel_mode_mono,
 )
 import requests
@@ -94,7 +95,14 @@ class FontCache(MutableMapping):
         return self.store[self._keytransform(item)]
 
     def __setitem__(self, key, value):
-        self.store[self._keytransform(key)] = Face(str(value))
+        transformed = self._keytransform(key)
+        try:
+            self.store[transformed] = Face(str(value))
+        except FT_Exception as exc:
+            file = transformed.split(":", 1)
+            raise cv.Invalid(
+                f"{file[0].capitalize()} {file[1]} is not a valid font file"
+            ) from exc
 
 
 FONT_CACHE = FontCache()

esphome/components/fs3000/fs3000.cpp

@@ -7,8 +7,6 @@ namespace fs3000 {
 static const char *const TAG = "fs3000";
 
 void FS3000Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (model_ == FIVE) {
     // datasheet gives 9 points to interpolate from for the 1005 model
     static const uint16_t RAW_DATA_POINTS_1005[9] = {409, 915, 1522, 2066, 2523, 2908, 3256, 3572, 3686};

esphome/components/ft5x06/touchscreen/ft5x06_touchscreen.cpp

@@ -9,7 +9,6 @@ namespace ft5x06 {
 static const char *const TAG = "ft5x06.touchscreen";
 
 void FT5x06Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->setup();
     this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
@@ -50,7 +49,6 @@ void FT5x06Touchscreen::continue_setup_() {
       this->y_raw_max_ = this->display_->get_native_height();
     }
   }
-  ESP_LOGCONFIG(TAG, "FT5x06 Touchscreen setup complete");
 }
 
 void FT5x06Touchscreen::update_touches() {

esphome/components/ft63x6/ft63x6.cpp

@@ -28,7 +28,6 @@ static const uint8_t FT63X6_ADDR_CHIP_ID = 0xA3;
 static const char *const TAG = "FT63X6";
 
 void FT63X6Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
     this->interrupt_pin_->setup();

esphome/components/gdk101/gdk101.cpp

@@ -34,7 +34,6 @@ void GDK101Component::update() {
 
 void GDK101Component::setup() {
   uint8_t data[2];
-  ESP_LOGCONFIG(TAG, "Running setup");
   // first, reset the sensor
   if (!this->reset_sensor_(data)) {
     this->status_set_error("Reset failed!");

esphome/components/gl_r01_i2c/gl_r01_i2c.cpp

@@ -17,7 +17,6 @@ static const uint8_t RESTART_CMD2 = 0xA5;
 static const uint8_t READ_DELAY = 40;  // minimum milliseconds from datasheet to safely read measurement result
 
 void GLR01I2CComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up GL-R01 I2C...");
   // Verify sensor presence
   if (!this->read_byte_16(REG_VERSION, &this->version_)) {
     ESP_LOGE(TAG, "Failed to communicate with GL-R01 I2C sensor!");

esphome/components/gl_r01_i2c/sensor.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import i2c, sensor
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
     DEVICE_CLASS_DISTANCE,

esphome/components/gpio/one_wire/gpio_one_wire.cpp

@@ -8,7 +8,6 @@ namespace gpio {
 static const char *const TAG = "gpio.one_wire";
 
 void GPIOOneWireBus::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->t_pin_->setup();
   this->t_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
   // clear bus with 480µs high, otherwise initial reset in search might fail

esphome/components/gpio/switch/gpio_switch.cpp

@@ -8,8 +8,6 @@ static const char *const TAG = "switch.gpio";
 
 float GPIOSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 void GPIOSwitch::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
-
   bool initial_state = this->get_initial_state_with_restore_mode().value_or(false);
 
   // write state before setup