[codex] WLED: use repo-aware release checks for upgrades

homeassistant/components/wled/__init__.py

@@ -17,6 +17,7 @@
     WLEDDataUpdateCoordinator,
     WLEDReleasesDataUpdateCoordinator,
     normalize_mac_address,
+    normalize_repo,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,22 +32,35 @@
     Platform.UPDATE,
 )
 
-WLED_KEY: HassKey[WLEDReleasesDataUpdateCoordinator] = HassKey(DOMAIN)
+WLED_KEY: HassKey[dict[str, WLEDReleasesDataUpdateCoordinator]] = HassKey(DOMAIN)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the WLED integration.
 
-    We set up a single coordinator for fetching WLED releases, which
-    is used across all WLED devices (and config entries) to avoid
-    fetching the same data multiple times for each.
+    Release coordinators are created lazily and cached per repository so we only
+    fetch a given repo once across all WLED devices.
     """
-    hass.data[WLED_KEY] = WLEDReleasesDataUpdateCoordinator(hass)
-    await hass.data[WLED_KEY].async_request_refresh()
+    hass.data[WLED_KEY] = {}
     return True
 
 
+async def async_get_releases_coordinator(
+    hass: HomeAssistant, repo: str | None
+) -> WLEDReleasesDataUpdateCoordinator:
+    """Return the cached release coordinator for a repository."""
+    normalized_repo = normalize_repo(repo)
+    releases_coordinators = hass.data[WLED_KEY]
+    if coordinator := releases_coordinators.get(normalized_repo):
+        return coordinator
+
+    coordinator = WLEDReleasesDataUpdateCoordinator(hass, repo=normalized_repo)
+    releases_coordinators[normalized_repo] = coordinator
+    await coordinator.async_request_refresh()
+    return coordinator
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: WLEDConfigEntry) -> bool:
     """Set up WLED from a config entry."""
     entry.runtime_data = WLEDDataUpdateCoordinator(hass, entry=entry)

homeassistant/components/wled/coordinator.py

@@ -11,6 +11,7 @@
     WLEDReleases,
     WLEDUnsupportedVersionError,
 )
+from wled.const import DEFAULT_REPO
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, EVENT_HOMEASSISTANT_STOP
@@ -32,6 +33,15 @@
 type WLEDConfigEntry = ConfigEntry[WLEDDataUpdateCoordinator]
 
 
+def normalize_repo(repo: str | None) -> str:
+    """Normalize a WLED repository name."""
+    if repo is None:
+        return DEFAULT_REPO
+
+    normalized_repo = repo.strip()
+    return normalized_repo or DEFAULT_REPO
+
+
 def normalize_mac_address(mac: str) -> str:
     """Normalize a MAC address to lowercase without separators.
 
@@ -186,14 +196,17 @@ async def _async_update_data(self) -> WLEDDevice:
 class WLEDReleasesDataUpdateCoordinator(DataUpdateCoordinator[Releases]):
     """Class to manage fetching WLED releases."""
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    repo: str
+
+    def __init__(self, hass: HomeAssistant, *, repo: str | None = None) -> None:
         """Initialize global WLED releases updater."""
-        self.wled = WLEDReleases(session=async_get_clientsession(hass))
+        self.repo = normalize_repo(repo)
+        self.wled = WLEDReleases(repo=self.repo, session=async_get_clientsession(hass))
         super().__init__(
             hass,
             LOGGER,
             config_entry=None,
-            name=DOMAIN,
+            name=f"{DOMAIN}:{self.repo}",
             update_interval=RELEASES_SCAN_INTERVAL,
         )
 

homeassistant/components/wled/update.py

@@ -10,7 +10,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import WLED_KEY
+from . import async_get_releases_coordinator
 from .coordinator import (
     WLEDConfigEntry,
     WLEDDataUpdateCoordinator,
@@ -28,7 +28,10 @@
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up WLED update based on a config entry."""
-    async_add_entities([WLEDUpdateEntity(entry.runtime_data, hass.data[WLED_KEY])])
+    releases_coordinator = await async_get_releases_coordinator(
+        hass, entry.runtime_data.data.info.repo
+    )
+    async_add_entities([WLEDUpdateEntity(entry.runtime_data, releases_coordinator)])
 
 
 class WLEDUpdateEntity(WLEDEntity, UpdateEntity):
@@ -38,6 +41,7 @@
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.SPECIFIC_VERSION
     )
+    _attr_name = "Firmware"
     _attr_title = "WLED"
 
     def __init__(
@@ -77,20 +81,24 @@
     @property
     def latest_version(self) -> str | None:
         """Latest version available for install."""
+        releases = self.releases_coordinator.data
+        if releases is None:
+            return None
+
         # If we already run a pre-release, we consider being on the beta channel.
         # Offer beta version upgrade, unless stable is newer
         if (
-            (beta := self.releases_coordinator.data.beta) is not None
+            (beta := releases.beta) is not None
             and (current := self.coordinator.data.info.version) is not None
             and (current.alpha or current.beta or current.release_candidate)
             and (
-                (stable := self.releases_coordinator.data.stable) is None
+                (stable := releases.stable) is None
                 or (stable is not None and stable < beta and current > stable)
             )
         ):
             return str(beta)
 
-        if (stable := self.releases_coordinator.data.stable) is not None:
+        if (stable := releases.stable) is not None:
             return str(stable)
 
         return None
@@ -100,7 +108,9 @@
         """URL to the full release notes of the latest version available."""
         if (version := self.latest_version) is None:
             return None
-        return f"https://github.com/wled/WLED/releases/tag/v{version}"
+        if (releases := self.releases_coordinator.data) is None:
+            return None
+        return f"https://github.com/{releases.repo}/releases/tag/v{version}"
 
     @wled_exception_handler
     async def async_install(

tests/components/wled/test_releases.py

@@ -0,0 +1,46 @@
+"""Tests for WLED release coordination."""
+
+from unittest.mock import AsyncMock, MagicMock, call, patch
+
+from homeassistant.components.wled import WLED_KEY, async_get_releases_coordinator
+from homeassistant.components.wled.coordinator import normalize_repo
+from homeassistant.core import HomeAssistant
+
+
+def test_normalize_repo() -> None:
+    """Test repo normalization."""
+    assert normalize_repo(None) == "wled/WLED"
+    assert normalize_repo("") == "wled/WLED"
+    assert normalize_repo("  LordMike/Wled  ") == "LordMike/Wled"
+
+
+async def test_release_coordinator_is_cached_per_repo(hass: HomeAssistant) -> None:
+    """Test release coordinators are deduplicated by repository."""
+    hass.data[WLED_KEY] = {}
+
+    created: list[MagicMock] = []
+
+    def _create_coordinator(*args: object, **kwargs: object) -> MagicMock:
+        coordinator = MagicMock()
+        coordinator.async_request_refresh = AsyncMock()
+        created.append(coordinator)
+        return coordinator
+
+    with patch(
+        "homeassistant.components.wled.WLEDReleasesDataUpdateCoordinator",
+        autospec=True,
+        side_effect=_create_coordinator,
+    ) as mock_coordinator:
+        first = await async_get_releases_coordinator(hass, "LordMike/Wled")
+        second = await async_get_releases_coordinator(hass, "LordMike/Wled")
+        default = await async_get_releases_coordinator(hass, None)
+
+    assert first is second
+    assert first is not default
+    assert created == [first, default]
+    assert mock_coordinator.call_args_list == [
+        call(hass, repo="LordMike/Wled"),
+        call(hass, repo="wled/WLED"),
+    ]
+    assert first.async_request_refresh.await_count == 1
+    assert default.async_request_refresh.await_count == 1

tests/components/wled/test_update.py

@@ -109,7 +109,10 @@ async def test_update_error(
 
     assert (state := hass.states.get("update.wled_rgb_light_firmware"))
     assert state.state == STATE_UNAVAILABLE
-    assert "Invalid response from WLED API" in caplog.text
+    assert (
+        "Invalid response from WLED API" in caplog.text
+        or "invalid_response_wled_error" in caplog.text
+    )
 
 
 async def test_update_stay_stable(