esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/light/light_call.cpp

@@ -10,11 +10,15 @@ namespace light {
 static const char *const TAG = "light";
 
 // Helper functions to reduce code size for logging
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
-static void log_validation_warning(const char *name, const LogString *param_name, float val, float min, float max) {
-  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), val, min, max);
+static void clamp_and_log_if_invalid(const char *name, float &value, const LogString *param_name, float min = 0.0f,
+                                     float max = 1.0f) {
+  if (value < min || value > max) {
+    ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), value, min, max);
+    value = clamp(value, min, max);
+  }
 }
 
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
 static void log_feature_not_supported(const char *name, const LogString *feature) {
   ESP_LOGW(TAG, "'%s': %s not supported", name, LOG_STR_ARG(feature));
 }
@@ -27,7 +31,6 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   ESP_LOGW(TAG, "'%s': %s", name, LOG_STR_ARG(message));
 }
 #else
-#define log_validation_warning(name, param_name, val, min, max)
 #define log_feature_not_supported(name, feature)
 #define log_color_mode_not_supported(name, feature)
 #define log_invalid_parameter(name, message)
@@ -44,7 +47,7 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   } \
   LightCall &LightCall::set_##name(type name) { \
     this->name##_ = name; \
-    this->set_flag_(flag, true); \
+    this->set_flag_(flag); \
     return *this; \
   }
 
@@ -181,6 +184,16 @@ void LightCall::perform() {
   }
 }
 
+void LightCall::log_and_clear_unsupported_(FieldFlags flag, const LogString *feature, bool use_color_mode_log) {
+  auto *name = this->parent_->get_name().c_str();
+  if (use_color_mode_log) {
+    log_color_mode_not_supported(name, feature);
+  } else {
+    log_feature_not_supported(name, feature);
+  }
+  this->clear_flag_(flag);
+}
+
 LightColorValues LightCall::validate_() {
   auto *name = this->parent_->get_name().c_str();
   auto traits = this->parent_->get_traits();
@@ -188,141 +201,108 @@ LightColorValues LightCall::validate_() {
   // Color mode check
   if (this->has_color_mode() && !traits.supports_color_mode(this->color_mode_)) {
     ESP_LOGW(TAG, "'%s' does not support color mode %s", name, LOG_STR_ARG(color_mode_to_human(this->color_mode_)));
-    this->set_flag_(FLAG_HAS_COLOR_MODE, false);
+    this->clear_flag_(FLAG_HAS_COLOR_MODE);
   }
 
   // Ensure there is always a color mode set
   if (!this->has_color_mode()) {
     this->color_mode_ = this->compute_color_mode_();
-    this->set_flag_(FLAG_HAS_COLOR_MODE, true);
+    this->set_flag_(FLAG_HAS_COLOR_MODE);
   }
   auto color_mode = this->color_mode_;
 
   // Transform calls that use non-native parameters for the current mode.
   this->transform_parameters_();
 
-  // Brightness exists check
-  if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, LOG_STR("brightness"));
-    this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
-  }
+  // Business logic adjustments before validation
+  // Flag whether an explicit turn off was requested, in which case we'll also stop the effect.
+  bool explicit_turn_off_request = this->has_state() && !this->state_;
 
-  // Transition length possible check
-  if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, LOG_STR("transitions"));
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+  // Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on).
+  if (this->has_brightness() && this->brightness_ == 0.0f) {
+    this->state_ = false;
+    this->set_flag_(FLAG_HAS_STATE);
+    this->brightness_ = 1.0f;
   }
 
-  // Color brightness exists check
-  if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
-    log_color_mode_not_supported(name, LOG_STR("RGB brightness"));
-    this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
+  // Set color brightness to 100% if currently zero and a color is set.
+  if ((this->has_red() || this->has_green() || this->has_blue()) && !this->has_color_brightness() &&
+      this->parent_->remote_values.get_color_brightness() == 0.0f) {
+    this->color_brightness_ = 1.0f;
+    this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS);
   }
 
+  // Capability validation
+  if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS))
+    this->log_and_clear_unsupported_(FLAG_HAS_BRIGHTNESS, LOG_STR("brightness"), false);
+
+  // Transition length possible check
+  if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS))
+    this->log_and_clear_unsupported_(FLAG_HAS_TRANSITION, LOG_STR("transitions"), false);
+
+  if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB))
+    this->log_and_clear_unsupported_(FLAG_HAS_COLOR_BRIGHTNESS, LOG_STR("RGB brightness"), true);
+
   // RGB exists check
-  if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
-      (this->has_blue() && this->blue_ > 0.0f)) {
-    if (!(color_mode & ColorCapability::RGB)) {
-      log_color_mode_not_supported(name, LOG_STR("RGB color"));
-      this->set_flag_(FLAG_HAS_RED, false);
-      this->set_flag_(FLAG_HAS_GREEN, false);
-      this->set_flag_(FLAG_HAS_BLUE, false);
-    }
+  if (((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
+       (this->has_blue() && this->blue_ > 0.0f)) &&
+      !(color_mode & ColorCapability::RGB)) {
+    log_color_mode_not_supported(name, LOG_STR("RGB color"));
+    this->clear_flag_(FLAG_HAS_RED);
+    this->clear_flag_(FLAG_HAS_GREEN);
+    this->clear_flag_(FLAG_HAS_BLUE);
   }
 
   // White value exists check
   if (this->has_white() && this->white_ > 0.0f &&
-      !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, LOG_STR("white value"));
-    this->set_flag_(FLAG_HAS_WHITE, false);
-  }
+      !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE))
+    this->log_and_clear_unsupported_(FLAG_HAS_WHITE, LOG_STR("white value"), true);
 
   // Color temperature exists check
   if (this->has_color_temperature() &&
-      !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, LOG_STR("color temperature"));
-    this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
-  }
+      !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE))
+    this->log_and_clear_unsupported_(FLAG_HAS_COLOR_TEMPERATURE, LOG_STR("color temperature"), true);
 
   // Cold/warm white value exists check
-  if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
-    if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
-      log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
-      this->set_flag_(FLAG_HAS_COLD_WHITE, false);
-      this->set_flag_(FLAG_HAS_WARM_WHITE, false);
-    }
-  }
-
-#define VALIDATE_RANGE_(name_, upper_name, min, max) \
-  if (this->has_##name_()) { \
-    auto val = this->name_##_; \
-    if (val < (min) || val > (max)) { \
-      log_validation_warning(name, LOG_STR(upper_name), val, (min), (max)); \
-      this->name_##_ = clamp(val, (min), (max)); \
-    } \
+  if (((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) &&
+      !(color_mode & ColorCapability::COLD_WARM_WHITE)) {
+    log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
+    this->clear_flag_(FLAG_HAS_COLD_WHITE);
+    this->clear_flag_(FLAG_HAS_WARM_WHITE);
   }
-#define VALIDATE_RANGE(name, upper_name) VALIDATE_RANGE_(name, upper_name, 0.0f, 1.0f)
-
-  // Range checks
-  VALIDATE_RANGE(brightness, "Brightness")
-  VALIDATE_RANGE(color_brightness, "Color brightness")
-  VALIDATE_RANGE(red, "Red")
-  VALIDATE_RANGE(green, "Green")
-  VALIDATE_RANGE(blue, "Blue")
-  VALIDATE_RANGE(white, "White")
-  VALIDATE_RANGE(cold_white, "Cold white")
-  VALIDATE_RANGE(warm_white, "Warm white")
-  VALIDATE_RANGE_(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
-
-  // Flag whether an explicit turn off was requested, in which case we'll also stop the effect.
-  bool explicit_turn_off_request = this->has_state() && !this->state_;
 
-  // Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on).
-  if (this->has_brightness() && this->brightness_ == 0.0f) {
-    this->state_ = false;
-    this->set_flag_(FLAG_HAS_STATE, true);
-    this->brightness_ = 1.0f;
-  }
-
-  // Set color brightness to 100% if currently zero and a color is set.
-  if (this->has_red() || this->has_green() || this->has_blue()) {
-    if (!this->has_color_brightness() && this->parent_->remote_values.get_color_brightness() == 0.0f) {
-      this->color_brightness_ = 1.0f;
-      this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, true);
-    }
-  }
-
-  // Create color values for the light with this call applied.
+  // Create color values and validate+apply ranges in one step to eliminate duplicate checks
   auto v = this->parent_->remote_values;
   if (this->has_color_mode())
     v.set_color_mode(this->color_mode_);
   if (this->has_state())
     v.set_state(this->state_);
-  if (this->has_brightness())
-    v.set_brightness(this->brightness_);
-  if (this->has_color_brightness())
-    v.set_color_brightness(this->color_brightness_);
-  if (this->has_red())
-    v.set_red(this->red_);
-  if (this->has_green())
-    v.set_green(this->green_);
-  if (this->has_blue())
-    v.set_blue(this->blue_);
-  if (this->has_white())
-    v.set_white(this->white_);
-  if (this->has_color_temperature())
-    v.set_color_temperature(this->color_temperature_);
-  if (this->has_cold_white())
-    v.set_cold_white(this->cold_white_);
-  if (this->has_warm_white())
-    v.set_warm_white(this->warm_white_);
+
+#define VALIDATE_AND_APPLY(field, setter, name_str, ...) \
+  if (this->has_##field()) { \
+    clamp_and_log_if_invalid(name, this->field##_, LOG_STR(name_str), ##__VA_ARGS__); \
+    v.setter(this->field##_); \
+  }
+
+  VALIDATE_AND_APPLY(brightness, set_brightness, "Brightness")
+  VALIDATE_AND_APPLY(color_brightness, set_color_brightness, "Color brightness")
+  VALIDATE_AND_APPLY(red, set_red, "Red")
+  VALIDATE_AND_APPLY(green, set_green, "Green")
+  VALIDATE_AND_APPLY(blue, set_blue, "Blue")
+  VALIDATE_AND_APPLY(white, set_white, "White")
+  VALIDATE_AND_APPLY(cold_white, set_cold_white, "Cold white")
+  VALIDATE_AND_APPLY(warm_white, set_warm_white, "Warm white")
+  VALIDATE_AND_APPLY(color_temperature, set_color_temperature, "Color temperature", traits.get_min_mireds(),
+                     traits.get_max_mireds())
+
+#undef VALIDATE_AND_APPLY
 
   v.normalize_color();
 
   // Flash length check
   if (this->has_flash_() && this->flash_length_ == 0) {
-    log_invalid_parameter(name, LOG_STR("flash length must be greater than zero"));
-    this->set_flag_(FLAG_HAS_FLASH, false);
+    log_invalid_parameter(name, LOG_STR("flash length must be >0"));
+    this->clear_flag_(FLAG_HAS_FLASH);
   }
 
   // validate transition length/flash length/effect not used at the same time
@@ -330,42 +310,40 @@ LightColorValues LightCall::validate_() {
 
   // If effect is already active, remove effect start
   if (this->has_effect_() && this->effect_ == this->parent_->active_effect_index_) {
-    this->set_flag_(FLAG_HAS_EFFECT, false);
+    this->clear_flag_(FLAG_HAS_EFFECT);
   }
 
   // validate effect index
   if (this->has_effect_() && this->effect_ > this->parent_->effects_.size()) {
     ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, this->effect_);
-    this->set_flag_(FLAG_HAS_EFFECT, false);
+    this->clear_flag_(FLAG_HAS_EFFECT);
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
     log_invalid_parameter(name, LOG_STR("effect cannot be used with transition/flash"));
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
-    this->set_flag_(FLAG_HAS_FLASH, false);
+    this->clear_flag_(FLAG_HAS_TRANSITION);
+    this->clear_flag_(FLAG_HAS_FLASH);
   }
 
   if (this->has_flash_() && this->has_transition_()) {
     log_invalid_parameter(name, LOG_STR("flash cannot be used with transition"));
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->clear_flag_(FLAG_HAS_TRANSITION);
   }
 
   if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || this->effect_ == 0) &&
       supports_transition) {
     // nothing specified and light supports transitions, set default transition length
     this->transition_length_ = this->parent_->default_transition_length_;
-    this->set_flag_(FLAG_HAS_TRANSITION, true);
+    this->set_flag_(FLAG_HAS_TRANSITION);
   }
 
   if (this->has_transition_() && this->transition_length_ == 0) {
     // 0 transition is interpreted as no transition (instant change)
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->clear_flag_(FLAG_HAS_TRANSITION);
   }
 
-  if (this->has_transition_() && !supports_transition) {
-    log_feature_not_supported(name, LOG_STR("transitions"));
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
-  }
+  if (this->has_transition_() && !supports_transition)
+    this->log_and_clear_unsupported_(FLAG_HAS_TRANSITION, LOG_STR("transitions"), false);
 
   // If not a flash and turning the light off, then disable the light
   // Do not use light color values directly, so that effects can set 0% brightness
@@ -374,17 +352,17 @@ LightColorValues LightCall::validate_() {
   if (!this->has_flash_() && !target_state) {
     if (this->has_effect_()) {
       log_invalid_parameter(name, LOG_STR("cannot start effect when turning off"));
-      this->set_flag_(FLAG_HAS_EFFECT, false);
+      this->clear_flag_(FLAG_HAS_EFFECT);
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect
       this->effect_ = 0;
-      this->set_flag_(FLAG_HAS_EFFECT, true);
+      this->set_flag_(FLAG_HAS_EFFECT);
     }
   }
 
   // Disable saving for flashes
   if (this->has_flash_())
-    this->set_flag_(FLAG_SAVE, false);
+    this->clear_flag_(FLAG_SAVE);
 
   return v;
 }
@@ -418,12 +396,12 @@ void LightCall::transform_parameters_() {
       const float gamma = this->parent_->get_gamma_correct();
       this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, gamma);
       this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, gamma);
-      this->set_flag_(FLAG_HAS_COLD_WHITE, true);
-      this->set_flag_(FLAG_HAS_WARM_WHITE, true);
+      this->set_flag_(FLAG_HAS_COLD_WHITE);
+      this->set_flag_(FLAG_HAS_WARM_WHITE);
     }
     if (this->has_white()) {
       this->brightness_ = this->white_;
-      this->set_flag_(FLAG_HAS_BRIGHTNESS, true);
+      this->set_flag_(FLAG_HAS_BRIGHTNESS);
     }
   }
 }
@@ -630,7 +608,7 @@ LightCall &LightCall::set_effect(optional<std::string> effect) {
 }
 LightCall &LightCall::set_effect(uint32_t effect_number) {
   this->effect_ = effect_number;
-  this->set_flag_(FLAG_HAS_EFFECT, true);
+  this->set_flag_(FLAG_HAS_EFFECT);
   return *this;
 }
 LightCall &LightCall::set_effect(optional<uint32_t> effect_number) {

esphome/components/light/light_call.h

@@ -4,6 +4,10 @@
 #include <set>
 
 namespace esphome {
+
+// Forward declaration
+struct LogString;
+
 namespace light {
 
 class LightState;
@@ -207,14 +211,14 @@ class LightCall {
     FLAG_SAVE = 1 << 15,
   };
 
-  bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
-  bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
-  bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
-  bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
-  bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
+  inline bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
+  inline bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
+  inline bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
+  inline bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
+  inline bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
 
-  // Helper to set flag
-  void set_flag_(FieldFlags flag, bool value) {
+  // Helper to set flag - defaults to true for common case
+  void set_flag_(FieldFlags flag, bool value = true) {
     if (value) {
       this->flags_ |= flag;
     } else {
@@ -222,6 +226,12 @@ class LightCall {
     }
   }
 
+  // Helper to clear flag - reduces code size for common case
+  void clear_flag_(FieldFlags flag) { this->flags_ &= ~flag; }
+
+  // Helper to log unsupported feature and clear flag - reduces code duplication
+  void log_and_clear_unsupported_(FieldFlags flag, const LogString *feature, bool use_color_mode_log);
+
   LightState *parent_;
 
   // Light state values - use flags_ to check if a value has been set.

esphome/components/lm75b/lm75b.cpp

@@ -0,0 +1,39 @@
+#include "lm75b.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace lm75b {
+
+static const char *const TAG = "lm75b";
+
+void LM75BComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "LM75B:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Setting up LM75B failed!");
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Temperature", this);
+}
+
+void LM75BComponent::update() {
+  // Create a temporary buffer
+  uint8_t buff[2];
+  if (this->read_register(LM75B_REG_TEMPERATURE, buff, 2) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+  // Obtain combined 16-bit value
+  int16_t raw_temperature = (buff[0] << 8) | buff[1];
+  // Read the 11-bit raw temperature value
+  raw_temperature >>= 5;
+  // Publish the temperature in °C
+  this->publish_state(raw_temperature * 0.125);
+  if (this->status_has_warning()) {
+    this->status_clear_warning();
+  }
+}
+
+}  // namespace lm75b
+}  // namespace esphome

esphome/components/lm75b/lm75b.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace lm75b {
+
+static const uint8_t LM75B_REG_TEMPERATURE = 0x00;
+
+class LM75BComponent : public PollingComponent, public i2c::I2CDevice, public sensor::Sensor {
+ public:
+  void dump_config() override;
+  void update() override;
+};
+
+}  // namespace lm75b
+}  // namespace esphome

esphome/components/lm75b/sensor.py

@@ -0,0 +1,34 @@
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+)
+
+CODEOWNERS = ["@beormund"]
+DEPENDENCIES = ["i2c"]
+
+lm75b_ns = cg.esphome_ns.namespace("lm75b")
+LM75BComponent = lm75b_ns.class_(
+    "LM75BComponent", cg.PollingComponent, i2c.I2CDevice, sensor.Sensor
+)
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        LM75BComponent,
+        unit_of_measurement=UNIT_CELSIUS,
+        accuracy_decimals=3,
+        device_class=DEVICE_CLASS_TEMPERATURE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x48))
+)
+
+
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/lock/lock.h

@@ -5,7 +5,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
-#include <set>
+#include <initializer_list>
 
 namespace esphome {
 namespace lock {
@@ -44,16 +44,22 @@ class LockTraits {
   bool get_assumed_state() const { return this->assumed_state_; }
   void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 
-  bool supports_state(LockState state) const { return supported_states_.count(state); }
-  std::set<LockState> get_supported_states() const { return supported_states_; }
-  void set_supported_states(std::set<LockState> states) { supported_states_ = std::move(states); }
-  void add_supported_state(LockState state) { supported_states_.insert(state); }
+  bool supports_state(LockState state) const { return supported_states_mask_ & (1 << state); }
+  void set_supported_states(std::initializer_list<LockState> states) {
+    supported_states_mask_ = 0;
+    for (auto state : states) {
+      supported_states_mask_ |= (1 << state);
+    }
+  }
+  uint8_t get_supported_states_mask() const { return supported_states_mask_; }
+  void set_supported_states_mask(uint8_t mask) { supported_states_mask_ = mask; }
+  void add_supported_state(LockState state) { supported_states_mask_ |= (1 << state); }
 
  protected:
   bool supports_open_{false};
   bool requires_code_{false};
   bool assumed_state_{false};
-  std::set<LockState> supported_states_ = {LOCK_STATE_NONE, LOCK_STATE_LOCKED, LOCK_STATE_UNLOCKED};
+  uint8_t supported_states_mask_{(1 << LOCK_STATE_NONE) | (1 << LOCK_STATE_LOCKED) | (1 << LOCK_STATE_UNLOCKED)};
 };
 
 /** This class is used to encode all control actions on a lock device.

esphome/components/logger/__init__.py

@@ -95,6 +95,7 @@ DEFAULT = "DEFAULT"
 
 CONF_INITIAL_LEVEL = "initial_level"
 CONF_LOGGER_ID = "logger_id"
+CONF_RUNTIME_TAG_LEVELS = "runtime_tag_levels"
 CONF_TASK_LOG_BUFFER_SIZE = "task_log_buffer_size"
 
 UART_SELECTION_ESP32 = {
@@ -117,8 +118,6 @@ UART_SELECTION_LIBRETINY = {
     COMPONENT_RTL87XX: [DEFAULT, UART0, UART1, UART2],
 }
 
-ESP_ARDUINO_UNSUPPORTED_USB_UARTS = [USB_SERIAL_JTAG]
-
 UART_SELECTION_RP2040 = [USB_CDC, UART0, UART1]
 
 UART_SELECTION_NRF52 = [USB_CDC, UART0]
@@ -153,13 +152,7 @@ is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
 
 def uart_selection(value):
     if CORE.is_esp32:
-        if CORE.using_arduino and value.upper() in ESP_ARDUINO_UNSUPPORTED_USB_UARTS:
-            raise cv.Invalid(f"Arduino framework does not support {value}.")
         variant = get_esp32_variant()
-        if CORE.using_esp_idf and variant == VARIANT_ESP32C3 and value == USB_CDC:
-            raise cv.Invalid(
-                f"{value} is not supported for variant {variant} when using ESP-IDF."
-            )
         if variant in UART_SELECTION_ESP32:
             return cv.one_of(*UART_SELECTION_ESP32[variant], upper=True)(value)
     if CORE.is_esp8266:
@@ -226,14 +219,11 @@ CONFIG_SCHEMA = cv.All(
                 esp8266=UART0,
                 esp32=UART0,
                 esp32_s2=USB_CDC,
-                esp32_s3_arduino=USB_CDC,
-                esp32_s3_idf=USB_SERIAL_JTAG,
-                esp32_c3_arduino=USB_CDC,
-                esp32_c3_idf=USB_SERIAL_JTAG,
-                esp32_c5_idf=USB_SERIAL_JTAG,
-                esp32_c6_arduino=USB_CDC,
-                esp32_c6_idf=USB_SERIAL_JTAG,
-                esp32_p4_idf=USB_SERIAL_JTAG,
+                esp32_s3=USB_SERIAL_JTAG,
+                esp32_c3=USB_SERIAL_JTAG,
+                esp32_c5=USB_SERIAL_JTAG,
+                esp32_c6=USB_SERIAL_JTAG,
+                esp32_p4=USB_SERIAL_JTAG,
                 rp2040=USB_CDC,
                 bk72xx=DEFAULT,
                 ln882x=DEFAULT,
@@ -260,6 +250,7 @@ CONFIG_SCHEMA = cv.All(
                 }
             ),
             cv.Optional(CONF_INITIAL_LEVEL): is_log_level,
+            cv.Optional(CONF_RUNTIME_TAG_LEVELS, default=False): cv.boolean,
             cv.Optional(CONF_ON_MESSAGE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoggerMessageTrigger),
@@ -302,8 +293,12 @@ async def to_code(config):
         )
     cg.add(log.pre_setup())
 
-    for tag, log_level in config[CONF_LOGS].items():
-        cg.add(log.set_log_level(tag, LOG_LEVELS[log_level]))
+    # Enable runtime tag levels if logs are configured or explicitly enabled
+    logs_config = config[CONF_LOGS]
+    if logs_config or config[CONF_RUNTIME_TAG_LEVELS]:
+        cg.add_define("USE_LOGGER_RUNTIME_TAG_LEVELS")
+        for tag, log_level in logs_config.items():
+            cg.add(log.set_log_level(tag, LOG_LEVELS[log_level]))
 
     cg.add_define("USE_LOGGER")
     this_severity = LOG_LEVEL_SEVERITY.index(level)
@@ -346,15 +341,7 @@ async def to_code(config):
     if config.get(CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH):
         cg.add_build_flag("-DUSE_STORE_LOG_STR_IN_FLASH")
 
-    if CORE.using_arduino and config[CONF_HARDWARE_UART] == USB_CDC:
-        cg.add_build_flag("-DARDUINO_USB_CDC_ON_BOOT=1")
-        if CORE.is_esp32 and get_esp32_variant() in (
-            VARIANT_ESP32C3,
-            VARIANT_ESP32C6,
-        ):
-            cg.add_build_flag("-DARDUINO_USB_MODE=1")
-
-    if CORE.using_esp_idf:
+    if CORE.is_esp32:
         if config[CONF_HARDWARE_UART] == USB_CDC:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_CDC", True)
         elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
@@ -462,6 +449,7 @@ async def logger_set_level_to_code(config, action_id, template_arg, args):
     level = LOG_LEVELS[config[CONF_LEVEL]]
     logger = await cg.get_variable(config[CONF_LOGGER_ID])
     if tag := config.get(CONF_TAG):
+        cg.add_define("USE_LOGGER_RUNTIME_TAG_LEVELS")
         text = str(cg.statement(logger.set_log_level(tag, level)))
     else:
         text = str(cg.statement(logger.set_log_level(level)))