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

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -72,70 +72,57 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
 
  protected:
   /// @brief Function for the FreeRTOS task handling audio output.
-  /// After receiving the COMMAND_START signal, allocates space for the buffers, starts the I2S driver, and reads
-  /// audio from the ring buffer and writes audio to the I2S port. Stops immmiately after receiving the COMMAND_STOP
-  /// signal and stops only after the ring buffer is empty after receiving the COMMAND_STOP_GRACEFULLY signal. Stops if
-  /// the ring buffer hasn't read data for more than timeout_ milliseconds. When stopping, it deallocates the buffers,
-  /// stops the I2S driver, unlocks the I2S port, and deletes the task. It communicates the state and any errors via
-  /// event_group_.
+  /// Allocates space for the buffers, reads audio from the ring buffer and writes audio to the I2S port. Stops
+  /// immmiately after receiving the COMMAND_STOP signal and stops only after the ring buffer is empty after receiving
+  /// the COMMAND_STOP_GRACEFULLY signal. Stops if the ring buffer hasn't read data for more than timeout_ milliseconds.
+  /// When stopping, it deallocates the buffers. It communicates its state and any errors via ``event_group_``.
   /// @param params I2SAudioSpeaker component
   static void speaker_task(void *params);
 
-  /// @brief Sends a stop command to the speaker task via event_group_.
+  /// @brief Sends a stop command to the speaker task via ``event_group_``.
   /// @param wait_on_empty If false, sends the COMMAND_STOP signal. If true, sends the COMMAND_STOP_GRACEFULLY signal.
   void stop_(bool wait_on_empty);
 
-  /// @brief Sets the corresponding ERR_ESP event group bits.
-  /// @param err esp_err_t error code.
-  /// @return True if an ERR_ESP bit is set and false if err == ESP_OK
-  bool send_esp_err_to_event_group_(esp_err_t err);
-
 #ifndef USE_I2S_LEGACY
-  static bool i2s_overflow_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx);
+  /// @brief Callback function used to send playback timestamps the to the speaker task.
+  /// @param handle (i2s_chan_handle_t)
+  /// @param event (i2s_event_data_t)
+  /// @param user_ctx (void*) User context pointer that the callback accesses
+  /// @return True if a higher priority task was interrupted
+  static bool i2s_on_sent_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx);
 #endif
 
-  /// @brief Allocates the data buffer and ring buffer
-  /// @param data_buffer_size Number of bytes to allocate for the data buffer.
-  /// @param ring_buffer_size Number of bytes to allocate for the ring buffer.
-  /// @return ESP_ERR_NO_MEM if either buffer fails to allocate
-  ///         ESP_OK if successful
-  esp_err_t allocate_buffers_(size_t data_buffer_size, size_t ring_buffer_size);
-
   /// @brief Starts the ESP32 I2S driver.
   /// Attempts to lock the I2S port, starts the I2S driver using the passed in stream information, and sets the data out
-  /// pin. If it fails, it will unlock the I2S port and uninstall the driver, if necessary.
+  /// pin. If it fails, it will unlock the I2S port and uninstalls the driver, if necessary.
   /// @param audio_stream_info Stream information for the I2S driver.
   /// @return ESP_ERR_NOT_ALLOWED if the I2S port can't play the incoming audio stream.
   ///         ESP_ERR_INVALID_STATE if the I2S port is already locked.
-  ///         ESP_ERR_INVALID_ARG if nstalling the driver or setting the data outpin fails due to a parameter error.
+  ///         ESP_ERR_INVALID_ARG if installing the driver or setting the data outpin fails due to a parameter error.
   ///         ESP_ERR_NO_MEM if the driver fails to install due to a memory allocation error.
-  ///         ESP_FAIL if setting the data out pin fails due to an IO error ESP_OK if successful
+  ///         ESP_FAIL if setting the data out pin fails due to an IO error
+  ///         ESP_OK if successful
   esp_err_t start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info);
 
-  /// @brief Deletes the speaker's task.
-  /// Deallocates the data_buffer_ and audio_ring_buffer_, if necessary, and deletes the task. Should only be called by
-  /// the speaker_task itself.
-  /// @param buffer_size The allocated size of the data_buffer_.
-  void delete_task_(size_t buffer_size);
+  /// @brief Stops the I2S driver and unlocks the I2S port
+  void stop_i2s_driver_();
 
   TaskHandle_t speaker_task_handle_{nullptr};
   EventGroupHandle_t event_group_{nullptr};
 
   QueueHandle_t i2s_event_queue_;
 
-  uint8_t *data_buffer_;
-  std::shared_ptr<RingBuffer> audio_ring_buffer_;
+  std::weak_ptr<RingBuffer> audio_ring_buffer_;
 
   uint32_t buffer_duration_ms_;
 
   optional<uint32_t> timeout_;
 
-  bool task_created_{false};
   bool pause_state_{false};
 
   int16_t q15_volume_factor_{INT16_MAX};
 
-  size_t bytes_written_{0};
+  audio::AudioStreamInfo current_stream_info_;  // The currently loaded driver's stream info
 
 #ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_DAC
@@ -148,8 +135,6 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   std::string i2s_comm_fmt_;
   i2s_chan_handle_t tx_handle_;
 #endif
-
-  uint32_t accumulated_frames_written_{0};
 };
 
 }  // namespace i2s_audio

esphome/components/ili9xxx/display.py

@@ -138,9 +138,10 @@ def _validate(config):
     ]:
         raise cv.Invalid("Selected model can't run on ESP8266.")
 
-    if model == "CUSTOM":
-        if CONF_INIT_SEQUENCE not in config or CONF_DIMENSIONS not in config:
-            raise cv.Invalid("CUSTOM model requires init_sequence and dimensions")
+    if model == "CUSTOM" and (
+        CONF_INIT_SEQUENCE not in config or CONF_DIMENSIONS not in config
+    ):
+        raise cv.Invalid("CUSTOM model requires init_sequence and dimensions")
 
     return config
 

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -31,8 +31,6 @@ void ILI9XXXDisplay::set_madctl() {
 }
 
 void ILI9XXXDisplay::setup() {
-  ESP_LOGD(TAG, "Setting up ILI9xxx");
-
   this->setup_pins_();
   this->init_lcd_(this->init_sequence_);
   this->init_lcd_(this->extra_init_sequence_.data());

esphome/components/image/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import hashlib
 import io
 import logging
@@ -107,6 +108,24 @@ class ImageEncoder:
         :return:
         """
 
+    @classmethod
+    def is_endian(cls) -> bool:
+        """
+        Check if the image encoder supports endianness configuration
+        """
+        return getattr(cls, "set_big_endian", None) is not None
+
+    @classmethod
+    def get_options(cls) -> list[str]:
+        """
+        Get the available options for this image encoder
+        """
+        options = [*OPTIONS]
+        if not cls.is_endian():
+            options.remove(CONF_BYTE_ORDER)
+        options.append(CONF_RAW_DATA_ID)
+        return options
+
 
 def is_alpha_only(image: Image):
     """
@@ -174,9 +193,8 @@ class ImageGrayscale(ImageEncoder):
                 b = 1
         if self.invert_alpha:
             b ^= 0xFF
-        if self.transparency == CONF_ALPHA_CHANNEL:
-            if a != 0xFF:
-                b = a
+        if self.transparency == CONF_ALPHA_CHANNEL and a != 0xFF:
+            b = a
         self.data[self.index] = b
         self.index += 1
 
@@ -446,13 +464,14 @@ def validate_type(image_types):
     return validate
 
 
-def validate_settings(value):
+def validate_settings(value, path=()):
     """
     Validate the settings for a single image configuration.
     """
     conf_type = value[CONF_TYPE]
     type_class = IMAGE_TYPE[conf_type]
-    transparency = value[CONF_TRANSPARENCY].lower()
+
+    transparency = value.get(CONF_TRANSPARENCY, CONF_OPAQUE).lower()
     if transparency not in type_class.allow_config:
         raise cv.Invalid(
             f"Image format '{conf_type}' cannot have transparency: {transparency}"
@@ -464,11 +483,10 @@ def validate_settings(value):
         and CONF_INVERT_ALPHA not in type_class.allow_config
     ):
         raise cv.Invalid("No alpha channel to invert")
-    if value.get(CONF_BYTE_ORDER) is not None and not callable(
-        getattr(type_class, "set_big_endian", None)
-    ):
+    if value.get(CONF_BYTE_ORDER) is not None and not type_class.is_endian():
         raise cv.Invalid(
-            f"Image format '{conf_type}' does not support byte order configuration"
+            f"Image format '{conf_type}' does not support byte order configuration",
+            path=path,
         )
     if file := value.get(CONF_FILE):
         file = Path(file)
@@ -479,7 +497,7 @@ def validate_settings(value):
                 Image.open(file)
             except UnidentifiedImageError as exc:
                 raise cv.Invalid(
-                    f"File can't be opened as image: {file.absolute()}"
+                    f"File can't be opened as image: {file.absolute()}", path=path
                 ) from exc
     return value
 
@@ -499,6 +517,10 @@ OPTIONS_SCHEMA = {
     cv.Optional(CONF_INVERT_ALPHA, default=False): cv.boolean,
     cv.Optional(CONF_BYTE_ORDER): cv.one_of("BIG_ENDIAN", "LITTLE_ENDIAN", upper=True),
     cv.Optional(CONF_TRANSPARENCY, default=CONF_OPAQUE): validate_transparency(),
+}
+
+DEFAULTS_SCHEMA = {
+    **OPTIONS_SCHEMA,
     cv.Optional(CONF_TYPE): validate_type(IMAGE_TYPE),
 }
 
@@ -510,47 +532,61 @@ IMAGE_SCHEMA_NO_DEFAULTS = {
     **{cv.Optional(key): OPTIONS_SCHEMA[key] for key in OPTIONS},
 }
 
-BASE_SCHEMA = cv.Schema(
+IMAGE_SCHEMA = cv.Schema(
     {
         **IMAGE_ID_SCHEMA,
         **OPTIONS_SCHEMA,
-    }
-).add_extra(validate_settings)
-
-IMAGE_SCHEMA = BASE_SCHEMA.extend(
-    {
         cv.Required(CONF_TYPE): validate_type(IMAGE_TYPE),
     }
 )
 
 
+def apply_defaults(image, defaults, path):
+    """
+    Apply defaults to an image configuration
+    """
+    type = image.get(CONF_TYPE, defaults.get(CONF_TYPE))
+    if type is None:
+        raise cv.Invalid(
+            "Type is required either in the image config or in the defaults", path=path
+        )
+    type_class = IMAGE_TYPE[type]
+    config = {
+        **{key: image.get(key, defaults.get(key)) for key in type_class.get_options()},
+        **{key.schema: image[key.schema] for key in IMAGE_ID_SCHEMA},
+        CONF_TYPE: image.get(CONF_TYPE, defaults.get(CONF_TYPE)),
+    }
+    validate_settings(config, path)
+    return config
+
+
 def validate_defaults(value):
     """
-    Validate the options for images with defaults
+    Apply defaults to the images in the configuration and flatten to a single list.
     """
     defaults = value[CONF_DEFAULTS]
     result = []
-    for index, image in enumerate(value[CONF_IMAGES]):
-        type = image.get(CONF_TYPE, defaults.get(CONF_TYPE))
-        if type is None:
-            raise cv.Invalid(
-                "Type is required either in the image config or in the defaults",
-                path=[CONF_IMAGES, index],
-            )
-        type_class = IMAGE_TYPE[type]
-        # A default byte order should be simply ignored if the type does not support it
-        available_options = [*OPTIONS]
-        if (
-            not callable(getattr(type_class, "set_big_endian", None))
-            and CONF_BYTE_ORDER not in image
-        ):
-            available_options.remove(CONF_BYTE_ORDER)
-        config = {
-            **{key: image.get(key, defaults.get(key)) for key in available_options},
-            **{key.schema: image[key.schema] for key in IMAGE_ID_SCHEMA},
-        }
-        validate_settings(config)
-        result.append(config)
+    # Apply defaults to the images: list and add the list entries to the result
+    for index, image in enumerate(value.get(CONF_IMAGES, [])):
+        result.append(apply_defaults(image, defaults, [CONF_IMAGES, index]))
+
+    # Apply defaults to images under the type keys and add them to the result
+    for image_type, type_config in value.items():
+        type_upper = image_type.upper()
+        if type_upper not in IMAGE_TYPE:
+            continue
+        type_class = IMAGE_TYPE[type_upper]
+        if isinstance(type_config, list):
+            # If the type is a list, apply defaults to each entry
+            for index, image in enumerate(type_config):
+                result.append(apply_defaults(image, defaults, [image_type, index]))
+        else:
+            # Handle transparency options for the type
+            for trans_type in set(type_class.allow_config).intersection(type_config):
+                for index, image in enumerate(type_config[trans_type]):
+                    result.append(
+                        apply_defaults(image, defaults, [image_type, trans_type, index])
+                    )
     return result
 
 
@@ -562,16 +598,20 @@ def typed_image_schema(image_type):
         cv.Schema(
             {
                 cv.Optional(t.lower()): cv.ensure_list(
-                    BASE_SCHEMA.extend(
-                        {
-                            cv.Optional(
-                                CONF_TRANSPARENCY, default=t
-                            ): validate_transparency((t,)),
-                            cv.Optional(CONF_TYPE, default=image_type): validate_type(
-                                (image_type,)
-                            ),
-                        }
-                    )
+                    {
+                        **IMAGE_ID_SCHEMA,
+                        **{
+                            cv.Optional(key): OPTIONS_SCHEMA[key]
+                            for key in OPTIONS
+                            if key != CONF_TRANSPARENCY
+                        },
+                        cv.Optional(
+                            CONF_TRANSPARENCY, default=t
+                        ): validate_transparency((t,)),
+                        cv.Optional(CONF_TYPE, default=image_type): validate_type(
+                            (image_type,)
+                        ),
+                    }
                 )
                 for t in IMAGE_TYPE[image_type].allow_config.intersection(
                     TRANSPARENCY_TYPES
@@ -580,46 +620,44 @@ def typed_image_schema(image_type):
         ),
         # Allow a default configuration with no transparency preselected
         cv.ensure_list(
-            BASE_SCHEMA.extend(
-                {
-                    cv.Optional(
-                        CONF_TRANSPARENCY, default=CONF_OPAQUE
-                    ): validate_transparency(),
-                    cv.Optional(CONF_TYPE, default=image_type): validate_type(
-                        (image_type,)
-                    ),
-                }
-            )
+            {
+                **IMAGE_SCHEMA_NO_DEFAULTS,
+                cv.Optional(CONF_TYPE, default=image_type): validate_type(
+                    (image_type,)
+                ),
+            }
         ),
     )
 
 
 # The config schema can be a (possibly empty) single list of images,
-# or a dictionary of image types each with a list of images
-# or a dictionary with keys `defaults:` and `images:`
+# or a dictionary with optional keys `defaults:`, `images:` and the image types
 
 
-def _config_schema(config):
-    if isinstance(config, list):
-        return cv.Schema([IMAGE_SCHEMA])(config)
-    if not isinstance(config, dict):
+def _config_schema(value):
+    if isinstance(value, list) or (
+        isinstance(value, dict) and (CONF_ID in value or CONF_FILE in value)
+    ):
+        return cv.ensure_list(cv.All(IMAGE_SCHEMA, validate_settings))(value)
+    if not isinstance(value, dict):
         raise cv.Invalid(
-            "Badly formed image configuration, expected a list or a dictionary"
-        )
-    if CONF_DEFAULTS in config or CONF_IMAGES in config:
-        return validate_defaults(
-            cv.Schema(
-                {
-                    cv.Required(CONF_DEFAULTS): OPTIONS_SCHEMA,
-                    cv.Required(CONF_IMAGES): cv.ensure_list(IMAGE_SCHEMA_NO_DEFAULTS),
-                }
-            )(config)
+            "Badly formed image configuration, expected a list or a dictionary",
         )
-    if CONF_ID in config or CONF_FILE in config:
-        return cv.ensure_list(IMAGE_SCHEMA)([config])
-    return cv.Schema(
-        {cv.Optional(t.lower()): typed_image_schema(t) for t in IMAGE_TYPE}
-    )(config)
+    return cv.All(
+        cv.Schema(
+            {
+                cv.Optional(CONF_DEFAULTS, default={}): DEFAULTS_SCHEMA,
+                cv.Optional(CONF_IMAGES, default=[]): cv.ensure_list(
+                    {
+                        **IMAGE_SCHEMA_NO_DEFAULTS,
+                        cv.Optional(CONF_TYPE): validate_type(IMAGE_TYPE),
+                    }
+                ),
+                **{cv.Optional(t.lower()): typed_image_schema(t) for t in IMAGE_TYPE},
+            }
+        ),
+        validate_defaults,
+    )(value)
 
 
 CONFIG_SCHEMA = _config_schema
@@ -668,14 +706,12 @@ async def write_image(config, all_frames=False):
         else Image.Dither.FLOYDSTEINBERG
     )
     type = config[CONF_TYPE]
-    transparency = config[CONF_TRANSPARENCY]
+    transparency = config.get(CONF_TRANSPARENCY, CONF_OPAQUE)
     invert_alpha = config[CONF_INVERT_ALPHA]
     frame_count = 1
     if all_frames:
-        try:
+        with contextlib.suppress(AttributeError):
             frame_count = image.n_frames
-        except AttributeError:
-            pass
         if frame_count <= 1:
             _LOGGER.warning("Image file %s has no animation frames", path)
 
@@ -701,14 +737,9 @@ async def write_image(config, all_frames=False):
 
 
 async def to_code(config):
-    if isinstance(config, list):
-        for entry in config:
-            await to_code(entry)
-    elif CONF_ID not in config:
-        for entry in config.values():
-            await to_code(entry)
-    else:
-        prog_arr, width, height, image_type, trans_value, _ = await write_image(config)
+    # By now the config should be a simple list.
+    for entry in config:
+        prog_arr, width, height, image_type, trans_value, _ = await write_image(entry)
         cg.new_Pvariable(
-            config[CONF_ID], prog_arr, width, height, image_type, trans_value
+            entry[CONF_ID], prog_arr, width, height, image_type, trans_value
         )

esphome/components/improv_serial/__init__.py

@@ -27,14 +27,13 @@ def validate_logger(config):
     logger_conf = fv.full_config.get()[CONF_LOGGER]
     if logger_conf[CONF_BAUD_RATE] == 0:
         raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0")
-    if CORE.using_esp_idf:
-        if (
-            logger_conf[CONF_HARDWARE_UART] == USB_CDC
-            and get_esp32_variant() == VARIANT_ESP32S3
-        ):
-            raise cv.Invalid(
-                "improv_serial does not support the selected logger hardware_uart"
-            )
+    if CORE.using_esp_idf and (
+        logger_conf[CONF_HARDWARE_UART] == USB_CDC
+        and get_esp32_variant() == VARIANT_ESP32S3
+    ):
+        raise cv.Invalid(
+            "improv_serial does not support the selected logger hardware_uart"
+        )
     return config
 
 

esphome/components/ina219/ina219.cpp

@@ -34,7 +34,6 @@ static const uint8_t INA219_REGISTER_CURRENT = 0x04;
 static const uint8_t INA219_REGISTER_CALIBRATION = 0x05;
 
 void INA219Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // Config Register
   // 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
   if (!this->write_byte_16(INA219_REGISTER_CONFIG, 0x8000)) {

esphome/components/ina226/ina226.cpp

@@ -37,8 +37,6 @@ static const uint16_t INA226_ADC_TIMES[] = {140, 204, 332, 588, 1100, 2116, 4156
 static const uint16_t INA226_ADC_AVG_SAMPLES[] = {1, 4, 16, 64, 128, 256, 512, 1024};
 
 void INA226Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   ConfigurationRegister config;
 
   config.reset = 1;

esphome/components/ina260/ina260.cpp

@@ -35,8 +35,6 @@ static const uint8_t INA260_REGISTER_MANUFACTURE_ID = 0xFE;
 static const uint8_t INA260_REGISTER_DEVICE_ID = 0xFF;
 
 void INA260Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Reset device on setup
   if (!this->write_byte_16(INA260_REGISTER_CONFIG, 0x8000)) {
     this->error_code_ = DEVICE_RESET_FAILED;

esphome/components/ina2xx_base/__init__.py

@@ -78,11 +78,8 @@ def validate_model_config(config):
     model = config[CONF_MODEL]
 
     for key in config:
-        if key in SENSOR_MODEL_OPTIONS:
-            if model not in SENSOR_MODEL_OPTIONS[key]:
-                raise cv.Invalid(
-                    f"Device model '{model}' does not support '{key}' sensor"
-                )
+        if key in SENSOR_MODEL_OPTIONS and model not in SENSOR_MODEL_OPTIONS[key]:
+            raise cv.Invalid(f"Device model '{model}' does not support '{key}' sensor")
 
     tempco = config[CONF_TEMPERATURE_COEFFICIENT]
     if tempco > 0 and model not in ["INA228", "INA229"]:

esphome/components/ina2xx_base/ina2xx_base.cpp

@@ -50,8 +50,6 @@ static bool check_model_and_device_match(INAModel model, uint16_t dev_id) {
 }
 
 void INA2XX::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (!this->reset_config_()) {
     ESP_LOGE(TAG, "Reset failed, check connection");
     this->mark_failed();

esphome/components/ina3221/ina3221.cpp

@@ -22,7 +22,6 @@ static const uint8_t INA3221_REGISTER_CHANNEL3_BUS_VOLTAGE = 0x06;
 // A0 = SCL -> 0x43
 
 void INA3221Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // Config Register
   // 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
   if (!this->write_byte_16(INA3221_REGISTER_CONFIG, 0x8000)) {

esphome/components/internal_temperature/internal_temperature.cpp

@@ -84,8 +84,6 @@ void InternalTemperatureSensor::setup() {
 #if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32S2) || \
     defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32C2) || \
     defined(USE_ESP32_VARIANT_ESP32P4)
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   temperature_sensor_config_t tsens_config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(-10, 80);
 
   esp_err_t result = temperature_sensor_install(&tsens_config, &tsensNew);

esphome/components/interval/interval.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/log.h"
 #include "esphome/core/automation.h"
 
 namespace esphome {
@@ -8,16 +9,12 @@ namespace interval {
 
 class IntervalTrigger : public Trigger<>, public PollingComponent {
  public:
-  void update() override {
-    if (this->started_)
-      this->trigger();
-  }
+  void update() override { this->trigger(); }
 
   void setup() override {
-    if (this->startup_delay_ == 0) {
-      this->started_ = true;
-    } else {
-      this->set_timeout(this->startup_delay_, [this] { this->started_ = true; });
+    if (this->startup_delay_ != 0) {
+      this->stop_poller();
+      this->set_timeout(this->startup_delay_, [this] { this->start_poller(); });
     }
   }
 
@@ -25,7 +22,6 @@ class IntervalTrigger : public Trigger<>, public PollingComponent {
 
  protected:
   uint32_t startup_delay_{0};
-  bool started_{false};
 };
 
 }  // namespace interval

esphome/components/json/__init__.py

@@ -2,7 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.core import coroutine_with_priority
 
-CODEOWNERS = ["@OttoWinter"]
+CODEOWNERS = ["@esphome/core"]
 json_ns = cg.esphome_ns.namespace("json")
 
 CONFIG_SCHEMA = cv.All(

esphome/components/kmeteriso/kmeteriso.cpp

@@ -14,7 +14,6 @@ static const uint8_t KMETER_INTERNAL_TEMP_VAL_REG = 0x10;
 static const uint8_t KMETER_FIRMWARE_VERSION_REG = 0xFE;
 
 void KMeterISOComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->error_code_ = NONE;
 
   // Mark as not failed before initializing. Some devices will turn off sensors to save on batteries
@@ -46,7 +45,6 @@ void KMeterISOComponent::setup() {
     this->mark_failed();
     return;
   }
-  ESP_LOGCONFIG(TAG, "The device was successfully setup.");
 }
 
 float KMeterISOComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/lc709203f/lc709203f.cpp

@@ -49,8 +49,6 @@ void Lc709203f::setup() {
   //  initialization code checks the return code from those functions. If they don't return
   //  NO_ERROR (0x00), that part of the initialization aborts and will be retried on the next
   //  call to update().
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Set power mode to on. Note that, unlike some other similar devices, in sleep mode the IC
   //  does not record power usage. If there is significant power consumption during sleep mode,
   //  the pack RSOC will likely no longer be correct. Because of that, I do not implement

esphome/components/lcd_gpio/display.py

@@ -41,9 +41,7 @@ CONFIG_SCHEMA = lcd_base.LCD_SCHEMA.extend(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await lcd_base.setup_lcd_display(var, config)
-    pins_ = []
-    for conf in config[CONF_DATA_PINS]:
-        pins_.append(await cg.gpio_pin_expression(conf))
+    pins_ = [await cg.gpio_pin_expression(conf) for conf in config[CONF_DATA_PINS]]
     cg.add(var.set_data_pins(*pins_))
     enable = await cg.gpio_pin_expression(config[CONF_ENABLE_PIN])
     cg.add(var.set_enable_pin(enable))

esphome/components/lcd_gpio/gpio_lcd_display.cpp

@@ -7,7 +7,6 @@ namespace lcd_gpio {
 static const char *const TAG = "lcd_gpio";
 
 void GPIOLCDDisplay::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->rs_pin_->setup();  // OUTPUT
   this->rs_pin_->digital_write(false);
   if (this->rw_pin_ != nullptr) {

esphome/components/lcd_pcf8574/pcf8574_display.cpp

@@ -11,7 +11,6 @@ static const uint8_t LCD_DISPLAY_BACKLIGHT_ON = 0x08;
 static const uint8_t LCD_DISPLAY_BACKLIGHT_OFF = 0x00;
 
 void PCF8574LCDDisplay::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->backlight_value_ = LCD_DISPLAY_BACKLIGHT_ON;
   if (!this->write_bytes(this->backlight_value_, nullptr, 0)) {
     this->mark_failed();