esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/sound_level/sound_level.cpp

@@ -0,0 +1,194 @@
+#include "sound_level.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/log.h"
+
+#include <cmath>
+#include <cstdint>
+
+namespace esphome {
+namespace sound_level {
+
+static const char *const TAG = "sound_level";
+
+static const uint32_t AUDIO_BUFFER_DURATION_MS = 30;
+static const uint32_t RING_BUFFER_DURATION_MS = 120;
+
+// Square INT16_MIN since INT16_MIN^2 > INT16_MAX^2
+static const double MAX_SAMPLE_SQUARED_DENOMINATOR = INT16_MIN * INT16_MIN;
+
+void SoundLevelComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Sound Level Component:");
+  ESP_LOGCONFIG(TAG, "  Measurement Duration: %" PRIu32 " ms", measurement_duration_ms_);
+  LOG_SENSOR("  ", "Peak:", this->peak_sensor_);
+
+  LOG_SENSOR("  ", "RMS:", this->rms_sensor_);
+}
+
+void SoundLevelComponent::setup() {
+  this->microphone_source_->add_data_callback([this](const std::vector<uint8_t> &data) {
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (this->ring_buffer_.use_count() == 2) {
+      // ``audio_buffer_`` and ``temp_ring_buffer`` share ownership of a ring buffer, so its safe/useful to write
+      temp_ring_buffer->write((void *) data.data(), data.size());
+    }
+  });
+
+  if (!this->microphone_source_->is_passive()) {
+    // Automatically start the microphone if not in passive mode
+    this->microphone_source_->start();
+  }
+}
+
+void SoundLevelComponent::loop() {
+  if ((this->peak_sensor_ == nullptr) && (this->rms_sensor_ == nullptr)) {
+    // No sensors configured, nothing to do
+    return;
+  }
+
+  if (this->microphone_source_->is_running() && !this->status_has_error()) {
+    // Allocate buffers
+    if (this->start_()) {
+      this->status_clear_warning();
+    }
+  } else {
+    if (!this->status_has_warning()) {
+      this->status_set_warning("Microphone isn't running, can't compute statistics");
+
+      // Deallocate buffers, if necessary
+      this->stop_();
+
+      // Reset sensor outputs
+      if (this->peak_sensor_ != nullptr) {
+        this->peak_sensor_->publish_state(NAN);
+      }
+      if (this->rms_sensor_ != nullptr) {
+        this->rms_sensor_->publish_state(NAN);
+      }
+
+      // Reset accumulators
+      this->squared_peak_ = 0;
+      this->squared_samples_sum_ = 0;
+      this->sample_count_ = 0;
+    }
+
+    return;
+  }
+
+  if (this->status_has_error()) {
+    return;
+  }
+
+  // Copy data from ring buffer into the transfer buffer - don't block to avoid slowing the main loop
+  this->audio_buffer_->transfer_data_from_source(0);
+
+  if (this->audio_buffer_->available() == 0) {
+    // No new audio available for processing
+    return;
+  }
+
+  const uint32_t samples_in_window =
+      this->microphone_source_->get_audio_stream_info().ms_to_samples(this->measurement_duration_ms_);
+  const uint32_t samples_available_to_process =
+      this->microphone_source_->get_audio_stream_info().bytes_to_samples(this->audio_buffer_->available());
+  const uint32_t samples_to_process = std::min(samples_in_window - this->sample_count_, samples_available_to_process);
+
+  // MicrophoneSource always provides int16 samples due to Python codegen settings
+  const int16_t *audio_data = reinterpret_cast<const int16_t *>(this->audio_buffer_->get_buffer_start());
+
+  // Process all the new audio samples
+  for (uint32_t i = 0; i < samples_to_process; ++i) {
+    // Squaring int16 samples won't overflow an int32
+    int32_t squared_sample = static_cast<int32_t>(audio_data[i]) * static_cast<int32_t>(audio_data[i]);
+
+    if (this->peak_sensor_ != nullptr) {
+      this->squared_peak_ = std::max(this->squared_peak_, squared_sample);
+    }
+
+    if (this->rms_sensor_ != nullptr) {
+      // Squared sum is an uint64 type - at max levels, an uint32 type would overflow after ~8 samples
+      this->squared_samples_sum_ += squared_sample;
+    }
+
+    ++this->sample_count_;
+  }
+
+  // Remove the processed samples from ``audio_buffer_``
+  this->audio_buffer_->decrease_buffer_length(
+      this->microphone_source_->get_audio_stream_info().samples_to_bytes(samples_to_process));
+
+  if (this->sample_count_ == samples_in_window) {
+    // Processed enough samples for the measurement window, compute and publish the sensor values
+    if (this->peak_sensor_ != nullptr) {
+      const float peak_db = 10.0f * log10(static_cast<float>(this->squared_peak_) / MAX_SAMPLE_SQUARED_DENOMINATOR);
+      this->peak_sensor_->publish_state(peak_db);
+
+      this->squared_peak_ = 0;  // reset accumulator
+    }
+
+    if (this->rms_sensor_ != nullptr) {
+      // Calculations are done with doubles instead of floats - floats lose precision for even modest window durations
+      const double rms_db = 10.0 * log10((this->squared_samples_sum_ / MAX_SAMPLE_SQUARED_DENOMINATOR) /
+                                         static_cast<double>(samples_in_window));
+      this->rms_sensor_->publish_state(rms_db);
+
+      this->squared_samples_sum_ = 0;  // reset accumulator
+    }
+
+    this->sample_count_ = 0;  // reset counter
+  }
+}
+
+void SoundLevelComponent::start() {
+  if (this->microphone_source_->is_passive()) {
+    ESP_LOGW(TAG, "Can't start the microphone in passive mode");
+    return;
+  }
+  this->microphone_source_->start();
+}
+
+void SoundLevelComponent::stop() {
+  if (this->microphone_source_->is_passive()) {
+    ESP_LOGW(TAG, "Can't stop microphone in passive mode");
+    return;
+  }
+  this->microphone_source_->stop();
+}
+
+bool SoundLevelComponent::start_() {
+  if (this->audio_buffer_ != nullptr) {
+    return true;
+  }
+
+  // Allocate a transfer buffer
+  this->audio_buffer_ = audio::AudioSourceTransferBuffer::create(
+      this->microphone_source_->get_audio_stream_info().ms_to_bytes(AUDIO_BUFFER_DURATION_MS));
+  if (this->audio_buffer_ == nullptr) {
+    this->status_momentary_error("Failed to allocate transfer buffer", 15000);
+    return false;
+  }
+
+  // Allocates a new ring buffer, adds it as a source for the transfer buffer, and points ring_buffer_ to it
+  this->ring_buffer_.reset();  // Reset pointer to any previous ring buffer allocation
+  std::shared_ptr<RingBuffer> temp_ring_buffer =
+      RingBuffer::create(this->microphone_source_->get_audio_stream_info().ms_to_bytes(RING_BUFFER_DURATION_MS));
+  if (temp_ring_buffer.use_count() == 0) {
+    this->status_momentary_error("Failed to allocate ring buffer", 15000);
+    this->stop_();
+    return false;
+  } else {
+    this->ring_buffer_ = temp_ring_buffer;
+    this->audio_buffer_->set_source(temp_ring_buffer);
+  }
+
+  this->status_clear_error();
+  return true;
+}
+
+void SoundLevelComponent::stop_() { this->audio_buffer_.reset(); }
+
+}  // namespace sound_level
+}  // namespace esphome
+
+#endif

esphome/components/sound_level/sound_level.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include "esphome/components/audio/audio_transfer_buffer.h"
+#include "esphome/components/microphone/microphone_source.h"
+#include "esphome/components/sensor/sensor.h"
+
+#include "esphome/core/component.h"
+#include "esphome/core/ring_buffer.h"
+
+namespace esphome {
+namespace sound_level {
+
+class SoundLevelComponent : public Component {
+ public:
+  void dump_config() override;
+  void setup() override;
+  void loop() override;
+
+  float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
+
+  void set_measurement_duration(uint32_t measurement_duration_ms) {
+    this->measurement_duration_ms_ = measurement_duration_ms;
+  }
+  void set_microphone_source(microphone::MicrophoneSource *microphone_source) {
+    this->microphone_source_ = microphone_source;
+  }
+  void set_peak_sensor(sensor::Sensor *peak_sensor) { this->peak_sensor_ = peak_sensor; }
+  void set_rms_sensor(sensor::Sensor *rms_sensor) { this->rms_sensor_ = rms_sensor; }
+
+  /// @brief Starts the MicrophoneSource to start measuring sound levels
+  void start();
+
+  /// @brief Stops the MicrophoneSource
+  void stop();
+
+ protected:
+  /// @brief Internal start command that, if necessary, allocates ``audio_buffer_`` and a ring buffer which
+  /// ``audio_buffer_`` owns and ``ring_buffer_`` points to. Returns true if allocations were successful.
+  bool start_();
+
+  /// @brief Internal stop command the deallocates ``audio_buffer_`` (which automatically deallocates its ring buffer)
+  void stop_();
+
+  microphone::MicrophoneSource *microphone_source_{nullptr};
+
+  sensor::Sensor *peak_sensor_{nullptr};
+  sensor::Sensor *rms_sensor_{nullptr};
+
+  std::unique_ptr<audio::AudioSourceTransferBuffer> audio_buffer_;
+  std::weak_ptr<RingBuffer> ring_buffer_;
+
+  int32_t squared_peak_{0};
+  uint64_t squared_samples_sum_{0};
+  uint32_t sample_count_{0};
+
+  uint32_t measurement_duration_ms_;
+};
+
+template<typename... Ts> class StartAction : public Action<Ts...>, public Parented<SoundLevelComponent> {
+ public:
+  void play(Ts... x) override { this->parent_->start(); }
+};
+
+template<typename... Ts> class StopAction : public Action<Ts...>, public Parented<SoundLevelComponent> {
+ public:
+  void play(Ts... x) override { this->parent_->stop(); }
+};
+
+}  // namespace sound_level
+}  // namespace esphome
+#endif

esphome/components/speaker/media_player/__init__.py

@@ -271,9 +271,8 @@ PIPELINE_SCHEMA = cv.Schema(
 )
 
 CONFIG_SCHEMA = cv.All(
-    media_player.MEDIA_PLAYER_SCHEMA.extend(
+    media_player.media_player_schema(SpeakerMediaPlayer).extend(
         {
-            cv.GenerateID(): cv.declare_id(SpeakerMediaPlayer),
             cv.Required(CONF_ANNOUNCEMENT_PIPELINE): PIPELINE_SCHEMA,
             cv.Optional(CONF_MEDIA_PIPELINE): PIPELINE_SCHEMA,
             cv.Optional(CONF_BUFFER_SIZE, default=1000000): cv.int_range(
@@ -332,22 +331,19 @@ async def to_code(config):
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_MSS", 1436)
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_MSL", 60000)
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_SND_BUF_DEFAULT", 65535)
-        esp32.add_idf_sdkconfig_option(
-            "CONFIG_TCP_WND_DEFAULT", 65535
-        )  # Adjusted from referenced settings to avoid compilation error
+        esp32.add_idf_sdkconfig_option("CONFIG_TCP_WND_DEFAULT", 512000)
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_RECVMBOX_SIZE", 512)
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_QUEUE_OOSEQ", True)
         esp32.add_idf_sdkconfig_option("CONFIG_TCP_OVERSIZE_MSS", True)
         esp32.add_idf_sdkconfig_option("CONFIG_LWIP_WND_SCALE", True)
-        esp32.add_idf_sdkconfig_option("CONFIG_TCP_RCV_SCALE", 3)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RCV_SCALE", 3)
         esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 512)
 
         # Allocate wifi buffers in PSRAM
         esp32.add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)
 
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await media_player.new_media_player(config)
     await cg.register_component(var, config)
-    await media_player.register_media_player(var, config)
 
     cg.add_define("USE_OTA_STATE_CALLBACK")
 

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -106,16 +106,6 @@ void SpeakerMediaPlayer::setup() {
       ESP_LOGE(TAG, "Failed to create media pipeline");
       this->mark_failed();
     }
-
-    // Setup callback to track the duration of audio played by the media pipeline
-    this->media_speaker_->add_audio_output_callback(
-        [this](uint32_t new_playback_ms, uint32_t remainder_us, uint32_t pending_ms, uint32_t write_timestamp) {
-          this->playback_ms_ += new_playback_ms;
-          this->remainder_us_ = remainder_us;
-          this->pending_ms_ = pending_ms;
-          this->last_audio_write_timestamp_ = write_timestamp;
-          this->playback_us_ = this->playback_ms_ * 1000 + this->remainder_us_;
-        });
   }
 
   ESP_LOGI(TAG, "Set up speaker media player");
@@ -321,7 +311,6 @@ void SpeakerMediaPlayer::loop() {
   AudioPipelineState old_media_pipeline_state = this->media_pipeline_state_;
   if (this->media_pipeline_ != nullptr) {
     this->media_pipeline_state_ = this->media_pipeline_->process_state();
-    this->decoded_playback_ms_ = this->media_pipeline_->get_playback_ms();
   }
 
   if (this->media_pipeline_state_ == AudioPipelineState::ERROR_READING) {
@@ -379,13 +368,6 @@ void SpeakerMediaPlayer::loop() {
       } else if (this->media_pipeline_state_ == AudioPipelineState::PLAYING) {
         this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
       } else if (this->media_pipeline_state_ == AudioPipelineState::STOPPED) {
-        // Reset playback durations
-        this->decoded_playback_ms_ = 0;
-        this->playback_us_ = 0;
-        this->playback_ms_ = 0;
-        this->remainder_us_ = 0;
-        this->pending_ms_ = 0;
-
         if (!media_playlist_.empty()) {
           uint32_t timeout_ms = 0;
           if (old_media_pipeline_state == AudioPipelineState::PLAYING) {

esphome/components/speaker/media_player/speaker_media_player.h

@@ -73,10 +73,6 @@ class SpeakerMediaPlayer : public Component, public media_player::MediaPlayer {
 
   void play_file(audio::AudioFile *media_file, bool announcement, bool enqueue);
 
-  uint32_t get_playback_ms() const { return this->playback_ms_; }
-  uint32_t get_playback_us() const { return this->playback_us_; }
-  uint32_t get_decoded_playback_ms() const { return this->decoded_playback_ms_; }
-
   void set_playlist_delay_ms(AudioPipelineType pipeline_type, uint32_t delay_ms);
 
  protected:
@@ -141,13 +137,6 @@ class SpeakerMediaPlayer : public Component, public media_player::MediaPlayer {
   Trigger<> *mute_trigger_ = new Trigger<>();
   Trigger<> *unmute_trigger_ = new Trigger<>();
   Trigger<float> *volume_trigger_ = new Trigger<float>();
-
-  uint32_t decoded_playback_ms_{0};
-  uint32_t playback_us_{0};
-  uint32_t playback_ms_{0};
-  uint32_t remainder_us_{0};
-  uint32_t pending_ms_{0};
-  uint32_t last_audio_write_timestamp_{0};
 };
 
 }  // namespace speaker

esphome/components/speaker/speaker.h

@@ -104,12 +104,9 @@ class Speaker {
 
   /// Callback function for sending the duration of the audio written to the speaker since the last callback.
   /// Parameters:
-  ///   - Duration in milliseconds. Never rounded and should always be less than or equal to the actual duration.
-  ///   - Remainder duration in microseconds. Rounded duration after subtracting the previous parameter from the actual
-  ///     duration.
-  ///   - Duration of remaining, unwritten audio buffered in the speaker in milliseconds.
-  ///   - System time in microseconds when the last write was completed.
-  void add_audio_output_callback(std::function<void(uint32_t, uint32_t, uint32_t, uint32_t)> &&callback) {
+  ///   - Frames played
+  ///   - System time in microseconds when the frames were written to the DAC
+  void add_audio_output_callback(std::function<void(uint32_t, int64_t)> &&callback) {
     this->audio_output_callback_.add(std::move(callback));
   }
 
@@ -123,7 +120,7 @@ class Speaker {
   audio_dac::AudioDac *audio_dac_{nullptr};
 #endif
 
-  CallbackManager<void(uint32_t, uint32_t, uint32_t, uint32_t)> audio_output_callback_{};
+  CallbackManager<void(uint32_t, int64_t)> audio_output_callback_{};
 };
 
 }  // namespace speaker

esphome/components/speed/fan/__init__.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_DIRECTION_OUTPUT,
     CONF_OSCILLATION_OUTPUT,
     CONF_OUTPUT,
-    CONF_OUTPUT_ID,
     CONF_PRESET_MODES,
     CONF_SPEED,
     CONF_SPEED_COUNT,
@@ -16,25 +15,27 @@ from .. import speed_ns
 
 SpeedFan = speed_ns.class_("SpeedFan", cg.Component, fan.Fan)
 
-CONFIG_SCHEMA = fan.FAN_SCHEMA.extend(
-    {
-        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(SpeedFan),
-        cv.Required(CONF_OUTPUT): cv.use_id(output.FloatOutput),
-        cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput),
-        cv.Optional(CONF_DIRECTION_OUTPUT): cv.use_id(output.BinaryOutput),
-        cv.Optional(CONF_SPEED): cv.invalid(
-            "Configuring individual speeds is deprecated."
-        ),
-        cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
-        cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    fan.fan_schema(SpeedFan)
+    .extend(
+        {
+            cv.Required(CONF_OUTPUT): cv.use_id(output.FloatOutput),
+            cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput),
+            cv.Optional(CONF_DIRECTION_OUTPUT): cv.use_id(output.BinaryOutput),
+            cv.Optional(CONF_SPEED): cv.invalid(
+                "Configuring individual speeds is deprecated."
+            ),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
+            cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_OUTPUT_ID], config[CONF_SPEED_COUNT])
+    var = await fan.new_fan(config, config[CONF_SPEED_COUNT])
     await cg.register_component(var, config)
-    await fan.register_fan(var, config)
 
     output_ = await cg.get_variable(config[CONF_OUTPUT])
     cg.add(var.set_output(output_))

esphome/components/spi/spi.h

@@ -1,5 +1,4 @@
 #pragma once
-
 #include "esphome/core/application.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
@@ -28,6 +27,11 @@ using SPIInterface = spi_host_device_t;
 
 #endif  // USE_ESP_IDF
 
+#ifdef USE_ZEPHYR
+// TODO supprse clang-tidy. Remove after SPI driver for nrf52 is added.
+using SPIInterface = void *;
+#endif
+
 /**
  * Implementation of SPI Controller mode.
  */
@@ -351,6 +355,12 @@ class SPIComponent : public Component {
 
   void setup() override;
   void dump_config() override;
+  size_t get_bus_width() const {
+    if (this->data_pins_.empty()) {
+      return 1;
+    }
+    return this->data_pins_.size();
+  }
 
  protected:
   GPIOPin *clk_pin_{nullptr};

esphome/components/sprinkler/__init__.py

@@ -4,7 +4,6 @@ import esphome.codegen as cg
 from esphome.components import number, switch
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ENTITY_CATEGORY,
     CONF_ID,
     CONF_INITIAL_VALUE,
     CONF_MAX_VALUE,
@@ -296,12 +295,11 @@ SPRINKLER_VALVE_SCHEMA = cv.Schema(
         cv.Optional(CONF_PUMP_SWITCH_ID): cv.use_id(switch.Switch),
         cv.Optional(CONF_RUN_DURATION): cv.positive_time_period_seconds,
         cv.Optional(CONF_RUN_DURATION_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=900): cv.positive_int,
                     cv.Optional(CONF_MAX_VALUE, default=86400): cv.positive_int,
                     cv.Optional(CONF_MIN_VALUE, default=1): cv.positive_int,
@@ -314,7 +312,8 @@ SPRINKLER_VALVE_SCHEMA = cv.Schema(
                         CONF_UNIT_OF_MEASUREMENT, default=UNIT_SECOND
                     ): cv.one_of(UNIT_MINUTE, UNIT_SECOND, lower="True"),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),
@@ -371,12 +370,11 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
         cv.Optional(CONF_NEXT_PREV_IGNORE_DISABLED, default=False): cv.boolean,
         cv.Optional(CONF_MANUAL_SELECTION_DELAY): cv.positive_time_period_seconds,
         cv.Optional(CONF_MULTIPLIER_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=1): cv.positive_float,
                     cv.Optional(CONF_MAX_VALUE, default=10): cv.positive_float,
                     cv.Optional(CONF_MIN_VALUE, default=0): cv.positive_float,
@@ -386,18 +384,18 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
                         single=True
                     ),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),
         cv.Optional(CONF_REPEAT): cv.positive_int,
         cv.Optional(CONF_REPEAT_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=0): cv.positive_int,
                     cv.Optional(CONF_MAX_VALUE, default=10): cv.positive_int,
                     cv.Optional(CONF_MIN_VALUE, default=0): cv.positive_int,
@@ -407,7 +405,8 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
                         single=True
                     ),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),

esphome/components/switch/__init__.py

@@ -72,6 +72,9 @@ _SWITCH_SCHEMA = (
         {
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSwitchComponent),
             cv.Optional(CONF_INVERTED): cv.boolean,
+            cv.Optional(CONF_RESTORE_MODE, default="ALWAYS_OFF"): cv.enum(
+                RESTORE_MODES, upper=True, space="_"
+            ),
             cv.Optional(CONF_ON_TURN_ON): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SwitchTurnOnTrigger),
@@ -87,57 +90,44 @@ _SWITCH_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def switch_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass,
     *,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
-    icon: str = _UNDEF,
     block_inverted: bool = False,
-    default_restore_mode: str = "ALWAYS_OFF",
+    default_restore_mode: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
 ):
-    schema = _SWITCH_SCHEMA.extend(
-        {
-            cv.Optional(CONF_RESTORE_MODE, default=default_restore_mode): cv.enum(
-                RESTORE_MODES, upper=True, space="_"
-            ),
-        }
-    )
-    if class_ is not _UNDEF:
-        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
-    if entity_category is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_ENTITY_CATEGORY, default=entity_category
-                ): cv.entity_category
-            }
-        )
-    if device_class is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_DEVICE_CLASS, default=device_class
-                ): validate_device_class
-            }
-        )
-    if icon is not _UNDEF:
-        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
+    schema = {cv.GenerateID(): cv.declare_id(class_)}
+
+    for key, default, validator in [
+        (CONF_DEVICE_CLASS, device_class, validate_device_class),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+        (
+            CONF_RESTORE_MODE,
+            default_restore_mode,
+            cv.enum(RESTORE_MODES, upper=True, space="_")
+            if default_restore_mode is not cv.UNDEFINED
+            else cv.UNDEFINED,
+        ),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
     if block_inverted:
-        schema = schema.extend(
-            {
-                cv.Optional(CONF_INVERTED): cv.invalid(
-                    "Inverted is not supported for this platform!"
-                )
-            }
+        schema[cv.Optional(CONF_INVERTED)] = cv.invalid(
+            "Inverted is not supported for this platform!"
         )
-    return schema
+
+    return _SWITCH_SCHEMA.extend(schema)
 
 
-SWITCH_SCHEMA = switch_schema()  # for compatibility
+# Remove before 2025.11.0
+SWITCH_SCHEMA = switch_schema(Switch)
+SWITCH_SCHEMA.add_extra(cv.deprecated_schema_constant("switch"))
 
 
 async def setup_switch_core_(var, config):