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

esphome/components/scd30/sensor.py

@@ -3,6 +3,8 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_AMBIENT_PRESSURE_COMPENSATION,
+    CONF_AUTOMATIC_SELF_CALIBRATION,
     CONF_CO2,
     CONF_HUMIDITY,
     CONF_ID,
@@ -18,8 +20,6 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
-    CONF_AUTOMATIC_SELF_CALIBRATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION,
 )
 
 DEPENDENCIES = ["i2c"]

esphome/components/scd4x/scd4x.cpp

@@ -7,6 +7,8 @@ namespace scd4x {
 
 static const char *const TAG = "scd4x";
 
+static const uint16_t SCD41_ID = 0x1408;
+static const uint16_t SCD40_ID = 0x440;
 static const uint16_t SCD4X_CMD_GET_SERIAL_NUMBER = 0x3682;
 static const uint16_t SCD4X_CMD_TEMPERATURE_OFFSET = 0x241d;
 static const uint16_t SCD4X_CMD_ALTITUDE_COMPENSATION = 0x2427;
@@ -23,8 +25,6 @@ static const uint16_t SCD4X_CMD_STOP_MEASUREMENTS = 0x3f86;
 static const uint16_t SCD4X_CMD_FACTORY_RESET = 0x3632;
 static const uint16_t SCD4X_CMD_GET_FEATURESET = 0x202f;
 static const float SCD4X_TEMPERATURE_OFFSET_MULTIPLIER = (1 << 16) / 175.0f;
-static const uint16_t SCD41_ID = 0x1408;
-static const uint16_t SCD40_ID = 0x440;
 
 void SCD4XComponent::setup() {
   ESP_LOGCONFIG(TAG, "Running setup");
@@ -51,47 +51,66 @@ void SCD4XComponent::setup() {
 
       if (!this->write_command(SCD4X_CMD_TEMPERATURE_OFFSET,
                                (uint16_t) (temperature_offset_ * SCD4X_TEMPERATURE_OFFSET_MULTIPLIER))) {
-        ESP_LOGE(TAG, "Error setting temperature offset.");
+        ESP_LOGE(TAG, "Error setting temperature offset");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
 
-      // If pressure compensation available use it
-      // else use altitude
-      if (ambient_pressure_compensation_) {
-        if (!this->update_ambient_pressure_compensation_(ambient_pressure_)) {
-          ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
+      // If pressure compensation available use it, else use altitude
+      if (this->ambient_pressure_) {
+        if (!this->update_ambient_pressure_compensation_(this->ambient_pressure_)) {
+          ESP_LOGE(TAG, "Error setting ambient pressure compensation");
           this->error_code_ = MEASUREMENT_INIT_FAILED;
           this->mark_failed();
           return;
         }
       } else {
-        if (!this->write_command(SCD4X_CMD_ALTITUDE_COMPENSATION, altitude_compensation_)) {
-          ESP_LOGE(TAG, "Error setting altitude compensation.");
+        if (!this->write_command(SCD4X_CMD_ALTITUDE_COMPENSATION, this->altitude_compensation_)) {
+          ESP_LOGE(TAG, "Error setting altitude compensation");
           this->error_code_ = MEASUREMENT_INIT_FAILED;
           this->mark_failed();
           return;
         }
       }
 
-      if (!this->write_command(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, enable_asc_ ? 1 : 0)) {
-        ESP_LOGE(TAG, "Error setting automatic self calibration.");
+      if (!this->write_command(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, this->enable_asc_ ? 1 : 0)) {
+        ESP_LOGE(TAG, "Error setting automatic self calibration");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
 
-      initialized_ = true;
+      this->initialized_ = true;
       // Finally start sensor measurements
       this->start_measurement_();
-      ESP_LOGD(TAG, "Sensor initialized");
     });
   });
 }
 
 void SCD4XComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "scd4x:");
+  static const char *const MM_PERIODIC_STR = "Periodic (5s)";
+  static const char *const MM_LOW_POWER_PERIODIC_STR = "Low power periodic (30s)";
+  static const char *const MM_SINGLE_SHOT_STR = "Single shot";
+  static const char *const MM_SINGLE_SHOT_RHT_ONLY_STR = "Single shot rht only";
+  const char *measurement_mode_str = MM_PERIODIC_STR;
+
+  switch (this->measurement_mode_) {
+    case PERIODIC:
+      // measurement_mode_str = MM_PERIODIC_STR;
+      break;
+    case LOW_POWER_PERIODIC:
+      measurement_mode_str = MM_LOW_POWER_PERIODIC_STR;
+      break;
+    case SINGLE_SHOT:
+      measurement_mode_str = MM_SINGLE_SHOT_STR;
+      break;
+    case SINGLE_SHOT_RHT_ONLY:
+      measurement_mode_str = MM_SINGLE_SHOT_RHT_ONLY_STR;
+      break;
+  }
+
+  ESP_LOGCONFIG(TAG, "SCD4X:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     switch (this->error_code_) {
@@ -102,19 +121,23 @@ void SCD4XComponent::dump_config() {
         ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case SERIAL_NUMBER_IDENTIFICATION_FAILED:
-        ESP_LOGW(TAG, "Unable to read sensor firmware version");
+        ESP_LOGW(TAG, "Unable to read firmware version");
         break;
       default:
         ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   }
-  ESP_LOGCONFIG(TAG, "  Automatic self calibration: %s", ONOFF(this->enable_asc_));
+  ESP_LOGCONFIG(TAG,
+                "  Automatic self calibration: %s\n"
+                "  Measurement mode: %s\n"
+                "  Temperature offset: %.2f °C",
+                ONOFF(this->enable_asc_), measurement_mode_str, this->temperature_offset_);
   if (this->ambient_pressure_source_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  Dynamic ambient pressure compensation using sensor '%s'",
+    ESP_LOGCONFIG(TAG, "  Dynamic ambient pressure compensation using '%s'",
                   this->ambient_pressure_source_->get_name().c_str());
   } else {
-    if (this->ambient_pressure_compensation_) {
+    if (this->ambient_pressure_) {
       ESP_LOGCONFIG(TAG,
                     "  Altitude compensation disabled\n"
                     "  Ambient pressure compensation: %dmBar",
@@ -126,21 +149,6 @@ void SCD4XComponent::dump_config() {
                     this->altitude_compensation_);
     }
   }
-  switch (this->measurement_mode_) {
-    case PERIODIC:
-      ESP_LOGCONFIG(TAG, "  Measurement mode: periodic (5s)");
-      break;
-    case LOW_POWER_PERIODIC:
-      ESP_LOGCONFIG(TAG, "  Measurement mode: low power periodic (30s)");
-      break;
-    case SINGLE_SHOT:
-      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot");
-      break;
-    case SINGLE_SHOT_RHT_ONLY:
-      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot rht only");
-      break;
-  }
-  ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f °C", this->temperature_offset_);
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
@@ -148,20 +156,20 @@ void SCD4XComponent::dump_config() {
 }
 
 void SCD4XComponent::update() {
-  if (!initialized_) {
+  if (!this->initialized_) {
     return;
   }
 
   if (this->ambient_pressure_source_ != nullptr) {
     float pressure = this->ambient_pressure_source_->state;
     if (!std::isnan(pressure)) {
-      set_ambient_pressure_compensation(pressure);
+      this->set_ambient_pressure_compensation(pressure);
     }
   }
 
   uint32_t wait_time = 0;
   if (this->measurement_mode_ == SINGLE_SHOT || this->measurement_mode_ == SINGLE_SHOT_RHT_ONLY) {
-    start_measurement_();
+    this->start_measurement_();
     wait_time =
         this->measurement_mode_ == SINGLE_SHOT ? 5000 : 50;  // Single shot measurement takes 5 secs rht mode 50 ms
   }
@@ -176,12 +184,12 @@ void SCD4XComponent::update() {
 
     if (!this->read_data(raw_read_status) || raw_read_status == 0x00) {
       this->status_set_warning();
-      ESP_LOGW(TAG, "Data not ready yet!");
+      ESP_LOGW(TAG, "Data not ready");
       return;
     }
 
     if (!this->write_command(SCD4X_CMD_READ_MEASUREMENT)) {
-      ESP_LOGW(TAG, "Error reading measurement!");
+      ESP_LOGW(TAG, "Error reading measurement");
       this->status_set_warning();
       return;  // NO RETRY
     }
@@ -218,19 +226,19 @@ bool SCD4XComponent::perform_forced_calibration(uint16_t current_co2_concentrati
   }
   this->set_timeout(500, [this, current_co2_concentration]() {
     if (this->write_command(SCD4X_CMD_PERFORM_FORCED_CALIBRATION, current_co2_concentration)) {
-      ESP_LOGD(TAG, "setting forced calibration Co2 level %d ppm", current_co2_concentration);
+      ESP_LOGD(TAG, "Setting forced calibration Co2 level %d ppm", current_co2_concentration);
       // frc takes 400 ms
       // because this method will be used very rarly
       // the simple approach with delay is ok
-      delay(400);  // NOLINT'
+      delay(400);  // NOLINT
       if (!this->start_measurement_()) {
         return false;
       } else {
-        ESP_LOGD(TAG, "forced calibration complete");
+        ESP_LOGD(TAG, "Forced calibration complete");
       }
       return true;
     } else {
-      ESP_LOGE(TAG, "force calibration failed");
+      ESP_LOGE(TAG, "Force calibration failed");
       this->error_code_ = FRC_FAILED;
       this->status_set_warning();
       return false;
@@ -259,27 +267,26 @@ bool SCD4XComponent::factory_reset() {
 }
 
 void SCD4XComponent::set_ambient_pressure_compensation(float pressure_in_hpa) {
-  ambient_pressure_compensation_ = true;
-  uint16_t new_ambient_pressure = (uint16_t) pressure_in_hpa;
-  if (!initialized_) {
-    ambient_pressure_ = new_ambient_pressure;
+  uint16_t new_ambient_pressure = static_cast<uint16_t>(pressure_in_hpa);
+  if (!this->initialized_) {
+    this->ambient_pressure_ = new_ambient_pressure;
     return;
   }
   // Only send pressure value if it has changed since last update
-  if (new_ambient_pressure != ambient_pressure_) {
-    update_ambient_pressure_compensation_(new_ambient_pressure);
-    ambient_pressure_ = new_ambient_pressure;
+  if (new_ambient_pressure != this->ambient_pressure_) {
+    this->update_ambient_pressure_compensation_(new_ambient_pressure);
+    this->ambient_pressure_ = new_ambient_pressure;
   } else {
-    ESP_LOGD(TAG, "ambient pressure compensation skipped - no change required");
+    ESP_LOGD(TAG, "Ambient pressure compensation skipped; no change required");
   }
 }
 
 bool SCD4XComponent::update_ambient_pressure_compensation_(uint16_t pressure_in_hpa) {
   if (this->write_command(SCD4X_CMD_AMBIENT_PRESSURE_COMPENSATION, pressure_in_hpa)) {
-    ESP_LOGD(TAG, "setting ambient pressure compensation to %d hPa", pressure_in_hpa);
+    ESP_LOGD(TAG, "Setting ambient pressure compensation to %d hPa", pressure_in_hpa);
     return true;
   } else {
-    ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
+    ESP_LOGE(TAG, "Error setting ambient pressure compensation");
     return false;
   }
 }
@@ -304,7 +311,7 @@ bool SCD4XComponent::start_measurement_() {
   static uint8_t remaining_retries = 3;
   while (remaining_retries) {
     if (!this->write_command(measurement_command)) {
-      ESP_LOGE(TAG, "Error starting measurements.");
+      ESP_LOGE(TAG, "Error starting measurements");
       this->error_code_ = MEASUREMENT_INIT_FAILED;
       this->status_set_warning();
       if (--remaining_retries == 0)

esphome/components/scd4x/scd4x.h

@@ -8,18 +8,23 @@
 namespace esphome {
 namespace scd4x {
 
-enum ERRORCODE {
+enum ErrorCode : uint8_t {
   COMMUNICATION_FAILED,
   SERIAL_NUMBER_IDENTIFICATION_FAILED,
   MEASUREMENT_INIT_FAILED,
   FRC_FAILED,
-  UNKNOWN
+  UNKNOWN,
+};
+
+enum MeasurementMode : uint8_t {
+  PERIODIC,
+  LOW_POWER_PERIODIC,
+  SINGLE_SHOT,
+  SINGLE_SHOT_RHT_ONLY,
 };
-enum MeasurementMode { PERIODIC, LOW_POWER_PERIODIC, SINGLE_SHOT, SINGLE_SHOT_RHT_ONLY };
 
 class SCD4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;
@@ -40,21 +45,18 @@ class SCD4XComponent : public PollingComponent, public sensirion_common::Sensiri
  protected:
   bool update_ambient_pressure_compensation_(uint16_t pressure_in_hpa);
   bool start_measurement_();
-  ERRORCODE error_code_;
 
-  bool initialized_{false};
-
-  float temperature_offset_;
-  uint16_t altitude_compensation_;
-  bool ambient_pressure_compensation_;
-  uint16_t ambient_pressure_;
-  bool enable_asc_;
-  MeasurementMode measurement_mode_{PERIODIC};
   sensor::Sensor *co2_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};
-  // used for compensation
-  sensor::Sensor *ambient_pressure_source_{nullptr};
+  sensor::Sensor *ambient_pressure_source_{nullptr};  // used for compensation
+  float temperature_offset_;
+  uint16_t altitude_compensation_{0};
+  uint16_t ambient_pressure_{0};  // Per datasheet, valid values are 700 to 1200 hPa; 0 is a valid sentinel value
+  bool initialized_{false};
+  bool enable_asc_{false};
+  ErrorCode error_code_;
+  MeasurementMode measurement_mode_{PERIODIC};
 };
 
 }  // namespace scd4x

esphome/components/scd4x/sensor.py

@@ -4,9 +4,13 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_AMBIENT_PRESSURE_COMPENSATION,
+    CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE,
+    CONF_AUTOMATIC_SELF_CALIBRATION,
     CONF_CO2,
     CONF_HUMIDITY,
     CONF_ID,
+    CONF_MEASUREMENT_MODE,
     CONF_TEMPERATURE,
     CONF_TEMPERATURE_OFFSET,
     CONF_VALUE,
@@ -20,10 +24,6 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
-    CONF_AUTOMATIC_SELF_CALIBRATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE,
-    CONF_MEASUREMENT_MODE,
 )
 
 CODEOWNERS = ["@sjtrny", "@martgras"]

esphome/components/script/script.h

@@ -239,8 +239,6 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
     this->play_next_tuple_(this->var_);
   }
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void play(Ts... x) override { /* ignore - see play_complex */
   }
 

esphome/components/sdp3x/sensor.py

@@ -2,10 +2,10 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_MEASUREMENT_MODE,
     DEVICE_CLASS_PRESSURE,
     STATE_CLASS_MEASUREMENT,
     UNIT_HECTOPASCAL,
-    CONF_MEASUREMENT_MODE,
 )
 
 DEPENDENCIES = ["i2c"]

esphome/components/select/__init__.py

@@ -17,8 +17,8 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
-from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@esphome/core"]
 IS_PLATFORM_COMPONENT = True
@@ -65,6 +65,9 @@ _SELECT_SCHEMA = (
 )
 
 
+_SELECT_SCHEMA.add_extra(entity_duplicate_validator("select"))
+
+
 def select_schema(
     class_: MockObjClass,
     *,
@@ -89,7 +92,7 @@ SELECT_SCHEMA.add_extra(cv.deprecated_schema_constant("select"))
 
 
 async def setup_select_core_(var, config, *, options: list[str]):
-    await setup_entity(var, config)
+    await setup_entity(var, config, "select")
 
     cg.add(var.traits.set_options(options))
 

esphome/components/sen5x/sen5x.h

@@ -48,7 +48,6 @@ struct TemperatureCompensation {
 
 class SEN5XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/senseair/senseair.h

@@ -10,7 +10,6 @@ namespace senseair {
 
 class SenseAirComponent : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_co2_sensor(sensor::Sensor *co2_sensor) { co2_sensor_ = co2_sensor; }
 
   void update() override;

esphome/components/sensor/__init__.py

@@ -101,8 +101,8 @@ from esphome.const import (
     ENTITY_CATEGORY_CONFIG,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
-from esphome.cpp_helpers import setup_entity
 from esphome.util import Registry
 
 CODEOWNERS = ["@esphome/core"]
@@ -318,6 +318,8 @@ _SENSOR_SCHEMA = (
     )
 )
 
+_SENSOR_SCHEMA.add_extra(entity_duplicate_validator("sensor"))
+
 
 def sensor_schema(
     class_: MockObjClass = cv.UNDEFINED,
@@ -787,7 +789,7 @@ async def build_filters(config):
 
 
 async def setup_sensor_core_(var, config):
-    await setup_entity(var, config)
+    await setup_entity(var, config, "sensor")
 
     if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
         cg.add(var.set_device_class(device_class))

esphome/components/sensor/filter.cpp

@@ -118,7 +118,7 @@ optional<float> QuantileFilter::new_value(float value) {
       size_t queue_size = quantile_queue.size();
       if (queue_size) {
         size_t position = ceilf(queue_size * this->quantile_) - 1;
-        ESP_LOGVV(TAG, "QuantileFilter(%p)::position: %d/%d", this, position + 1, queue_size);
+        ESP_LOGVV(TAG, "QuantileFilter(%p)::position: %zu/%zu", this, position + 1, queue_size);
         result = quantile_queue[position];
       }
     }

esphome/components/sensor/sensor.cpp

@@ -23,16 +23,22 @@ std::string state_class_to_string(StateClass state_class) {
 Sensor::Sensor() : state(NAN), raw_state(NAN) {}
 
 int8_t Sensor::get_accuracy_decimals() {
-  if (this->accuracy_decimals_.has_value())
-    return *this->accuracy_decimals_;
+  if (this->sensor_flags_.has_accuracy_override)
+    return this->accuracy_decimals_;
   return 0;
 }
-void Sensor::set_accuracy_decimals(int8_t accuracy_decimals) { this->accuracy_decimals_ = accuracy_decimals; }
+void Sensor::set_accuracy_decimals(int8_t accuracy_decimals) {
+  this->accuracy_decimals_ = accuracy_decimals;
+  this->sensor_flags_.has_accuracy_override = true;
+}
 
-void Sensor::set_state_class(StateClass state_class) { this->state_class_ = state_class; }
+void Sensor::set_state_class(StateClass state_class) {
+  this->state_class_ = state_class;
+  this->sensor_flags_.has_state_class_override = true;
+}
 StateClass Sensor::get_state_class() {
-  if (this->state_class_.has_value())
-    return *this->state_class_;
+  if (this->sensor_flags_.has_state_class_override)
+    return this->state_class_;
   return StateClass::STATE_CLASS_NONE;
 }
 

esphome/components/sensor/sensor.h

@@ -80,9 +80,9 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa
    * state changes to the database when they are published, even if the state is the
    * same as before.
    */
-  bool get_force_update() const { return force_update_; }
+  bool get_force_update() const { return sensor_flags_.force_update; }
   /// Set force update mode.
-  void set_force_update(bool force_update) { force_update_ = force_update; }
+  void set_force_update(bool force_update) { sensor_flags_.force_update = force_update; }
 
   /// Add a filter to the filter chain. Will be appended to the back.
   void add_filter(Filter *filter);
@@ -155,9 +155,17 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa
 
   Filter *filter_list_{nullptr};  ///< Store all active filters.
 
-  optional<int8_t> accuracy_decimals_;                  ///< Accuracy in decimals override
-  optional<StateClass> state_class_{STATE_CLASS_NONE};  ///< State class override
-  bool force_update_{false};                            ///< Force update mode
+  // Group small members together to avoid padding
+  int8_t accuracy_decimals_{-1};              ///< Accuracy in decimals (-1 = not set)
+  StateClass state_class_{STATE_CLASS_NONE};  ///< State class (STATE_CLASS_NONE = not set)
+
+  // Bit-packed flags for sensor-specific settings
+  struct SensorFlags {
+    uint8_t has_accuracy_override : 1;
+    uint8_t has_state_class_override : 1;
+    uint8_t force_update : 1;
+    uint8_t reserved : 5;  // Reserved for future use
+  } sensor_flags_{};
 };
 
 }  // namespace sensor

esphome/components/servo/servo.cpp

@@ -88,9 +88,9 @@ void Servo::internal_write(float value) {
   value = clamp(value, -1.0f, 1.0f);
   float level;
   if (value < 0.0) {
-    level = lerp(-value, this->idle_level_, this->min_level_);
+    level = std::lerp(this->idle_level_, this->min_level_, -value);
   } else {
-    level = lerp(value, this->idle_level_, this->max_level_);
+    level = std::lerp(this->idle_level_, this->max_level_, value);
   }
   this->output_->set_level(level);
   this->current_value_ = value;

esphome/components/servo/servo.h

@@ -20,7 +20,6 @@ class Servo : public Component {
   void detach();
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_min_level(float min_level) { min_level_ = min_level; }
   void set_idle_level(float idle_level) { idle_level_ = idle_level; }
   void set_max_level(float max_level) { max_level_ = max_level; }

esphome/components/sfa30/sfa30.h

@@ -11,7 +11,6 @@ class SFA30Component : public PollingComponent, public sensirion_common::Sensiri
   enum ErrorCode { DEVICE_MARKING_READ_FAILED, MEASUREMENT_INIT_FAILED, UNKNOWN };
 
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/sgp30/sgp30.h

@@ -32,7 +32,6 @@ class SGP30Component : 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; }
 
  protected:
   void send_env_data_();

esphome/components/sgp4x/sgp4x.h

@@ -75,7 +75,6 @@ class SGP4xComponent : public PollingComponent, public sensor::Sensor, public se
   void update() override;
   void take_sample();
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; }
   void set_voc_sensor(sensor::Sensor *voc_sensor) { voc_sensor_ = voc_sensor; }
   void set_nox_sensor(sensor::Sensor *nox_sensor) { nox_sensor_ = nox_sensor; }

esphome/components/shelly_dimmer/stm32flash.cpp

@@ -445,8 +445,7 @@ template<typename T> stm32_err_t stm32_check_ack_timeout(const stm32_err_t s_err
       return STM32_ERR_OK;
     case STM32_ERR_NACK:
       log();
-      // TODO: c++17 [[fallthrough]]
-      /* fallthrough */
+      [[fallthrough]];
     default:
       return STM32_ERR_UNKNOWN;
   }

esphome/components/sht4x/sht4x.h

@@ -17,7 +17,6 @@ enum SHT4XHEATERTIME : uint16_t { SHT4X_HEATERTIME_LONG = 1100, SHT4X_HEATERTIME
 
 class SHT4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/sm300d2/sm300d2.h

@@ -9,8 +9,6 @@ namespace sm300d2 {
 
 class SM300D2Sensor : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void set_co2_sensor(sensor::Sensor *co2_sensor) { co2_sensor_ = co2_sensor; }
   void set_formaldehyde_sensor(sensor::Sensor *formaldehyde_sensor) { formaldehyde_sensor_ = formaldehyde_sensor; }
   void set_tvoc_sensor(sensor::Sensor *tvoc_sensor) { tvoc_sensor_ = tvoc_sensor; }

esphome/components/smt100/sensor.py

@@ -6,6 +6,7 @@ from esphome.const import (
     CONF_DIELECTRIC_CONSTANT,
     CONF_ID,
     CONF_MOISTURE,
+    CONF_PERMITTIVITY,
     CONF_TEMPERATURE,
     CONF_VOLTAGE,
     DEVICE_CLASS_TEMPERATURE,
@@ -33,7 +34,10 @@ CONFIG_SCHEMA = (
                 accuracy_decimals=0,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
-            cv.Optional(CONF_DIELECTRIC_CONSTANT): sensor.sensor_schema(
+            cv.Optional(CONF_DIELECTRIC_CONSTANT): cv.invalid(
+                "Use 'permittivity' instead"
+            ),
+            cv.Optional(CONF_PERMITTIVITY): sensor.sensor_schema(
                 unit_of_measurement=UNIT_EMPTY,
                 accuracy_decimals=2,
                 state_class=STATE_CLASS_MEASUREMENT,
@@ -76,9 +80,9 @@ async def to_code(config):
         sens = await sensor.new_sensor(config[CONF_COUNTS])
         cg.add(var.set_counts_sensor(sens))
 
-    if CONF_DIELECTRIC_CONSTANT in config:
-        sens = await sensor.new_sensor(config[CONF_DIELECTRIC_CONSTANT])
-        cg.add(var.set_dielectric_constant_sensor(sens))
+    if CONF_PERMITTIVITY in config:
+        sens = await sensor.new_sensor(config[CONF_PERMITTIVITY])
+        cg.add(var.set_permittivity_sensor(sens))
 
     if CONF_TEMPERATURE in config:
         sens = await sensor.new_sensor(config[CONF_TEMPERATURE])