review comments

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.5
+    rev: v0.14.4
     hooks:
       # Run the linter.
       - id: ruff

esphome/components/uart/__init__.py

@@ -1,4 +1,3 @@
-from logging import getLogger
 import math
 import re
 
@@ -36,8 +35,6 @@ from esphome.core import CORE, ID
 import esphome.final_validate as fv
 from esphome.yaml_util import make_data_base
 
-_LOGGER = getLogger(__name__)
-
 CODEOWNERS = ["@esphome/core"]
 uart_ns = cg.esphome_ns.namespace("uart")
 UARTComponent = uart_ns.class_("UARTComponent")
@@ -133,21 +130,6 @@ def validate_host_config(config):
     return config
 
 
-def validate_rx_buffer_size(config):
-    if CORE.is_esp32:
-        # ESP32 UART hardware FIFO is 128 bytes (LP UART is 16 bytes, but we use 128 as safe minimum)
-        # rx_buffer_size must be greater than the hardware FIFO length
-        min_buffer_size = 128
-        if config[CONF_RX_BUFFER_SIZE] <= min_buffer_size:
-            _LOGGER.warning(
-                "UART rx_buffer_size (%d bytes) is too small and must be greater than the hardware "
-                "FIFO size (%d bytes). The buffer size will be automatically adjusted at runtime.",
-                config[CONF_RX_BUFFER_SIZE],
-                min_buffer_size,
-            )
-    return config
-
-
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -265,7 +247,6 @@ CONFIG_SCHEMA = cv.All(
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
     validate_host_config,
-    validate_rx_buffer_size,
 )
 
 

esphome/components/uart/uart_component_esp_idf.cpp

@@ -91,16 +91,6 @@ void IDFUARTComponent::setup() {
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
   this->lock_ = xSemaphoreCreateMutex();
 
-#if (SOC_UART_LP_NUM >= 1)
-  size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
-#else
-  size_t fifo_len = SOC_UART_FIFO_LEN;
-#endif
-  if (this->rx_buffer_size_ <= fifo_len) {
-    ESP_LOGW(TAG, "rx_buffer_size is too small, must be greater than %zu", fifo_len);
-    this->rx_buffer_size_ = fifo_len * 2;
-  }
-
   xSemaphoreTake(this->lock_, portMAX_DELAY);
 
   this->load_settings(false);
@@ -247,12 +237,8 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  uart_write_bytes(this->uart_num_, data, len);
   xSemaphoreGive(this->lock_);
-  if (write_len != (int32_t) len) {
-    ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
-    this->mark_failed();
-  }
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_TX, data[i]);
@@ -281,7 +267,6 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
 
 bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   size_t length_to_read = len;
-  int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
   xSemaphoreTake(this->lock_, portMAX_DELAY);
@@ -292,31 +277,25 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
   xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
   }
 #endif
-  return read_len == (int32_t) length_to_read;
+  return true;
 }
 
 int IDFUARTComponent::available() {
-  size_t available = 0;
-  esp_err_t err;
+  size_t available;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  err = uart_get_buffered_data_len(this->uart_num_, &available);
+  uart_get_buffered_data_len(this->uart_num_, &available);
+  if (this->has_peek_)
+    available++;
   xSemaphoreGive(this->lock_);
 
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-  }
-  if (this->has_peek_) {
-    available++;
-  }
   return available;
 }
 

esphome/components/web_server/ota/__init__.py

@@ -1,10 +1,17 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
+from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
-from esphome.const import CONF_ID
+from esphome.const import CONF_ID, CONF_OTA, CONF_PLATFORM, CONF_WEB_SERVER
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network", "web_server_base"]
@@ -12,6 +19,53 @@ DEPENDENCIES = ["network", "web_server_base"]
 web_server_ns = cg.esphome_ns.namespace("web_server")
 WebServerOTAComponent = web_server_ns.class_("WebServerOTAComponent", OTAComponent)
 
+
+def _web_server_ota_final_validate(config: ConfigType) -> None:
+    """Merge multiple web_server OTA instances into one.
+
+    Multiple web_server OTA instances register duplicate HTTP handlers for /update,
+    causing undefined behavior. Merge them into a single instance.
+    """
+    full_conf = fv.full_config.get()
+    ota_confs = full_conf.get(CONF_OTA, [])
+
+    web_server_ota_configs: list[ConfigType] = []
+    other_ota_configs: list[ConfigType] = []
+
+    for ota_conf in ota_confs:
+        if ota_conf.get(CONF_PLATFORM) == CONF_WEB_SERVER:
+            web_server_ota_configs.append(ota_conf)
+        else:
+            other_ota_configs.append(ota_conf)
+
+    if len(web_server_ota_configs) <= 1:
+        return
+
+    # Merge all web_server OTA configs into the first one
+    merged = web_server_ota_configs[0]
+    for ota_conf in web_server_ota_configs[1:]:
+        # Validate that IDs are consistent if manually specified
+        if (
+            merged[CONF_ID].is_manual
+            and ota_conf[CONF_ID].is_manual
+            and merged[CONF_ID] != ota_conf[CONF_ID]
+        ):
+            raise cv.Invalid(
+                f"Found multiple web_server OTA configurations but {CONF_ID} is inconsistent"
+            )
+        merged = merge_config(merged, ota_conf)
+
+    _LOGGER.warning(
+        "Found and merged %d web_server OTA configurations into one instance",
+        len(web_server_ota_configs),
+    )
+
+    # Replace OTA configs with merged web_server + other OTA platforms
+    other_ota_configs.append(merged)
+    full_conf[CONF_OTA] = other_ota_configs
+    fv.full_config.set(full_conf)
+
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -22,6 +76,8 @@ CONFIG_SCHEMA = (
     .extend(cv.COMPONENT_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = _web_server_ota_final_validate
+
 
 @coroutine_with_priority(CoroPriority.WEB_SERVER_OTA)
 async def to_code(config):

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==4.0.3
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.5  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.4  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.1  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

tests/component_tests/ota/test_web_server_ota.py

@@ -1,6 +1,18 @@
 """Tests for the web_server OTA platform."""
 
+from __future__ import annotations
+
 from collections.abc import Callable
+import logging
+from typing import Any
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.web_server.ota import _web_server_ota_final_validate
+from esphome.const import CONF_ID, CONF_OTA, CONF_PLATFORM, CONF_WEB_SERVER
+from esphome.core import ID
+import esphome.final_validate as fv
 
 
 def test_web_server_ota_generated(generate_main: Callable[[str], str]) -> None:
@@ -100,3 +112,144 @@ def test_web_server_ota_esp8266(generate_main: Callable[[str], str]) -> None:
     # Check web server OTA component is present
     assert "WebServerOTAComponent" in main_cpp
     assert "web_server::WebServerOTAComponent" in main_cpp
+
+
+@pytest.mark.parametrize(
+    ("ota_configs", "expected_count", "warning_expected"),
+    [
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web", is_manual=False),
+                }
+            ],
+            1,
+            False,
+            id="single_instance_no_merge",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_1", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_2", is_manual=False),
+                },
+            ],
+            1,
+            True,
+            id="two_instances_merged",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_1", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: "esphome",
+                    CONF_ID: ID("ota_esphome", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_2", is_manual=False),
+                },
+            ],
+            2,
+            True,
+            id="mixed_platforms_web_server_merged",
+        ),
+    ],
+)
+def test_web_server_ota_instance_merging(
+    ota_configs: list[dict[str, Any]],
+    expected_count: int,
+    warning_expected: bool,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test web_server OTA instance merging behavior."""
+    full_conf = {CONF_OTA: ota_configs.copy()}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _web_server_ota_final_validate({})
+
+        updated_conf = fv.full_config.get()
+
+        # Verify total number of OTA platforms
+        assert len(updated_conf[CONF_OTA]) == expected_count
+
+        # Verify warning
+        if warning_expected:
+            assert any(
+                "Found and merged" in record.message
+                and "web_server OTA" in record.message
+                for record in caplog.records
+            ), "Expected merge warning not found in log"
+        else:
+            assert len(caplog.records) == 0, "Unexpected warnings logged"
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_web_server_ota_consistent_manual_ids(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that consistent manual IDs can be merged successfully."""
+    ota_configs = [
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web", is_manual=True),
+        },
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web", is_manual=True),
+        },
+    ]
+
+    full_conf = {CONF_OTA: ota_configs}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _web_server_ota_final_validate({})
+
+        updated_conf = fv.full_config.get()
+        assert len(updated_conf[CONF_OTA]) == 1
+        assert updated_conf[CONF_OTA][0][CONF_ID].id == "ota_web"
+        assert any(
+            "Found and merged" in record.message and "web_server OTA" in record.message
+            for record in caplog.records
+        )
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_web_server_ota_inconsistent_manual_ids() -> None:
+    """Test that inconsistent manual IDs raise an error."""
+    ota_configs = [
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web_1", is_manual=True),
+        },
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web_2", is_manual=True),
+        },
+    ]
+
+    full_conf = {CONF_OTA: ota_configs}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with pytest.raises(
+            cv.Invalid,
+            match="Found multiple web_server OTA configurations but id is inconsistent",
+        ):
+            _web_server_ota_final_validate({})
+    finally:
+        fv.full_config.reset(token)