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

esphome/components/rf_bridge/__init__.py

@@ -136,8 +136,7 @@ RFBRIDGE_ID_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(RFBridgeComponent)})
 @automation.register_action("rf_bridge.learn", RFBridgeLearnAction, RFBRIDGE_ID_SCHEMA)
 async def rf_bridge_learnx_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -149,8 +148,7 @@ async def rf_bridge_start_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -162,8 +160,7 @@ async def rf_bridge_stop_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -175,8 +172,7 @@ async def rf_bridge_start_bucket_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 RFBRIDGE_SEND_ADVANCED_CODE_SCHEMA = cv.Schema(

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -129,8 +129,6 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
 }
 
 void RotaryEncoderSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
-
   int32_t initial_value = 0;
   switch (this->restore_mode_) {
     case ROTARY_ENCODER_RESTORE_DEFAULT_ZERO:

esphome/components/rp2040/__init__.py

@@ -16,6 +16,7 @@ from esphome.const import (
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_RP2040,
+    ThreadModel,
 )
 from esphome.core import CORE, EsphomeError, coroutine_with_priority
 from esphome.helpers import copy_file_if_changed, mkdir_p, read_file, write_file
@@ -171,6 +172,7 @@ async def to_code(config):
     cg.set_cpp_standard("gnu++20")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", "RP2040")
+    cg.add_define(ThreadModel.SINGLE)
 
     cg.add_platformio_option("extra_scripts", ["post:post_build.py"])
 
@@ -204,7 +206,7 @@ def add_pio_file(component: str, key: str, data: str):
         cv.validate_id_name(key)
     except cv.Invalid as e:
         raise EsphomeError(
-            f"[{component}] Invalid PIO key: {key}. Allowed characters: [{ascii_letters}{digits}_]\nPlease report an issue https://github.com/esphome/issues"
+            f"[{component}] Invalid PIO key: {key}. Allowed characters: [{ascii_letters}{digits}_]\nPlease report an issue https://github.com/esphome/esphome/issues"
         ) from e
     CORE.data[KEY_RP2040][KEY_PIO_FILES][key] = data
 

esphome/components/rp2040_pio_led_strip/led_strip.cpp

@@ -40,8 +40,6 @@ void RP2040PIOLEDStripLightOutput::dma_write_complete_handler_() {
 }
 
 void RP2040PIOLEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   size_t buffer_size = this->get_buffer_size_();
 
   RAMAllocator<uint8_t> allocator;

esphome/components/rp2040_pio_led_strip/light.py

@@ -125,8 +125,7 @@ writezero:
 
 def time_to_cycles(time_us):
     cycles_per_us = 57.5
-    cycles = round(float(time_us) * cycles_per_us)
-    return cycles
+    return round(float(time_us) * cycles_per_us)
 
 
 CONF_PIO = "pio"

esphome/components/rp2040_pwm/rp2040_pwm.cpp

@@ -16,11 +16,7 @@ namespace rp2040_pwm {
 
 static const char *const TAG = "rp2040_pwm";
 
-void RP2040PWM::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
-  this->setup_pwm_();
-}
+void RP2040PWM::setup() { this->setup_pwm_(); }
 
 void RP2040PWM::setup_pwm_() {
   pwm_config config = pwm_get_default_config();

esphome/components/rpi_dpi_rgb/display.py

@@ -2,6 +2,18 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display
 from esphome.components.esp32 import const, only_on_variant
+from esphome.components.mipi import (
+    CONF_DE_PIN,
+    CONF_HSYNC_BACK_PORCH,
+    CONF_HSYNC_FRONT_PORCH,
+    CONF_HSYNC_PULSE_WIDTH,
+    CONF_PCLK_FREQUENCY,
+    CONF_PCLK_INVERTED,
+    CONF_PCLK_PIN,
+    CONF_VSYNC_BACK_PORCH,
+    CONF_VSYNC_FRONT_PORCH,
+    CONF_VSYNC_PULSE_WIDTH,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUE,
@@ -27,18 +39,6 @@ from esphome.const import (
 
 DEPENDENCIES = ["esp32"]
 
-CONF_DE_PIN = "de_pin"
-CONF_PCLK_PIN = "pclk_pin"
-
-CONF_HSYNC_FRONT_PORCH = "hsync_front_porch"
-CONF_HSYNC_PULSE_WIDTH = "hsync_pulse_width"
-CONF_HSYNC_BACK_PORCH = "hsync_back_porch"
-CONF_VSYNC_FRONT_PORCH = "vsync_front_porch"
-CONF_VSYNC_PULSE_WIDTH = "vsync_pulse_width"
-CONF_VSYNC_BACK_PORCH = "vsync_back_porch"
-CONF_PCLK_FREQUENCY = "pclk_frequency"
-CONF_PCLK_INVERTED = "pclk_inverted"
-
 rpi_dpi_rgb_ns = cg.esphome_ns.namespace("rpi_dpi_rgb")
 RPI_DPI_RGB = rpi_dpi_rgb_ns.class_("RpiDpiRgb", display.Display, cg.Component)
 ColorOrder = display.display_ns.enum("ColorMode")
@@ -140,7 +140,6 @@ async def to_code(config):
     cg.add(var.set_vsync_front_porch(config[CONF_VSYNC_FRONT_PORCH]))
     cg.add(var.set_pclk_inverted(config[CONF_PCLK_INVERTED]))
     cg.add(var.set_pclk_frequency(config[CONF_PCLK_FREQUENCY]))
-    index = 0
     dpins = []
     if CONF_RED in config[CONF_DATA_PINS]:
         red_pins = config[CONF_DATA_PINS][CONF_RED]
@@ -158,10 +157,9 @@ async def to_code(config):
         dpins = dpins[8:16] + dpins[0:8]
     else:
         dpins = config[CONF_DATA_PINS]
-    for pin in dpins:
+    for index, pin in enumerate(dpins):
         data_pin = await cg.gpio_pin_expression(pin)
         cg.add(var.add_data_pin(data_pin, index))
-        index += 1
 
     if enable_pin := config.get(CONF_ENABLE_PIN):
         enable = await cg.gpio_pin_expression(enable_pin)

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp

@@ -6,7 +6,6 @@ namespace esphome {
 namespace rpi_dpi_rgb {
 
 void RpiDpiRgb::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->reset_display_();
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;
@@ -23,7 +22,6 @@ void RpiDpiRgb::setup() {
   config.timings.flags.pclk_active_neg = this->pclk_inverted_;
   config.timings.pclk_hz = this->pclk_frequency_;
   config.clk_src = LCD_CLK_SRC_PLL160M;
-  config.psram_trans_align = 64;
   size_t data_pin_count = sizeof(this->data_pins_) / sizeof(this->data_pins_[0]);
   for (size_t i = 0; i != data_pin_count; i++) {
     config.data_gpio_nums[i] = this->data_pins_[i]->get_pin();
@@ -42,7 +40,6 @@ void RpiDpiRgb::setup() {
   }
   ESP_ERROR_CHECK(esp_lcd_panel_reset(this->handle_));
   ESP_ERROR_CHECK(esp_lcd_panel_init(this->handle_));
-  ESP_LOGCONFIG(TAG, "RPI_DPI_RGB setup complete");
 }
 void RpiDpiRgb::loop() {
   if (this->handle_ != nullptr)

esphome/components/runtime_stats/__init__.py

@@ -0,0 +1,34 @@
+"""
+Runtime statistics component for ESPHome.
+"""
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@bdraco"]
+
+CONF_LOG_INTERVAL = "log_interval"
+
+runtime_stats_ns = cg.esphome_ns.namespace("runtime_stats")
+RuntimeStatsCollector = runtime_stats_ns.class_("RuntimeStatsCollector")
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(RuntimeStatsCollector),
+        cv.Optional(
+            CONF_LOG_INTERVAL, default="60s"
+        ): cv.positive_time_period_milliseconds,
+    }
+)
+
+
+async def to_code(config):
+    """Generate code for the runtime statistics component."""
+    # Define USE_RUNTIME_STATS when this component is used
+    cg.add_define("USE_RUNTIME_STATS")
+
+    # Create the runtime stats instance (constructor sets global_runtime_stats)
+    var = cg.new_Pvariable(config[CONF_ID])
+
+    cg.add(var.set_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/runtime_stats/runtime_stats.cpp

@@ -0,0 +1,102 @@
+#include "runtime_stats.h"
+
+#ifdef USE_RUNTIME_STATS
+
+#include "esphome/core/component.h"
+#include <algorithm>
+
+namespace esphome {
+
+namespace runtime_stats {
+
+RuntimeStatsCollector::RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0) {
+  global_runtime_stats = this;
+}
+
+void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
+  if (component == nullptr)
+    return;
+
+  // Check if we have cached the name for this component
+  auto name_it = this->component_names_cache_.find(component);
+  if (name_it == this->component_names_cache_.end()) {
+    // First time seeing this component, cache its name
+    const char *source = component->get_component_source();
+    this->component_names_cache_[component] = source;
+    this->component_stats_[source].record_time(duration_ms);
+  } else {
+    this->component_stats_[name_it->second].record_time(duration_ms);
+  }
+
+  if (this->next_log_time_ == 0) {
+    this->next_log_time_ = current_time + this->log_interval_;
+    return;
+  }
+}
+
+void RuntimeStatsCollector::log_stats_() {
+  ESP_LOGI(TAG, "Component Runtime Statistics");
+  ESP_LOGI(TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
+
+  // First collect stats we want to display
+  std::vector<ComponentStatPair> stats_to_display;
+
+  for (const auto &it : this->component_stats_) {
+    const ComponentRuntimeStats &stats = it.second;
+    if (stats.get_period_count() > 0) {
+      ComponentStatPair pair = {it.first, &stats};
+      stats_to_display.push_back(pair);
+    }
+  }
+
+  // Sort by period runtime (descending)
+  std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
+
+  // Log top components by period runtime
+  for (const auto &it : stats_to_display) {
+    const char *source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source,
+             stats->get_period_count(), stats->get_period_avg_time_ms(), stats->get_period_max_time_ms(),
+             stats->get_period_time_ms());
+  }
+
+  // Log total stats since boot
+  ESP_LOGI(TAG, "Total stats (since boot):");
+
+  // Re-sort by total runtime for all-time stats
+  std::sort(stats_to_display.begin(), stats_to_display.end(),
+            [](const ComponentStatPair &a, const ComponentStatPair &b) {
+              return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
+            });
+
+  for (const auto &it : stats_to_display) {
+    const char *source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source,
+             stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
+             stats->get_total_time_ms());
+  }
+}
+
+void RuntimeStatsCollector::process_pending_stats(uint32_t current_time) {
+  if (this->next_log_time_ == 0)
+    return;
+
+  if (current_time >= this->next_log_time_) {
+    this->log_stats_();
+    this->reset_stats_();
+    this->next_log_time_ = current_time + this->log_interval_;
+  }
+}
+
+}  // namespace runtime_stats
+
+runtime_stats::RuntimeStatsCollector *global_runtime_stats =
+    nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome
+
+#endif  // USE_RUNTIME_STATS

esphome/components/runtime_stats/runtime_stats.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_RUNTIME_STATS
+
+#include <map>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+
+class Component;  // Forward declaration
+
+namespace runtime_stats {
+
+static const char *const TAG = "runtime_stats";
+
+class ComponentRuntimeStats {
+ public:
+  ComponentRuntimeStats()
+      : period_count_(0),
+        period_time_ms_(0),
+        period_max_time_ms_(0),
+        total_count_(0),
+        total_time_ms_(0),
+        total_max_time_ms_(0) {}
+
+  void record_time(uint32_t duration_ms) {
+    // Update period counters
+    this->period_count_++;
+    this->period_time_ms_ += duration_ms;
+    if (duration_ms > this->period_max_time_ms_)
+      this->period_max_time_ms_ = duration_ms;
+
+    // Update total counters
+    this->total_count_++;
+    this->total_time_ms_ += duration_ms;
+    if (duration_ms > this->total_max_time_ms_)
+      this->total_max_time_ms_ = duration_ms;
+  }
+
+  void reset_period_stats() {
+    this->period_count_ = 0;
+    this->period_time_ms_ = 0;
+    this->period_max_time_ms_ = 0;
+  }
+
+  // Period stats (reset each logging interval)
+  uint32_t get_period_count() const { return this->period_count_; }
+  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
+  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
+  float get_period_avg_time_ms() const {
+    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
+  }
+
+  // Total stats (persistent until reboot)
+  uint32_t get_total_count() const { return this->total_count_; }
+  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
+  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
+  float get_total_avg_time_ms() const {
+    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
+  }
+
+ protected:
+  // Period stats (reset each logging interval)
+  uint32_t period_count_;
+  uint32_t period_time_ms_;
+  uint32_t period_max_time_ms_;
+
+  // Total stats (persistent until reboot)
+  uint32_t total_count_;
+  uint32_t total_time_ms_;
+  uint32_t total_max_time_ms_;
+};
+
+// For sorting components by run time
+struct ComponentStatPair {
+  const char *name;
+  const ComponentRuntimeStats *stats;
+
+  bool operator>(const ComponentStatPair &other) const {
+    // Sort by period time as that's what we're displaying in the logs
+    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
+  }
+};
+
+class RuntimeStatsCollector {
+ public:
+  RuntimeStatsCollector();
+
+  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
+  uint32_t get_log_interval() const { return this->log_interval_; }
+
+  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
+
+  // Process any pending stats printing (should be called after component loop)
+  void process_pending_stats(uint32_t current_time);
+
+ protected:
+  void log_stats_();
+
+  void reset_stats_() {
+    for (auto &it : this->component_stats_) {
+      it.second.reset_period_stats();
+    }
+  }
+
+  // Use const char* keys for efficiency
+  // Custom comparator for const char* keys in map
+  // Without this, std::map would compare pointer addresses instead of string contents,
+  // causing identical component names at different addresses to be treated as different keys
+  struct CStrCompare {
+    bool operator()(const char *a, const char *b) const { return std::strcmp(a, b) < 0; }
+  };
+  std::map<const char *, ComponentRuntimeStats, CStrCompare> component_stats_;
+  std::map<Component *, const char *> component_names_cache_;
+  uint32_t log_interval_;
+  uint32_t next_log_time_;
+};
+
+}  // namespace runtime_stats
+
+extern runtime_stats::RuntimeStatsCollector
+    *global_runtime_stats;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome
+
+#endif  // USE_RUNTIME_STATS

esphome/components/scd30/scd30.cpp

@@ -26,8 +26,6 @@ static const uint16_t SCD30_CMD_TEMPERATURE_OFFSET = 0x5403;
 static const uint16_t SCD30_CMD_SOFT_RESET = 0xD304;
 
 void SCD30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
 #ifdef USE_ESP8266
   Wire.setClockStretchLimit(150000);
 #endif

esphome/components/scd30/sensor.py

@@ -3,6 +3,7 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALTITUDE_COMPENSATION,
     CONF_AMBIENT_PRESSURE_COMPENSATION,
     CONF_AUTOMATIC_SELF_CALIBRATION,
     CONF_CO2,
@@ -35,8 +36,6 @@ ForceRecalibrationWithReference = scd30_ns.class_(
     "ForceRecalibrationWithReference", automation.Action
 )
 
-CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {

esphome/components/scd4x/scd4x.cpp

@@ -27,7 +27,6 @@ static const uint16_t SCD4X_CMD_GET_FEATURESET = 0x202f;
 static const float SCD4X_TEMPERATURE_OFFSET_MULTIPLIER = (1 << 16) / 175.0f;
 
 void SCD4XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
     this->status_clear_error();

esphome/components/scd4x/sensor.py

@@ -4,6 +4,7 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALTITUDE_COMPENSATION,
     CONF_AMBIENT_PRESSURE_COMPENSATION,
     CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE,
     CONF_AUTOMATIC_SELF_CALIBRATION,
@@ -49,9 +50,6 @@ PerformForcedCalibrationAction = scd4x_ns.class_(
 )
 FactoryResetAction = scd4x_ns.class_("FactoryResetAction", automation.Action)
 
-
-CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {

esphome/components/sdl/display.py

@@ -36,7 +36,9 @@ def get_sdl_options(value):
     if value != "":
         return value
     try:
-        return subprocess.check_output(["sdl2-config", "--cflags", "--libs"]).decode()
+        return subprocess.check_output(
+            ["sdl2-config", "--cflags", "--libs"], close_fds=False
+        ).decode()
     except Exception as e:
         raise cv.Invalid("Unable to run sdl2-config - have you installed sdl2?") from e
 

esphome/components/sdl/sdl_esphome.cpp

@@ -6,7 +6,6 @@ namespace esphome {
 namespace sdl {
 
 void Sdl::setup() {
-  ESP_LOGD(TAG, "Starting setup");
   SDL_Init(SDL_INIT_VIDEO);
   this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
                                    this->window_options_);
@@ -15,7 +14,6 @@ void Sdl::setup() {
   this->texture_ =
       SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
   SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
-  ESP_LOGD(TAG, "Setup Complete");
 }
 void Sdl::update() {
   this->do_update_();

esphome/components/sdp3x/sdp3x.cpp

@@ -17,8 +17,6 @@ static const uint16_t SDP3X_STOP_MEAS = 0x3FF9;
 void SDP3XComponent::update() { this->read_pressure_(); }
 
 void SDP3XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (!this->write_command(SDP3X_STOP_MEAS)) {
     ESP_LOGW(TAG, "Stop failed");  // This sometimes fails for no good reason
   }

esphome/components/seeed_mr24hpc1/seeed_mr24hpc1.cpp

@@ -62,7 +62,6 @@ void MR24HPC1Component::dump_config() {
 
 // Initialisation functions
 void MR24HPC1Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->check_uart_settings(115200);
 
   if (this->custom_mode_number_ != nullptr) {
@@ -91,7 +90,6 @@ void MR24HPC1Component::setup() {
   memset(this->sg_frame_buf_, 0, FRAME_BUF_MAX_SIZE);
 
   this->set_interval(8000, [this]() { this->update_(); });
-  ESP_LOGCONFIG(TAG, "Set up MR24HPC1 complete");
 }
 
 // Timed polling of radar data

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -31,7 +31,6 @@ void MR60FDA2Component::dump_config() {
 
 // Initialisation functions
 void MR60FDA2Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->check_uart_settings(115200);
 
   this->current_frame_locate_ = LOCATE_FRAME_HEADER;
@@ -43,8 +42,6 @@ void MR60FDA2Component::setup() {
 
   memset(this->current_frame_buf_, 0, FRAME_BUF_MAX_SIZE);
   memset(this->current_data_buf_, 0, DATA_BUF_MAX_SIZE);
-
-  ESP_LOGCONFIG(TAG, "Set up MR60FDA2 complete");
 }
 
 // main loop

esphome/components/select/__init__.py

@@ -118,15 +118,14 @@ async def register_select(var, config, *, options: list[str]):
     await setup_select_core_(var, config, options=options)
 
 
-async def new_select(config, *, options: list[str]):
-    var = cg.new_Pvariable(config[CONF_ID])
+async def new_select(config, *args, options: list[str]):
+    var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_select(var, config, options=options)
     return var
 
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_SELECT")
     cg.add_global(select_ns.using)
 
 

esphome/components/select/select_traits.cpp

@@ -5,7 +5,7 @@ namespace select {
 
 void SelectTraits::set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
 
-std::vector<std::string> SelectTraits::get_options() const { return this->options_; }
+const std::vector<std::string> &SelectTraits::get_options() const { return this->options_; }
 
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select_traits.h

@@ -9,7 +9,7 @@ namespace select {
 class SelectTraits {
  public:
   void set_options(std::vector<std::string> options);
-  std::vector<std::string> get_options() const;
+  const std::vector<std::string> &get_options() const;
 
  protected:
   std::vector<std::string> options_;

esphome/components/sen0321/sen0321.cpp

@@ -8,7 +8,6 @@ namespace sen0321_sensor {
 static const char *const TAG = "sen0321_sensor.sensor";
 
 void Sen0321Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->write_byte(SENSOR_MODE_REGISTER, SENSOR_MODE_AUTO)) {
     ESP_LOGW(TAG, "Error setting measurement mode.");
     this->mark_failed();

esphome/components/sen5x/sen5x.cpp

@@ -30,8 +30,6 @@ static const int8_t SEN5X_MIN_INDEX_VALUE = 1 * SEN5X_INDEX_SCALE_FACTOR;     //
 static const int16_t SEN5X_MAX_INDEX_VALUE = 500 * SEN5X_INDEX_SCALE_FACTOR;  // must be adjusted by the scale factor
 
 void SEN5XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
     // Check if measurement is ready before reading the value