2025.2.4 (#138530)

* Bump python-kasa to 0.10.2 (#138381)

* Bump hass-nabucasa from 0.90.0 to 0.91.0 (#138441)

* Bump aiowebostv to 0.6.2 (#138488)

* Bump ZHA to 0.0.49 to fix Tuya TRV issues (#138492)

Bump ZHA to 0.0.49

* Bump pyseventeentrack to 1.0.2 (#138506)

Bump pyseventeentrack version

* Bump hass-nabucasa from 0.91.0 to 0.92.0 (#138510)

* Bump py-synologydsm-api to 2.6.3 (#138516)

bump py-synologydsm-api to 2.6.3

* Update frontend to 20250214.0 (#138521)

* Bump version to 2025.2.4

---------

Co-authored-by: Steven B. <51370195+sdb9696@users.noreply.github.com>
Co-authored-by: Joakim Sørensen <joasoe@gmail.com>
Co-authored-by: Shay Levy <levyshay1@gmail.com>
Co-authored-by: TheJulianJES <TheJulianJES@users.noreply.github.com>
Co-authored-by: Shai Ungar <shai.ungar@riskified.com>
Co-authored-by: Erik Montnemery <erik@montnemery.com>
Co-authored-by: Michael <35783820+mib1185@users.noreply.github.com>
Co-authored-by: Bram Kragten <mail@bramkragten.nl>

homeassistant/components/airthings_ble/config_flow.py

@@ -144,7 +144,7 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
 
             return self.async_create_entry(title=discovery.name, data={})
 
-        current_addresses = self._async_current_ids()
+        current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/apsystems/entity.py

@@ -19,10 +19,20 @@ class ApSystemsEntity(Entity):
         data: ApSystemsData,
     ) -> None:
         """Initialize the APsystems entity."""
+
+        # Handle device version safely
+        sw_version = None
+        if data.coordinator.device_version:
+            version_parts = data.coordinator.device_version.split(" ")
+            if len(version_parts) > 1:
+                sw_version = version_parts[1]
+            else:
+                sw_version = version_parts[0]
+
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, data.device_id)},
             manufacturer="APsystems",
             model="EZ1-M",
             serial_number=data.device_id,
-            sw_version=data.coordinator.device_version.split(" ")[1],
+            sw_version=sw_version,
         )

homeassistant/components/aranet/config_flow.py

@@ -92,7 +92,7 @@ class AranetConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address][0], data={}
             )
 
-        current_addresses = self._async_current_ids()
+        current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/aranet/manifest.json

@@ -19,5 +19,5 @@
   "documentation": "https://www.home-assistant.io/integrations/aranet",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["aranet4==2.5.0"]
+  "requirements": ["aranet4==2.5.1"]
 }

homeassistant/components/assist_satellite/intent.py

@@ -1,5 +1,7 @@
 """Assist Satellite intents."""
 
+from typing import Final
+
 import voluptuous as vol
 
 from homeassistant.core import HomeAssistant
@@ -7,6 +9,8 @@ from homeassistant.helpers import entity_registry as er, intent
 
 from .const import DOMAIN, AssistSatelliteEntityFeature
 
+EXCLUDED_DOMAINS: Final[set[str]] = {"voip"}
+
 
 async def async_setup_intents(hass: HomeAssistant) -> None:
     """Set up the intents."""
@@ -30,19 +34,36 @@ class BroadcastIntentHandler(intent.IntentHandler):
         ent_reg = er.async_get(hass)
 
         # Find all assist satellite entities that are not the one invoking the intent
-        entities = {
-            entity: entry
-            for entity in hass.states.async_entity_ids(DOMAIN)
-            if (entry := ent_reg.async_get(entity))
-            and entry.supported_features & AssistSatelliteEntityFeature.ANNOUNCE
-        }
+        entities: dict[str, er.RegistryEntry] = {}
+        for entity in hass.states.async_entity_ids(DOMAIN):
+            entry = ent_reg.async_get(entity)
+            if (
+                (entry is None)
+                or (
+                    # Supports announce
+                    not (
+                        entry.supported_features & AssistSatelliteEntityFeature.ANNOUNCE
+                    )
+                )
+                # Not the invoking device
+                or (intent_obj.device_id and (entry.device_id == intent_obj.device_id))
+            ):
+                # Skip satellite
+                continue
 
-        if intent_obj.device_id:
-            entities = {
-                entity: entry
-                for entity, entry in entities.items()
-                if entry.device_id != intent_obj.device_id
-            }
+            # Check domain of config entry against excluded domains
+            if (
+                entry.config_entry_id
+                and (
+                    config_entry := hass.config_entries.async_get_entry(
+                        entry.config_entry_id
+                    )
+                )
+                and (config_entry.domain in EXCLUDED_DOMAINS)
+            ):
+                continue
+
+            entities[entity] = entry
 
         await hass.services.async_call(
             DOMAIN,
@@ -54,7 +75,6 @@ class BroadcastIntentHandler(intent.IntentHandler):
         )
 
         response = intent_obj.create_response()
-        response.async_set_speech("Done")
         response.response_type = intent.IntentResponseType.ACTION_DONE
         response.async_set_results(
             success_results=[

homeassistant/components/backup/__init__.py

@@ -26,15 +26,18 @@ from .manager import (
     BackupReaderWriterError,
     CoreBackupReaderWriter,
     CreateBackupEvent,
+    CreateBackupStage,
+    CreateBackupState,
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
     NewBackup,
     RestoreBackupEvent,
+    RestoreBackupStage,
     RestoreBackupState,
     WrittenBackup,
 )
-from .models import AddonInfo, AgentBackup, Folder
+from .models import AddonInfo, AgentBackup, BackupNotFound, Folder
 from .util import suggested_filename, suggested_filename_from_name_date
 from .websocket import async_register_websocket_handlers
 
@@ -45,10 +48,13 @@ __all__ = [
     "BackupAgentError",
     "BackupAgentPlatformProtocol",
     "BackupManagerError",
+    "BackupNotFound",
     "BackupPlatformProtocol",
     "BackupReaderWriter",
     "BackupReaderWriterError",
     "CreateBackupEvent",
+    "CreateBackupStage",
+    "CreateBackupState",
     "Folder",
     "IdleEvent",
     "IncorrectPasswordError",
@@ -56,6 +62,7 @@ __all__ = [
     "ManagerBackup",
     "NewBackup",
     "RestoreBackupEvent",
+    "RestoreBackupStage",
     "RestoreBackupState",
     "WrittenBackup",
     "async_get_manager",

homeassistant/components/backup/agent.py

@@ -11,13 +11,7 @@ from propcache.api import cached_property
 
 from homeassistant.core import HomeAssistant, callback
 
-from .models import AgentBackup, BackupError
-
-
-class BackupAgentError(BackupError):
-    """Base class for backup agent errors."""
-
-    error_code = "backup_agent_error"
+from .models import AgentBackup, BackupAgentError
 
 
 class BackupAgentUnreachableError(BackupAgentError):
@@ -27,12 +21,6 @@ class BackupAgentUnreachableError(BackupAgentError):
     _message = "The backup agent is unreachable."
 
 
-class BackupNotFound(BackupAgentError):
-    """Raised when a backup is not found."""
-
-    error_code = "backup_not_found"
-
-
 class BackupAgent(abc.ABC):
     """Backup agent interface."""
 

homeassistant/components/backup/backup.py

@@ -11,9 +11,9 @@ from typing import Any
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.hassio import is_hassio
 
-from .agent import BackupAgent, BackupNotFound, LocalBackupAgent
+from .agent import BackupAgent, LocalBackupAgent
 from .const import DOMAIN, LOGGER
-from .models import AgentBackup
+from .models import AgentBackup, BackupNotFound
 from .util import read_backup, suggested_filename
 
 

homeassistant/components/backup/http.py

@@ -21,6 +21,7 @@ from . import util
 from .agent import BackupAgent
 from .const import DATA_MANAGER
 from .manager import BackupManager
+from .models import BackupNotFound
 
 
 @callback
@@ -69,13 +70,16 @@ class DownloadBackupView(HomeAssistantView):
             CONTENT_DISPOSITION: f"attachment; filename={slugify(backup.name)}.tar"
         }
 
-        if not password or not backup.protected:
-            return await self._send_backup_no_password(
-                request, headers, backup_id, agent_id, agent, manager
+        try:
+            if not password or not backup.protected:
+                return await self._send_backup_no_password(
+                    request, headers, backup_id, agent_id, agent, manager
+                )
+            return await self._send_backup_with_password(
+                hass, request, headers, backup_id, agent_id, password, agent, manager
             )
-        return await self._send_backup_with_password(
-            hass, request, headers, backup_id, agent_id, password, agent, manager
-        )
+        except BackupNotFound:
+            return Response(status=HTTPStatus.NOT_FOUND)
 
     async def _send_backup_no_password(
         self,

homeassistant/components/backup/manager.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import abc
 import asyncio
+from collections import defaultdict
 from collections.abc import AsyncIterator, Callable, Coroutine
 from dataclasses import dataclass, replace
 from enum import StrEnum
 import hashlib
 import io
+from itertools import chain
 import json
 from pathlib import Path, PurePath
 import shutil
@@ -50,7 +52,14 @@ from .const import (
     EXCLUDE_FROM_BACKUP,
     LOGGER,
 )
-from .models import AgentBackup, BackupError, BackupManagerError, BaseBackup, Folder
+from .models import (
+    AgentBackup,
+    BackupError,
+    BackupManagerError,
+    BackupReaderWriterError,
+    BaseBackup,
+    Folder,
+)
 from .store import BackupStore
 from .util import (
     AsyncIteratorReader,
@@ -274,12 +283,6 @@ class BackupReaderWriter(abc.ABC):
         """Get restore events after core restart."""
 
 
-class BackupReaderWriterError(BackupError):
-    """Backup reader/writer error."""
-
-    error_code = "backup_reader_writer_error"
-
-
 class IncorrectPasswordError(BackupReaderWriterError):
     """Raised when the password is incorrect."""
 
@@ -558,8 +561,15 @@ class BackupManager:
             return_exceptions=True,
         )
         for idx, result in enumerate(list_backups_results):
+            agent_id = agent_ids[idx]
             if isinstance(result, BackupAgentError):
-                agent_errors[agent_ids[idx]] = result
+                agent_errors[agent_id] = result
+                continue
+            if isinstance(result, Exception):
+                agent_errors[agent_id] = result
+                LOGGER.error(
+                    "Unexpected error for %s: %s", agent_id, result, exc_info=result
+                )
                 continue
             if isinstance(result, BaseException):
                 raise result  # unexpected error
@@ -586,7 +596,7 @@ class BackupManager:
                         name=agent_backup.name,
                         with_automatic_settings=with_automatic_settings,
                     )
-                backups[backup_id].agents[agent_ids[idx]] = AgentBackupStatus(
+                backups[backup_id].agents[agent_id] = AgentBackupStatus(
                     protected=agent_backup.protected,
                     size=agent_backup.size,
                 )
@@ -609,8 +619,15 @@ class BackupManager:
             return_exceptions=True,
         )
         for idx, result in enumerate(get_backup_results):
+            agent_id = agent_ids[idx]
             if isinstance(result, BackupAgentError):
-                agent_errors[agent_ids[idx]] = result
+                agent_errors[agent_id] = result
+                continue
+            if isinstance(result, Exception):
+                agent_errors[agent_id] = result
+                LOGGER.error(
+                    "Unexpected error for %s: %s", agent_id, result, exc_info=result
+                )
                 continue
             if isinstance(result, BaseException):
                 raise result  # unexpected error
@@ -638,7 +655,7 @@ class BackupManager:
                     name=result.name,
                     with_automatic_settings=with_automatic_settings,
                 )
-            backup.agents[agent_ids[idx]] = AgentBackupStatus(
+            backup.agents[agent_id] = AgentBackupStatus(
                 protected=result.protected,
                 size=result.size,
             )
@@ -661,21 +678,31 @@ class BackupManager:
             return None
         return with_automatic_settings
 
-    async def async_delete_backup(self, backup_id: str) -> dict[str, Exception]:
+    async def async_delete_backup(
+        self, backup_id: str, *, agent_ids: list[str] | None = None
+    ) -> dict[str, Exception]:
         """Delete a backup."""
         agent_errors: dict[str, Exception] = {}
-        agent_ids = list(self.backup_agents)
+        if agent_ids is None:
+            agent_ids = list(self.backup_agents)
 
         delete_backup_results = await asyncio.gather(
             *(
-                agent.async_delete_backup(backup_id)
-                for agent in self.backup_agents.values()
+                self.backup_agents[agent_id].async_delete_backup(backup_id)
+                for agent_id in agent_ids
             ),
             return_exceptions=True,
         )
         for idx, result in enumerate(delete_backup_results):
+            agent_id = agent_ids[idx]
             if isinstance(result, BackupAgentError):
-                agent_errors[agent_ids[idx]] = result
+                agent_errors[agent_id] = result
+                continue
+            if isinstance(result, Exception):
+                agent_errors[agent_id] = result
+                LOGGER.error(
+                    "Unexpected error for %s: %s", agent_id, result, exc_info=result
+                )
                 continue
             if isinstance(result, BaseException):
                 raise result  # unexpected error
@@ -708,35 +735,71 @@ class BackupManager:
         # Run the include filter first to ensure we only consider backups that
         # should be included in the deletion process.
         backups = include_filter(backups)
+        backups_by_agent: dict[str, dict[str, ManagerBackup]] = defaultdict(dict)
+        for backup_id, backup in backups.items():
+            for agent_id in backup.agents:
+                backups_by_agent[agent_id][backup_id] = backup
 
-        LOGGER.debug("Total automatic backups: %s", backups)
+        LOGGER.debug("Backups returned by include filter: %s", backups)
+        LOGGER.debug(
+            "Backups returned by include filter by agent: %s",
+            {agent_id: list(backups) for agent_id, backups in backups_by_agent.items()},
+        )
 
         backups_to_delete = delete_filter(backups)
 
+        LOGGER.debug("Backups returned by delete filter: %s", backups_to_delete)
+
         if not backups_to_delete:
             return
 
         # always delete oldest backup first
-        backups_to_delete = dict(
-            sorted(
-                backups_to_delete.items(),
-                key=lambda backup_item: backup_item[1].date,
-            )
+        backups_to_delete_by_agent: dict[str, dict[str, ManagerBackup]] = defaultdict(
+            dict
+        )
+        for backup_id, backup in sorted(
+            backups_to_delete.items(),
+            key=lambda backup_item: backup_item[1].date,
+        ):
+            for agent_id in backup.agents:
+                backups_to_delete_by_agent[agent_id][backup_id] = backup
+        LOGGER.debug(
+            "Backups returned by delete filter by agent: %s",
+            {
+                agent_id: list(backups)
+                for agent_id, backups in backups_to_delete_by_agent.items()
+            },
+        )
+        for agent_id, to_delete_from_agent in backups_to_delete_by_agent.items():
+            if len(to_delete_from_agent) >= len(backups_by_agent[agent_id]):
+                # Never delete the last backup.
+                last_backup = to_delete_from_agent.popitem()
+                LOGGER.debug(
+                    "Keeping the last backup %s for agent %s", last_backup, agent_id
+                )
+
+        LOGGER.debug(
+            "Backups to delete by agent: %s",
+            {
+                agent_id: list(backups)
+                for agent_id, backups in backups_to_delete_by_agent.items()
+            },
         )
 
-        if len(backups_to_delete) >= len(backups):
-            # Never delete the last backup.
-            last_backup = backups_to_delete.popitem()
-            LOGGER.debug("Keeping the last backup: %s", last_backup)
+        backup_ids_to_delete: dict[str, set[str]] = defaultdict(set)
+        for agent_id, to_delete in backups_to_delete_by_agent.items():
+            for backup_id in to_delete:
+                backup_ids_to_delete[backup_id].add(agent_id)
 
-        LOGGER.debug("Backups to delete: %s", backups_to_delete)
-
-        if not backups_to_delete:
+        if not backup_ids_to_delete:
             return
 
-        backup_ids = list(backups_to_delete)
+        backup_ids = list(backup_ids_to_delete)
         delete_results = await asyncio.gather(
-            *(self.async_delete_backup(backup_id) for backup_id in backups_to_delete)
+            *(
+                self.async_delete_backup(backup_id, agent_ids=list(agent_ids))
+                for backup_id, agent_ids in backup_ids_to_delete.items()
+            )
         )
         agent_errors = {
             backup_id: error
@@ -826,7 +889,7 @@ class BackupManager:
             password=None,
         )
         await written_backup.release_stream()
-        self.known_backups.add(written_backup.backup, agent_errors)
+        self.known_backups.add(written_backup.backup, agent_errors, [])
         return written_backup.backup.backup_id
 
     async def async_create_backup(
@@ -950,12 +1013,23 @@ class BackupManager:
         with_automatic_settings: bool,
     ) -> NewBackup:
         """Initiate generating a backup."""
-        if not agent_ids:
-            raise BackupManagerError("At least one agent must be selected")
-        if invalid_agents := [
+        unavailable_agents = [
             agent_id for agent_id in agent_ids if agent_id not in self.backup_agents
-        ]:
-            raise BackupManagerError(f"Invalid agents selected: {invalid_agents}")
+        ]
+        if not (
+            available_agents := [
+                agent_id for agent_id in agent_ids if agent_id in self.backup_agents
+            ]
+        ):
+            raise BackupManagerError(
+                f"At least one available backup agent must be selected, got {agent_ids}"
+            )
+        if unavailable_agents:
+            LOGGER.warning(
+                "Backup agents %s are not available, will backupp to %s",
+                unavailable_agents,
+                available_agents,
+            )
         if include_all_addons and include_addons:
             raise BackupManagerError(
                 "Cannot include all addons and specify specific addons"
@@ -972,7 +1046,7 @@ class BackupManager:
                 new_backup,
                 self._backup_task,
             ) = await self._reader_writer.async_create_backup(
-                agent_ids=agent_ids,
+                agent_ids=available_agents,
                 backup_name=backup_name,
                 extra_metadata=extra_metadata
                 | {
@@ -991,7 +1065,9 @@ class BackupManager:
             raise BackupManagerError(str(err)) from err
 
         backup_finish_task = self._backup_finish_task = self.hass.async_create_task(
-            self._async_finish_backup(agent_ids, with_automatic_settings, password),
+            self._async_finish_backup(
+                available_agents, unavailable_agents, with_automatic_settings, password
+            ),
             name="backup_manager_finish_backup",
         )
         if not raise_task_error:
@@ -1008,7 +1084,11 @@ class BackupManager:
         return new_backup
 
     async def _async_finish_backup(
-        self, agent_ids: list[str], with_automatic_settings: bool, password: str | None
+        self,
+        available_agents: list[str],
+        unavailable_agents: list[str],
+        with_automatic_settings: bool,
+        password: str | None,
     ) -> None:
         """Finish a backup."""
         if TYPE_CHECKING:
@@ -1027,7 +1107,7 @@ class BackupManager:
             LOGGER.debug(
                 "Generated new backup with backup_id %s, uploading to agents %s",
                 written_backup.backup.backup_id,
-                agent_ids,
+                available_agents,
             )
             self.async_on_backup_event(
                 CreateBackupEvent(
@@ -1040,13 +1120,15 @@ class BackupManager:
             try:
                 agent_errors = await self._async_upload_backup(
                     backup=written_backup.backup,
-                    agent_ids=agent_ids,
+                    agent_ids=available_agents,
                     open_stream=written_backup.open_stream,
                     password=password,
                 )
             finally:
                 await written_backup.release_stream()
-            self.known_backups.add(written_backup.backup, agent_errors)
+            self.known_backups.add(
+                written_backup.backup, agent_errors, unavailable_agents
+            )
             if not agent_errors:
                 if with_automatic_settings:
                     # create backup was successful, update last_completed_automatic_backup
@@ -1055,7 +1137,7 @@ class BackupManager:
                 backup_success = True
 
             if with_automatic_settings:
-                self._update_issue_after_agent_upload(agent_errors)
+                self._update_issue_after_agent_upload(agent_errors, unavailable_agents)
             # delete old backups more numerous than copies
             # try this regardless of agent errors above
             await delete_backups_exceeding_configured_count(self)
@@ -1215,10 +1297,10 @@ class BackupManager:
         )
 
     def _update_issue_after_agent_upload(
-        self, agent_errors: dict[str, Exception]
+        self, agent_errors: dict[str, Exception], unavailable_agents: list[str]
     ) -> None:
         """Update issue registry after a backup is uploaded to agents."""
-        if not agent_errors:
+        if not agent_errors and not unavailable_agents:
             ir.async_delete_issue(self.hass, DOMAIN, "automatic_backup_failed")
             return
         ir.async_create_issue(
@@ -1232,7 +1314,13 @@ class BackupManager:
             translation_key="automatic_backup_failed_upload_agents",
             translation_placeholders={
                 "failed_agents": ", ".join(
-                    self.backup_agents[agent_id].name for agent_id in agent_errors
+                    chain(
+                        (
+                            self.backup_agents[agent_id].name
+                            for agent_id in agent_errors
+                        ),
+                        unavailable_agents,
+                    )
                 )
             },
         )
@@ -1301,11 +1389,12 @@ class KnownBackups:
         self,
         backup: AgentBackup,
         agent_errors: dict[str, Exception],
+        unavailable_agents: list[str],
     ) -> None:
         """Add a backup."""
         self._backups[backup.backup_id] = KnownBackup(
             backup_id=backup.backup_id,
-            failed_agent_ids=list(agent_errors),
+            failed_agent_ids=list(chain(agent_errors, unavailable_agents)),
         )
         self._manager.store.save()
 
@@ -1411,7 +1500,11 @@ class CoreBackupReaderWriter(BackupReaderWriter):
         manager = self._hass.data[DATA_MANAGER]
 
         agent_config = manager.config.data.agents.get(self._local_agent_id)
-        if agent_config and not agent_config.protected:
+        if (
+            self._local_agent_id in agent_ids
+            and agent_config
+            and not agent_config.protected
+        ):
             password = None
 
         backup = AgentBackup(

homeassistant/components/backup/models.py

@@ -41,12 +41,6 @@ class BaseBackup:
     homeassistant_version: str | None  # None if homeassistant_included is False
     name: str
 
-    def as_frontend_json(self) -> dict:
-        """Return a dict representation of this backup for sending to frontend."""
-        return {
-            key: val for key, val in asdict(self).items() if key != "extra_metadata"
-        }
-
 
 @dataclass(frozen=True, kw_only=True)
 class AgentBackup(BaseBackup):
@@ -83,7 +77,25 @@ class BackupError(HomeAssistantError):
     error_code = "unknown"
 
 
+class BackupAgentError(BackupError):
+    """Base class for backup agent errors."""
+
+    error_code = "backup_agent_error"
+
+
 class BackupManagerError(BackupError):
     """Backup manager error."""
 
     error_code = "backup_manager_error"
+
+
+class BackupReaderWriterError(BackupError):
+    """Backup reader/writer error."""
+
+    error_code = "backup_reader_writer_error"
+
+
+class BackupNotFound(BackupAgentError, BackupManagerError):
+    """Raised when a backup is not found."""
+
+    error_code = "backup_not_found"

homeassistant/components/backup/util.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import AsyncIterator, Callable, Coroutine
+from concurrent.futures import CancelledError, Future
 import copy
 from dataclasses import dataclass, replace
 from io import BytesIO
@@ -12,6 +13,7 @@ import os
 from pathlib import Path, PurePath
 from queue import SimpleQueue
 import tarfile
+import threading
 from typing import IO, Any, Self, cast
 
 import aiohttp
@@ -22,7 +24,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.util import dt as dt_util
 from homeassistant.util.json import JsonObjectType, json_loads_object
-from homeassistant.util.thread import ThreadWithException
 
 from .const import BUF_SIZE, LOGGER
 from .models import AddonInfo, AgentBackup, Folder
@@ -121,7 +122,7 @@ def read_backup(backup_path: Path) -> AgentBackup:
 def suggested_filename_from_name_date(name: str, date_str: str) -> str:
     """Suggest a filename for the backup."""
     date = dt_util.parse_datetime(date_str, raise_on_error=True)
-    return "_".join(f"{name} - {date.strftime('%Y-%m-%d %H.%M %S%f')}.tar".split())
+    return "_".join(f"{name} {date.strftime('%Y-%m-%d %H.%M %S%f')}.tar".split())
 
 
 def suggested_filename(backup: AgentBackup) -> str:
@@ -167,23 +168,38 @@ class AsyncIteratorReader:
 
     def __init__(self, hass: HomeAssistant, stream: AsyncIterator[bytes]) -> None:
         """Initialize the wrapper."""
+        self._aborted = False
         self._hass = hass
         self._stream = stream
         self._buffer: bytes | None = None
+        self._next_future: Future[bytes | None] | None = None
         self._pos: int = 0
 
     async def _next(self) -> bytes | None:
         """Get the next chunk from the iterator."""
         return await anext(self._stream, None)
 
+    def abort(self) -> None:
+        """Abort the reader."""
+        self._aborted = True
+        if self._next_future is not None:
+            self._next_future.cancel()
+
     def read(self, n: int = -1, /) -> bytes:
         """Read data from the iterator."""
         result = bytearray()
         while n < 0 or len(result) < n:
             if not self._buffer:
-                self._buffer = asyncio.run_coroutine_threadsafe(
+                self._next_future = asyncio.run_coroutine_threadsafe(
                     self._next(), self._hass.loop
-                ).result()
+                )
+                if self._aborted:
+                    self._next_future.cancel()
+                    raise AbortCipher
+                try:
+                    self._buffer = self._next_future.result()
+                except CancelledError as err:
+                    raise AbortCipher from err
                 self._pos = 0
             if not self._buffer:
                 # The stream is exhausted
@@ -205,9 +221,11 @@ class AsyncIteratorWriter:
 
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the wrapper."""
+        self._aborted = False
         self._hass = hass
         self._pos: int = 0
         self._queue: asyncio.Queue[bytes | None] = asyncio.Queue(maxsize=1)
+        self._write_future: Future[bytes | None] | None = None
 
     def __aiter__(self) -> Self:
         """Return the iterator."""
@@ -219,13 +237,28 @@ class AsyncIteratorWriter:
             return data
         raise StopAsyncIteration
 
+    def abort(self) -> None:
+        """Abort the writer."""
+        self._aborted = True
+        if self._write_future is not None:
+            self._write_future.cancel()
+
     def tell(self) -> int:
         """Return the current position in the iterator."""
         return self._pos
 
     def write(self, s: bytes, /) -> int:
         """Write data to the iterator."""
-        asyncio.run_coroutine_threadsafe(self._queue.put(s), self._hass.loop).result()
+        self._write_future = asyncio.run_coroutine_threadsafe(
+            self._queue.put(s), self._hass.loop
+        )
+        if self._aborted:
+            self._write_future.cancel()
+            raise AbortCipher
+        try:
+            self._write_future.result()
+        except CancelledError as err:
+            raise AbortCipher from err
         self._pos += len(s)
         return len(s)
 
@@ -415,7 +448,9 @@ def _encrypt_backup(
 class _CipherWorkerStatus:
     done: asyncio.Event
     error: Exception | None = None
-    thread: ThreadWithException
+    reader: AsyncIteratorReader
+    thread: threading.Thread
+    writer: AsyncIteratorWriter
 
 
 class _CipherBackupStreamer:
@@ -468,11 +503,13 @@ class _CipherBackupStreamer:
         stream = await self._open_stream()
         reader = AsyncIteratorReader(self._hass, stream)
         writer = AsyncIteratorWriter(self._hass)
-        worker = ThreadWithException(
+        worker = threading.Thread(
             target=self._cipher_func,
             args=[reader, writer, self._password, on_done, self.size(), self._nonces],
         )
-        worker_status = _CipherWorkerStatus(done=asyncio.Event(), thread=worker)
+        worker_status = _CipherWorkerStatus(
+            done=asyncio.Event(), reader=reader, thread=worker, writer=writer
+        )
         self._workers.append(worker_status)
         worker.start()
         return writer
@@ -480,9 +517,8 @@ class _CipherBackupStreamer:
     async def wait(self) -> None:
         """Wait for the worker threads to finish."""
         for worker in self._workers:
-            if not worker.thread.is_alive():
-                continue
-            worker.thread.raise_exc(AbortCipher)
+            worker.reader.abort()
+            worker.writer.abort()
         await asyncio.gather(*(worker.done.wait() for worker in self._workers))
 
 

homeassistant/components/backup/websocket.py

@@ -15,7 +15,7 @@ from .manager import (
     IncorrectPasswordError,
     ManagerStateEvent,
 )
-from .models import Folder
+from .models import BackupNotFound, Folder
 
 
 @callback
@@ -57,7 +57,7 @@ async def handle_info(
             "agent_errors": {
                 agent_id: str(err) for agent_id, err in agent_errors.items()
             },
-            "backups": [backup.as_frontend_json() for backup in backups.values()],
+            "backups": list(backups.values()),
             "last_attempted_automatic_backup": manager.config.data.last_attempted_automatic_backup,
             "last_completed_automatic_backup": manager.config.data.last_completed_automatic_backup,
             "last_non_idle_event": manager.last_non_idle_event,
@@ -91,7 +91,7 @@ async def handle_details(
             "agent_errors": {
                 agent_id: str(err) for agent_id, err in agent_errors.items()
             },
-            "backup": backup.as_frontend_json() if backup else None,
+            "backup": backup,
         },
     )
 
@@ -151,6 +151,8 @@ async def handle_restore(
             restore_folders=msg.get("restore_folders"),
             restore_homeassistant=msg["restore_homeassistant"],
         )
+    except BackupNotFound:
+        connection.send_error(msg["id"], "backup_not_found", "Backup not found")
     except IncorrectPasswordError:
         connection.send_error(msg["id"], "password_incorrect", "Incorrect password")
     else:
@@ -179,6 +181,8 @@ async def handle_can_decrypt_on_download(
             agent_id=msg["agent_id"],
             password=msg.get("password"),
         )
+    except BackupNotFound:
+        connection.send_error(msg["id"], "backup_not_found", "Backup not found")
     except IncorrectPasswordError:
         connection.send_error(msg["id"], "password_incorrect", "Incorrect password")
     except DecryptOnDowloadNotSupported:

homeassistant/components/bluetooth/__init__.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import datetime
 import logging
 import platform
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from bleak_retry_connector import BleakSlotManager
 from bluetooth_adapters import (
@@ -80,6 +80,7 @@ from .const import (
     CONF_DETAILS,
     CONF_PASSIVE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
+    CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,
     CONF_SOURCE_MODEL,
     DOMAIN,
@@ -297,7 +298,11 @@ async def async_discover_adapters(
 
 
 async def async_update_device(
-    hass: HomeAssistant, entry: ConfigEntry, adapter: str, details: AdapterDetails
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    adapter: str,
+    details: AdapterDetails,
+    via_device_id: str | None = None,
 ) -> None:
     """Update device registry entry.
 
@@ -306,7 +311,8 @@ async def async_update_device(
     update the device with the new location so they can
     figure out where the adapter is.
     """
-    dr.async_get(hass).async_get_or_create(
+    device_registry = dr.async_get(hass)
+    device_entry = device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
         name=adapter_human_name(adapter, details[ADAPTER_ADDRESS]),
         connections={(dr.CONNECTION_BLUETOOTH, details[ADAPTER_ADDRESS])},
@@ -315,6 +321,11 @@ async def async_update_device(
         sw_version=details.get(ADAPTER_SW_VERSION),
         hw_version=details.get(ADAPTER_HW_VERSION),
     )
+    if via_device_id and (via_device_entry := device_registry.async_get(via_device_id)):
+        kwargs: dict[str, Any] = {"via_device_id": via_device_id}
+        if not device_entry.area_id and via_device_entry.area_id:
+            kwargs["area_id"] = via_device_entry.area_id
+        device_registry.async_update_device(device_entry.id, **kwargs)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -349,6 +360,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             entry,
             source_entry.title,
             details,
+            entry.data.get(CONF_SOURCE_DEVICE_ID),
         )
         return True
     manager = _get_manager(hass)

homeassistant/components/bluetooth/api.py

@@ -181,10 +181,16 @@ def async_register_scanner(
     source_domain: str | None = None,
     source_model: str | None = None,
     source_config_entry_id: str | None = None,
+    source_device_id: str | None = None,
 ) -> CALLBACK_TYPE:
     """Register a BleakScanner."""
     return _get_manager(hass).async_register_hass_scanner(
-        scanner, connection_slots, source_domain, source_model, source_config_entry_id
+        scanner,
+        connection_slots,
+        source_domain,
+        source_model,
+        source_config_entry_id,
+        source_device_id,
     )
 
 

homeassistant/components/bluetooth/config_flow.py

@@ -37,6 +37,7 @@ from .const import (
     CONF_PASSIVE,
     CONF_SOURCE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
+    CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,
     CONF_SOURCE_MODEL,
     DOMAIN,
@@ -139,7 +140,7 @@ class BluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=adapter_title(adapter, details), data={}
             )
 
-        configured_addresses = self._async_current_ids()
+        configured_addresses = self._async_current_ids(include_ignore=False)
         bluetooth_adapters = get_adapters()
         await bluetooth_adapters.refresh()
         self._adapters = bluetooth_adapters.adapters
@@ -154,12 +155,8 @@ class BluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             and not (system == "Linux" and details[ADAPTER_ADDRESS] == DEFAULT_ADDRESS)
         ]
         if not unconfigured_adapters:
-            ignored_adapters = len(
-                self._async_current_entries(include_ignore=True)
-            ) - len(self._async_current_entries(include_ignore=False))
             return self.async_abort(
                 reason="no_adapters",
-                description_placeholders={"ignored_adapters": str(ignored_adapters)},
             )
         if len(unconfigured_adapters) == 1:
             self._adapter = list(self._adapters)[0]
@@ -194,6 +191,7 @@ class BluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             CONF_SOURCE_MODEL: user_input[CONF_SOURCE_MODEL],
             CONF_SOURCE_DOMAIN: user_input[CONF_SOURCE_DOMAIN],
             CONF_SOURCE_CONFIG_ENTRY_ID: user_input[CONF_SOURCE_CONFIG_ENTRY_ID],
+            CONF_SOURCE_DEVICE_ID: user_input[CONF_SOURCE_DEVICE_ID],
         }
         self._abort_if_unique_id_configured(updates=data)
         manager = get_manager()

homeassistant/components/bluetooth/const.py

@@ -22,7 +22,7 @@ CONF_SOURCE: Final = "source"
 CONF_SOURCE_DOMAIN: Final = "source_domain"
 CONF_SOURCE_MODEL: Final = "source_model"
 CONF_SOURCE_CONFIG_ENTRY_ID: Final = "source_config_entry_id"
-
+CONF_SOURCE_DEVICE_ID: Final = "source_device_id"
 
 SOURCE_LOCAL: Final = "local"
 

homeassistant/components/bluetooth/manager.py

@@ -25,6 +25,7 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from .const import (
     CONF_SOURCE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
+    CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,
     CONF_SOURCE_MODEL,
     DOMAIN,
@@ -254,6 +255,7 @@ class HomeAssistantBluetoothManager(BluetoothManager):
         source_domain: str | None = None,
         source_model: str | None = None,
         source_config_entry_id: str | None = None,
+        source_device_id: str | None = None,
     ) -> CALLBACK_TYPE:
         """Register a scanner."""
         cancel = self.async_register_scanner(scanner, connection_slots)
@@ -261,9 +263,6 @@ class HomeAssistantBluetoothManager(BluetoothManager):
             isinstance(scanner, BaseHaRemoteScanner)
             and source_domain
             and source_config_entry_id
-            and not self.hass.config_entries.async_entry_for_domain_unique_id(
-                DOMAIN, scanner.source
-            )
         ):
             self.hass.async_create_task(
                 self.hass.config_entries.flow.async_init(
@@ -274,6 +273,7 @@ class HomeAssistantBluetoothManager(BluetoothManager):
                         CONF_SOURCE_DOMAIN: source_domain,
                         CONF_SOURCE_MODEL: source_model,
                         CONF_SOURCE_CONFIG_ENTRY_ID: source_config_entry_id,
+                        CONF_SOURCE_DEVICE_ID: source_device_id,
                     },
                 )
             )

homeassistant/components/bluetooth/manifest.json

@@ -16,11 +16,11 @@
   "quality_scale": "internal",
   "requirements": [
     "bleak==0.22.3",
-    "bleak-retry-connector==3.8.0",
-    "bluetooth-adapters==0.21.1",
+    "bleak-retry-connector==3.8.1",
+    "bluetooth-adapters==0.21.4",
     "bluetooth-auto-recovery==1.4.2",
-    "bluetooth-data-tools==1.22.0",
-    "dbus-fast==2.30.2",
-    "habluetooth==3.20.1"
+    "bluetooth-data-tools==1.23.4",
+    "dbus-fast==2.33.0",
+    "habluetooth==3.21.1"
   ]
 }

homeassistant/components/bluetooth/match.py

@@ -411,7 +411,7 @@ def ble_device_matches(
     ) and service_data_uuid not in service_info.service_data:
         return False
 
-    if manufacturer_id := matcher.get(MANUFACTURER_ID):
+    if (manufacturer_id := matcher.get(MANUFACTURER_ID)) is not None:
         if manufacturer_id not in service_info.manufacturer_data:
             return False
 

homeassistant/components/bluetooth/strings.json

@@ -23,7 +23,7 @@
     },
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "no_adapters": "No unconfigured Bluetooth adapters found. There are {ignored_adapters} ignored adapters."
+      "no_adapters": "No unconfigured Bluetooth adapters found."
     }
   },
   "options": {

homeassistant/components/bthome/config_flow.py

@@ -132,7 +132,7 @@ class BTHomeConfigFlow(ConfigFlow, domain=DOMAIN):
 
             return self._async_get_or_create_entry()
 
-        current_addresses = self._async_current_ids()
+        current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/cloud/backup.py

@@ -3,21 +3,16 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 from collections.abc import AsyncIterator, Callable, Coroutine, Mapping
-import hashlib
 import logging
 import random
 from typing import Any
 
-from aiohttp import ClientError, ClientTimeout
+from aiohttp import ClientError
 from hass_nabucasa import Cloud, CloudError
-from hass_nabucasa.cloud_api import (
-    async_files_delete_file,
-    async_files_download_details,
-    async_files_list,
-    async_files_upload_details,
-)
+from hass_nabucasa.api import CloudApiNonRetryableError
+from hass_nabucasa.cloud_api import async_files_delete_file, async_files_list
+from hass_nabucasa.files import FilesError, StorageType, calculate_b64md5
 
 from homeassistant.components.backup import AgentBackup, BackupAgent, BackupAgentError
 from homeassistant.core import HomeAssistant, callback
@@ -28,20 +23,11 @@ from .client import CloudClient
 from .const import DATA_CLOUD, DOMAIN, EVENT_CLOUD_EVENT
 
 _LOGGER = logging.getLogger(__name__)
-_STORAGE_BACKUP = "backup"
 _RETRY_LIMIT = 5
 _RETRY_SECONDS_MIN = 60
 _RETRY_SECONDS_MAX = 600
 
 
-async def _b64md5(stream: AsyncIterator[bytes]) -> str:
-    """Calculate the MD5 hash of a file."""
-    file_hash = hashlib.md5()
-    async for chunk in stream:
-        file_hash.update(chunk)
-    return base64.b64encode(file_hash.digest()).decode()
-
-
 async def async_get_backup_agents(
     hass: HomeAssistant,
     **kwargs: Any,
@@ -109,63 +95,14 @@ class CloudBackupAgent(BackupAgent):
             raise BackupAgentError("Backup not found")
 
         try:
-            details = await async_files_download_details(
-                self._cloud,
-                storage_type=_STORAGE_BACKUP,
+            content = await self._cloud.files.download(
+                storage_type=StorageType.BACKUP,
                 filename=self._get_backup_filename(),
             )
-        except (ClientError, CloudError) as err:
-            raise BackupAgentError("Failed to get download details") from err
+        except CloudError as err:
+            raise BackupAgentError(f"Failed to download backup: {err}") from err
 
-        try:
-            resp = await self._cloud.websession.get(
-                details["url"],
-                timeout=ClientTimeout(connect=10.0, total=43200.0),  # 43200s == 12h
-            )
-
-            resp.raise_for_status()
-        except ClientError as err:
-            raise BackupAgentError("Failed to download backup") from err
-
-        return ChunkAsyncStreamIterator(resp.content)
-
-    async def _async_do_upload_backup(
-        self,
-        *,
-        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
-        filename: str,
-        base64md5hash: str,
-        metadata: dict[str, Any],
-        size: int,
-    ) -> None:
-        """Upload a backup."""
-        try:
-            details = await async_files_upload_details(
-                self._cloud,
-                storage_type=_STORAGE_BACKUP,
-                filename=filename,
-                metadata=metadata,
-                size=size,
-                base64md5hash=base64md5hash,
-            )
-        except (ClientError, CloudError) as err:
-            raise BackupAgentError("Failed to get upload details") from err
-
-        try:
-            upload_status = await self._cloud.websession.put(
-                details["url"],
-                data=await open_stream(),
-                headers=details["headers"] | {"content-length": str(size)},
-                timeout=ClientTimeout(connect=10.0, total=43200.0),  # 43200s == 12h
-            )
-            _LOGGER.log(
-                logging.DEBUG if upload_status.status < 400 else logging.WARNING,
-                "Backup upload status: %s",
-                upload_status.status,
-            )
-            upload_status.raise_for_status()
-        except (TimeoutError, ClientError) as err:
-            raise BackupAgentError("Failed to upload backup") from err
+        return ChunkAsyncStreamIterator(content)
 
     async def async_upload_backup(
         self,
@@ -182,15 +119,19 @@ class CloudBackupAgent(BackupAgent):
         if not backup.protected:
             raise BackupAgentError("Cloud backups must be protected")
 
-        base64md5hash = await _b64md5(await open_stream())
+        size = backup.size
+        try:
+            base64md5hash = await calculate_b64md5(open_stream, size)
+        except FilesError as err:
+            raise BackupAgentError(err) from err
         filename = self._get_backup_filename()
         metadata = backup.as_dict()
-        size = backup.size
 
         tries = 1
         while tries <= _RETRY_LIMIT:
             try:
-                await self._async_do_upload_backup(
+                await self._cloud.files.upload(
+                    storage_type=StorageType.BACKUP,
                     open_stream=open_stream,
                     filename=filename,
                     base64md5hash=base64md5hash,
@@ -198,9 +139,19 @@ class CloudBackupAgent(BackupAgent):
                     size=size,
                 )
                 break
-            except BackupAgentError as err:
+            except CloudApiNonRetryableError as err:
+                if err.code == "NC-SH-FH-03":
+                    raise BackupAgentError(
+                        translation_domain=DOMAIN,
+                        translation_key="backup_size_too_large",
+                        translation_placeholders={
+                            "size": str(round(size / (1024**3), 2))
+                        },
+                    ) from err
+                raise BackupAgentError(f"Failed to upload backup {err}") from err
+            except CloudError as err:
                 if tries == _RETRY_LIMIT:
-                    raise
+                    raise BackupAgentError(f"Failed to upload backup {err}") from err
                 tries += 1
                 retry_timer = random.randint(_RETRY_SECONDS_MIN, _RETRY_SECONDS_MAX)
                 _LOGGER.info(
@@ -227,7 +178,7 @@ class CloudBackupAgent(BackupAgent):
         try:
             await async_files_delete_file(
                 self._cloud,
-                storage_type=_STORAGE_BACKUP,
+                storage_type=StorageType.BACKUP,
                 filename=self._get_backup_filename(),
             )
         except (ClientError, CloudError) as err:
@@ -236,7 +187,9 @@ class CloudBackupAgent(BackupAgent):
     async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
         """List backups."""
         try:
-            backups = await async_files_list(self._cloud, storage_type=_STORAGE_BACKUP)
+            backups = await async_files_list(
+                self._cloud, storage_type=StorageType.BACKUP
+            )
             _LOGGER.debug("Cloud backups: %s", backups)
         except (ClientError, CloudError) as err:
             raise BackupAgentError("Failed to list backups") from err

homeassistant/components/cloud/http_api.py

@@ -29,6 +29,7 @@ from homeassistant.components.google_assistant import helpers as google_helpers
 from homeassistant.components.homeassistant import exposed_entities
 from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
 from homeassistant.components.http.data_validator import RequestDataValidator
+from homeassistant.components.system_health import get_info as get_system_health_info
 from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -107,6 +108,7 @@ def async_setup(hass: HomeAssistant) -> None:
     hass.http.register_view(CloudRegisterView)
     hass.http.register_view(CloudResendConfirmView)
     hass.http.register_view(CloudForgotPasswordView)
+    hass.http.register_view(DownloadSupportPackageView)
 
     _CLOUD_ERRORS.update(
         {
@@ -389,6 +391,59 @@ class CloudForgotPasswordView(HomeAssistantView):
         return self.json_message("ok")
 
 
+class DownloadSupportPackageView(HomeAssistantView):
+    """Download support package view."""
+
+    url = "/api/cloud/support_package"
+    name = "api:cloud:support_package"
+
+    def _generate_markdown(
+        self, hass_info: dict[str, Any], domains_info: dict[str, dict[str, str]]
+    ) -> str:
+        def get_domain_table_markdown(domain_info: dict[str, Any]) -> str:
+            if len(domain_info) == 0:
+                return "No information available\n"
+
+            markdown = ""
+            first = True
+            for key, value in domain_info.items():
+                markdown += f"{key} | {value}\n"
+                if first:
+                    markdown += "--- | ---\n"
+                    first = False
+            return markdown + "\n"
+
+        markdown = "## System Information\n\n"
+        markdown += get_domain_table_markdown(hass_info)
+
+        for domain, domain_info in domains_info.items():
+            domain_info_md = get_domain_table_markdown(domain_info)
+            markdown += (
+                f"<details><summary>{domain}</summary>\n\n"
+                f"{domain_info_md}"
+                "</details>\n\n"
+            )
+
+        return markdown
+
+    async def get(self, request: web.Request) -> web.Response:
+        """Download support package file."""
+
+        hass = request.app[KEY_HASS]
+        domain_health = await get_system_health_info(hass)
+
+        hass_info = domain_health.pop("homeassistant", {})
+        markdown = self._generate_markdown(hass_info, domain_health)
+
+        return web.Response(
+            body=markdown,
+            content_type="text/markdown",
+            headers={
+                "Content-Disposition": 'attachment; filename="support_package.md"'
+            },
+        )
+
+
 @websocket_api.require_admin
 @websocket_api.websocket_command({vol.Required("type"): "cloud/remove_data"})
 @websocket_api.async_response

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["hass_nabucasa"],
-  "requirements": ["hass-nabucasa==0.88.1"],
+  "requirements": ["hass-nabucasa==0.92.0"],
   "single_config_entry": true
 }

homeassistant/components/cloud/strings.json

@@ -17,6 +17,11 @@
       "subscription_expiration": "Subscription expiration"
     }
   },
+  "exceptions": {
+    "backup_size_too_large": {
+      "message": "The backup size of {size}GB is too large to be uploaded to Home Assistant Cloud."
+    }
+  },
   "issues": {
     "deprecated_gender": {
       "title": "The {deprecated_option} text-to-speech option is deprecated",

homeassistant/components/coinbase/__init__.py

@@ -140,8 +140,10 @@ def get_accounts(client, version):
             API_ACCOUNT_ID: account[API_V3_ACCOUNT_ID],
             API_ACCOUNT_NAME: account[API_ACCOUNT_NAME],
             API_ACCOUNT_CURRENCY: account[API_ACCOUNT_CURRENCY],
-            API_ACCOUNT_AMOUNT: account[API_ACCOUNT_AVALIABLE][API_ACCOUNT_VALUE]
-            + account[API_ACCOUNT_HOLD][API_ACCOUNT_VALUE],
+            API_ACCOUNT_AMOUNT: (
+                float(account[API_ACCOUNT_AVALIABLE][API_ACCOUNT_VALUE])
+                + float(account[API_ACCOUNT_HOLD][API_ACCOUNT_VALUE])
+            ),
             ACCOUNT_IS_VAULT: account[API_RESOURCE_TYPE] == API_V3_TYPE_VAULT,
         }
         for account in accounts

homeassistant/components/config/config_entries.py

@@ -302,7 +302,8 @@ def config_entries_progress(
         [
             flw
             for flw in hass.config_entries.flow.async_progress()
-            if flw["context"]["source"] != config_entries.SOURCE_USER
+            if flw["context"]["source"]
+            not in (config_entries.SOURCE_RECONFIGURE, config_entries.SOURCE_USER)
         ],
     )
 

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["hassil==2.2.0", "home-assistant-intents==2025.1.28"]
+  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.2.5"]
 }

homeassistant/components/dhcp/manifest.json

@@ -14,7 +14,7 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "aiodhcpwatcher==1.0.2",
+    "aiodhcpwatcher==1.0.3",
     "aiodiscover==2.1.0",
     "cached-ipaddress==0.8.0"
   ]

homeassistant/components/discovergy/coordinator.py

@@ -44,9 +44,7 @@ class DiscovergyUpdateCoordinator(DataUpdateCoordinator[Reading]):
             )
         except InvalidLogin as err:
             raise ConfigEntryAuthFailed(
-                f"Auth expired while fetching last reading for meter {self.meter.meter_id}"
+                "Auth expired while fetching last reading"
             ) from err
         except (HTTPError, DiscovergyClientError) as err:
-            raise UpdateFailed(
-                f"Error while fetching last reading for meter {self.meter.meter_id}"
-            ) from err
+            raise UpdateFailed(f"Error while fetching last reading: {err}") from err

homeassistant/components/econet/climate.py

@@ -23,7 +23,7 @@ from homeassistant.components.climate import (
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 
 from . import EconetConfigEntry
 from .const import DOMAIN
@@ -35,8 +35,13 @@ ECONET_STATE_TO_HA = {
     ThermostatOperationMode.OFF: HVACMode.OFF,
     ThermostatOperationMode.AUTO: HVACMode.HEAT_COOL,
     ThermostatOperationMode.FAN_ONLY: HVACMode.FAN_ONLY,
+    ThermostatOperationMode.EMERGENCY_HEAT: HVACMode.HEAT,
+}
+HA_STATE_TO_ECONET = {
+    value: key
+    for key, value in ECONET_STATE_TO_HA.items()
+    if key != ThermostatOperationMode.EMERGENCY_HEAT
 }
-HA_STATE_TO_ECONET = {value: key for key, value in ECONET_STATE_TO_HA.items()}
 
 ECONET_FAN_STATE_TO_HA = {
     ThermostatFanMode.AUTO: FAN_AUTO,
@@ -209,7 +214,7 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
 
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""
-        async_create_issue(
+        create_issue(
             self.hass,
             DOMAIN,
             "migrate_aux_heat",
@@ -223,7 +228,7 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
 
     def turn_aux_heat_off(self) -> None:
         """Turn auxiliary heater off."""
-        async_create_issue(
+        create_issue(
             self.hass,
             DOMAIN,
             "migrate_aux_heat",

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.10", "deebot-client==11.1.0b2"]
+  "requirements": ["py-sucks==0.9.10", "deebot-client==12.1.0"]
 }

homeassistant/components/eheimdigital/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["eheimdigital"],
   "quality_scale": "bronze",
-  "requirements": ["eheimdigital==1.0.5"],
+  "requirements": ["eheimdigital==1.0.6"],
   "zeroconf": [
     { "type": "_http._tcp.local.", "name": "eheimdigital._http._tcp.local." }
   ]

homeassistant/components/electric_kiwi/__init__.py

@@ -4,12 +4,16 @@ from __future__ import annotations
 
 import aiohttp
 from electrickiwi_api import ElectricKiwiApi
-from electrickiwi_api.exceptions import ApiException
+from electrickiwi_api.exceptions import ApiException, AuthException
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_entry_oauth2_flow,
+    entity_registry as er,
+)
 
 from . import api
 from .coordinator import (
@@ -44,7 +48,9 @@ async def async_setup_entry(
         raise ConfigEntryNotReady from err
 
     ek_api = ElectricKiwiApi(
-        api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
+        api.ConfigEntryElectricKiwiAuth(
+            aiohttp_client.async_get_clientsession(hass), session
+        )
     )
     hop_coordinator = ElectricKiwiHOPDataCoordinator(hass, entry, ek_api)
     account_coordinator = ElectricKiwiAccountDataCoordinator(hass, entry, ek_api)
@@ -53,6 +59,8 @@ async def async_setup_entry(
         await ek_api.set_active_session()
         await hop_coordinator.async_config_entry_first_refresh()
         await account_coordinator.async_config_entry_first_refresh()
+    except AuthException as err:
+        raise ConfigEntryAuthFailed from err
     except ApiException as err:
         raise ConfigEntryNotReady from err
 
@@ -70,3 +78,53 @@ async def async_unload_entry(
 ) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: ElectricKiwiConfigEntry
+) -> bool:
+    """Migrate old entry."""
+    if config_entry.version == 1 and config_entry.minor_version == 1:
+        implementation = (
+            await config_entry_oauth2_flow.async_get_config_entry_implementation(
+                hass, config_entry
+            )
+        )
+
+        session = config_entry_oauth2_flow.OAuth2Session(
+            hass, config_entry, implementation
+        )
+
+        ek_api = ElectricKiwiApi(
+            api.ConfigEntryElectricKiwiAuth(
+                aiohttp_client.async_get_clientsession(hass), session
+            )
+        )
+        try:
+            await ek_api.set_active_session()
+            connection_details = await ek_api.get_connection_details()
+        except AuthException:
+            config_entry.async_start_reauth(hass)
+            return False
+        except ApiException:
+            return False
+        unique_id = str(ek_api.customer_number)
+        identifier = ek_api.electricity.identifier
+        hass.config_entries.async_update_entry(
+            config_entry, unique_id=unique_id, minor_version=2
+        )
+        entity_registry = er.async_get(hass)
+        entity_entries = er.async_entries_for_config_entry(
+            entity_registry, config_entry_id=config_entry.entry_id
+        )
+
+        for entity in entity_entries:
+            assert entity.config_entry_id
+            entity_registry.async_update_entity(
+                entity.entity_id,
+                new_unique_id=entity.unique_id.replace(
+                    f"{unique_id}_{connection_details.id}", f"{unique_id}_{identifier}"
+                ),
+            )
+
+    return True

homeassistant/components/electric_kiwi/api.py

@@ -2,17 +2,16 @@
 
 from __future__ import annotations
 
-from typing import cast
-
 from aiohttp import ClientSession
 from electrickiwi_api import AbstractAuth
 
-from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
 
 from .const import API_BASE_URL
 
 
-class AsyncConfigEntryAuth(AbstractAuth):
+class ConfigEntryElectricKiwiAuth(AbstractAuth):
     """Provide Electric Kiwi authentication tied to an OAuth2 based config entry."""
 
     def __init__(
@@ -29,4 +28,21 @@ class AsyncConfigEntryAuth(AbstractAuth):
         """Return a valid access token."""
         await self._oauth_session.async_ensure_token_valid()
 
-        return cast(str, self._oauth_session.token["access_token"])
+        return str(self._oauth_session.token["access_token"])
+
+
+class ConfigFlowElectricKiwiAuth(AbstractAuth):
+    """Provide Electric Kiwi authentication tied to an OAuth2 based config flow."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        token: str,
+    ) -> None:
+        """Initialize ConfigFlowFitbitApi."""
+        super().__init__(aiohttp_client.async_get_clientsession(hass), API_BASE_URL)
+        self._token = token
+
+    async def async_get_access_token(self) -> str:
+        """Return the token for the Electric Kiwi API."""
+        return self._token

homeassistant/components/electric_kiwi/config_flow.py

@@ -6,9 +6,14 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from homeassistant.config_entries import ConfigFlowResult
+from electrickiwi_api import ElectricKiwiApi
+from electrickiwi_api.exceptions import ApiException
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.const import CONF_NAME
 from homeassistant.helpers import config_entry_oauth2_flow
 
+from . import api
 from .const import DOMAIN, SCOPE_VALUES
 
 
@@ -17,6 +22,8 @@ class ElectricKiwiOauth2FlowHandler(
 ):
     """Config flow to handle Electric Kiwi OAuth2 authentication."""
 
+    VERSION = 1
+    MINOR_VERSION = 2
     DOMAIN = DOMAIN
 
     @property
@@ -40,12 +47,30 @@ class ElectricKiwiOauth2FlowHandler(
     ) -> ConfigFlowResult:
         """Dialog that informs the user that reauth is required."""
         if user_input is None:
-            return self.async_show_form(step_id="reauth_confirm")
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                description_placeholders={CONF_NAME: self._get_reauth_entry().title},
+            )
         return await self.async_step_user()
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an entry for Electric Kiwi."""
-        existing_entry = await self.async_set_unique_id(DOMAIN)
-        if existing_entry:
-            return self.async_update_reload_and_abort(existing_entry, data=data)
-        return await super().async_oauth_create_entry(data)
+        ek_api = ElectricKiwiApi(
+            api.ConfigFlowElectricKiwiAuth(self.hass, data["token"]["access_token"])
+        )
+
+        try:
+            session = await ek_api.get_active_session()
+        except ApiException:
+            return self.async_abort(reason="connection_error")
+
+        unique_id = str(session.data.customer_number)
+        await self.async_set_unique_id(unique_id)
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch(reason="wrong_account")
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(), data=data
+            )
+
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(title=unique_id, data=data)

homeassistant/components/electric_kiwi/const.py

@@ -8,4 +8,4 @@ OAUTH2_AUTHORIZE = "https://welcome.electrickiwi.co.nz/oauth/authorize"
 OAUTH2_TOKEN = "https://welcome.electrickiwi.co.nz/oauth/token"
 API_BASE_URL = "https://api.electrickiwi.co.nz"
 
-SCOPE_VALUES = "read_connection_detail read_billing_frequency read_account_running_balance read_consumption_summary read_consumption_averages read_hop_intervals_config read_hop_connection save_hop_connection read_session"
+SCOPE_VALUES = "read_customer_details read_connection_detail read_connection read_billing_address get_bill_address read_billing_frequency read_billing_details read_billing_bills read_billing_bill read_billing_bill_id read_billing_bill_file read_account_running_balance read_customer_account_summary read_consumption_summary download_consumption_file read_consumption_averages get_consumption_averages read_hop_intervals_config read_hop_intervals read_hop_connection read_hop_specific_connection save_hop_connection save_hop_specific_connection read_outage_contact get_outage_contact_info_for_icp read_session read_session_data_login"

homeassistant/components/electric_kiwi/coordinator.py

@@ -10,7 +10,7 @@ import logging
 
 from electrickiwi_api import ElectricKiwiApi
 from electrickiwi_api.exceptions import ApiException, AuthException
-from electrickiwi_api.model import AccountBalance, Hop, HopIntervals
+from electrickiwi_api.model import AccountSummary, Hop, HopIntervals
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -34,7 +34,7 @@ class ElectricKiwiRuntimeData:
 type ElectricKiwiConfigEntry = ConfigEntry[ElectricKiwiRuntimeData]
 
 
-class ElectricKiwiAccountDataCoordinator(DataUpdateCoordinator[AccountBalance]):
+class ElectricKiwiAccountDataCoordinator(DataUpdateCoordinator[AccountSummary]):
     """ElectricKiwi Account Data object."""
 
     def __init__(
@@ -51,13 +51,13 @@ class ElectricKiwiAccountDataCoordinator(DataUpdateCoordinator[AccountBalance]):
             name="Electric Kiwi Account Data",
             update_interval=ACCOUNT_SCAN_INTERVAL,
         )
-        self._ek_api = ek_api
+        self.ek_api = ek_api
 
-    async def _async_update_data(self) -> AccountBalance:
+    async def _async_update_data(self) -> AccountSummary:
         """Fetch data from Account balance API endpoint."""
         try:
             async with asyncio.timeout(60):
-                return await self._ek_api.get_account_balance()
+                return await self.ek_api.get_account_summary()
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:
@@ -85,7 +85,7 @@ class ElectricKiwiHOPDataCoordinator(DataUpdateCoordinator[Hop]):
             # Polling interval. Will only be polled if there are subscribers.
             update_interval=HOP_SCAN_INTERVAL,
         )
-        self._ek_api = ek_api
+        self.ek_api = ek_api
         self.hop_intervals: HopIntervals | None = None
 
     def get_hop_options(self) -> dict[str, int]:
@@ -100,7 +100,7 @@ class ElectricKiwiHOPDataCoordinator(DataUpdateCoordinator[Hop]):
     async def async_update_hop(self, hop_interval: int) -> Hop:
         """Update selected hop and data."""
         try:
-            self.async_set_updated_data(await self._ek_api.post_hop(hop_interval))
+            self.async_set_updated_data(await self.ek_api.post_hop(hop_interval))
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:
@@ -118,7 +118,7 @@ class ElectricKiwiHOPDataCoordinator(DataUpdateCoordinator[Hop]):
         try:
             async with asyncio.timeout(60):
                 if self.hop_intervals is None:
-                    hop_intervals: HopIntervals = await self._ek_api.get_hop_intervals()
+                    hop_intervals: HopIntervals = await self.ek_api.get_hop_intervals()
                     hop_intervals.intervals = OrderedDict(
                         filter(
                             lambda pair: pair[1].active == 1,
@@ -127,7 +127,7 @@ class ElectricKiwiHOPDataCoordinator(DataUpdateCoordinator[Hop]):
                     )
 
                     self.hop_intervals = hop_intervals
-                return await self._ek_api.get_hop()
+                return await self.ek_api.get_hop()
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:

homeassistant/components/electric_kiwi/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/electric_kiwi",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "requirements": ["electrickiwi-api==0.8.5"]
+  "requirements": ["electrickiwi-api==0.9.14"]
 }

homeassistant/components/electric_kiwi/select.py

@@ -53,8 +53,8 @@ class ElectricKiwiSelectHOPEntity(
         """Initialise the HOP selection entity."""
         super().__init__(coordinator)
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
         self.values_dict = coordinator.get_hop_options()

homeassistant/components/electric_kiwi/sensor.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
-from electrickiwi_api.model import AccountBalance, Hop
+from electrickiwi_api.model import AccountSummary, Hop
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -39,7 +39,15 @@ ATTR_HOP_PERCENTAGE = "hop_percentage"
 class ElectricKiwiAccountSensorEntityDescription(SensorEntityDescription):
     """Describes Electric Kiwi sensor entity."""
 
-    value_func: Callable[[AccountBalance], float | datetime]
+    value_func: Callable[[AccountSummary], float | datetime]
+
+
+def _get_hop_percentage(account_balance: AccountSummary) -> float:
+    """Return the hop percentage from account summary."""
+    if power := account_balance.services.get("power"):
+        if connection := power.connections[0]:
+            return float(connection.hop_percentage)
+    return 0.0
 
 
 ACCOUNT_SENSOR_TYPES: tuple[ElectricKiwiAccountSensorEntityDescription, ...] = (
@@ -72,9 +80,7 @@ ACCOUNT_SENSOR_TYPES: tuple[ElectricKiwiAccountSensorEntityDescription, ...] = (
         translation_key="hop_power_savings",
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        value_func=lambda account_balance: float(
-            account_balance.connections[0].hop_percentage
-        ),
+        value_func=_get_hop_percentage,
     ),
 )
 
@@ -165,8 +171,8 @@ class ElectricKiwiAccountEntity(
         super().__init__(coordinator)
 
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
 
@@ -194,8 +200,8 @@ class ElectricKiwiHOPEntity(
         super().__init__(coordinator)
 
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
 

homeassistant/components/electric_kiwi/strings.json

@@ -21,7 +21,8 @@
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
       "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
-      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]"
+      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "connection_error": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"

homeassistant/components/enphase_envoy/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/enphase_envoy",
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
-  "requirements": ["pyenphase==1.23.1"],
+  "requirements": ["pyenphase==1.25.1"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/eq3btsmart/manifest.json

@@ -22,5 +22,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["eq3btsmart"],
-  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.6.0"]
+  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.7.0"]
 }

homeassistant/components/esphome/bluetooth.py

@@ -28,6 +28,7 @@ def async_connect_scanner(
     entry_data: RuntimeEntryData,
     cli: APIClient,
     device_info: DeviceInfo,
+    device_id: str,
 ) -> CALLBACK_TYPE:
     """Connect scanner."""
     client_data = connect_scanner(cli, device_info, entry_data.available)
@@ -45,6 +46,7 @@ def async_connect_scanner(
                 source_domain=DOMAIN,
                 source_model=device_info.model,
                 source_config_entry_id=entry_data.entry_id,
+                source_device_id=device_id,
             ),
             scanner.async_setup(),
         ],

homeassistant/components/esphome/manager.py

@@ -425,7 +425,9 @@ class ESPHomeManager:
 
         if device_info.bluetooth_proxy_feature_flags_compat(api_version):
             entry_data.disconnect_callbacks.add(
-                async_connect_scanner(hass, entry_data, cli, device_info)
+                async_connect_scanner(
+                    hass, entry_data, cli, device_info, self.device_id
+                )
             )
         else:
             bluetooth.async_remove_scanner(hass, device_info.mac_address)
@@ -571,7 +573,9 @@ def _async_setup_device_registry(
 
     configuration_url = None
     if device_info.webserver_port > 0:
-        configuration_url = f"http://{entry.data['host']}:{device_info.webserver_port}"
+        entry_host = entry.data["host"]
+        host = f"[{entry_host}]" if ":" in entry_host else entry_host
+        configuration_url = f"http://{host}:{device_info.webserver_port}"
     elif (
         (dashboard := async_get_dashboard(hass))
         and dashboard.data

homeassistant/components/esphome/manifest.json

@@ -18,7 +18,7 @@
   "requirements": [
     "aioesphomeapi==29.0.0",
     "esphome-dashboard-api==1.2.3",
-    "bleak-esphome==2.6.0"
+    "bleak-esphome==2.7.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/fireservicerota/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/fireservicerota",
   "iot_class": "cloud_polling",
   "loggers": ["pyfireservicerota"],
-  "requirements": ["pyfireservicerota==0.0.43"]
+  "requirements": ["pyfireservicerota==0.0.46"]
 }

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20250131.0"]
+  "requirements": ["home-assistant-frontend==20250214.0"]
 }

homeassistant/components/google_drive/__init__.py

@@ -7,7 +7,7 @@ from collections.abc import Callable
 from google_drive_api.exceptions import GoogleDriveApiError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -49,6 +49,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry)
     except GoogleDriveApiError as err:
         raise ConfigEntryNotReady from err
 
+    _async_notify_backup_listeners_soon(hass)
+
     return True
 
 
@@ -56,10 +58,15 @@ async def async_unload_entry(
     hass: HomeAssistant, entry: GoogleDriveConfigEntry
 ) -> bool:
     """Unload a config entry."""
-    hass.loop.call_soon(_notify_backup_listeners, hass)
+    _async_notify_backup_listeners_soon(hass)
     return True
 
 
-def _notify_backup_listeners(hass: HomeAssistant) -> None:
+def _async_notify_backup_listeners(hass: HomeAssistant) -> None:
     for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
         listener()
+
+
+@callback
+def _async_notify_backup_listeners_soon(hass: HomeAssistant) -> None:
+    hass.loop.call_soon(_async_notify_backup_listeners, hass)

homeassistant/components/google_drive/api.py

@@ -146,9 +146,10 @@ class DriveClient:
             backup.backup_id,
             backup_metadata,
         )
-        await self._api.upload_file(
+        await self._api.resumable_upload_file(
             backup_metadata,
             open_stream,
+            backup.size,
             timeout=ClientTimeout(total=_UPLOAD_AND_DOWNLOAD_TIMEOUT),
         )
         _LOGGER.debug(

homeassistant/components/google_drive/application_credentials.py

@@ -2,7 +2,10 @@
 
 from homeassistant.components.application_credentials import AuthorizationServer
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    AUTH_CALLBACK_PATH,
+    MY_AUTH_CALLBACK_PATH,
+)
 
 
 async def async_get_authorization_server(hass: HomeAssistant) -> AuthorizationServer:
@@ -15,9 +18,14 @@ async def async_get_authorization_server(hass: HomeAssistant) -> AuthorizationSe
 
 async def async_get_description_placeholders(hass: HomeAssistant) -> dict[str, str]:
     """Return description placeholders for the credentials dialog."""
+    if "my" in hass.config.components:
+        redirect_url = MY_AUTH_CALLBACK_PATH
+    else:
+        ha_host = hass.config.external_url or "https://YOUR_DOMAIN:PORT"
+        redirect_url = f"{ha_host}{AUTH_CALLBACK_PATH}"
     return {
         "oauth_consent_url": "https://console.cloud.google.com/apis/credentials/consent",
         "more_info_url": "https://www.home-assistant.io/integrations/google_drive/",
         "oauth_creds_url": "https://console.cloud.google.com/apis/credentials",
-        "redirect_url": config_entry_oauth2_flow.async_get_redirect_uri(hass),
+        "redirect_url": redirect_url,
     }

homeassistant/components/google_drive/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["google_drive_api"],
   "quality_scale": "platinum",
-  "requirements": ["python-google-drive-api==0.0.2"]
+  "requirements": ["python-google-drive-api==0.1.0"]
 }

homeassistant/components/govee_ble/manifest.json

@@ -38,6 +38,10 @@
       "local_name": "GV5126*",
       "connectable": false
     },
+    {
+      "local_name": "GV5179*",
+      "connectable": false
+    },
     {
       "local_name": "GVH5127*",
       "connectable": false
@@ -131,5 +135,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/govee_ble",
   "iot_class": "local_push",
-  "requirements": ["govee-ble==0.42.0"]
+  "requirements": ["govee-ble==0.43.0"]
 }

homeassistant/components/habitica/coordinator.py

@@ -11,6 +11,7 @@ from typing import Any
 
 from aiohttp import ClientError
 from habiticalib import (
+    Avatar,
     ContentData,
     Habitica,
     HabiticaException,
@@ -19,7 +20,6 @@ from habiticalib import (
     TaskFilter,
     TooManyRequestsError,
     UserData,
-    UserStyles,
 )
 
 from homeassistant.config_entries import ConfigEntry
@@ -159,12 +159,10 @@ class HabiticaDataUpdateCoordinator(DataUpdateCoordinator[HabiticaData]):
         else:
             await self.async_request_refresh()
 
-    async def generate_avatar(self, user_styles: UserStyles) -> bytes:
+    async def generate_avatar(self, avatar: Avatar) -> bytes:
         """Generate Avatar."""
 
-        avatar = BytesIO()
-        await self.habitica.generate_avatar(
-            fp=avatar, user_styles=user_styles, fmt="PNG"
-        )
+        png = BytesIO()
+        await self.habitica.generate_avatar(fp=png, avatar=avatar, fmt="PNG")
 
-        return avatar.getvalue()
+        return png.getvalue()

homeassistant/components/habitica/diagnostics.py

@@ -23,5 +23,5 @@ async def async_get_config_entry_diagnostics(
             CONF_URL: config_entry.data[CONF_URL],
             CONF_API_USER: config_entry.data[CONF_API_USER],
         },
-        "habitica_data": habitica_data.to_dict()["data"],
+        "habitica_data": habitica_data.to_dict(omit_none=False)["data"],
     }

homeassistant/components/habitica/image.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from dataclasses import asdict
 from enum import StrEnum
 
-from habiticalib import UserStyles
+from habiticalib import Avatar, extract_avatar
 
 from homeassistant.components.image import ImageEntity, ImageEntityDescription
 from homeassistant.core import HomeAssistant
@@ -45,7 +44,7 @@ class HabiticaImage(HabiticaBase, ImageEntity):
         translation_key=HabiticaImageEntity.AVATAR,
     )
     _attr_content_type = "image/png"
-    _current_appearance: UserStyles | None = None
+    _current_appearance: Avatar | None = None
     _cache: bytes | None = None
 
     def __init__(
@@ -60,7 +59,7 @@ class HabiticaImage(HabiticaBase, ImageEntity):
 
     def _handle_coordinator_update(self) -> None:
         """Check if equipped gear and other things have changed since last avatar image generation."""
-        new_appearance = UserStyles.from_dict(asdict(self.coordinator.data.user))
+        new_appearance = extract_avatar(self.coordinator.data.user)
 
         if self._current_appearance != new_appearance:
             self._current_appearance = new_appearance

homeassistant/components/habitica/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/habitica",
   "iot_class": "cloud_polling",
   "loggers": ["habiticalib"],
-  "requirements": ["habiticalib==0.3.3"]
+  "requirements": ["habiticalib==0.3.7"]
 }

homeassistant/components/habitica/services.py

@@ -77,7 +77,7 @@ SERVICE_API_CALL_SCHEMA = vol.Schema(
 
 SERVICE_CAST_SKILL_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Required(ATTR_SKILL): cv.string,
         vol.Optional(ATTR_TASK): cv.string,
     }
@@ -85,12 +85,12 @@ SERVICE_CAST_SKILL_SCHEMA = vol.Schema(
 
 SERVICE_MANAGE_QUEST_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
     }
 )
 SERVICE_SCORE_TASK_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Required(ATTR_TASK): cv.string,
         vol.Optional(ATTR_DIRECTION): cv.string,
     }
@@ -98,7 +98,7 @@ SERVICE_SCORE_TASK_SCHEMA = vol.Schema(
 
 SERVICE_TRANSFORMATION_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Required(ATTR_ITEM): cv.string,
         vol.Required(ATTR_TARGET): cv.string,
     }
@@ -106,7 +106,7 @@ SERVICE_TRANSFORMATION_SCHEMA = vol.Schema(
 
 SERVICE_GET_TASKS_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Optional(ATTR_TYPE): vol.All(
             cv.ensure_list, [vol.All(vol.Upper, vol.In({x.name for x in TaskType}))]
         ),
@@ -510,7 +510,10 @@ def async_setup_services(hass: HomeAssistant) -> None:  # noqa: C901
                 or (task.notes and keyword in task.notes.lower())
                 or any(keyword in item.text.lower() for item in task.checklist)
             ]
-        result: dict[str, Any] = {"tasks": response}
+        result: dict[str, Any] = {
+            "tasks": [task.to_dict(omit_none=False) for task in response]
+        }
+
         return result
 
     hass.services.async_register(

homeassistant/components/hassio/backup.py

@@ -20,6 +20,7 @@ from aiohasupervisor.models import (
     backups as supervisor_backups,
     mounts as supervisor_mounts,
 )
+from aiohasupervisor.models.backups import LOCATION_CLOUD_BACKUP, LOCATION_LOCAL_STORAGE
 
 from homeassistant.components.backup import (
     DATA_MANAGER,
@@ -27,15 +28,19 @@ from homeassistant.components.backup import (
     AgentBackup,
     BackupAgent,
     BackupManagerError,
+    BackupNotFound,
     BackupReaderWriter,
     BackupReaderWriterError,
     CreateBackupEvent,
+    CreateBackupStage,
+    CreateBackupState,
     Folder,
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
     NewBackup,
     RestoreBackupEvent,
+    RestoreBackupStage,
     RestoreBackupState,
     WrittenBackup,
     async_get_manager as async_get_backup_manager,
@@ -47,12 +52,11 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util import dt as dt_util
+from homeassistant.util.enum import try_parse_enum
 
 from .const import DOMAIN, EVENT_SUPERVISOR_EVENT
 from .handler import get_supervisor_client
 
-LOCATION_CLOUD_BACKUP = ".cloud_backup"
-LOCATION_LOCAL = ".local"
 MOUNT_JOBS = ("mount_manager_create_mount", "mount_manager_remove_mount")
 RESTORE_JOB_ID_ENV = "SUPERVISOR_RESTORE_JOB_ID"
 # Set on backups automatically created when updating an addon
@@ -67,7 +71,9 @@ async def async_get_backup_agents(
     """Return the hassio backup agents."""
     client = get_supervisor_client(hass)
     mounts = await client.mounts.info()
-    agents: list[BackupAgent] = [SupervisorBackupAgent(hass, "local", None)]
+    agents: list[BackupAgent] = [
+        SupervisorBackupAgent(hass, "local", LOCATION_LOCAL_STORAGE)
+    ]
     for mount in mounts.mounts:
         if mount.usage is not supervisor_mounts.MountUsage.BACKUP:
             continue
@@ -107,7 +113,7 @@ def async_register_backup_agents_listener(
 
 
 def _backup_details_to_agent_backup(
-    details: supervisor_backups.BackupComplete, location: str | None
+    details: supervisor_backups.BackupComplete, location: str
 ) -> AgentBackup:
     """Convert a supervisor backup details object to an agent backup."""
     homeassistant_included = details.homeassistant is not None
@@ -120,7 +126,6 @@ def _backup_details_to_agent_backup(
         for addon in details.addons
     ]
     extra_metadata = details.extra or {}
-    location = location or LOCATION_LOCAL
     return AgentBackup(
         addons=addons,
         backup_id=details.slug,
@@ -143,7 +148,7 @@ class SupervisorBackupAgent(BackupAgent):
 
     domain = DOMAIN
 
-    def __init__(self, hass: HomeAssistant, name: str, location: str | None) -> None:
+    def __init__(self, hass: HomeAssistant, name: str, location: str) -> None:
         """Initialize the backup agent."""
         super().__init__()
         self._hass = hass
@@ -158,10 +163,15 @@ class SupervisorBackupAgent(BackupAgent):
         **kwargs: Any,
     ) -> AsyncIterator[bytes]:
         """Download a backup file."""
-        return await self._client.backups.download_backup(
-            backup_id,
-            options=supervisor_backups.DownloadBackupOptions(location=self.location),
-        )
+        try:
+            return await self._client.backups.download_backup(
+                backup_id,
+                options=supervisor_backups.DownloadBackupOptions(
+                    location=self.location
+                ),
+            )
+        except SupervisorNotFoundError as err:
+            raise BackupNotFound from err
 
     async def async_upload_backup(
         self,
@@ -196,7 +206,7 @@ class SupervisorBackupAgent(BackupAgent):
         backup_list = await self._client.backups.list()
         result = []
         for backup in backup_list:
-            if not backup.locations or self.location not in backup.locations:
+            if self.location not in backup.location_attributes:
                 continue
             details = await self._client.backups.backup_info(backup.slug)
             result.append(_backup_details_to_agent_backup(details, self.location))
@@ -212,7 +222,7 @@ class SupervisorBackupAgent(BackupAgent):
             details = await self._client.backups.backup_info(backup_id)
         except SupervisorNotFoundError:
             return None
-        if self.location not in details.locations:
+        if self.location not in details.location_attributes:
             return None
         return _backup_details_to_agent_backup(details, self.location)
 
@@ -285,8 +295,8 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
         # will be handled by async_upload_backup.
         # If the lists are the same length, it does not matter which one we send,
         # we send the encrypted list to have a well defined behavior.
-        encrypted_locations: list[str | None] = []
-        decrypted_locations: list[str | None] = []
+        encrypted_locations: list[str] = []
+        decrypted_locations: list[str] = []
         agents_settings = manager.config.data.agents
         for hassio_agent in hassio_agents:
             if password is not None:
@@ -336,31 +346,43 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
             self._async_wait_for_backup(
                 backup,
                 locations,
+                on_progress=on_progress,
                 remove_after_upload=locations == [LOCATION_CLOUD_BACKUP],
             ),
             name="backup_manager_create_backup",
             eager_start=False,  # To ensure the task is not started before we return
         )
 
-        return (NewBackup(backup_job_id=backup.job_id), backup_task)
+        return (NewBackup(backup_job_id=backup.job_id.hex), backup_task)
 
     async def _async_wait_for_backup(
         self,
         backup: supervisor_backups.NewBackup,
-        locations: list[str | None],
+        locations: list[str],
         *,
+        on_progress: Callable[[CreateBackupEvent], None],
         remove_after_upload: bool,
     ) -> WrittenBackup:
         """Wait for a backup to complete."""
         backup_complete = asyncio.Event()
         backup_id: str | None = None
+        create_errors: list[dict[str, str]] = []
 
         @callback
         def on_job_progress(data: Mapping[str, Any]) -> None:
             """Handle backup progress."""
             nonlocal backup_id
+            if not (stage := try_parse_enum(CreateBackupStage, data.get("stage"))):
+                _LOGGER.debug("Unknown create stage: %s", data.get("stage"))
+            else:
+                on_progress(
+                    CreateBackupEvent(
+                        reason=None, stage=stage, state=CreateBackupState.IN_PROGRESS
+                    )
+                )
             if data.get("done") is True:
                 backup_id = data.get("reference")
+                create_errors.extend(data.get("errors", []))
                 backup_complete.set()
 
         unsub = self._async_listen_job_events(backup.job_id, on_job_progress)
@@ -369,8 +391,11 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
             await backup_complete.wait()
         finally:
             unsub()
-        if not backup_id:
-            raise BackupReaderWriterError("Backup failed")
+        if not backup_id or create_errors:
+            # We should add more specific error handling here in the future
+            raise BackupReaderWriterError(
+                f"Backup failed: {create_errors or 'no backup_id'}"
+            )
 
         async def open_backup() -> AsyncIterator[bytes]:
             try:
@@ -483,7 +508,7 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
             else None
         )
 
-        restore_location: str | None
+        restore_location: str
         if manager.backup_agents[agent_id].domain != DOMAIN:
             # Download the backup to the supervisor. Supervisor will clean up the backup
             # two days after the restore is done.
@@ -509,6 +534,8 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
                     location=restore_location,
                 ),
             )
+        except SupervisorNotFoundError as err:
+            raise BackupNotFound from err
         except SupervisorBadRequestError as err:
             # Supervisor currently does not transmit machine parsable error types
             message = err.args[0]
@@ -517,17 +544,30 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
             raise HomeAssistantError(message) from err
 
         restore_complete = asyncio.Event()
+        restore_errors: list[dict[str, str]] = []
 
         @callback
         def on_job_progress(data: Mapping[str, Any]) -> None:
             """Handle backup restore progress."""
+            if not (stage := try_parse_enum(RestoreBackupStage, data.get("stage"))):
+                _LOGGER.debug("Unknown restore stage: %s", data.get("stage"))
+            else:
+                on_progress(
+                    RestoreBackupEvent(
+                        reason=None, stage=stage, state=RestoreBackupState.IN_PROGRESS
+                    )
+                )
             if data.get("done") is True:
                 restore_complete.set()
+                restore_errors.extend(data.get("errors", []))
 
         unsub = self._async_listen_job_events(job.job_id, on_job_progress)
         try:
             await self._get_job_state(job.job_id, on_job_progress)
             await restore_complete.wait()
+            if restore_errors:
+                # We should add more specific error handling here in the future
+                raise BackupReaderWriterError(f"Restore failed: {restore_errors}")
         finally:
             unsub()
 
@@ -537,28 +577,52 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
         on_progress: Callable[[RestoreBackupEvent | IdleEvent], None],
     ) -> None:
         """Check restore status after core restart."""
-        if not (restore_job_id := os.environ.get(RESTORE_JOB_ID_ENV)):
+        if not (restore_job_str := os.environ.get(RESTORE_JOB_ID_ENV)):
             _LOGGER.debug("No restore job ID found in environment")
             return
 
+        restore_job_id = UUID(restore_job_str)
         _LOGGER.debug("Found restore job ID %s in environment", restore_job_id)
 
+        sent_event = False
+
         @callback
         def on_job_progress(data: Mapping[str, Any]) -> None:
             """Handle backup restore progress."""
+            nonlocal sent_event
+
+            if not (stage := try_parse_enum(RestoreBackupStage, data.get("stage"))):
+                _LOGGER.debug("Unknown restore stage: %s", data.get("stage"))
+
             if data.get("done") is not True:
-                on_progress(
-                    RestoreBackupEvent(
-                        reason="", stage=None, state=RestoreBackupState.IN_PROGRESS
+                if stage or not sent_event:
+                    sent_event = True
+                    on_progress(
+                        RestoreBackupEvent(
+                            reason=None,
+                            stage=stage,
+                            state=RestoreBackupState.IN_PROGRESS,
+                        )
                     )
-                )
                 return
 
-            on_progress(
-                RestoreBackupEvent(
-                    reason="", stage=None, state=RestoreBackupState.COMPLETED
+            restore_errors = data.get("errors", [])
+            if restore_errors:
+                _LOGGER.warning("Restore backup failed: %s", restore_errors)
+                # We should add more specific error handling here in the future
+                on_progress(
+                    RestoreBackupEvent(
+                        reason="unknown_error",
+                        stage=stage,
+                        state=RestoreBackupState.FAILED,
+                    )
+                )
+            else:
+                on_progress(
+                    RestoreBackupEvent(
+                        reason=None, stage=stage, state=RestoreBackupState.COMPLETED
+                    )
                 )
-            )
             on_progress(IdleEvent())
             unsub()
 
@@ -571,7 +635,7 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
 
     @callback
     def _async_listen_job_events(
-        self, job_id: str, on_event: Callable[[Mapping[str, Any]], None]
+        self, job_id: UUID, on_event: Callable[[Mapping[str, Any]], None]
     ) -> Callable[[], None]:
         """Listen for job events."""
 
@@ -586,7 +650,7 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
             if (
                 data.get("event") != "job"
                 or not (event_data := data.get("data"))
-                or event_data.get("uuid") != job_id
+                or event_data.get("uuid") != job_id.hex
             ):
                 return
             on_event(event_data)
@@ -597,10 +661,10 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
         return unsub
 
     async def _get_job_state(
-        self, job_id: str, on_event: Callable[[Mapping[str, Any]], None]
+        self, job_id: UUID, on_event: Callable[[Mapping[str, Any]], None]
     ) -> None:
         """Poll a job for its state."""
-        job = await self._client.jobs.get_job(UUID(job_id))
+        job = await self._client.jobs.get_job(job_id)
         _LOGGER.debug("Job state: %s", job)
         on_event(job.to_dict())
 

homeassistant/components/hassio/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/hassio",
   "iot_class": "local_polling",
   "quality_scale": "internal",
-  "requirements": ["aiohasupervisor==0.2.2b6"],
+  "requirements": ["aiohasupervisor==0.3.0"],
   "single_config_entry": true
 }

homeassistant/components/heos/__init__.py

@@ -37,11 +37,24 @@ async def async_setup_entry(hass: HomeAssistant, entry: HeosConfigEntry) -> bool
     for device in device_registry.devices.get_devices_for_config_entry_id(
         entry.entry_id
     ):
-        for domain, player_id in device.identifiers:
-            if domain == DOMAIN and not isinstance(player_id, str):
-                device_registry.async_update_device(  # type: ignore[unreachable]
-                    device.id, new_identifiers={(DOMAIN, str(player_id))}
+        for ident in device.identifiers:
+            if ident[0] != DOMAIN or isinstance(ident[1], str):
+                continue
+
+            player_id = int(ident[1])  # type: ignore[unreachable]
+
+            # Create set of identifiers excluding this integration
+            identifiers = {ident for ident in device.identifiers if ident[0] != DOMAIN}
+            migrated_identifiers = {(DOMAIN, str(player_id))}
+            # Add migrated if not already present in another device, which occurs if the user downgraded and then upgraded
+            if not device_registry.async_get_device(migrated_identifiers):
+                identifiers.update(migrated_identifiers)
+            if len(identifiers) > 0:
+                device_registry.async_update_device(
+                    device.id, new_identifiers=identifiers
                 )
+            else:
+                device_registry.async_remove_device(device.id)
             break
 
     coordinator = HeosCoordinator(hass, entry)

homeassistant/components/heos/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_push",
   "loggers": ["pyheos"],
   "quality_scale": "silver",
-  "requirements": ["pyheos==1.0.1"],
+  "requirements": ["pyheos==1.0.2"],
   "single_config_entry": true,
   "ssdp": [
     {

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.65", "babel==2.15.0"]
+  "requirements": ["holidays==0.66", "babel==2.15.0"]
 }

homeassistant/components/homee/const.py

@@ -1,6 +1,7 @@
 """Constants for the homee integration."""
 
 from homeassistant.const import (
+    DEGREE,
     LIGHT_LUX,
     PERCENTAGE,
     REVOLUTIONS_PER_MINUTE,
@@ -32,6 +33,7 @@ HOMEE_UNIT_TO_HA_UNIT = {
     "W": UnitOfPower.WATT,
     "m/s": UnitOfSpeed.METERS_PER_SECOND,
     "km/h": UnitOfSpeed.KILOMETERS_PER_HOUR,
+    "°": DEGREE,
     "°F": UnitOfTemperature.FAHRENHEIT,
     "°C": UnitOfTemperature.CELSIUS,
     "K": UnitOfTemperature.KELVIN,
@@ -51,7 +53,7 @@ OPEN_CLOSE_MAP_REVERSED = {
     0.0: "closed",
     1.0: "open",
     2.0: "partial",
-    3.0: "cosing",
+    3.0: "closing",
     4.0: "opening",
 }
 WINDOW_MAP = {

homeassistant/components/homekit/util.py

@@ -78,6 +78,7 @@ from .const import (
     CONF_VIDEO_CODEC,
     CONF_VIDEO_MAP,
     CONF_VIDEO_PACKET_SIZE,
+    CONF_VIDEO_PROFILE_NAMES,
     DEFAULT_AUDIO_CODEC,
     DEFAULT_AUDIO_MAP,
     DEFAULT_AUDIO_PACKET_SIZE,
@@ -90,6 +91,7 @@ from .const import (
     DEFAULT_VIDEO_CODEC,
     DEFAULT_VIDEO_MAP,
     DEFAULT_VIDEO_PACKET_SIZE,
+    DEFAULT_VIDEO_PROFILE_NAMES,
     DOMAIN,
     FEATURE_ON_OFF,
     FEATURE_PLAY_PAUSE,
@@ -163,6 +165,9 @@ CAMERA_SCHEMA = BASIC_INFO_SCHEMA.extend(
         vol.Optional(CONF_VIDEO_CODEC, default=DEFAULT_VIDEO_CODEC): vol.In(
             VALID_VIDEO_CODECS
         ),
+        vol.Optional(CONF_VIDEO_PROFILE_NAMES, default=DEFAULT_VIDEO_PROFILE_NAMES): [
+            cv.string
+        ],
         vol.Optional(
             CONF_AUDIO_PACKET_SIZE, default=DEFAULT_AUDIO_PACKET_SIZE
         ): cv.positive_int,

homeassistant/components/homewizard/__init__.py

@@ -25,7 +25,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeWizardConfigEntry) -
 
     api: HomeWizardEnergy
 
-    if token := entry.data.get(CONF_TOKEN):
+    is_battery = entry.unique_id.startswith("HWE-BAT") if entry.unique_id else False
+
+    if (token := entry.data.get(CONF_TOKEN)) and is_battery:
         api = HomeWizardEnergyV2(
             entry.data[CONF_IP_ADDRESS],
             token=token,
@@ -37,7 +39,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeWizardConfigEntry) -
             clientsession=async_get_clientsession(hass),
         )
 
-        await async_check_v2_support_and_create_issue(hass, entry)
+        if is_battery:
+            await async_check_v2_support_and_create_issue(hass, entry)
 
     coordinator = HWEnergyDeviceUpdateCoordinator(hass, api)
     try:

homeassistant/components/homewizard/config_flow.py

@@ -272,9 +272,14 @@ class HomeWizardConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle reconfiguration of the integration."""
         errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+
         if user_input:
             try:
-                device_info = await async_try_connect(user_input[CONF_IP_ADDRESS])
+                device_info = await async_try_connect(
+                    user_input[CONF_IP_ADDRESS],
+                    token=reconfigure_entry.data.get(CONF_TOKEN),
+                )
 
             except RecoverableError as ex:
                 LOGGER.error(ex)
@@ -288,7 +293,6 @@ class HomeWizardConfigFlow(ConfigFlow, domain=DOMAIN):
                     self._get_reconfigure_entry(),
                     data_updates=user_input,
                 )
-        reconfigure_entry = self._get_reconfigure_entry()
         return self.async_show_form(
             step_id="reconfigure",
             data_schema=vol.Schema(
@@ -306,7 +310,7 @@ class HomeWizardConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
 
-async def async_try_connect(ip_address: str) -> Device:
+async def async_try_connect(ip_address: str, token: str | None = None) -> Device:
     """Try to connect.
 
     Make connection with device to test the connection
@@ -317,7 +321,7 @@ async def async_try_connect(ip_address: str) -> Device:
 
     # Determine if device is v1 or v2 capable
     if await has_v2_api(ip_address):
-        energy_api = HomeWizardEnergyV2(ip_address)
+        energy_api = HomeWizardEnergyV2(ip_address, token=token)
     else:
         energy_api = HomeWizardEnergyV1(ip_address)
 

homeassistant/components/hydrawise/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/hydrawise",
   "iot_class": "cloud_polling",
   "loggers": ["pydrawise"],
-  "requirements": ["pydrawise==2025.1.0"]
+  "requirements": ["pydrawise==2025.2.0"]
 }

homeassistant/components/idasen_desk/config_flow.py

@@ -87,7 +87,7 @@ class IdasenDeskConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery := self._discovery_info:
             self._discovered_devices[discovery.address] = discovery
         else:
-            current_addresses = self._async_current_ids()
+            current_addresses = self._async_current_ids(include_ignore=False)
             for discovery in async_discovered_service_info(self.hass):
                 if (
                     discovery.address in current_addresses

homeassistant/components/inkbird/config_flow.py

@@ -72,7 +72,7 @@ class INKBIRDConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids()
+        current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/lacrosse_view/coordinator.py

@@ -10,8 +10,8 @@ from lacrosse_view import HTTPError, LaCrosse, Location, LoginError, Sensor
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import SCAN_INTERVAL
 
@@ -26,6 +26,7 @@ class LaCrosseUpdateCoordinator(DataUpdateCoordinator[list[Sensor]]):
     name: str
     id: str
     hass: HomeAssistant
+    devices: list[Sensor] | None = None
 
     def __init__(
         self,
@@ -60,24 +61,34 @@ class LaCrosseUpdateCoordinator(DataUpdateCoordinator[list[Sensor]]):
             except LoginError as error:
                 raise ConfigEntryAuthFailed from error
 
+        if self.devices is None:
+            _LOGGER.debug("Getting devices")
+            try:
+                self.devices = await self.api.get_devices(
+                    location=Location(id=self.id, name=self.name),
+                )
+            except HTTPError as error:
+                raise UpdateFailed from error
+
         try:
             # Fetch last hour of data
-            sensors = await self.api.get_sensors(
-                location=Location(id=self.id, name=self.name),
-                tz=self.hass.config.time_zone,
-                start=str(now - 3600),
-                end=str(now),
-            )
-        except HTTPError as error:
-            raise ConfigEntryNotReady from error
+            for sensor in self.devices:
+                sensor.data = (
+                    await self.api.get_sensor_status(
+                        sensor=sensor,
+                        tz=self.hass.config.time_zone,
+                    )
+                )["data"]["current"]
+                _LOGGER.debug("Got data: %s", sensor.data)
 
-        _LOGGER.debug("Got data: %s", sensors)
+        except HTTPError as error:
+            raise UpdateFailed from error
 
         # Verify that we have permission to read the sensors
-        for sensor in sensors:
+        for sensor in self.devices:
             if not sensor.permissions.get("read", False):
                 raise ConfigEntryAuthFailed(
                     f"This account does not have permission to read {sensor.name}"
                 )
 
-        return sensors
+        return self.devices

homeassistant/components/lacrosse_view/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/lacrosse_view",
   "iot_class": "cloud_polling",
   "loggers": ["lacrosse_view"],
-  "requirements": ["lacrosse-view==1.0.3"]
+  "requirements": ["lacrosse-view==1.1.1"]
 }

homeassistant/components/lacrosse_view/sensor.py

@@ -45,10 +45,10 @@ class LaCrosseSensorEntityDescription(SensorEntityDescription):
 
 def get_value(sensor: Sensor, field: str) -> float | int | str | None:
     """Get the value of a sensor field."""
-    field_data = sensor.data.get(field)
+    field_data = sensor.data.get(field) if sensor.data is not None else None
     if field_data is None:
         return None
-    value = field_data["values"][-1]["s"]
+    value = field_data["spot"]["value"]
     try:
         value = float(value)
     except ValueError:
@@ -178,7 +178,7 @@ async def async_setup_entry(
                 continue
 
             # if the API returns a different unit of measurement from the description, update it
-            if sensor.data.get(field) is not None:
+            if sensor.data is not None and sensor.data.get(field) is not None:
                 native_unit_of_measurement = UNIT_OF_MEASUREMENT_MAP.get(
                     sensor.data[field].get("unit")
                 )
@@ -240,7 +240,9 @@ class LaCrosseViewSensor(
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
+        data = self.coordinator.data[self.index].data
         return (
             super().available
-            and self.entity_description.key in self.coordinator.data[self.index].data
+            and data is not None
+            and self.entity_description.key in data
         )

homeassistant/components/lcn/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/lcn",
   "iot_class": "local_push",
   "loggers": ["pypck"],
-  "requirements": ["pypck==0.8.3", "lcn-frontend==0.2.3"]
+  "requirements": ["pypck==0.8.5", "lcn-frontend==0.2.3"]
 }

homeassistant/components/ld2410_ble/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ld2410_ble",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["bluetooth-data-tools==1.22.0", "ld2410-ble==0.1.1"]
+  "requirements": ["bluetooth-data-tools==1.23.4", "ld2410-ble==0.1.1"]
 }

homeassistant/components/led_ble/manifest.json

@@ -35,5 +35,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/led_ble",
   "iot_class": "local_polling",
-  "requirements": ["bluetooth-data-tools==1.22.0", "led-ble==1.1.4"]
+  "requirements": ["bluetooth-data-tools==1.23.4", "led-ble==1.1.6"]
 }

homeassistant/components/lutron_caseta/device_trigger.py

@@ -277,20 +277,6 @@ FOUR_GROUP_REMOTE_TRIGGER_SCHEMA = LUTRON_BUTTON_TRIGGER_SCHEMA.extend(
     }
 )
 
-PADDLE_SWITCH_PICO_BUTTON_TYPES_TO_LIP = {
-    "button_0": 2,
-    "button_2": 4,
-}
-PADDLE_SWITCH_PICO_BUTTON_TYPES_TO_LEAP = {
-    "button_0": 0,
-    "button_2": 2,
-}
-PADDLE_SWITCH_PICO_TRIGGER_SCHEMA = LUTRON_BUTTON_TRIGGER_SCHEMA.extend(
-    {
-        vol.Required(CONF_SUBTYPE): vol.In(PADDLE_SWITCH_PICO_BUTTON_TYPES_TO_LIP),
-    }
-)
-
 
 DEVICE_TYPE_SCHEMA_MAP = {
     "Pico2Button": PICO_2_BUTTON_TRIGGER_SCHEMA,
@@ -302,7 +288,6 @@ DEVICE_TYPE_SCHEMA_MAP = {
     "Pico4ButtonZone": PICO_4_BUTTON_ZONE_TRIGGER_SCHEMA,
     "Pico4Button2Group": PICO_4_BUTTON_2_GROUP_TRIGGER_SCHEMA,
     "FourGroupRemote": FOUR_GROUP_REMOTE_TRIGGER_SCHEMA,
-    "PaddleSwitchPico": PADDLE_SWITCH_PICO_TRIGGER_SCHEMA,
 }
 
 DEVICE_TYPE_SUBTYPE_MAP_TO_LIP = {
@@ -315,7 +300,6 @@ DEVICE_TYPE_SUBTYPE_MAP_TO_LIP = {
     "Pico4ButtonZone": PICO_4_BUTTON_ZONE_BUTTON_TYPES_TO_LIP,
     "Pico4Button2Group": PICO_4_BUTTON_2_GROUP_BUTTON_TYPES_TO_LIP,
     "FourGroupRemote": FOUR_GROUP_REMOTE_BUTTON_TYPES_TO_LIP,
-    "PaddleSwitchPico": PADDLE_SWITCH_PICO_BUTTON_TYPES_TO_LIP,
 }
 
 DEVICE_TYPE_SUBTYPE_MAP_TO_LEAP = {
@@ -328,7 +312,6 @@ DEVICE_TYPE_SUBTYPE_MAP_TO_LEAP = {
     "Pico4ButtonZone": PICO_4_BUTTON_ZONE_BUTTON_TYPES_TO_LEAP,
     "Pico4Button2Group": PICO_4_BUTTON_2_GROUP_BUTTON_TYPES_TO_LEAP,
     "FourGroupRemote": FOUR_GROUP_REMOTE_BUTTON_TYPES_TO_LEAP,
-    "PaddleSwitchPico": PADDLE_SWITCH_PICO_BUTTON_TYPES_TO_LEAP,
 }
 
 LEAP_TO_DEVICE_TYPE_SUBTYPE_MAP: dict[str, dict[int, str]] = {
@@ -343,7 +326,6 @@ TRIGGER_SCHEMA = vol.Any(
     PICO_4_BUTTON_ZONE_TRIGGER_SCHEMA,
     PICO_4_BUTTON_2_GROUP_TRIGGER_SCHEMA,
     FOUR_GROUP_REMOTE_TRIGGER_SCHEMA,
-    PADDLE_SWITCH_PICO_TRIGGER_SCHEMA,
 )
 
 

homeassistant/components/mcp_server/__init__.py

@@ -6,7 +6,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
-from . import http
+from . import http, llm_api
 from .const import DOMAIN
 from .session import SessionManager
 from .types import MCPServerConfigEntry
@@ -25,6 +25,7 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Model Context Protocol component."""
     http.async_register(hass)
+    llm_api.async_register_api(hass)
     return True
 
 

homeassistant/components/mcp_server/config_flow.py

@@ -16,7 +16,7 @@ from homeassistant.helpers.selector import (
     SelectSelectorConfig,
 )
 
-from .const import DOMAIN
+from .const import DOMAIN, LLM_API, LLM_API_NAME
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,6 +33,12 @@ class ModelContextServerProtocolConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         llm_apis = {api.id: api.name for api in llm.async_get_apis(self.hass)}
+        if LLM_API not in llm_apis:
+            # MCP server component is not loaded yet, so make the LLM API a choice.
+            llm_apis = {
+                LLM_API: LLM_API_NAME,
+                **llm_apis,
+            }
 
         if user_input is not None:
             return self.async_create_entry(

homeassistant/components/mcp_server/const.py

@@ -2,3 +2,5 @@
 
 DOMAIN = "mcp_server"
 TITLE = "Model Context Protocol Server"
+LLM_API = "stateless_assist"
+LLM_API_NAME = "Stateless Assist"

homeassistant/components/mcp_server/llm_api.py

@@ -0,0 +1,48 @@
+"""LLM API for MCP Server."""
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import llm
+from homeassistant.util import yaml as yaml_util
+
+from .const import LLM_API, LLM_API_NAME
+
+EXPOSED_ENTITY_FIELDS = {"name", "domain", "description", "areas", "names"}
+
+
+def async_register_api(hass: HomeAssistant) -> None:
+    """Register the LLM API."""
+    llm.async_register_api(hass, StatelessAssistAPI(hass))
+
+
+class StatelessAssistAPI(llm.AssistAPI):
+    """LLM API for MCP Server that provides the Assist API without state information in the prompt.
+
+    Syncing the state information is possible, but may put unnecessary load on
+    the system so we are instead providing the prompt without entity state. Since
+    actions don't care about the current state, there is little quality loss.
+    """
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize the StatelessAssistAPI."""
+        super().__init__(hass)
+        self.id = LLM_API
+        self.name = LLM_API_NAME
+
+    @callback
+    def _async_get_exposed_entities_prompt(
+        self, llm_context: llm.LLMContext, exposed_entities: dict | None
+    ) -> list[str]:
+        """Return the prompt for the exposed entities."""
+        prompt = []
+
+        if exposed_entities and exposed_entities["entities"]:
+            prompt.append(
+                "An overview of the areas and the devices in this smart home:"
+            )
+            entities = [
+                {k: v for k, v in entity_info.items() if k in EXPOSED_ENTITY_FIELDS}
+                for entity_info in exposed_entities["entities"].values()
+            ]
+            prompt.append(yaml_util.dump(list(entities)))
+
+        return prompt

homeassistant/components/mill/climate.py

@@ -105,10 +105,8 @@ class MillHeater(MillBaseEntity, ClimateEntity):
         self, coordinator: MillDataUpdateCoordinator, device: mill.Heater
     ) -> None:
         """Initialize the thermostat."""
-
-        super().__init__(coordinator, device)
         self._attr_unique_id = device.device_id
-        self._update_attr(device)
+        super().__init__(coordinator, device)
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""

homeassistant/components/mill/entity.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from abc import abstractmethod
 
-from mill import Heater, MillDevice
+from mill import MillDevice
 
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -45,7 +45,7 @@ class MillBaseEntity(CoordinatorEntity[MillDataUpdateCoordinator]):
 
     @abstractmethod
     @callback
-    def _update_attr(self, device: MillDevice | Heater) -> None:
+    def _update_attr(self, device: MillDevice) -> None:
         """Update the attribute of the entity."""
 
     @property

homeassistant/components/mill/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/mill",
   "iot_class": "local_polling",
   "loggers": ["mill", "mill_local"],
-  "requirements": ["millheater==0.12.2", "mill-local==0.3.0"]
+  "requirements": ["millheater==0.12.3", "mill-local==0.3.0"]
 }

homeassistant/components/mill/number.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from mill import MillDevice
+from mill import Heater, MillDevice
 
 from homeassistant.components.number import NumberDeviceClass, NumberEntity
 from homeassistant.config_entries import ConfigEntry
@@ -27,6 +27,7 @@ async def async_setup_entry(
         async_add_entities(
             MillNumber(mill_data_coordinator, mill_device)
             for mill_device in mill_data_coordinator.data.values()
+            if isinstance(mill_device, Heater)
         )
 
 
@@ -45,9 +46,8 @@ class MillNumber(MillBaseEntity, NumberEntity):
         mill_device: MillDevice,
     ) -> None:
         """Initialize the number."""
-        super().__init__(coordinator, mill_device)
         self._attr_unique_id = f"{mill_device.device_id}_max_heating_power"
-        self._update_attr(mill_device)
+        super().__init__(coordinator, mill_device)
 
     @callback
     def _update_attr(self, device: MillDevice) -> None:

homeassistant/components/mill/sensor.py

@@ -192,9 +192,9 @@ class MillSensor(MillBaseEntity, SensorEntity):
         mill_device: mill.Socket | mill.Heater,
     ) -> None:
         """Initialize the sensor."""
-        super().__init__(coordinator, mill_device)
         self.entity_description = entity_description
         self._attr_unique_id = f"{mill_device.device_id}_{entity_description.key}"
+        super().__init__(coordinator, mill_device)
 
     @callback
     def _update_attr(self, device):

homeassistant/components/monarch_money/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/monarchmoney",
   "iot_class": "cloud_polling",
-  "requirements": ["typedmonarchmoney==0.3.1"]
+  "requirements": ["typedmonarchmoney==0.4.4"]
 }

homeassistant/components/mopeka/config_flow.py

@@ -111,7 +111,7 @@ class MopekaConfigFlow(ConfigFlow, domain=DOMAIN):
                 data={CONF_MEDIUM_TYPE: user_input[CONF_MEDIUM_TYPE]},
             )
 
-        current_addresses = self._async_current_ids()
+        current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/motionmount/entity.py

@@ -28,7 +28,7 @@ class MotionMountEntity(Entity):
         self.config_entry = config_entry
 
         # We store the pin, as we might need it during reconnect
-        self.pin = config_entry.data[CONF_PIN]
+        self.pin = config_entry.data.get(CONF_PIN)
 
         mac = format_mac(mm.mac.hex())
 

homeassistant/components/mqtt/__init__.py

@@ -236,7 +236,7 @@ CONFIG_SCHEMA = vol.Schema(
 MQTT_PUBLISH_SCHEMA = vol.Schema(
     {
         vol.Required(ATTR_TOPIC): valid_publish_topic,
-        vol.Required(ATTR_PAYLOAD): cv.string,
+        vol.Required(ATTR_PAYLOAD, default=None): vol.Any(cv.string, None),
         vol.Optional(ATTR_EVALUATE_PAYLOAD): cv.boolean,
         vol.Optional(ATTR_QOS, default=DEFAULT_QOS): valid_qos_schema,
         vol.Optional(ATTR_RETAIN, default=DEFAULT_RETAIN): cv.boolean,

homeassistant/components/mqtt/config_flow.py

@@ -485,7 +485,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
             errors,
         ):
             if is_reconfigure:
-                update_password_from_user_input(
+                validated_user_input = update_password_from_user_input(
                     reconfigure_entry.data.get(CONF_PASSWORD), validated_user_input
                 )
 

homeassistant/components/mqtt/services.yaml

@@ -8,7 +8,6 @@ publish:
       selector:
         text:
     payload:
-      required: true
       example: "The temperature is {{ states('sensor.temperature') }}"
       selector:
         template:

homeassistant/components/mqtt/strings.json

@@ -246,11 +246,7 @@
         },
         "payload": {
           "name": "Payload",
-          "description": "The payload to publish."
-        },
-        "payload_template": {
-          "name": "Payload template",
-          "description": "Template to render as a payload value. If a payload is provided, the template is ignored."
+          "description": "The payload to publish. Publishes an empty message if not provided."
         },
         "qos": {
           "name": "QoS",

homeassistant/components/nest/__init__.py

@@ -8,7 +8,7 @@ from collections.abc import Awaitable, Callable
 from http import HTTPStatus
 import logging
 
-from aiohttp import web
+from aiohttp import ClientError, ClientResponseError, web
 from google_nest_sdm.camera_traits import CameraClipPreviewTrait
 from google_nest_sdm.device import Device
 from google_nest_sdm.event import EventMessage
@@ -198,7 +198,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: NestConfigEntry) -> bool
             entry, unique_id=entry.data[CONF_PROJECT_ID]
         )
 
-    subscriber = await api.new_subscriber(hass, entry)
+    auth = await api.new_auth(hass, entry)
+    try:
+        await auth.async_get_access_token()
+    except ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed from err
+        raise ConfigEntryNotReady from err
+    except ClientError as err:
+        raise ConfigEntryNotReady from err
+
+    subscriber = await api.new_subscriber(hass, entry, auth)
     if not subscriber:
         return False
     # Keep media for last N events in memory

homeassistant/components/nest/api.py

@@ -50,13 +50,14 @@ class AsyncConfigEntryAuth(AbstractAuth):
         return cast(str, self._oauth_session.token["access_token"])
 
     async def async_get_creds(self) -> Credentials:
-        """Return an OAuth credential for Pub/Sub Subscriber."""
-        # We don't have a way for Home Assistant to refresh creds on behalf
-        # of the google pub/sub subscriber. Instead, build a full
-        # Credentials object with enough information for the subscriber to
-        # handle this on its own. We purposely don't refresh the token here
-        # even when it is expired to fully hand off this responsibility and
-        # know it is working at startup (then if not, fail loudly).
+        """Return an OAuth credential for Pub/Sub Subscriber.
+
+        The subscriber will call this when connecting to the stream to refresh
+        the token. We construct a credentials object using the underlying
+        OAuth2Session since the subscriber may expect the expiry fields to
+        be present.
+        """
+        await self.async_get_access_token()
         token = self._oauth_session.token
         creds = Credentials(  # type: ignore[no-untyped-call]
             token=token["access_token"],
@@ -101,9 +102,7 @@ class AccessTokenAuthImpl(AbstractAuth):
         )
 
 
-async def new_subscriber(
-    hass: HomeAssistant, entry: NestConfigEntry
-) -> GoogleNestSubscriber | None:
+async def new_auth(hass: HomeAssistant, entry: NestConfigEntry) -> AbstractAuth:
     """Create a GoogleNestSubscriber."""
     implementation = (
         await config_entry_oauth2_flow.async_get_config_entry_implementation(
@@ -114,14 +113,22 @@ async def new_subscriber(
         implementation, config_entry_oauth2_flow.LocalOAuth2Implementation
     ):
         raise TypeError(f"Unexpected auth implementation {implementation}")
-    if (subscription_name := entry.data.get(CONF_SUBSCRIPTION_NAME)) is None:
-        subscription_name = entry.data[CONF_SUBSCRIBER_ID]
-    auth = AsyncConfigEntryAuth(
+    return AsyncConfigEntryAuth(
         aiohttp_client.async_get_clientsession(hass),
         config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation),
         implementation.client_id,
         implementation.client_secret,
     )
+
+
+async def new_subscriber(
+    hass: HomeAssistant,
+    entry: NestConfigEntry,
+    auth: AbstractAuth,
+) -> GoogleNestSubscriber:
+    """Create a GoogleNestSubscriber."""
+    if (subscription_name := entry.data.get(CONF_SUBSCRIPTION_NAME)) is None:
+        subscription_name = entry.data[CONF_SUBSCRIBER_ID]
     return GoogleNestSubscriber(auth, entry.data[CONF_PROJECT_ID], subscription_name)
 
 

homeassistant/components/nest/manifest.json

@@ -19,5 +19,5 @@
   "documentation": "https://www.home-assistant.io/integrations/nest",
   "iot_class": "cloud_push",
   "loggers": ["google_nest_sdm"],
-  "requirements": ["google-nest-sdm==7.1.1"]
+  "requirements": ["google-nest-sdm==7.1.3"]
 }

homeassistant/components/nordpool/services.py

@@ -41,7 +41,7 @@ ATTR_CURRENCY = "currency"
 SERVICE_GET_PRICES_FOR_DATE = "get_prices_for_date"
 SERVICE_GET_PRICES_SCHEMA = vol.Schema(
     {
-        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Required(ATTR_DATE): cv.date,
         vol.Optional(ATTR_AREAS): vol.All(vol.In(list(AREAS)), cv.ensure_list, [str]),
         vol.Optional(ATTR_CURRENCY): vol.All(

homeassistant/components/ohme/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "cloud_polling",
   "quality_scale": "silver",
-  "requirements": ["ohme==1.2.8"]
+  "requirements": ["ohme==1.2.9"]
 }