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

esphome/components/sgp4x/sgp4x.cpp

@@ -9,34 +9,34 @@ namespace sgp4x {
 static const char *const TAG = "sgp4x";
 
 void SGP4xComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SGP4x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Serial Number identification
   uint16_t raw_serial_number[3];
   if (!this->get_register(SGP4X_CMD_GET_SERIAL_ID, raw_serial_number, 3, 1)) {
-    ESP_LOGE(TAG, "Failed to read serial number");
+    ESP_LOGE(TAG, "Get serial number failed");
     this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
     this->mark_failed();
     return;
   }
   this->serial_number_ = (uint64_t(raw_serial_number[0]) << 24) | (uint64_t(raw_serial_number[1]) << 16) |
                          (uint64_t(raw_serial_number[2]));
-  ESP_LOGD(TAG, "Serial Number: %" PRIu64, this->serial_number_);
+  ESP_LOGD(TAG, "Serial number: %" PRIu64, this->serial_number_);
 
   // Featureset identification for future use
-  uint16_t raw_featureset;
-  if (!this->get_register(SGP4X_CMD_GET_FEATURESET, raw_featureset, 1)) {
-    ESP_LOGD(TAG, "raw_featureset write_command_ failed");
+  uint16_t featureset;
+  if (!this->get_register(SGP4X_CMD_GET_FEATURESET, featureset, 1)) {
+    ESP_LOGD(TAG, "Get feature set failed");
     this->mark_failed();
     return;
   }
-  this->featureset_ = raw_featureset;
-  if ((this->featureset_ & 0x1FF) == SGP40_FEATURESET) {
-    sgp_type_ = SGP40;
-    self_test_time_ = SPG40_SELFTEST_TIME;
-    measure_time_ = SGP40_MEASURE_TIME;
+  featureset &= 0x1FF;
+  if (featureset == SGP40_FEATURESET) {
+    this->sgp_type_ = SGP40;
+    this->self_test_time_ = SPG40_SELFTEST_TIME;
+    this->measure_time_ = SGP40_MEASURE_TIME;
     if (this->nox_sensor_) {
-      ESP_LOGE(TAG, "Measuring NOx requires a SGP41 sensor but a SGP40 sensor is detected");
+      ESP_LOGE(TAG, "SGP41 required for NOx");
       // disable the sensor
       this->nox_sensor_->set_disabled_by_default(true);
       // make sure it's not visible in HA
@@ -45,20 +45,17 @@ void SGP4xComponent::setup() {
       // remove pointer to sensor
       this->nox_sensor_ = nullptr;
     }
+  } else if (featureset == SGP41_FEATURESET) {
+    this->sgp_type_ = SGP41;
+    this->self_test_time_ = SPG41_SELFTEST_TIME;
+    this->measure_time_ = SGP41_MEASURE_TIME;
   } else {
-    if ((this->featureset_ & 0x1FF) == SGP41_FEATURESET) {
-      sgp_type_ = SGP41;
-      self_test_time_ = SPG41_SELFTEST_TIME;
-      measure_time_ = SGP41_MEASURE_TIME;
-    } else {
-      ESP_LOGD(TAG, "Product feature set failed 0x%0X , expecting 0x%0X", uint16_t(this->featureset_ & 0x1FF),
-               SGP40_FEATURESET);
-      this->mark_failed();
-      return;
-    }
+    ESP_LOGD(TAG, "Unknown feature set 0x%0X", featureset);
+    this->mark_failed();
+    return;
   }
 
-  ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
+  ESP_LOGD(TAG, "Version 0x%0X", featureset);
 
   if (this->store_baseline_) {
     // Hash with compilation time and serial number
@@ -70,7 +67,7 @@ void SGP4xComponent::setup() {
     if (this->pref_.load(&this->voc_baselines_storage_)) {
       this->voc_state0_ = this->voc_baselines_storage_.state0;
       this->voc_state1_ = this->voc_baselines_storage_.state1;
-      ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
+      ESP_LOGV(TAG, "Loaded VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
     }
 
@@ -78,7 +75,7 @@ void SGP4xComponent::setup() {
     this->seconds_since_last_store_ = 0;
 
     if (this->voc_baselines_storage_.state0 > 0 && this->voc_baselines_storage_.state1 > 0) {
-      ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
+      ESP_LOGV(TAG, "Setting VOC baseline from save state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
       voc_algorithm_.set_states(this->voc_baselines_storage_.state0, this->voc_baselines_storage_.state1);
     }
@@ -110,39 +107,29 @@ void SGP4xComponent::setup() {
   limit the amount of communication done over wifi for power consumption or to keep the
   number of records reported from being overwhelming.
   */
-  ESP_LOGD(TAG, "Component requires sampling of 1Hz, setting up background sampler");
+  ESP_LOGV(TAG, "Component requires sampling of 1Hz, setting up background sampler");
   this->set_interval(1000, [this]() { this->take_sample(); });
 }
 
 void SGP4xComponent::self_test_() {
-  ESP_LOGD(TAG, "Self-test started");
+  ESP_LOGD(TAG, "Starting self-test");
   if (!this->write_command(SGP4X_CMD_SELF_TEST)) {
     this->error_code_ = COMMUNICATION_FAILED;
-    ESP_LOGD(TAG, "Self-test communication failed");
+    ESP_LOGD(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
   }
 
-  this->set_timeout(self_test_time_, [this]() {
-    uint16_t reply;
-    if (!this->read_data(reply)) {
+  this->set_timeout(this->self_test_time_, [this]() {
+    uint16_t reply = 0;
+    if (!this->read_data(reply) || (reply != 0xD400)) {
       this->error_code_ = SELF_TEST_FAILED;
-      ESP_LOGD(TAG, "Self-test read_data_ failed");
+      ESP_LOGW(TAG, "Self-test failed (0x%X)", reply);
       this->mark_failed();
       return;
     }
 
-    if (reply == 0xD400) {
-      this->self_test_complete_ = true;
-      ESP_LOGD(TAG, "Self-test completed");
-      return;
-    } else {
-      this->error_code_ = SELF_TEST_FAILED;
-      ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
-      return;
-    }
-
-    ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
-    this->mark_failed();
+    this->self_test_complete_ = true;
+    ESP_LOGD(TAG, "Self-test complete");
   });
 }
 
@@ -150,7 +137,7 @@ void SGP4xComponent::update_gas_indices_() {
   this->voc_index_ = this->voc_algorithm_.process(this->voc_sraw_);
   if (this->nox_sensor_ != nullptr)
     this->nox_index_ = this->nox_algorithm_.process(this->nox_sraw_);
-  ESP_LOGV(TAG, "VOC = %" PRId32 ", NOx = %" PRId32, this->voc_index_, this->nox_index_);
+  ESP_LOGV(TAG, "VOC: %" PRId32 ", NOx: %" PRId32, this->voc_index_, this->nox_index_);
   // Store baselines after defined interval or if the difference between current and stored baseline becomes too
   // much
   if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
@@ -162,18 +149,18 @@ void SGP4xComponent::update_gas_indices_() {
       this->voc_baselines_storage_.state1 = this->voc_state1_;
 
       if (this->pref_.save(&this->voc_baselines_storage_)) {
-        ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04" PRIX32 " ,state1: 0x%04" PRIX32,
+        ESP_LOGV(TAG, "Stored VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                  this->voc_baselines_storage_.state0, this->voc_baselines_storage_.state1);
       } else {
-        ESP_LOGW(TAG, "Could not store VOC baselines");
+        ESP_LOGW(TAG, "Storing VOC baselines failed");
       }
     }
   }
 
   if (this->samples_read_ < this->samples_to_stabilize_) {
     this->samples_read_++;
-    ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %" PRIu32, this->samples_read_,
-             this->samples_to_stabilize_, this->voc_index_);
+    ESP_LOGD(TAG, "Stabilizing (%d/%d); VOC index: %" PRIu32, this->samples_read_, this->samples_to_stabilize_,
+             this->voc_index_);
   }
 }
 
@@ -182,7 +169,7 @@ void SGP4xComponent::measure_raw_() {
   static uint32_t nox_conditioning_start = millis();
 
   if (!this->self_test_complete_) {
-    ESP_LOGD(TAG, "Self-test not yet complete");
+    ESP_LOGW(TAG, "Self-test incomplete");
     return;
   }
   if (this->humidity_sensor_ != nullptr) {
@@ -270,37 +257,38 @@ void SGP4xComponent::update() {
 void SGP4xComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SGP4x:");
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  store_baseline: %d", this->store_baseline_);
+  ESP_LOGCONFIG(TAG, "  Store baseline: %s", YESNO(this->store_baseline_));
 
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
         break;
       case SERIAL_NUMBER_IDENTIFICATION_FAILED:
-        ESP_LOGW(TAG, "Get Serial number failed.");
+        ESP_LOGW(TAG, "Get serial number failed");
         break;
       case SELF_TEST_FAILED:
-        ESP_LOGW(TAG, "Self test failed.");
+        ESP_LOGW(TAG, "Self-test failed");
         break;
-
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown error");
         break;
     }
   } else {
-    ESP_LOGCONFIG(TAG, "  Type: %s", sgp_type_ == SGP41 ? "SGP41" : "SPG40");
-    ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
-    ESP_LOGCONFIG(TAG, "  Minimum Samples: %f", GasIndexAlgorithm_INITIAL_BLACKOUT);
+    ESP_LOGCONFIG(TAG,
+                  "  Type: %s\n"
+                  "  Serial number: %" PRIu64 "\n"
+                  "  Minimum Samples: %f",
+                  sgp_type_ == SGP41 ? "SGP41" : "SPG40", this->serial_number_, GasIndexAlgorithm_INITIAL_BLACKOUT);
   }
   LOG_UPDATE_INTERVAL(this);
 
+  ESP_LOGCONFIG(TAG, "  Compensation:");
   if (this->humidity_sensor_ != nullptr || this->temperature_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  Compensation:");
     LOG_SENSOR("    ", "Temperature Source:", this->temperature_sensor_);
     LOG_SENSOR("    ", "Humidity Source:", this->humidity_sensor_);
   } else {
-    ESP_LOGCONFIG(TAG, "  Compensation: No source configured");
+    ESP_LOGCONFIG(TAG, "    No source configured");
   }
   LOG_SENSOR("  ", "VOC", this->voc_sensor_);
   LOG_SENSOR("  ", "NOx", this->nox_sensor_);

esphome/components/sgp4x/sgp4x.h

@@ -115,7 +115,6 @@ class SGP4xComponent : public PollingComponent, public sensor::Sensor, public se
 
   SgpType sgp_type_{SGP40};
   uint64_t serial_number_;
-  uint16_t featureset_;
 
   bool self_test_complete_;
   uint16_t self_test_time_;

esphome/components/shelly_dimmer/shelly_dimmer.cpp

@@ -101,7 +101,7 @@ void ShellyDimmer::setup() {
   this->pin_nrst_->setup();
   this->pin_boot0_->setup();
 
-  ESP_LOGI(TAG, "Initializing Shelly Dimmer...");
+  ESP_LOGI(TAG, "Initializing");
 
   this->handle_firmware();
 
@@ -119,17 +119,21 @@ void ShellyDimmer::dump_config() {
   LOG_PIN("  NRST Pin: ", this->pin_nrst_);
   LOG_PIN("  BOOT0 Pin: ", this->pin_boot0_);
 
-  ESP_LOGCONFIG(TAG, "  Leading Edge: %s", YESNO(this->leading_edge_));
-  ESP_LOGCONFIG(TAG, "  Warmup Brightness: %d", this->warmup_brightness_);
+  ESP_LOGCONFIG(TAG,
+                "  Leading Edge: %s\n"
+                "  Warmup Brightness: %d\n"
+                "  Minimum Brightness: %d\n"
+                "  Maximum Brightness: %d",
+                YESNO(this->leading_edge_), this->warmup_brightness_, this->min_brightness_, this->max_brightness_);
   // ESP_LOGCONFIG(TAG, "  Warmup Time: %d", this->warmup_time_);
   // ESP_LOGCONFIG(TAG, "  Fade Rate: %d", this->fade_rate_);
-  ESP_LOGCONFIG(TAG, "  Minimum Brightness: %d", this->min_brightness_);
-  ESP_LOGCONFIG(TAG, "  Maximum Brightness: %d", this->max_brightness_);
 
   LOG_UPDATE_INTERVAL(this);
 
-  ESP_LOGCONFIG(TAG, "  STM32 current firmware version: %d.%d ", this->version_major_, this->version_minor_);
-  ESP_LOGCONFIG(TAG, "  STM32 required firmware version: %d.%d", USE_SHD_FIRMWARE_MAJOR_VERSION,
+  ESP_LOGCONFIG(TAG,
+                "  STM32 current firmware version: %d.%d \n"
+                "  STM32 required firmware version: %d.%d",
+                this->version_major_, this->version_minor_, USE_SHD_FIRMWARE_MAJOR_VERSION,
                 USE_SHD_FIRMWARE_MINOR_VERSION);
 
   if (this->version_major_ != USE_SHD_FIRMWARE_MAJOR_VERSION ||

esphome/components/sht3xd/sht3xd.cpp

@@ -25,7 +25,7 @@ static const uint16_t SHT3XD_COMMAND_POLLING_H = 0x2400;
 static const uint16_t SHT3XD_COMMAND_FETCH_DATA = 0xE000;
 
 void SHT3XDComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SHT3xD...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint16_t raw_serial_number[2];
   if (!this->get_register(SHT3XD_COMMAND_READ_SERIAL_NUMBER_CLOCK_STRETCHING, raw_serial_number, 2)) {
     this->error_code_ = READ_SERIAL_STRETCHED_FAILED;

esphome/components/sht4x/sht4x.cpp

@@ -18,7 +18,7 @@ void SHT4XComponent::start_heater_() {
 }
 
 void SHT4XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sht4x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
@@ -59,7 +59,7 @@ void SHT4XComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SHT4x:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with SHT4x failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/shtcx/shtcx.cpp

@@ -20,24 +20,18 @@ inline const char *to_string(SHTCXType type) {
     case SHTCX_TYPE_SHTC1:
       return "SHTC1";
     default:
-      return "[Unknown model]";
+      return "UNKNOWN";
   }
 }
 
 void SHTCXComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SHTCx...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->wake_up();
   this->soft_reset();
 
-  if (!this->write_command(SHTCX_COMMAND_READ_ID_REGISTER)) {
-    ESP_LOGE(TAG, "Error requesting Device ID");
-    this->mark_failed();
-    return;
-  }
-
   uint16_t device_id_register;
-  if (!this->read_data(&device_id_register, 1)) {
-    ESP_LOGE(TAG, "Error reading Device ID");
+  if (!this->write_command(SHTCX_COMMAND_READ_ID_REGISTER) || !this->read_data(&device_id_register, 1)) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
     return;
   }
@@ -53,31 +47,33 @@ void SHTCXComponent::setup() {
   } else {
     this->type_ = SHTCX_TYPE_UNKNOWN;
   }
-  ESP_LOGCONFIG(TAG, "  Device identified: %s (%04x)", to_string(this->type_), device_id_register);
 }
+
 void SHTCXComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SHTCx:");
   ESP_LOGCONFIG(TAG, "  Model: %s (%04x)", to_string(this->type_), this->sensor_id_);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with SHTCx failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
+
 float SHTCXComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void SHTCXComponent::update() {
   if (this->status_has_warning()) {
-    ESP_LOGW(TAG, "Retrying to reconnect the sensor.");
+    ESP_LOGW(TAG, "Retrying communication");
     this->soft_reset();
   }
   if (this->type_ != SHTCX_TYPE_SHTC1) {
     this->wake_up();
   }
   if (!this->write_command(SHTCX_COMMAND_POLLING_H)) {
-    ESP_LOGE(TAG, "sensor polling failed");
+    ESP_LOGE(TAG, "Polling failed");
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(NAN);
     if (this->humidity_sensor_ != nullptr)
@@ -91,13 +87,13 @@ void SHTCXComponent::update() {
     float humidity = NAN;
     uint16_t raw_data[2];
     if (!this->read_data(raw_data, 2)) {
-      ESP_LOGE(TAG, "sensor read failed");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       this->status_set_warning();
     } else {
       temperature = 175.0f * float(raw_data[0]) / 65536.0f - 45.0f;
       humidity = 100.0f * float(raw_data[1]) / 65536.0f;
 
-      ESP_LOGD(TAG, "Got temperature=%.2f°C humidity=%.2f%%", temperature, humidity);
+      ESP_LOGD(TAG, "Temperature=%.2f°C Humidity=%.2f%%", temperature, humidity);
     }
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(temperature);
@@ -114,6 +110,7 @@ void SHTCXComponent::soft_reset() {
   this->write_command(SHTCX_COMMAND_SOFT_RESET);
   delayMicroseconds(200);
 }
+
 void SHTCXComponent::sleep() { this->write_command(SHTCX_COMMAND_SLEEP); }
 
 void SHTCXComponent::wake_up() {

esphome/components/shutdown/button/shutdown_button.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "shutdown.button";
 
 void ShutdownButton::dump_config() { LOG_BUTTON("", "Shutdown Button", this); }
 void ShutdownButton::press_action() {
-  ESP_LOGI(TAG, "Shutting down...");
+  ESP_LOGI(TAG, "Shutting down");
   // Let MQTT settle a bit
   delay(100);  // NOLINT
   App.run_safe_shutdown_hooks();

esphome/components/shutdown/switch/shutdown_switch.cpp

@@ -21,7 +21,7 @@ void ShutdownSwitch::write_state(bool state) {
   this->publish_state(false);
 
   if (state) {
-    ESP_LOGI(TAG, "Shutting down...");
+    ESP_LOGI(TAG, "Shutting down");
     delay(100);  // NOLINT
 
     App.run_safe_shutdown_hooks();

esphome/components/sim800l/sim800l.cpp

@@ -28,7 +28,7 @@ void Sim800LComponent::update() {
       this->state_ = STATE_DIALING1;
     } else if (this->registered_ && this->connect_pending_) {
       this->connect_pending_ = false;
-      ESP_LOGI(TAG, "Connecting...");
+      ESP_LOGI(TAG, "Connecting");
       this->send_cmd_("ATA");
       this->state_ = STATE_ATA_SENT;
     } else if (this->registered_ && this->send_ussd_pending_) {
@@ -36,7 +36,7 @@ void Sim800LComponent::update() {
       this->state_ = STATE_SEND_USSD1;
     } else if (this->registered_ && this->disconnect_pending_) {
       this->disconnect_pending_ = false;
-      ESP_LOGI(TAG, "Disconnecting...");
+      ESP_LOGI(TAG, "Disconnecting");
       this->send_cmd_("ATH");
     } else if (this->registered_ && this->call_state_ != 6) {
       send_cmd_("AT+CLCC");

esphome/components/slow_pwm/slow_pwm_output.cpp

@@ -63,8 +63,10 @@ void SlowPWMOutput::dump_config() {
   if (this->turn_off_trigger_) {
     ESP_LOGCONFIG(TAG, "  Turn off automation configured");
   }
-  ESP_LOGCONFIG(TAG, "  Period: %d ms", this->period_);
-  ESP_LOGCONFIG(TAG, "  Restart cycle on state change: %s", YESNO(this->restart_cycle_on_state_change_));
+  ESP_LOGCONFIG(TAG,
+                "  Period: %d ms\n"
+                "  Restart cycle on state change: %s",
+                this->period_, YESNO(this->restart_cycle_on_state_change_));
   LOG_FLOAT_OUTPUT(this);
 }
 

esphome/components/sm16716/sm16716.cpp

@@ -7,7 +7,7 @@ namespace sm16716 {
 static const char *const TAG = "sm16716";
 
 void SM16716::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SM16716OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->clock_pin_->setup();

esphome/components/sm2135/sm2135.cpp

@@ -20,7 +20,7 @@ static const uint8_t SM2135_RGB = 0x00;  // RGB channel
 static const uint8_t SM2135_CW = 0x80;   // CW channel (Chip default)
 
 void SM2135::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SM2135OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->data_pin_->pin_mode(gpio::FLAG_OUTPUT);

esphome/components/sm2235/sm2235.cpp

@@ -7,7 +7,7 @@ namespace sm2235 {
 static const char *const TAG = "sm2235";
 
 void SM2235::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sm2235 Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();
@@ -19,8 +19,10 @@ void SM2235::dump_config() {
   ESP_LOGCONFIG(TAG, "sm2235:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 }  // namespace sm2235

esphome/components/sm2335/sm2335.cpp

@@ -7,7 +7,7 @@ namespace sm2335 {
 static const char *const TAG = "sm2335";
 
 void SM2335::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sm2335 Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();
@@ -19,8 +19,10 @@ void SM2335::dump_config() {
   ESP_LOGCONFIG(TAG, "sm2335:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 }  // namespace sm2335

esphome/components/sml/sml.cpp

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

esphome/components/sn74hc165/sn74hc165.cpp

@@ -7,8 +7,7 @@ namespace sn74hc165 {
 static const char *const TAG = "sn74hc165";
 
 void SN74HC165Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SN74HC165...");
-
+  ESP_LOGCONFIG(TAG, "Running setup");
   // initialize pins
   this->clock_pin_->setup();
   this->data_pin_->setup();

esphome/components/sn74hc595/sn74hc595.cpp

@@ -7,8 +7,7 @@ namespace sn74hc595 {
 static const char *const TAG = "sn74hc595";
 
 void SN74HC595Component::pre_setup_() {
-  ESP_LOGCONFIG(TAG, "Setting up SN74HC595...");
-
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->have_oe_pin_) {  // disable output
     this->oe_pin_->setup();
     this->oe_pin_->digital_write(true);

esphome/components/sntp/sntp_component.cpp

@@ -15,7 +15,7 @@ namespace sntp {
 static const char *const TAG = "sntp";
 
 void SNTPComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SNTP...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 #if defined(USE_ESP_IDF)
   if (esp_sntp_enabled()) {
     esp_sntp_stop();

esphome/components/socket/__init__.py

@@ -35,5 +35,7 @@ async def to_code(config):
         cg.add_define("USE_SOCKET_IMPL_LWIP_TCP")
     elif impl == IMPLEMENTATION_LWIP_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_LWIP_SOCKETS")
+        cg.add_define("USE_SOCKET_SELECT_SUPPORT")
     elif impl == IMPLEMENTATION_BSD_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
+        cg.add_define("USE_SOCKET_SELECT_SUPPORT")