code · pull · May 4, 2025 · May 3, 2025 · May 4, 2025 · May 4, 2025
diff --git a/homeassistant/components/bluetooth/manifest.json b/homeassistant/components/bluetooth/manifest.json
@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.5.1",
     "bluetooth-data-tools==1.28.1",
     "dbus-fast==2.43.0",
-    "habluetooth==3.47.1"
+    "habluetooth==3.48.2"
   ]
 }
diff --git a/homeassistant/components/bond/__init__.py b/homeassistant/components/bond/__init__.py
@@ -5,7 +5,7 @@
 from typing import Any
 
 from aiohttp import ClientError, ClientResponseError, ClientTimeout
-from bond_async import Bond, BPUPSubscriptions, start_bpup
+from bond_async import Bond, BPUPSubscriptions, RequestorUUID, start_bpup
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -49,6 +49,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: BondConfigEntry) -> bool
         token=token,
         timeout=ClientTimeout(total=_API_TIMEOUT),
         session=async_get_clientsession(hass),
+        requestor_uuid=RequestorUUID.HOME_ASSISTANT,
     )
     hub = BondHub(bond, host)
     try:

diff --git a/homeassistant/components/bond/config_flow.py b/homeassistant/components/bond/config_flow.py
@@ -8,7 +8,7 @@
 from typing import Any
 
 from aiohttp import ClientConnectionError, ClientResponseError
-from bond_async import Bond
+from bond_async import Bond, RequestorUUID
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState, ConfigFlow, ConfigFlowResult
@@ -34,7 +34,12 @@
 
 async def async_get_token(hass: HomeAssistant, host: str) -> str | None:
     """Try to fetch the token from the bond device."""
-    bond = Bond(host, "", session=async_get_clientsession(hass))
+    bond = Bond(
+        host,
+        "",
+        session=async_get_clientsession(hass),
+        requestor_uuid=RequestorUUID.HOME_ASSISTANT,
+    )
     response: dict[str, str] = {}
     with contextlib.suppress(ClientConnectionError):
         response = await bond.token()
@@ -45,7 +50,10 @@ async def _validate_input(hass: HomeAssistant, data: dict[str, Any]) -> tuple[st
     """Validate the user input allows us to connect."""
 
     bond = Bond(
-        data[CONF_HOST], data[CONF_ACCESS_TOKEN], session=async_get_clientsession(hass)
+        data[CONF_HOST],
+        data[CONF_ACCESS_TOKEN],
+        session=async_get_clientsession(hass),
+        requestor_uuid=RequestorUUID.HOME_ASSISTANT,
     )
     try:
         hub = BondHub(bond, data[CONF_HOST])

diff --git a/homeassistant/components/esphome/strings.json b/homeassistant/components/esphome/strings.json
@@ -195,7 +195,10 @@
       "message": "Error compiling {configuration}; Try again in ESPHome dashboard for more information."
     },
     "error_uploading": {
-      "message": "Error during OTA of {configuration}; Try again in ESPHome dashboard for more information."
+      "message": "Error during OTA (Over-The-Air) of {configuration}; Try again in ESPHome dashboard for more information."
+    },
+    "ota_in_progress": {
+      "message": "An OTA (Over-The-Air) update is already in progress for {configuration}."
     }
   }
 }
diff --git a/homeassistant/components/esphome/update.py b/homeassistant/components/esphome/update.py
@@ -125,21 +125,17 @@ def __init__(
                 (dr.CONNECTION_NETWORK_MAC, entry_data.device_info.mac_address)
             }
         )
+        self._install_lock = asyncio.Lock()
+        self._available_future: asyncio.Future[None] | None = None
         self._update_attrs()
 
     @callback
     def _update_attrs(self) -> None:
         """Update the supported features."""
-        # If the device has deep sleep, we can't assume we can install updates
-        # as the ESP will not be connectable (by design).
         coordinator = self.coordinator
         device_info = self._device_info
         # Install support can change at run time
-        if (
-            coordinator.last_update_success
-            and coordinator.supports_update
-            and not device_info.has_deep_sleep
-        ):
+        if coordinator.last_update_success and coordinator.supports_update:
             self._attr_supported_features = UpdateEntityFeature.INSTALL
         else:
             self._attr_supported_features = NO_FEATURES
@@ -178,6 +174,13 @@ def _handle_device_update(
         self, static_info: list[EntityInfo] | None = None
     ) -> None:
         """Handle updated data from the device."""
+        if (
+            self._entry_data.available
+            and self._available_future
+            and not self._available_future.done()
+        ):
+            self._available_future.set_result(None)
+            self._available_future = None
         self._update_attrs()
         self.async_write_ha_state()
 
@@ -192,17 +195,46 @@ async def async_added_to_hass(self) -> None:
             entry_data.async_subscribe_device_updated(self._handle_device_update)
         )
 
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle entity about to be removed from Home Assistant."""
+        if self._available_future and not self._available_future.done():
+            self._available_future.cancel()
+            self._available_future = None
+
+    async def _async_wait_available(self) -> None:
+        """Wait until the device is available."""
+        # If the device has deep sleep, we need to wait for it to wake up
+        # and connect to the network to be able to install the update.
+        if self._entry_data.available:
+            return
+        self._available_future = self.hass.loop.create_future()
+        try:
+            await self._available_future
+        finally:
+            self._available_future = None
+
     async def async_install(
         self, version: str | None, backup: bool, **kwargs: Any
     ) -> None:
         """Install an update."""
-        async with self.hass.data.setdefault(KEY_UPDATE_LOCK, asyncio.Lock()):
-            coordinator = self.coordinator
-            api = coordinator.api
-            device = coordinator.data.get(self._device_info.name)
-            assert device is not None
-            configuration = device["configuration"]
-            try:
+        if self._install_lock.locked():
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="ota_in_progress",
+                translation_placeholders={
+                    "configuration": self._device_info.name,
+                },
+            )
+
+        # Ensure only one OTA per device at a time
+        async with self._install_lock:
+            # Ensure only one compile at a time for ALL devices
+            async with self.hass.data.setdefault(KEY_UPDATE_LOCK, asyncio.Lock()):
+                coordinator = self.coordinator
+                api = coordinator.api
+                device = coordinator.data.get(self._device_info.name)
+                assert device is not None
+                configuration = device["configuration"]
                 if not await api.compile(configuration):
                     raise HomeAssistantError(
                         translation_domain=DOMAIN,
@@ -211,14 +243,25 @@ async def async_install(
                             "configuration": configuration,
                         },
                     )
-                if not await api.upload(configuration, "OTA"):
-                    raise HomeAssistantError(
-                        translation_domain=DOMAIN,
-                        translation_key="error_uploading",
-                        translation_placeholders={
-                            "configuration": configuration,
-                        },
-                    )
+
+            # If the device uses deep sleep, there's a small chance it goes
+            # to sleep right after the dashboard connects but before the OTA
+            # starts. In that case, the update won't go through, so we try
+            # again to catch it on its next wakeup.
+            attempts = 2 if self._device_info.has_deep_sleep else 1
+            try:
+                for attempt in range(1, attempts + 1):
+                    await self._async_wait_available()
+                    if await api.upload(configuration, "OTA"):
+                        break
+                    if attempt == attempts:
+                        raise HomeAssistantError(
+                            translation_domain=DOMAIN,
+                            translation_key="error_uploading",
+                            translation_placeholders={
+                                "configuration": configuration,
+                            },
+                        )
             finally:
                 await self.coordinator.async_request_refresh()
 

diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
@@ -34,7 +34,7 @@ dbus-fast==2.43.0
 fnv-hash-fast==1.5.0
 go2rtc-client==0.1.2
 ha-ffmpeg==3.2.2
-habluetooth==3.47.1
+habluetooth==3.48.2
 hass-nabucasa==0.96.0
 hassil==2.2.3
 home-assistant-bluetooth==1.13.1

diff --git a/requirements_all.txt b/requirements_all.txt
diff --git a/requirements_test_all.txt b/requirements_test_all.txt