Fixes from feedback

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

.claude/skills/integrations/SKILL.md

@@ -620,12 +620,14 @@ rules:
 
 ### Config Flow Testing
 - **100% Coverage Required**: All config flow paths must be tested
+- **Patch Boundaries**: Only patch library or client methods when testing config flows. Do not patch methods defined in `config_flow.py`; exercise the flow logic end-to-end.
 - **Test Scenarios**:
   - All flow initiation methods (user, discovery, import)
   - Successful configuration paths
   - Error recovery scenarios
   - Prevention of duplicate entries
   - Flow completion after errors
+  - Reauthentication/reconfigure flows
 
 ### Testing
 - **Integration-specific tests** (recommended):

.gitattributes

@@ -16,6 +16,7 @@ Dockerfile.dev linguist-language=Dockerfile
 CODEOWNERS linguist-generated=true
 Dockerfile linguist-generated=true
 homeassistant/generated/*.py linguist-generated=true
+machine/* linguist-generated=true
 mypy.ini linguist-generated=true
 requirements.txt linguist-generated=true
 requirements_all.txt linguist-generated=true

.github/workflows/builder.yml

@@ -35,6 +35,7 @@ jobs:
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
       architectures: ${{ env.ARCHITECTURES }}
+      base_image_version: ${{ env.BASE_IMAGE_VERSION }}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -100,7 +101,7 @@ jobs:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
         include:
           - arch: amd64
-            os: ubuntu-latest
+            os: ubuntu-24.04
           - arch: aarch64
             os: ubuntu-24.04-arm
     steps:
@@ -195,77 +196,20 @@ jobs:
         run: |
           echo "${GITHUB_SHA};${GITHUB_REF};${GITHUB_EVENT_NAME};${GITHUB_ACTOR}" > rootfs/OFFICIAL_IMAGE
 
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
-        with:
-          cosign-release: "v2.5.3"
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
-
-      - name: Build variables
-        id: vars
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: |
-          echo "base_image=ghcr.io/home-assistant/${ARCH}-homeassistant-base:${BASE_IMAGE_VERSION}" >> "$GITHUB_OUTPUT"
-          echo "cache_image=ghcr.io/home-assistant/${ARCH}-homeassistant:latest" >> "$GITHUB_OUTPUT"
-          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
-
-      - name: Verify base image signature
-        env:
-          BASE_IMAGE: ${{ steps.vars.outputs.base_image }}
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
-            "${BASE_IMAGE}"
-
-      - name: Verify cache image signature
-        id: cache
-        continue-on-error: true
-        env:
-          CACHE_IMAGE: ${{ steps.vars.outputs.cache_image }}
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
-            "${CACHE_IMAGE}"
-
       - name: Build base image
-        id: build
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
         with:
-          context: .
-          file: ./Dockerfile
-          platforms: ${{ steps.vars.outputs.platform }}
-          push: true
-          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
+          arch: ${{ matrix.arch }}
           build-args: |
-            BUILD_FROM=${{ steps.vars.outputs.base_image }}
-          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          outputs: type=image,push=true,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
-          labels: |
-            io.hass.arch=${{ matrix.arch }}
-            io.hass.version=${{ needs.init.outputs.version }}
-            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
-            org.opencontainers.image.version=${{ needs.init.outputs.version }}
-
-      - name: Sign image
-        env:
-          ARCH: ${{ matrix.arch }}
-          VERSION: ${{ needs.init.outputs.version }}
-          DIGEST: ${{ steps.build.outputs.digest }}
-        run: |
-          cosign sign --yes "ghcr.io/home-assistant/${ARCH}-homeassistant:${VERSION}@${DIGEST}"
+            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
+          cache-gha: false
+          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
+          cosign-base-identity: "https://github.com/home-assistant/docker/.*"
+          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
+          image: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant
+          image-tags: ${{ needs.init.outputs.version }}
+          push: true
+          version: ${{ needs.init.outputs.version }}
 
   build_machine:
     name: Build ${{ matrix.machine }} machine core image
@@ -314,35 +258,38 @@ jobs:
         with:
           persist-credentials: false
 
-      - name: Set build additional args
+      - name: Compute extra tags
+        id: tags
+        shell: bash
         env:
           VERSION: ${{ needs.init.outputs.version }}
         run: |
-          # Create general tags
           if [[ "${VERSION}" =~ d ]]; then
-            echo "BUILD_ARGS=--additional-tag dev" >> $GITHUB_ENV
+            echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
           elif [[ "${VERSION}" =~ b ]]; then
-            echo "BUILD_ARGS=--additional-tag beta" >> $GITHUB_ENV
+            echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
           else
-            echo "BUILD_ARGS=--additional-tag stable" >> $GITHUB_ENV
+            echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+      - name: Build machine image
+        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
         with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build base image
-        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
-        with:
-          image: ${{ matrix.arch }}
-          args: |
-            $BUILD_ARGS \
-            --target /data/machine \
-            --cosign \
-            --machine "${{ needs.init.outputs.version }}=${{ matrix.machine }}"
+          arch: ${{ matrix.arch }}
+          build-args: |
+            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          cache-gha: false
+          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
+          context: machine/
+          cosign-base-identity: "https://github.com/home-assistant/core/.*"
+          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          file: machine/${{ matrix.machine }}
+          image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
+          image-tags: |
+            ${{ needs.init.outputs.version }}
+            ${{ steps.tags.outputs.extra_tags }}
+          push: true
+          version: ${{ needs.init.outputs.version }}
 
   publish_ha:
     name: Publish version files

.strict-typing

@@ -173,6 +173,7 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
+homeassistant.components.dropbox.*
 homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*

CODEOWNERS

@@ -397,6 +397,8 @@ build.json @home-assistant/supervisor
 /tests/components/dremel_3d_printer/ @tkdrob
 /homeassistant/components/drop_connect/ @ChandlerSystems @pfrazer
 /tests/components/drop_connect/ @ChandlerSystems @pfrazer
+/homeassistant/components/dropbox/ @bdr99
+/tests/components/dropbox/ @bdr99
 /homeassistant/components/droplet/ @sarahseidman
 /tests/components/droplet/ @sarahseidman
 /homeassistant/components/dsmr/ @Robbie1221
@@ -1616,8 +1618,6 @@ build.json @home-assistant/supervisor
 /tests/components/srp_energy/ @briglx
 /homeassistant/components/starline/ @anonym-tsk
 /tests/components/starline/ @anonym-tsk
-/homeassistant/components/starlink/ @boswelja
-/tests/components/starlink/ @boswelja
 /homeassistant/components/statistics/ @ThomDietrich @gjohansson-ST
 /tests/components/statistics/ @ThomDietrich @gjohansson-ST
 /homeassistant/components/steam_online/ @tkdrob

Dockerfile

@@ -10,7 +10,6 @@ LABEL \
     org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
     org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
     org.opencontainers.image.licenses="Apache-2.0" \
-    org.opencontainers.image.source="https://github.com/home-assistant/core" \
     org.opencontainers.image.title="Home Assistant" \
     org.opencontainers.image.url="https://www.home-assistant.io/"
 

homeassistant/components/actron_air/config_flow.py

@@ -120,7 +120,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="timeout",
             )
-        del self.login_task
+        self.login_task = None
         return await self.async_step_user()
 
     async def async_step_reauth(

homeassistant/components/actron_air/manifest.json

@@ -12,6 +12,6 @@
   "documentation": "https://www.home-assistant.io/integrations/actron_air",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
   "requirements": ["actron-neo-api==0.4.1"]
 }

homeassistant/components/actron_air/quality_scale.yaml

@@ -37,7 +37,7 @@ rules:
   log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: done
-  test-coverage: todo
+  test-coverage: done
 
   # Gold
   devices: done

homeassistant/components/aladdin_connect/__init__.py

@@ -46,19 +46,10 @@ async def async_setup_entry(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    try:
-        doors = await client.get_doors()
-    except aiohttp.ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(err) from err
-        raise ConfigEntryNotReady from err
-    except aiohttp.ClientError as err:
-        raise ConfigEntryNotReady from err
+    coordinator = AladdinConnectCoordinator(hass, entry, client)
+    await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = {
-        door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)
-        for door in doors
-    }
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -100,7 +91,7 @@ def remove_stale_devices(
     device_entries = dr.async_entries_for_config_entry(
         device_registry, config_entry.entry_id
     )
-    all_device_ids = set(config_entry.runtime_data)
+    all_device_ids = set(config_entry.runtime_data.data)
 
     for device_entry in device_entries:
         device_id: str | None = None

homeassistant/components/aladdin_connect/coordinator.py

@@ -11,22 +11,24 @@ from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 _LOGGER = logging.getLogger(__name__)
-type AladdinConnectConfigEntry = ConfigEntry[dict[str, AladdinConnectCoordinator]]
+type AladdinConnectConfigEntry = ConfigEntry[AladdinConnectCoordinator]
 SCAN_INTERVAL = timedelta(seconds=15)
 
 
-class AladdinConnectCoordinator(DataUpdateCoordinator[GarageDoor]):
+class AladdinConnectCoordinator(DataUpdateCoordinator[dict[str, GarageDoor]]):
     """Coordinator for Aladdin Connect integration."""
 
+    config_entry: AladdinConnectConfigEntry
+
     def __init__(
         self,
         hass: HomeAssistant,
         entry: AladdinConnectConfigEntry,
         client: AladdinConnectClient,
-        garage_door: GarageDoor,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(
@@ -37,18 +39,16 @@ class AladdinConnectCoordinator(DataUpdateCoordinator[GarageDoor]):
             update_interval=SCAN_INTERVAL,
         )
         self.client = client
-        self.data = garage_door
 
-    async def _async_update_data(self) -> GarageDoor:
+    async def _async_update_data(self) -> dict[str, GarageDoor]:
         """Fetch data from the Aladdin Connect API."""
         try:
-            await self.client.update_door(self.data.device_id, self.data.door_number)
+            doors = await self.client.get_doors()
+        except aiohttp.ClientResponseError as err:
+            if 400 <= err.status < 500:
+                raise ConfigEntryAuthFailed(err) from err
+            raise UpdateFailed(f"Error communicating with API: {err}") from err
         except aiohttp.ClientError as err:
             raise UpdateFailed(f"Error communicating with API: {err}") from err
-        self.data.status = self.client.get_door_status(
-            self.data.device_id, self.data.door_number
-        )
-        self.data.battery_level = self.client.get_battery_status(
-            self.data.device_id, self.data.door_number
-        )
-        return self.data
+
+        return {door.unique_id: door for door in doors}

homeassistant/components/aladdin_connect/cover.py

@@ -7,7 +7,7 @@ from typing import Any
 import aiohttp
 
 from homeassistant.components.cover import CoverDeviceClass, CoverEntity
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -24,11 +24,22 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the cover platform."""
-    coordinators = entry.runtime_data
+    coordinator = entry.runtime_data
+    known_devices: set[str] = set()
 
-    async_add_entities(
-        AladdinCoverEntity(coordinator) for coordinator in coordinators.values()
-    )
+    @callback
+    def _async_add_new_devices() -> None:
+        """Detect and add entities for new doors."""
+        current_devices = set(coordinator.data)
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                AladdinCoverEntity(coordinator, door_id) for door_id in new_devices
+            )
+
+    _async_add_new_devices()
+    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_devices))
 
 
 class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
@@ -38,10 +49,10 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     _attr_supported_features = SUPPORTED_FEATURES
     _attr_name = None
 
-    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
         """Initialize the Aladdin Connect cover."""
-        super().__init__(coordinator)
-        self._attr_unique_id = coordinator.data.unique_id
+        super().__init__(coordinator, door_id)
+        self._attr_unique_id = door_id
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Issue open command to cover."""
@@ -66,16 +77,16 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     @property
     def is_closed(self) -> bool | None:
         """Update is closed attribute."""
-        if (status := self.coordinator.data.status) is None:
+        if (status := self.door.status) is None:
             return None
         return status == "closed"
 
     @property
     def is_closing(self) -> bool | None:
         """Update is closing attribute."""
-        return self.coordinator.data.status == "closing"
+        return self.door.status == "closing"
 
     @property
     def is_opening(self) -> bool | None:
         """Update is opening attribute."""
-        return self.coordinator.data.status == "opening"
+        return self.door.status == "opening"

homeassistant/components/aladdin_connect/diagnostics.py

@@ -20,13 +20,13 @@ async def async_get_config_entry_diagnostics(
         "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
         "doors": {
             uid: {
-                "device_id": coordinator.data.device_id,
-                "door_number": coordinator.data.door_number,
-                "name": coordinator.data.name,
-                "status": coordinator.data.status,
-                "link_status": coordinator.data.link_status,
-                "battery_level": coordinator.data.battery_level,
+                "device_id": door.device_id,
+                "door_number": door.door_number,
+                "name": door.name,
+                "status": door.status,
+                "link_status": door.link_status,
+                "battery_level": door.battery_level,
             }
-            for uid, coordinator in config_entry.runtime_data.items()
+            for uid, door in config_entry.runtime_data.data.items()
         },
     }

homeassistant/components/aladdin_connect/entity.py

@@ -1,6 +1,7 @@
 """Base class for Aladdin Connect entities."""
 
 from genie_partner_sdk.client import AladdinConnectClient
+from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -14,17 +15,28 @@ class AladdinConnectEntity(CoordinatorEntity[AladdinConnectCoordinator]):
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
         """Initialize Aladdin Connect entity."""
         super().__init__(coordinator)
-        device = coordinator.data
+        self._door_id = door_id
+        door = self.door
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.unique_id)},
+            identifiers={(DOMAIN, door.unique_id)},
             manufacturer="Aladdin Connect",
-            name=device.name,
+            name=door.name,
         )
-        self._device_id = device.device_id
-        self._number = device.door_number
+        self._device_id = door.device_id
+        self._number = door.door_number
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and self._door_id in self.coordinator.data
+
+    @property
+    def door(self) -> GarageDoor:
+        """Return the garage door data."""
+        return self.coordinator.data[self._door_id]
 
     @property
     def client(self) -> AladdinConnectClient:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -57,7 +57,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done

homeassistant/components/aladdin_connect/sensor.py

@@ -14,7 +14,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
@@ -49,13 +49,24 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Aladdin Connect sensor devices."""
-    coordinators = entry.runtime_data
+    coordinator = entry.runtime_data
+    known_devices: set[str] = set()
 
-    async_add_entities(
-        AladdinConnectSensor(coordinator, description)
-        for coordinator in coordinators.values()
-        for description in SENSOR_TYPES
-    )
+    @callback
+    def _async_add_new_devices() -> None:
+        """Detect and add entities for new doors."""
+        current_devices = set(coordinator.data)
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                AladdinConnectSensor(coordinator, door_id, description)
+                for door_id in new_devices
+                for description in SENSOR_TYPES
+            )
+
+    _async_add_new_devices()
+    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_devices))
 
 
 class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
@@ -66,14 +77,15 @@ class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
     def __init__(
         self,
         coordinator: AladdinConnectCoordinator,
+        door_id: str,
         entity_description: AladdinConnectSensorEntityDescription,
     ) -> None:
         """Initialize the Aladdin Connect sensor."""
-        super().__init__(coordinator)
+        super().__init__(coordinator, door_id)
         self.entity_description = entity_description
-        self._attr_unique_id = f"{coordinator.data.unique_id}-{entity_description.key}"
+        self._attr_unique_id = f"{door_id}-{entity_description.key}"
 
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
-        return self.entity_description.value_fn(self.coordinator.data)
+        return self.entity_description.value_fn(self.door)

homeassistant/components/automation/__init__.py

@@ -123,16 +123,23 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "climate",
     "cover",
     "device_tracker",
+    "door",
     "fan",
+    "garage_door",
+    "gate",
     "humidifier",
     "lawn_mower",
     "light",
     "lock",
     "media_player",
+    "motion",
+    "occupancy",
     "person",
+    "schedule",
     "siren",
     "switch",
     "vacuum",
+    "window",
 }
 
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {
@@ -159,6 +166,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "remote",
     "scene",
     "schedule",
+    "select",
     "siren",
     "switch",
     "text",

homeassistant/components/axis/manifest.json

@@ -29,7 +29,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["axis"],
-  "requirements": ["axis==66"],
+  "requirements": ["axis==67"],
   "ssdp": [
     {
       "manufacturer": "AXIS"

homeassistant/components/backup/util.py

@@ -246,6 +246,8 @@ def decrypt_backup(
         except (DecryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error decrypting backup: %s", err)
             error = err
+        except Abort:
+            raise
         except Exception as err:  # noqa: BLE001
             LOGGER.exception("Unexpected error when decrypting backup: %s", err)
             error = err
@@ -332,8 +334,10 @@ def encrypt_backup(
         except (EncryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error encrypting backup: %s", err)
             error = err
+        except Abort:
+            raise
         except Exception as err:  # noqa: BLE001
-            LOGGER.exception("Unexpected error when decrypting backup: %s", err)
+            LOGGER.exception("Unexpected error when encrypting backup: %s", err)
             error = err
         else:
             # Pad the output stream to the requested minimum size

homeassistant/components/bsblan/config_flow.py

@@ -183,90 +183,122 @@ class BSBLANFlowHandler(ConfigFlow, domain=DOMAIN):
         existing_entry = self._get_reauth_entry()
 
         if user_input is None:
-            # Preserve existing values as defaults
             return self.async_show_form(
                 step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=existing_entry.data.get(
-                                CONF_PASSKEY, vol.UNDEFINED
-                            ),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=existing_entry.data.get(
-                                CONF_USERNAME, vol.UNDEFINED
-                            ),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
+                data_schema=self._build_credentials_schema(existing_entry.data),
             )
 
-        # Combine existing data with the user's new input for validation.
-        # This correctly handles adding, changing, and clearing credentials.
-        config_data = existing_entry.data.copy()
-        config_data.update(user_input)
+        # Merge existing data with user input for validation
+        validate_data = {**existing_entry.data, **user_input}
+        errors = await self._async_validate_credentials(validate_data)
 
-        self.host = config_data[CONF_HOST]
-        self.port = config_data[CONF_PORT]
-        self.passkey = config_data.get(CONF_PASSKEY)
-        self.username = config_data.get(CONF_USERNAME)
-        self.password = config_data.get(CONF_PASSWORD)
+        if errors:
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                data_schema=self._build_credentials_schema(user_input),
+                errors=errors,
+            )
 
+        return self.async_update_reload_and_abort(
+            existing_entry, data_updates=user_input, reason="reauth_successful"
+        )
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration flow."""
+        existing_entry = self._get_reconfigure_entry()
+
+        if user_input is None:
+            return self.async_show_form(
+                step_id="reconfigure",
+                data_schema=self._build_connection_schema(existing_entry.data),
+            )
+
+        # Merge existing data with user input for validation
+        validate_data = {**existing_entry.data, **user_input}
+        errors = await self._async_validate_credentials(validate_data)
+
+        if errors:
+            return self.async_show_form(
+                step_id="reconfigure",
+                data_schema=self._build_connection_schema(user_input),
+                errors=errors,
+            )
+
+        # Prevent reconfiguring to a different physical device
+        # it gets the unique ID from the device info when it validates credentials
+        self._abort_if_unique_id_mismatch()
+
+        return self.async_update_reload_and_abort(
+            existing_entry,
+            data_updates=user_input,
+            reason="reconfigure_successful",
+        )
+
+    async def _async_validate_credentials(self, data: dict[str, Any]) -> dict[str, str]:
+        """Validate connection credentials and return errors dict."""
+        self.host = data[CONF_HOST]
+        self.port = data.get(CONF_PORT, DEFAULT_PORT)
+        self.passkey = data.get(CONF_PASSKEY)
+        self.username = data.get(CONF_USERNAME)
+        self.password = data.get(CONF_PASSWORD)
+
+        errors: dict[str, str] = {}
         try:
             await self._get_bsblan_info(raise_on_progress=False, is_reauth=True)
         except BSBLANAuthError:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=user_input.get(CONF_PASSKEY, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=user_input.get(CONF_USERNAME, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
-                errors={"base": "invalid_auth"},
-            )
+            errors["base"] = "invalid_auth"
         except BSBLANError:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=user_input.get(CONF_PASSKEY, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=user_input.get(CONF_USERNAME, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
-                errors={"base": "cannot_connect"},
-            )
+            errors["base"] = "cannot_connect"
+        return errors
 
-        # Update only the fields that were provided by the user
-        return self.async_update_reload_and_abort(
-            existing_entry, data_updates=user_input, reason="reauth_successful"
+    @callback
+    def _build_credentials_schema(self, defaults: Mapping[str, Any]) -> vol.Schema:
+        """Build schema for credentials-only forms (reauth)."""
+        return vol.Schema(
+            {
+                vol.Optional(
+                    CONF_PASSKEY,
+                    default=defaults.get(CONF_PASSKEY) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_USERNAME,
+                    default=defaults.get(CONF_USERNAME) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_PASSWORD,
+                    default=vol.UNDEFINED,
+                ): str,
+            }
+        )
+
+    @callback
+    def _build_connection_schema(self, defaults: Mapping[str, Any]) -> vol.Schema:
+        """Build schema for full connection forms (user and reconfigure)."""
+        return vol.Schema(
+            {
+                vol.Required(
+                    CONF_HOST,
+                    default=defaults.get(CONF_HOST, vol.UNDEFINED),
+                ): str,
+                vol.Optional(
+                    CONF_PORT,
+                    default=defaults.get(CONF_PORT, DEFAULT_PORT),
+                ): int,
+                vol.Optional(
+                    CONF_PASSKEY,
+                    default=defaults.get(CONF_PASSKEY) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_USERNAME,
+                    default=defaults.get(CONF_USERNAME) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_PASSWORD,
+                    default=vol.UNDEFINED,
+                ): str,
+            }
         )
 
     @callback
@@ -274,32 +306,9 @@ class BSBLANFlowHandler(ConfigFlow, domain=DOMAIN):
         self, errors: dict | None = None, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Show the setup form to the user."""
-        # Preserve user input if provided, otherwise use defaults
-        defaults = user_input or {}
-
         return self.async_show_form(
             step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_HOST, default=defaults.get(CONF_HOST, vol.UNDEFINED)
-                    ): str,
-                    vol.Optional(
-                        CONF_PORT, default=defaults.get(CONF_PORT, DEFAULT_PORT)
-                    ): int,
-                    vol.Optional(
-                        CONF_PASSKEY, default=defaults.get(CONF_PASSKEY, vol.UNDEFINED)
-                    ): str,
-                    vol.Optional(
-                        CONF_USERNAME,
-                        default=defaults.get(CONF_USERNAME, vol.UNDEFINED),
-                    ): str,
-                    vol.Optional(
-                        CONF_PASSWORD,
-                        default=defaults.get(CONF_PASSWORD, vol.UNDEFINED),
-                    ): str,
-                }
-            ),
+            data_schema=self._build_connection_schema(user_input or {}),
             errors=errors or {},
         )
 

homeassistant/components/bsblan/quality_scale.yaml

@@ -58,7 +58,7 @@ rules:
   entity-translations: done
   exception-translations: done
   icon-translations: todo
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: |

homeassistant/components/bsblan/strings.json

@@ -3,7 +3,9 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "unique_id_mismatch": "The device you are trying to reconfigure is not the same as the one previously configured."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -39,6 +41,24 @@
         "description": "The BSB-LAN integration needs to re-authenticate with {name}",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "passkey": "[%key:component::bsblan::config::step::user::data::passkey%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "port": "[%key:common::config_flow::data::port%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "host": "[%key:component::bsblan::config::step::user::data_description::host%]",
+          "passkey": "[%key:component::bsblan::config::step::user::data_description::passkey%]",
+          "password": "[%key:component::bsblan::config::step::user::data_description::password%]",
+          "port": "[%key:component::bsblan::config::step::user::data_description::port%]",
+          "username": "[%key:component::bsblan::config::step::user::data_description::username%]"
+        },
+        "description": "Update connection settings for your BSB-LAN device.",
+        "title": "Reconfigure BSB-LAN"
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",

homeassistant/components/clementine/media_player.py

@@ -66,6 +66,7 @@ class ClementineDevice(MediaPlayerEntity):
         | MediaPlayerEntityFeature.SELECT_SOURCE
         | MediaPlayerEntityFeature.PLAY
     )
+    _attr_volume_step = 0.04
 
     def __init__(self, client, name):
         """Initialize the Clementine device."""
@@ -124,16 +125,6 @@ class ClementineDevice(MediaPlayerEntity):
 
         return None, None
 
-    def volume_up(self) -> None:
-        """Volume up the media player."""
-        newvolume = min(self._client.volume + 4, 100)
-        self._client.set_volume(newvolume)
-
-    def volume_down(self) -> None:
-        """Volume down media player."""
-        newvolume = max(self._client.volume - 4, 0)
-        self._client.set_volume(newvolume)
-
     def mute_volume(self, mute: bool) -> None:
         """Send mute command."""
         self._client.set_volume(0)

homeassistant/components/cover/__init__.py

@@ -32,6 +32,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 
+from .condition import make_cover_is_closed_condition, make_cover_is_open_condition
 from .const import (
     ATTR_CURRENT_POSITION,
     ATTR_CURRENT_TILT_POSITION,
@@ -80,6 +81,8 @@ __all__ = [
     "CoverEntityFeature",
     "CoverState",
     "make_cover_closed_trigger",
+    "make_cover_is_closed_condition",
+    "make_cover_is_open_condition",
     "make_cover_opened_trigger",
 ]
 

homeassistant/components/demo/valve.py

@@ -9,9 +9,12 @@ from typing import Any
 from homeassistant.components.valve import ValveEntity, ValveEntityFeature, ValveState
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_track_utc_time_change
 
+from . import DOMAIN
+
 OPEN_CLOSE_DELAY = 2  # Used to give a realistic open/close experience in frontend
 
 
@@ -23,10 +26,10 @@ async def async_setup_entry(
     """Set up the Demo config entry."""
     async_add_entities(
         [
-            DemoValve("Front Garden", ValveState.OPEN),
-            DemoValve("Orchard", ValveState.CLOSED),
-            DemoValve("Back Garden", ValveState.CLOSED, position=70),
-            DemoValve("Trees", ValveState.CLOSED, position=30),
+            DemoValve("valve_1", "Front Garden", ValveState.OPEN),
+            DemoValve("valve_2", "Orchard", ValveState.CLOSED),
+            DemoValve("valve_3", "Back Garden", ValveState.CLOSED, position=70),
+            DemoValve("valve_4", "Trees", ValveState.CLOSED, position=30),
         ]
     )
 
@@ -34,17 +37,24 @@ async def async_setup_entry(
 class DemoValve(ValveEntity):
     """Representation of a Demo valve."""
 
+    _attr_has_entity_name = True
+    _attr_name = None
     _attr_should_poll = False
 
     def __init__(
         self,
+        unique_id: str,
         name: str,
         state: str,
         moveable: bool = True,
         position: int | None = None,
     ) -> None:
         """Initialize the valve."""
-        self._attr_name = name
+        self._attr_unique_id = unique_id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, unique_id)},
+            name=name,
+        )
         if moveable:
             self._attr_supported_features = (
                 ValveEntityFeature.OPEN | ValveEntityFeature.CLOSE

homeassistant/components/door/condition.py

@@ -0,0 +1,29 @@
+"""Provides conditions for doors."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_DOOR: dict[str, str] = {
+    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.DOOR,
+    COVER_DOMAIN: CoverDeviceClass.DOOR,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(device_classes=DEVICE_CLASSES_DOOR),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_DOOR),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for doors."""
+    return CONDITIONS

homeassistant/components/door/conditions.yaml

@@ -0,0 +1,28 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: door
+      - domain: cover
+        device_class: door
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: door
+      - domain: cover
+        device_class: door

homeassistant/components/door/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:door-closed"
+    },
+    "is_open": {
+      "condition": "mdi:door-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:door-closed"

homeassistant/components/door/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted doors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted doors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more doors are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::door::common::condition_behavior_description%]",
+          "name": "[%key:component::door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Door is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more doors are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::door::common::condition_behavior_description%]",
+          "name": "[%key:component::door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Door is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/dropbox/__init__.py

@@ -0,0 +1,64 @@
+"""The Dropbox integration."""
+
+from __future__ import annotations
+
+from python_dropbox_api import (
+    DropboxAPIClient,
+    DropboxAuthException,
+    DropboxUnknownException,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import aiohttp_client
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    ImplementationUnavailableError,
+    OAuth2Session,
+    async_get_config_entry_implementation,
+)
+
+from .auth import DropboxConfigEntryAuth
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+
+type DropboxConfigEntry = ConfigEntry[DropboxAPIClient]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> bool:
+    """Set up Dropbox from a config entry."""
+    try:
+        oauth2_implementation = await async_get_config_entry_implementation(hass, entry)
+    except ImplementationUnavailableError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="oauth2_implementation_unavailable",
+        ) from err
+    oauth2_session = OAuth2Session(hass, entry, oauth2_implementation)
+
+    auth = DropboxConfigEntryAuth(
+        aiohttp_client.async_get_clientsession(hass), oauth2_session
+    )
+
+    client = DropboxAPIClient(auth)
+
+    try:
+        await client.get_account_info()
+    except DropboxAuthException as err:
+        raise ConfigEntryAuthFailed from err
+    except (DropboxUnknownException, TimeoutError) as err:
+        raise ConfigEntryNotReady from err
+
+    entry.runtime_data = client
+
+    def async_notify_backup_listeners() -> None:
+        for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
+            listener()
+
+    entry.async_on_unload(entry.async_on_state_change(async_notify_backup_listeners))
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> bool:
+    """Unload a config entry."""
+    return True

homeassistant/components/dropbox/application_credentials.py

@@ -0,0 +1,38 @@
+"""Application credentials platform for the Dropbox integration."""
+
+from homeassistant.components.application_credentials import ClientCredential
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    AbstractOAuth2Implementation,
+    LocalOAuth2ImplementationWithPkce,
+)
+
+from .const import OAUTH2_AUTHORIZE, OAUTH2_SCOPES, OAUTH2_TOKEN
+
+
+async def async_get_auth_implementation(
+    hass: HomeAssistant, auth_domain: str, credential: ClientCredential
+) -> AbstractOAuth2Implementation:
+    """Return custom auth implementation."""
+    return DropboxOAuth2Implementation(
+        hass,
+        auth_domain,
+        credential.client_id,
+        OAUTH2_AUTHORIZE,
+        OAUTH2_TOKEN,
+        credential.client_secret,
+    )
+
+
+class DropboxOAuth2Implementation(LocalOAuth2ImplementationWithPkce):
+    """Custom Dropbox OAuth2 implementation to add the necessary authorize url parameters."""
+
+    @property
+    def extra_authorize_data(self) -> dict:
+        """Extra data that needs to be appended to the authorize url."""
+        data: dict = {
+            "token_access_type": "offline",
+            "scope": " ".join(OAUTH2_SCOPES),
+        }
+        data.update(super().extra_authorize_data)
+        return data

homeassistant/components/dropbox/auth.py

@@ -0,0 +1,44 @@
+"""Authentication for Dropbox."""
+
+from typing import cast
+
+from aiohttp import ClientSession
+from python_dropbox_api import Auth
+
+from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
+
+
+class DropboxConfigEntryAuth(Auth):
+    """Provide Dropbox authentication tied to an OAuth2 based config entry."""
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        oauth_session: OAuth2Session,
+    ) -> None:
+        """Initialize DropboxConfigEntryAuth."""
+        super().__init__(websession)
+        self._oauth_session = oauth_session
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        await self._oauth_session.async_ensure_token_valid()
+
+        return cast(str, self._oauth_session.token["access_token"])
+
+
+class DropboxConfigFlowAuth(Auth):
+    """Provide authentication tied to a fixed token for the config flow."""
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        token: str,
+    ) -> None:
+        """Initialize DropboxConfigFlowAuth."""
+        super().__init__(websession)
+        self._token = token
+
+    async def async_get_access_token(self) -> str:
+        """Return the fixed access token."""
+        return self._token

homeassistant/components/dropbox/backup.py

@@ -0,0 +1,230 @@
+"""Backup platform for the Dropbox integration."""
+
+from collections.abc import AsyncIterator, Callable, Coroutine
+from functools import wraps
+import json
+import logging
+from typing import Any, Concatenate
+
+from python_dropbox_api import (
+    DropboxAPIClient,
+    DropboxAuthException,
+    DropboxFileOrFolderNotFoundException,
+    DropboxUnknownException,
+)
+
+from homeassistant.components.backup import (
+    AgentBackup,
+    BackupAgent,
+    BackupAgentError,
+    BackupNotFound,
+    suggested_filename,
+)
+from homeassistant.core import HomeAssistant, callback
+
+from . import DropboxConfigEntry
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
+    """Return the suggested filenames for the backup and metadata."""
+    base_name = suggested_filename(backup).rsplit(".", 1)[0]
+    return f"{base_name}.tar", f"{base_name}.metadata.json"
+
+
+async def _async_string_iterator(content: str) -> AsyncIterator[bytes]:
+    """Yield a string as a single bytes chunk."""
+    yield content.encode()
+
+
+def handle_backup_errors[_R, **P](
+    func: Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]],
+) -> Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]]:
+    """Handle backup errors."""
+
+    @wraps(func)
+    async def wrapper(
+        self: DropboxBackupAgent, *args: P.args, **kwargs: P.kwargs
+    ) -> _R:
+        try:
+            return await func(self, *args, **kwargs)
+        except DropboxFileOrFolderNotFoundException as err:
+            raise BackupNotFound(
+                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
+            ) from err
+        except DropboxAuthException as err:
+            self._entry.async_start_reauth(self._hass)
+            raise BackupAgentError("Authentication error") from err
+        except DropboxUnknownException as err:
+            _LOGGER.error(
+                "Error during %s: %s",
+                func.__name__,
+                err,
+            )
+            _LOGGER.debug("Full error: %s", err, exc_info=True)
+            raise BackupAgentError(
+                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
+            ) from err
+
+    return wrapper
+
+
+async def async_get_backup_agents(
+    hass: HomeAssistant,
+    **kwargs: Any,
+) -> list[BackupAgent]:
+    """Return a list of backup agents."""
+    entries = hass.config_entries.async_loaded_entries(DOMAIN)
+    return [DropboxBackupAgent(hass, entry) for entry in entries]
+
+
+@callback
+def async_register_backup_agents_listener(
+    hass: HomeAssistant,
+    *,
+    listener: Callable[[], None],
+    **kwargs: Any,
+) -> Callable[[], None]:
+    """Register a listener to be called when agents are added or removed.
+
+    :return: A function to unregister the listener.
+    """
+    hass.data.setdefault(DATA_BACKUP_AGENT_LISTENERS, []).append(listener)
+
+    @callback
+    def remove_listener() -> None:
+        """Remove the listener."""
+        hass.data[DATA_BACKUP_AGENT_LISTENERS].remove(listener)
+        if not hass.data[DATA_BACKUP_AGENT_LISTENERS]:
+            del hass.data[DATA_BACKUP_AGENT_LISTENERS]
+
+    return remove_listener
+
+
+class DropboxBackupAgent(BackupAgent):
+    """Backup agent for the Dropbox integration."""
+
+    domain = DOMAIN
+
+    def __init__(self, hass: HomeAssistant, entry: DropboxConfigEntry) -> None:
+        """Initialize the backup agent."""
+        super().__init__()
+        self._hass = hass
+        self._entry = entry
+        self.name = entry.title
+        assert entry.unique_id
+        self.unique_id = entry.unique_id
+        self._api: DropboxAPIClient = entry.runtime_data
+
+    async def _async_get_backups(self) -> list[tuple[AgentBackup, str]]:
+        """Get backups and their corresponding file names."""
+        files = await self._api.list_folder("")
+
+        tar_files = {f.name for f in files if f.name.endswith(".tar")}
+        metadata_files = [f for f in files if f.name.endswith(".metadata.json")]
+
+        backups: list[tuple[AgentBackup, str]] = []
+        for metadata_file in metadata_files:
+            tar_name = metadata_file.name.removesuffix(".metadata.json") + ".tar"
+            if tar_name not in tar_files:
+                _LOGGER.warning(
+                    "Found metadata file '%s' without matching backup file",
+                    metadata_file.name,
+                )
+                continue
+
+            metadata_stream = self._api.download_file(f"/{metadata_file.name}")
+            raw = b"".join([chunk async for chunk in metadata_stream])
+            try:
+                data = json.loads(raw)
+                backup = AgentBackup.from_dict(data)
+            except (json.JSONDecodeError, ValueError, TypeError, KeyError) as err:
+                _LOGGER.warning(
+                    "Skipping invalid metadata file '%s': %s",
+                    metadata_file.name,
+                    err,
+                )
+                continue
+            backups.append((backup, tar_name))
+
+        return backups
+
+    @handle_backup_errors
+    async def async_upload_backup(
+        self,
+        *,
+        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
+        backup: AgentBackup,
+        **kwargs: Any,
+    ) -> None:
+        """Upload a backup."""
+        backup_filename, metadata_filename = _suggested_filenames(backup)
+        backup_path = f"/{backup_filename}"
+        metadata_path = f"/{metadata_filename}"
+
+        file_stream = await open_stream()
+        await self._api.upload_file(backup_path, file_stream)
+
+        metadata_stream = _async_string_iterator(json.dumps(backup.as_dict()))
+
+        try:
+            await self._api.upload_file(metadata_path, metadata_stream)
+        except (
+            DropboxAuthException,
+            DropboxUnknownException,
+        ):
+            await self._api.delete_file(backup_path)
+            raise
+
+    @handle_backup_errors
+    async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
+        """List backups."""
+        return [backup for backup, _ in await self._async_get_backups()]
+
+    @handle_backup_errors
+    async def async_download_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AsyncIterator[bytes]:
+        """Download a backup file."""
+        backups = await self._async_get_backups()
+        for backup, filename in backups:
+            if backup.backup_id == backup_id:
+                return self._api.download_file(f"/{filename}")
+
+        raise BackupNotFound(f"Backup {backup_id} not found")
+
+    @handle_backup_errors
+    async def async_get_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AgentBackup:
+        """Return a backup."""
+        backups = await self._async_get_backups()
+
+        for backup, _ in backups:
+            if backup.backup_id == backup_id:
+                return backup
+
+        raise BackupNotFound(f"Backup {backup_id} not found")
+
+    @handle_backup_errors
+    async def async_delete_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> None:
+        """Delete a backup file."""
+        backups = await self._async_get_backups()
+        for backup, tar_filename in backups:
+            if backup.backup_id == backup_id:
+                metadata_filename = tar_filename.removesuffix(".tar") + ".metadata.json"
+                await self._api.delete_file(f"/{tar_filename}")
+                await self._api.delete_file(f"/{metadata_filename}")
+                return
+
+        raise BackupNotFound(f"Backup {backup_id} not found")

homeassistant/components/dropbox/config_flow.py

@@ -0,0 +1,60 @@
+"""Config flow for Dropbox."""
+
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+from python_dropbox_api import DropboxAPIClient
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
+
+from .auth import DropboxConfigFlowAuth
+from .const import DOMAIN
+
+
+class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
+    """Config flow to handle Dropbox OAuth2 authentication."""
+
+    DOMAIN = DOMAIN
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Return logger."""
+        return logging.getLogger(__name__)
+
+    async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
+        """Create an entry for the flow, or update existing entry."""
+        access_token = data[CONF_TOKEN][CONF_ACCESS_TOKEN]
+
+        auth = DropboxConfigFlowAuth(async_get_clientsession(self.hass), access_token)
+
+        client = DropboxAPIClient(auth)
+        account_info = await client.get_account_info()
+
+        await self.async_set_unique_id(account_info.account_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=account_info.email, data=data)
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> 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 await self.async_step_user()

homeassistant/components/dropbox/const.py

@@ -0,0 +1,19 @@
+"""Constants for the Dropbox integration."""
+
+from collections.abc import Callable
+
+from homeassistant.util.hass_dict import HassKey
+
+DOMAIN = "dropbox"
+
+OAUTH2_AUTHORIZE = "https://www.dropbox.com/oauth2/authorize"
+OAUTH2_TOKEN = "https://api.dropboxapi.com/oauth2/token"
+OAUTH2_SCOPES = [
+    "account_info.read",
+    "files.content.read",
+    "files.content.write",
+]
+
+DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
+    f"{DOMAIN}.backup_agent_listeners"
+)

homeassistant/components/dropbox/manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "dropbox",
+  "name": "Dropbox",
+  "after_dependencies": ["backup"],
+  "codeowners": ["@bdr99"],
+  "config_flow": true,
+  "dependencies": ["application_credentials"],
+  "documentation": "https://www.home-assistant.io/integrations/dropbox",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["python-dropbox-api==0.1.3"]
+}

homeassistant/components/dropbox/quality_scale.yaml

@@ -0,0 +1,112 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register any actions.
+  appropriate-polling:
+    status: exempt
+    comment: Integration does not poll.
+  brands: done
+  common-modules:
+    status: exempt
+    comment: Integration does not have any entities or coordinators.
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not register any actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-unique-id:
+    status: exempt
+    comment: Integration does not have any entities.
+  has-entity-name:
+    status: exempt
+    comment: Integration does not have any entities.
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration does not register any actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: Integration does not have any configuration parameters.
+  docs-installation-parameters: done
+  entity-unavailable:
+    status: exempt
+    comment: Integration does not have any entities.
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates:
+    status: exempt
+    comment: Integration does not make any entity updates.
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices:
+    status: exempt
+    comment: Integration does not have any entities.
+  diagnostics:
+    status: exempt
+    comment: Integration does not have any data to diagnose.
+  discovery-update-info:
+    status: exempt
+    comment: Integration is a service.
+  discovery:
+    status: exempt
+    comment: Integration is a service.
+  docs-data-update:
+    status: exempt
+    comment: Integration does not update any data.
+  docs-examples:
+    status: exempt
+    comment: Integration only provides backup functionality.
+  docs-known-limitations: todo
+  docs-supported-devices:
+    status: exempt
+    comment: Integration does not support any devices.
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: Integration does not use any devices.
+  entity-category:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-device-class:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-translations:
+    status: exempt
+    comment: Integration does not have any entities.
+  exception-translations: todo
+  icon-translations:
+    status: exempt
+    comment: Integration does not have any entities.
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: Integration does not have any repairs.
+  stale-devices:
+    status: exempt
+    comment: Integration does not have any devices.
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/dropbox/strings.json

@@ -0,0 +1,35 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+      "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
+      "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
+      "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
+      "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
+      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
+      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]",
+      "wrong_account": "Wrong account: Please authenticate with the correct account."
+    },
+    "create_entry": {
+      "default": "[%key:common::config_flow::create_entry::authenticated%]"
+    },
+    "step": {
+      "pick_implementation": {
+        "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
+      },
+      "reauth_confirm": {
+        "description": "The Dropbox integration needs to re-authenticate your account.",
+        "title": "[%key:common::config_flow::title::reauth%]"
+      }
+    }
+  },
+  "exceptions": {
+    "oauth2_implementation_unavailable": {
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+    }
+  }
+}

homeassistant/components/fully_kiosk/button.py

@@ -27,6 +27,7 @@ class FullyButtonEntityDescription(ButtonEntityDescription):
     """Fully Kiosk Browser button description."""
 
     press_action: Callable[[FullyKiosk], Any]
+    refresh_after_press: bool = True
 
 
 BUTTONS: tuple[FullyButtonEntityDescription, ...] = (
@@ -68,6 +69,13 @@ BUTTONS: tuple[FullyButtonEntityDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         press_action=lambda fully: fully.clearCache(),
     ),
+    FullyButtonEntityDescription(
+        key="triggerMotion",
+        translation_key="trigger_motion",
+        entity_category=EntityCategory.CONFIG,
+        press_action=lambda fully: fully.triggerMotion(),
+        refresh_after_press=False,
+    ),
 )
 
 
@@ -102,4 +110,5 @@ class FullyButtonEntity(FullyKioskEntity, ButtonEntity):
     async def async_press(self) -> None:
         """Set the value of the entity."""
         await self.entity_description.press_action(self.coordinator.fully)
-        await self.coordinator.async_refresh()
+        if self.entity_description.refresh_after_press:
+            await self.coordinator.async_refresh()

homeassistant/components/fully_kiosk/sensor.py

@@ -12,7 +12,12 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfInformation
+from homeassistant.const import (
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfInformation,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -56,6 +61,14 @@ SENSORS: tuple[FullySensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    FullySensorEntityDescription(
+        key="batteryTemperature",
+        translation_key="battery_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
     FullySensorEntityDescription(
         key="currentPage",
         translation_key="current_page",

homeassistant/components/fully_kiosk/strings.json

@@ -88,6 +88,9 @@
       },
       "to_foreground": {
         "name": "Bring to foreground"
+      },
+      "trigger_motion": {
+        "name": "Trigger motion activity"
       }
     },
     "image": {
@@ -118,6 +121,9 @@
       }
     },
     "sensor": {
+      "battery_temperature": {
+        "name": "Battery temperature"
+      },
       "current_page": {
         "name": "Current page"
       },

homeassistant/components/garage_door/condition.py

@@ -0,0 +1,31 @@
+"""Provides conditions for garage doors."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_GARAGE_DOOR: dict[str, str] = {
+    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.GARAGE_DOOR,
+    COVER_DOMAIN: CoverDeviceClass.GARAGE,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(
+        device_classes=DEVICE_CLASSES_GARAGE_DOOR
+    ),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_GARAGE_DOOR),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for garage doors."""
+    return CONDITIONS

homeassistant/components/garage_door/conditions.yaml

@@ -0,0 +1,28 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: garage_door
+      - domain: cover
+        device_class: garage
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: garage_door
+      - domain: cover
+        device_class: garage

homeassistant/components/garage_door/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:garage"
+    },
+    "is_open": {
+      "condition": "mdi:garage-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:garage"

homeassistant/components/garage_door/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted garage doors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted garage doors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more garage doors are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::garage_door::common::condition_behavior_description%]",
+          "name": "[%key:component::garage_door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Garage door is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more garage doors are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::garage_door::common::condition_behavior_description%]",
+          "name": "[%key:component::garage_door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Garage door is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/gate/condition.py

@@ -0,0 +1,24 @@
+"""Provides conditions for gates."""
+
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_GATE: dict[str, str] = {
+    COVER_DOMAIN: CoverDeviceClass.GATE,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(device_classes=DEVICE_CLASSES_GATE),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_GATE),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for gates."""
+    return CONDITIONS

homeassistant/components/gate/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: gate
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: gate

homeassistant/components/gate/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:gate"
+    },
+    "is_open": {
+      "condition": "mdi:gate-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:gate"

homeassistant/components/gate/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted gates.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted gates to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more gates are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::condition_behavior_description%]",
+          "name": "[%key:component::gate::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Gate is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more gates are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::condition_behavior_description%]",
+          "name": "[%key:component::gate::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Gate is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/google_drive/__init__.py

@@ -12,6 +12,7 @@ from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import (
+    ImplementationUnavailableError,
     OAuth2Session,
     async_get_config_entry_implementation,
 )
@@ -30,11 +31,17 @@ _PLATFORMS = (Platform.SENSOR,)
 
 async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry) -> bool:
     """Set up Google Drive from a config entry."""
+    try:
+        implementation = await async_get_config_entry_implementation(hass, entry)
+    except ImplementationUnavailableError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="oauth2_implementation_unavailable",
+        ) from err
+
     auth = AsyncConfigEntryAuth(
         async_get_clientsession(hass),
-        OAuth2Session(
-            hass, entry, await async_get_config_entry_implementation(hass, entry)
-        ),
+        OAuth2Session(hass, entry, implementation),
     )
 
     # Test we can refresh the token and raise ConfigEntryAuthFailed or ConfigEntryNotReady if not
@@ -46,7 +53,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry)
     try:
         folder_id, _ = await client.async_create_ha_root_folder_if_not_exists()
     except GoogleDriveApiError as err:
-        raise ConfigEntryNotReady from err
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="failed_to_get_folder",
+            translation_placeholders={"folder": "Home Assistant"},
+        ) from err
 
     def async_notify_backup_listeners() -> None:
         for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):

homeassistant/components/google_drive/api.py

@@ -22,6 +22,8 @@ from homeassistant.exceptions import (
 )
 from homeassistant.helpers import config_entry_oauth2_flow
 
+from .const import DOMAIN
+
 _UPLOAD_AND_DOWNLOAD_TIMEOUT = 12 * 3600
 _UPLOAD_MAX_RETRIES = 20
 
@@ -61,14 +63,21 @@ class AsyncConfigEntryAuth(AbstractAuth):
             ):
                 if isinstance(ex, ClientResponseError) and 400 <= ex.status < 500:
                     raise ConfigEntryAuthFailed(
-                        "OAuth session is not valid, reauth required"
+                        translation_domain=DOMAIN,
+                        translation_key="authentication_not_valid",
                     ) from ex
-                raise ConfigEntryNotReady from ex
+                raise ConfigEntryNotReady(
+                    translation_domain=DOMAIN,
+                    translation_key="authentication_failed",
+                ) from ex
             if hasattr(ex, "status") and ex.status == 400:
                 self._oauth_session.config_entry.async_start_reauth(
                     self._oauth_session.hass
                 )
-            raise HomeAssistantError(ex) from ex
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="authentication_failed",
+            ) from ex
         return str(self._oauth_session.token[CONF_ACCESS_TOKEN])
 
 

homeassistant/components/google_drive/config_flow.py

@@ -8,7 +8,11 @@ from typing import Any, cast
 
 from google_drive_api.exceptions import GoogleDriveApiError
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlowResult,
+)
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
 from homeassistant.helpers import config_entry_oauth2_flow, instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -44,6 +48,12 @@ class OAuth2FlowHandler(
             "prompt": "consent",
         }
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a reconfiguration flow."""
+        return await self.async_step_user(user_input)
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
@@ -81,13 +91,16 @@ class OAuth2FlowHandler(
 
         await self.async_set_unique_id(email_address)
 
-        if self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
+        if self.source in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
+            if self.source == SOURCE_REAUTH:
+                entry = self._get_reauth_entry()
+            else:
+                entry = self._get_reconfigure_entry()
             self._abort_if_unique_id_mismatch(
                 reason="wrong_account",
-                description_placeholders={"email": cast(str, reauth_entry.unique_id)},
+                description_placeholders={"email": cast(str, entry.unique_id)},
             )
-            return self.async_update_reload_and_abort(reauth_entry, data=data)
+            return self.async_update_reload_and_abort(entry, data=data)
 
         self._abort_if_unique_id_configured()
 

homeassistant/components/google_drive/quality_scale.yaml

@@ -17,9 +17,7 @@ rules:
   docs-removal-instructions: done
   entity-event-setup: done
   entity-unique-id: done
-  has-entity-name:
-    status: exempt
-    comment: No entities.
+  has-entity-name: done
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
@@ -66,12 +64,8 @@ rules:
   entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
-  icon-translations:
-    status: exempt
-    comment: No entities.
-  reconfiguration-flow:
-    status: exempt
-    comment: No configuration options.
+  icon-translations: done
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: No repairs.

homeassistant/components/google_drive/strings.json

@@ -18,6 +18,7 @@
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
       "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unknown": "[%key:common::config_flow::error::unknown%]",
       "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]",
       "wrong_account": "Wrong account: Please authenticate with {email}."
@@ -62,5 +63,22 @@
         "name": "Used storage in Drive Trash"
       }
     }
+  },
+  "exceptions": {
+    "authentication_failed": {
+      "message": "Authentication failed"
+    },
+    "authentication_not_valid": {
+      "message": "OAuth session is not valid, reauthentication required"
+    },
+    "failed_to_get_folder": {
+      "message": "Failed to get {folder} folder"
+    },
+    "invalid_response_google_drive_error": {
+      "message": "Invalid response from Google Drive: {error}"
+    },
+    "oauth2_implementation_unavailable": {
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+    }
   }
 }

homeassistant/components/growatt_server/coordinator.py

@@ -251,7 +251,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
     def get_data(
         self, entity_description: GrowattSensorEntityDescription
-    ) -> str | int | float | None:
+    ) -> str | int | float | datetime.datetime | datetime.date | None:
         """Get the data."""
         variable = entity_description.api_key
         api_value = self.data.get(variable)

homeassistant/components/growatt_server/icons.json

@@ -1,4 +1,17 @@
 {
+  "entity": {
+    "sensor": {
+      "storage_load_consumption_solar_storage": {
+        "default": "mdi:lightning-bolt"
+      },
+      "total_money_today": {
+        "default": "mdi:cash"
+      },
+      "total_money_total": {
+        "default": "mdi:cash"
+      }
+    }
+  },
   "services": {
     "read_ac_charge_times": {
       "service": "mdi:battery-clock-outline"

homeassistant/components/growatt_server/number.py

@@ -17,7 +17,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
-from .sensor.sensor_entity_description import GrowattRequiredKeysMixin
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,9 +26,10 @@ PARALLEL_UPDATES = (
 
 
 @dataclass(frozen=True, kw_only=True)
-class GrowattNumberEntityDescription(NumberEntityDescription, GrowattRequiredKeysMixin):
+class GrowattNumberEntityDescription(NumberEntityDescription):
     """Describes Growatt number entity."""
 
+    api_key: str
     write_key: str | None = None  # Parameter ID for writing (if different from api_key)
 
 
@@ -130,6 +130,7 @@ class GrowattNumber(CoordinatorEntity[GrowattCoordinator], NumberEntity):
             identifiers={(DOMAIN, coordinator.device_id)},
             manufacturer="Growatt",
             name=coordinator.device_id,
+            serial_number=coordinator.device_id,
         )
 
     @property

homeassistant/components/growatt_server/quality_scale.yaml

@@ -32,9 +32,7 @@ rules:
   test-coverage: done
 
   # Gold
-  devices:
-    status: todo
-    comment: Add serial_number field to DeviceInfo in sensor, number, and switch platforms using device_id/serial_id.
+  devices: done
   diagnostics: todo
   discovery-update-info: todo
   discovery: todo
@@ -46,16 +44,12 @@ rules:
   docs-troubleshooting: todo
   docs-use-cases: todo
   dynamic-devices: todo
-  entity-category:
-    status: todo
-    comment: Add EntityCategory.DIAGNOSTIC to temperature and other diagnostic sensors. Merge GrowattRequiredKeysMixin into GrowattSensorEntityDescription using kw_only=True.
-  entity-device-class:
-    status: todo
-    comment: Replace custom precision field with suggested_display_precision to preserve full data granularity.
-  entity-disabled-by-default: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
   entity-translations: done
   exception-translations: todo
-  icon-translations: todo
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/growatt_server/sensor/__init__.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+from datetime import date, datetime
 import logging
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from ..const import DOMAIN
@@ -99,24 +101,18 @@ class GrowattSensor(CoordinatorEntity[GrowattCoordinator], SensorEntity):
         self.entity_description = description
 
         self._attr_unique_id = unique_id
-        self._attr_icon = "mdi:solar-power"
 
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_id)},
             manufacturer="Growatt",
             name=name,
+            serial_number=serial_id,
         )
 
     @property
-    def native_value(self) -> str | int | float | None:
+    def native_value(self) -> StateType | date | datetime:
         """Return the state of the sensor."""
-        result = self.coordinator.get_data(self.entity_description)
-        if (
-            isinstance(result, (int, float))
-            and self.entity_description.precision is not None
-        ):
-            result = round(result, self.entity_description.precision)
-        return result
+        return self.coordinator.get_data(self.entity_description)
 
     @property
     def native_unit_of_measurement(self) -> str | None:

homeassistant/components/growatt_server/sensor/inverter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -22,7 +23,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_energy_total",
@@ -30,7 +31,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="powerTotal",
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
-        precision=1,
+        suggested_display_precision=1,
         state_class=SensorStateClass.TOTAL,
     ),
     GrowattSensorEntityDescription(
@@ -40,7 +41,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_1",
@@ -49,7 +50,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_1",
@@ -58,7 +59,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_voltage_input_2",
@@ -67,7 +68,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_2",
@@ -76,7 +77,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_2",
@@ -85,7 +86,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_voltage_input_3",
@@ -94,7 +95,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_3",
@@ -103,7 +104,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_3",
@@ -112,7 +113,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_internal_wattage",
@@ -121,7 +122,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_reactive_voltage",
@@ -130,7 +131,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_inverter_reactive_amperage",
@@ -139,7 +142,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_frequency",
@@ -148,7 +153,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_current_wattage",
@@ -157,7 +164,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_current_reactive_wattage",
@@ -166,7 +173,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_ipm_temperature",
@@ -175,7 +184,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_temperature",
@@ -184,6 +195,8 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
 )

homeassistant/components/growatt_server/sensor/sensor_entity_description.py

@@ -7,18 +7,11 @@ from dataclasses import dataclass
 from homeassistant.components.sensor import SensorEntityDescription
 
 
-@dataclass(frozen=True)
-class GrowattRequiredKeysMixin:
-    """Mixin for required keys."""
-
-    api_key: str
-
-
-@dataclass(frozen=True)
-class GrowattSensorEntityDescription(SensorEntityDescription, GrowattRequiredKeysMixin):
+@dataclass(frozen=True, kw_only=True)
+class GrowattSensorEntityDescription(SensorEntityDescription):
     """Describes Growatt sensor entity."""
 
-    precision: int | None = None
+    api_key: str
     currency: bool = False
     previous_value_drop_threshold: float | None = None
     never_resets: bool = False

homeassistant/components/growatt_server/sensor/sph.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricPotential,
     UnitOfEnergy,
     UnitOfFrequency,
@@ -90,6 +91,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_1",
@@ -98,6 +101,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_2",
@@ -106,6 +111,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_3",
@@ -114,6 +121,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_4",
@@ -122,6 +131,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_5",
@@ -130,6 +141,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     # Values from 'sph_energy' API call
     GrowattSensorEntityDescription(

homeassistant/components/growatt_server/sensor/storage.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -189,7 +190,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_pv_charging_voltage",
@@ -198,7 +199,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_pv_charging_voltage_2",
@@ -207,7 +208,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_ac_input_frequency_out",
@@ -216,7 +217,9 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="storage_output_voltage",
@@ -225,7 +228,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_ac_output_frequency",
@@ -234,7 +237,9 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_PV",
@@ -243,7 +248,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_1",
@@ -252,7 +257,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_2",
@@ -261,7 +266,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_grid_amperage_input",
@@ -270,7 +275,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_grid_out_current",
@@ -279,7 +284,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_battery_voltage",
@@ -288,7 +293,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_load_percentage",
@@ -297,6 +302,6 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
 )

homeassistant/components/growatt_server/sensor/tlx.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -26,7 +27,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total",
@@ -35,7 +36,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -45,7 +46,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -55,7 +56,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_1",
@@ -63,7 +64,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv1",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_1",
@@ -71,7 +72,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv1",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_1",
@@ -80,7 +81,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_2",
@@ -89,7 +90,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -99,7 +100,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_2",
@@ -107,7 +108,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv2",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_2",
@@ -115,7 +116,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv2",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_2",
@@ -124,7 +125,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_3",
@@ -133,7 +134,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -143,7 +144,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_3",
@@ -151,7 +152,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv3",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_3",
@@ -159,7 +160,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv3",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_3",
@@ -168,7 +169,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_4",
@@ -177,7 +178,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -187,7 +188,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_4",
@@ -195,7 +196,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv4",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_4",
@@ -203,7 +204,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv4",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_4",
@@ -212,7 +213,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_solar_generation_today",
@@ -221,7 +222,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_solar_generation_total",
@@ -239,7 +240,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_reactive_voltage",
@@ -247,7 +248,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vacrs",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_frequency",
@@ -255,7 +258,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="fac",
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_current_wattage",
@@ -264,7 +269,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_1",
@@ -272,7 +277,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp1",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_2",
@@ -280,7 +287,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp2",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_3",
@@ -288,7 +297,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp3",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_4",
@@ -296,7 +307,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp4",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_5",
@@ -304,7 +317,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp5",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_all_batteries_discharge_today",
@@ -456,7 +471,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_pac_to_user_total",
@@ -465,7 +480,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_pac_to_grid_total",
@@ -474,7 +489,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_system_production_today",
@@ -483,7 +498,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_system_production_total",
@@ -493,7 +508,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_self_consumption_today",
@@ -502,7 +517,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_self_consumption_total",
@@ -512,7 +527,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_import_from_grid_today",
@@ -521,7 +536,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_import_from_grid_total",
@@ -531,7 +546,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_batteries_charged_from_grid_today",
@@ -540,7 +555,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_batteries_charged_from_grid_total",
@@ -550,7 +565,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_p_system",
@@ -559,7 +574,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_p_self",
@@ -568,6 +583,6 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
 )

homeassistant/components/growatt_server/switch.py

@@ -18,7 +18,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
-from .sensor.sensor_entity_description import GrowattRequiredKeysMixin
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,9 +27,10 @@ PARALLEL_UPDATES = (
 
 
 @dataclass(frozen=True, kw_only=True)
-class GrowattSwitchEntityDescription(SwitchEntityDescription, GrowattRequiredKeysMixin):
+class GrowattSwitchEntityDescription(SwitchEntityDescription):
     """Describes Growatt switch entity."""
 
+    api_key: str
     write_key: str | None = None  # Parameter ID for writing (if different from api_key)
 
 
@@ -87,6 +87,7 @@ class GrowattSwitch(CoordinatorEntity[GrowattCoordinator], SwitchEntity):
             identifiers={(DOMAIN, coordinator.device_id)},
             manufacturer="Growatt",
             name=coordinator.device_id,
+            serial_number=coordinator.device_id,
         )
 
     @property

homeassistant/components/hassio/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress
+from dataclasses import replace
 from datetime import datetime
 import logging
 import os
@@ -15,6 +16,7 @@ from aiohasupervisor import SupervisorError
 from aiohasupervisor.models import (
     GreenOptions,
     HomeAssistantInfo,
+    HomeAssistantOptions,
     HostInfo,
     InstalledAddon,
     NetworkInfo,
@@ -22,20 +24,28 @@ from aiohasupervisor.models import (
     RootInfo,
     StoreInfo,
     SupervisorInfo,
+    SupervisorOptions,
     YellowOptions,
 )
 import voluptuous as vol
 
 from homeassistant.auth.const import GROUP_ID_ADMIN
+from homeassistant.auth.models import RefreshToken
 from homeassistant.components import frontend, panel_custom
 from homeassistant.components.homeassistant import async_set_stop_handler
-from homeassistant.components.http import StaticPathConfig
+from homeassistant.components.http import (
+    CONF_SERVER_HOST,
+    CONF_SERVER_PORT,
+    CONF_SSL_CERTIFICATE,
+    StaticPathConfig,
+)
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
 from homeassistant.const import (
     ATTR_DEVICE_ID,
     ATTR_NAME,
     EVENT_CORE_CONFIG_UPDATE,
     HASSIO_USER_NAME,
+    SERVER_PORT,
     Platform,
 )
 from homeassistant.core import (
@@ -447,8 +457,30 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         require_admin=True,
     )
 
+    async def update_hass_api(http_config: dict[str, Any], refresh_token: RefreshToken):
+        """Update Home Assistant API data on Hass.io."""
+        options = HomeAssistantOptions(
+            ssl=CONF_SSL_CERTIFICATE in http_config,
+            port=http_config.get(CONF_SERVER_PORT) or SERVER_PORT,
+            refresh_token=refresh_token.token,
+        )
+
+        if http_config.get(CONF_SERVER_HOST) is not None:
+            options = replace(options, watchdog=False)
+            _LOGGER.warning(
+                "Found incompatible HTTP option 'server_host'. Watchdog feature"
+                " disabled"
+            )
+
+        try:
+            await supervisor_client.homeassistant.set_options(options)
+        except SupervisorError as err:
+            _LOGGER.warning(
+                "Failed to update Home Assistant options in Supervisor: %s", err
+            )
+
     update_hass_api_task = hass.async_create_task(
-        hassio.update_hass_api(config.get("http", {}), refresh_token), eager_start=True
+        update_hass_api(config.get("http", {}), refresh_token), eager_start=True
     )
 
     last_timezone = None
@@ -459,19 +491,25 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         nonlocal last_timezone
         nonlocal last_country
 
-        new_timezone = str(hass.config.time_zone)
-        new_country = str(hass.config.country)
+        new_timezone = hass.config.time_zone
+        new_country = hass.config.country
 
         if new_timezone != last_timezone or new_country != last_country:
             last_timezone = new_timezone
             last_country = new_country
-            await hassio.update_hass_config(new_timezone, new_country)
+
+            try:
+                await supervisor_client.supervisor.set_options(
+                    SupervisorOptions(timezone=new_timezone, country=new_country)
+                )
+            except SupervisorError as err:
+                _LOGGER.warning("Failed to update Supervisor options: %s", err)
 
     hass.bus.async_listen(EVENT_CORE_CONFIG_UPDATE, push_config)
 
     push_config_task = hass.async_create_task(push_config(None), eager_start=True)
     # Start listening for problems with supervisor and making issues
-    hass.data[DATA_KEY_SUPERVISOR_ISSUES] = issues = SupervisorIssues(hass, hassio)
+    hass.data[DATA_KEY_SUPERVISOR_ISSUES] = issues = SupervisorIssues(hass)
     issues_task = hass.async_create_task(issues.setup(), eager_start=True)
 
     async def async_service_handler(service: ServiceCall) -> None:
@@ -619,7 +657,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
     async_set_stop_handler(hass, _async_stop)
 
     # Init discovery Hass.io feature
-    async_setup_discovery_view(hass, hassio)
+    async_setup_discovery_view(hass)
 
     # Init auth Hass.io feature
     assert user is not None

homeassistant/components/hassio/const.py

@@ -132,6 +132,7 @@ ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED = "issue_addon_detached_addon_removed"
 ISSUE_KEY_ADDON_PWNED = "issue_addon_pwned"
 ISSUE_KEY_SYSTEM_FREE_SPACE = "issue_system_free_space"
 ISSUE_KEY_ADDON_DEPRECATED = "issue_addon_deprecated_addon"
+ISSUE_KEY_ADDON_DEPRECATED_ARCH = "issue_addon_deprecated_arch_addon"
 
 ISSUE_MOUNT_MOUNT_FAILED = "issue_mount_mount_failed"
 
@@ -172,6 +173,7 @@ EXTRA_PLACEHOLDERS = {
         "more_info_pwned": "https://www.home-assistant.io/more-info/pwned-passwords",
     },
     ISSUE_KEY_ADDON_DEPRECATED: HELP_URLS,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH: HELP_URLS,
 }
 
 

homeassistant/components/hassio/discovery.py

@@ -21,15 +21,15 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.service_info.hassio import HassioServiceInfo
 
 from .const import ATTR_ADDON, ATTR_UUID, DOMAIN
-from .handler import HassIO, get_supervisor_client
+from .handler import get_supervisor_client
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @callback
-def async_setup_discovery_view(hass: HomeAssistant, hassio: HassIO) -> None:
+def async_setup_discovery_view(hass: HomeAssistant) -> None:
     """Discovery setup."""
-    hassio_discovery = HassIODiscovery(hass, hassio)
+    hassio_discovery = HassIODiscovery(hass)
     supervisor_client = get_supervisor_client(hass)
     hass.http.register_view(hassio_discovery)
 
@@ -77,10 +77,9 @@ class HassIODiscovery(HomeAssistantView):
     name = "api:hassio_push:discovery"
     url = "/api/hassio_push/discovery/{uuid}"
 
-    def __init__(self, hass: HomeAssistant, hassio: HassIO) -> None:
+    def __init__(self, hass: HomeAssistant) -> None:
         """Initialize WebView."""
         self.hass = hass
-        self.hassio = hassio
         self._supervisor_client = get_supervisor_client(hass)
 
     async def post(self, request: web.Request, uuid: str) -> web.Response:

homeassistant/components/hassio/handler.py

@@ -14,13 +14,6 @@ from aiohasupervisor.models import SupervisorOptions
 import aiohttp
 from yarl import URL
 
-from homeassistant.auth.models import RefreshToken
-from homeassistant.components.http import (
-    CONF_SERVER_HOST,
-    CONF_SERVER_PORT,
-    CONF_SSL_CERTIFICATE,
-)
-from homeassistant.const import SERVER_PORT
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.singleton import singleton
 
@@ -35,22 +28,6 @@ class HassioAPIError(RuntimeError):
     """Return if a API trow a error."""
 
 
-def _api_bool[**_P](
-    funct: Callable[_P, Coroutine[Any, Any, dict[str, Any]]],
-) -> Callable[_P, Coroutine[Any, Any, bool]]:
-    """Return a boolean."""
-
-    async def _wrapper(*argv: _P.args, **kwargs: _P.kwargs) -> bool:
-        """Wrap function."""
-        try:
-            data = await funct(*argv, **kwargs)
-            return data["result"] == "ok"
-        except HassioAPIError:
-            return False
-
-    return _wrapper
-
-
 def api_data[**_P](
     funct: Callable[_P, Coroutine[Any, Any, dict[str, Any]]],
 ) -> Callable[_P, Coroutine[Any, Any, Any]]:
@@ -95,37 +72,6 @@ class HassIO:
         """
         return self.send_command("/ingress/panels", method="get")
 
-    @_api_bool
-    async def update_hass_api(
-        self, http_config: dict[str, Any], refresh_token: RefreshToken
-    ):
-        """Update Home Assistant API data on Hass.io."""
-        port = http_config.get(CONF_SERVER_PORT) or SERVER_PORT
-        options = {
-            "ssl": CONF_SSL_CERTIFICATE in http_config,
-            "port": port,
-            "refresh_token": refresh_token.token,
-        }
-
-        if http_config.get(CONF_SERVER_HOST) is not None:
-            options["watchdog"] = False
-            _LOGGER.warning(
-                "Found incompatible HTTP option 'server_host'. Watchdog feature"
-                " disabled"
-            )
-
-        return await self.send_command("/homeassistant/options", payload=options)
-
-    @_api_bool
-    def update_hass_config(self, timezone: str, country: str | None) -> Coroutine:
-        """Update Home-Assistant timezone data on Hass.io.
-
-        This method returns a coroutine.
-        """
-        return self.send_command(
-            "/supervisor/options", payload={"timezone": timezone, "country": country}
-        )
-
     async def send_command(
         self,
         command: str,

homeassistant/components/hassio/issues.py

@@ -47,6 +47,7 @@ from .const import (
     EVENT_SUPPORTED_CHANGED,
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     ISSUE_KEY_ADDON_DETACHED_ADDON_MISSING,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
@@ -62,7 +63,7 @@ from .const import (
     UPDATE_KEY_SUPERVISOR,
 )
 from .coordinator import HassioDataUpdateCoordinator, get_addons_list, get_host_info
-from .handler import HassIO, get_supervisor_client
+from .handler import get_supervisor_client
 
 ISSUE_KEY_UNHEALTHY = "unhealthy"
 ISSUE_KEY_UNSUPPORTED = "unsupported"
@@ -90,6 +91,8 @@ ISSUE_KEYS_FOR_REPAIRS = {
     "issue_system_disk_lifetime",
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_KEY_ADDON_PWNED,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
+    "issue_system_ntp_sync_failed",
 }
 
 _LOGGER = logging.getLogger(__name__)
@@ -172,10 +175,9 @@ class Issue:
 class SupervisorIssues:
     """Create issues from supervisor events."""
 
-    def __init__(self, hass: HomeAssistant, client: HassIO) -> None:
+    def __init__(self, hass: HomeAssistant) -> None:
         """Initialize supervisor issues."""
         self._hass = hass
-        self._client = client
         self._unsupported_reasons: set[str] = set()
         self._unhealthy_reasons: set[str] = set()
         self._issues: dict[UUID, Issue] = {}
@@ -253,9 +255,10 @@ class SupervisorIssues:
     def add_issue(self, issue: Issue) -> None:
         """Add or update an issue in the list. Create or update a repair if necessary."""
         if issue.key in ISSUE_KEYS_FOR_REPAIRS:
-            placeholders: dict[str, str] = {}
             if not issue.suggestions and issue.key in EXTRA_PLACEHOLDERS:
-                placeholders |= EXTRA_PLACEHOLDERS[issue.key]
+                placeholders: dict[str, str] = EXTRA_PLACEHOLDERS[issue.key].copy()
+            else:
+                placeholders = {}
 
             if issue.reference:
                 placeholders[PLACEHOLDER_KEY_REFERENCE] = issue.reference

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.4.1"],
+  "requirements": ["aiohasupervisor==0.4.2"],
   "single_config_entry": true
 }

homeassistant/components/hassio/repairs.py

@@ -21,6 +21,7 @@ from .const import (
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
     ISSUE_KEY_ADDON_DEPRECATED,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
     ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
@@ -64,11 +65,16 @@ class SupervisorIssueRepairFlow(RepairsFlow):
     @property
     def description_placeholders(self) -> dict[str, str] | None:
         """Get description placeholders for steps."""
-        placeholders = {}
-        if self.issue:
-            placeholders = EXTRA_PLACEHOLDERS.get(self.issue.key, {})
-            if self.issue.reference:
-                placeholders |= {PLACEHOLDER_KEY_REFERENCE: self.issue.reference}
+        if not self.issue:
+            return None
+
+        if self.issue.key in EXTRA_PLACEHOLDERS:
+            placeholders: dict[str, str] = EXTRA_PLACEHOLDERS[self.issue.key].copy()
+        else:
+            placeholders = {}
+
+        if self.issue.reference:
+            placeholders |= {PLACEHOLDER_KEY_REFERENCE: self.issue.reference}
 
         return placeholders or None
 
@@ -232,6 +238,7 @@ async def async_create_fix_flow(
         ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
         ISSUE_KEY_ADDON_BOOT_FAIL,
         ISSUE_KEY_ADDON_PWNED,
+        ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     }:
         return AddonIssueRepairFlow(hass, issue_id)
 

homeassistant/components/hassio/strings.json

@@ -85,6 +85,19 @@
       },
       "title": "Installed app is deprecated"
     },
+    "issue_addon_deprecated_arch_addon": {
+      "fix_flow": {
+        "abort": {
+          "apply_suggestion_fail": "Could not uninstall the app. Check the Supervisor logs for more details."
+        },
+        "step": {
+          "addon_execute_remove": {
+            "description": "App {addon} only supports architectures and/or machines which are no longer supported by Home Assistant. It will stop working in a future release.\n\nSelecting **Submit** will uninstall this deprecated app. Alternatively, you can check [Home Assistant help]({help_url}) and the [community forum]({community_url}) for alternatives to migrate to."
+          }
+        }
+      },
+      "title": "Installed app is built for unsupported architectures and/or machines"
+    },
     "issue_addon_detached_addon_missing": {
       "description": "Repository for app {addon} is missing. This means it will not get updates, and backups may not be restored correctly as the Home Assistant Supervisor may not be able to build/download the resources required.\n\nPlease check the [app's documentation]({addon_url}) for installation instructions and add the repository to the store.",
       "title": "Missing repository for an installed app"
@@ -164,6 +177,19 @@
       },
       "title": "Multiple data disks detected"
     },
+    "issue_system_ntp_sync_failed": {
+      "fix_flow": {
+        "abort": {
+          "apply_suggestion_fail": "Could not re-enable NTP. Check the Supervisor logs for more details."
+        },
+        "step": {
+          "system_enable_ntp": {
+            "description": "The device could not contact its configured time servers (NTP). Using a secondary online time check, we detected that the system clock was more than 1 hour incorrect. The time has been corrected and the NTP service was temporarily disabled so the correction could be applied. To keep the system time accurate, we recommend fixing the issue preventing access to the NTP servers.\n\nCheck the **Host logs** to investigate why NTP servers could not be reached. Once resolved, select **Submit** to re-enable the NTP service."
+          }
+        }
+      },
+      "title": "Time synchronization issue detected"
+    },
     "issue_system_reboot_required": {
       "fix_flow": {
         "abort": {

homeassistant/components/huum/climate.py

@@ -72,13 +72,6 @@ class HuumDevice(HuumBaseEntity, ClimateEntity):
             return HVACMode.HEAT
         return HVACMode.OFF
 
-    @property
-    def icon(self) -> str:
-        """Return nice icon for heater."""
-        if self.hvac_mode == HVACMode.HEAT:
-            return "mdi:radiator"
-        return "mdi:radiator-off"
-
     @property
     def current_temperature(self) -> int | None:
         """Return the current temperature."""

homeassistant/components/huum/config_flow.py

@@ -45,8 +45,6 @@ class HuumConfigFlow(ConfigFlow, domain=DOMAIN):
                 )
                 await huum.status()
             except Forbidden, NotAuthenticated:
-                # Most likely Forbidden as that is what is returned from `.status()` with bad creds
-                _LOGGER.error("Could not log in to Huum with given credentials")
                 errors["base"] = "invalid_auth"
             except Exception:
                 _LOGGER.exception("Unknown error")

homeassistant/components/huum/coordinator.py

@@ -54,7 +54,6 @@ class HuumDataUpdateCoordinator(DataUpdateCoordinator[HuumStatusResponse]):
         try:
             return await self.huum.status()
         except (Forbidden, NotAuthenticated) as err:
-            _LOGGER.error("Could not log in to Huum with given credentials")
             raise UpdateFailed(
                 "Could not log in to Huum with given credentials"
             ) from err

homeassistant/components/huum/quality_scale.yaml

@@ -7,11 +7,7 @@ rules:
   brands: done
   common-modules: done
   config-flow-test-coverage: done
-  config-flow:
-    status: done
-    comment: |
-      PLANNED: Remove _LOGGER.error call from config_flow.py — the error
-      message is redundant with the errors dict entry.
+  config-flow: done
   dependency-transparency: done
   docs-actions:
     status: exempt
@@ -40,11 +36,7 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable:
-    status: done
-    comment: |
-      PLANNED: Remove _LOGGER.error from coordinator.py — the message is already
-      passed to UpdateFailed, so logging it separately is redundant.
+  log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: todo
   test-coverage:
@@ -74,11 +66,7 @@ rules:
     comment: All entities are core functionality.
   entity-translations: done
   exception-translations: todo
-  icon-translations:
-    status: done
-    comment: |
-      PLANNED: Remove the icon property from climate.py — entities should not set
-      custom icons. Use HA defaults or icon translations instead.
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/intellifire/strings.json

@@ -22,7 +22,13 @@
         "description": "Authenticate against IntelliFire cloud"
       },
       "pick_cloud_device": {
-        "description": "Select fireplace by serial number:",
+        "data": {
+          "serial": "Fireplace serial number"
+        },
+        "data_description": {
+          "serial": "Serial number of the fireplace to configure"
+        },
+        "description": "Select fireplace by serial number.",
         "title": "Configure fireplace"
       }
     }
@@ -159,6 +165,10 @@
           "control_mode": "Send commands to",
           "read_mode": "Read data from"
         },
+        "data_description": {
+          "control_mode": "Whether to send fireplace commands via the `Local` or `Cloud` API",
+          "read_mode": "Whether to read fireplace state via the `Local` or `Cloud` API"
+        },
         "description": "Some users find that their fireplace hardware prioritizes `Cloud` communication and may experience timeouts with `Local` control. If you encounter connectivity issues, try switching to `Cloud` for the affected endpoint.",
         "title": "Endpoint selection"
       }

homeassistant/components/jvc_projector/coordinator.py

@@ -151,7 +151,9 @@ class JvcProjectorDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
 
         return value
 
-    def get_options_map(self, command: str) -> dict[str, str]:
+    def get_options_map(
+        self, command: str, *, snake_case: bool = False
+    ) -> dict[str, str]:
         """Get the available options for a command."""
         capabilities = self.capabilities.get(command, {})
 
@@ -162,7 +164,10 @@ class JvcProjectorDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
 
         values = list(capabilities.get("parameter", {}).get("read", {}).values())
 
-        return {v: v.translate(TRANSLATIONS) for v in values}
+        options = {v: v.translate(TRANSLATIONS) for v in values}
+        if snake_case:
+            return {k: v.replace("-", "_") for k, v in options.items()}
+        return options
 
     def supports(self, command: type[Command]) -> bool:
         """Check if the device supports a command."""

homeassistant/components/jvc_projector/icons.json

@@ -18,6 +18,9 @@
       "dynamic_control": {
         "default": "mdi:lightbulb-on-outline"
       },
+      "hdr_processing": {
+        "default": "mdi:image-filter-hdr-outline"
+      },
       "input": {
         "default": "mdi:hdmi-port"
       },
@@ -26,6 +29,9 @@
       },
       "light_power": {
         "default": "mdi:lightbulb-on-outline"
+      },
+      "picture_mode": {
+        "default": "mdi:movie-roll"
       }
     },
     "sensor": {

homeassistant/components/jvc_projector/select.py

@@ -20,6 +20,7 @@ class JvcProjectorSelectDescription(SelectEntityDescription):
     """Describes JVC Projector select entities."""
 
     command: type[Command]
+    snake_case_states: bool = False
 
 
 SELECTS: Final[tuple[JvcProjectorSelectDescription, ...]] = (
@@ -49,6 +50,18 @@ SELECTS: Final[tuple[JvcProjectorSelectDescription, ...]] = (
         command=cmd.Anamorphic,
         entity_registry_enabled_default=False,
     ),
+    JvcProjectorSelectDescription(
+        key="hdr_processing",
+        command=cmd.HdrProcessing,
+        entity_registry_enabled_default=False,
+        snake_case_states=True,
+    ),
+    JvcProjectorSelectDescription(
+        key="picture_mode",
+        command=cmd.PictureMode,
+        entity_registry_enabled_default=False,
+        snake_case_states=True,
+    ),
 )
 
 
@@ -84,7 +97,8 @@ class JvcProjectorSelectEntity(JvcProjectorEntity, SelectEntity):
         self._attr_unique_id = f"{self._attr_unique_id}_{description.key}"
 
         self._options_map: dict[str, str] = coordinator.get_options_map(
-            self.command.name
+            self.command.name,
+            snake_case=description.snake_case_states,
         )
 
     @property

homeassistant/components/jvc_projector/sensor.py

@@ -7,16 +7,19 @@ from dataclasses import dataclass
 from jvcprojector import Command, command as cmd
 
 from homeassistant.components.sensor import (
+    DOMAIN as SENSOR_DOMAIN,
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
 from homeassistant.const import EntityCategory, UnitOfTime
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import JVCConfigEntry, JvcProjectorDataUpdateCoordinator
 from .entity import JvcProjectorEntity
+from .util import deprecate_entity
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -84,12 +87,29 @@ async def async_setup_entry(
 ) -> None:
     """Set up the JVC Projector platform from a config entry."""
     coordinator = entry.runtime_data
+    entity_registry = er.async_get(hass)
 
-    async_add_entities(
-        JvcProjectorSensorEntity(coordinator, description)
-        for description in SENSORS
-        if coordinator.supports(description.command)
-    )
+    entities: list[JvcProjectorSensorEntity] = []
+    for description in SENSORS:
+        if not coordinator.supports(description.command):
+            continue
+        if description.key in (
+            "hdr_processing",
+            "picture_mode",
+        ) and not deprecate_entity(
+            hass,
+            entity_registry,
+            SENSOR_DOMAIN,
+            f"{coordinator.unique_id}_{description.key}",
+            f"deprecated_sensor_{entry.entry_id}_{description.key}",
+            "deprecated_sensor",
+            f"{coordinator.unique_id}_{description.key}",
+            f"select.jvc_projector_{description.key}",
+        ):
+            continue
+        entities.append(JvcProjectorSensorEntity(coordinator, description))
+
+    async_add_entities(entities)
 
 
 class JvcProjectorSensorEntity(JvcProjectorEntity, SensorEntity):

homeassistant/components/jvc_projector/strings.json

@@ -71,6 +71,15 @@
           "off": "[%key:common::state::off%]"
         }
       },
+      "hdr_processing": {
+        "name": "HDR Processing",
+        "state": {
+          "frame_by_frame": "Frame-by-Frame",
+          "hdr10p": "HDR10+",
+          "scene_by_scene": "Scene-by-Scene",
+          "static": "Static"
+        }
+      },
       "input": {
         "name": "Input",
         "state": {
@@ -101,6 +110,23 @@
           "mid": "[%key:common::state::medium%]",
           "normal": "[%key:common::state::normal%]"
         }
+      },
+      "picture_mode": {
+        "name": "Picture Mode",
+        "state": {
+          "frame_adapt_hdr": "Frame Adapt HDR",
+          "frame_adapt_hdr2": "Frame Adapt HDR2",
+          "frame_adapt_hdr3": "Frame Adapt HDR3",
+          "hdr1": "HDR1",
+          "hdr10": "HDR10",
+          "hdr10_ll": "HDR10 LL",
+          "hdr2": "HDR2",
+          "last_setting": "Last setting",
+          "pana_pq": "Pana PQ",
+          "user_4": "User 4",
+          "user_5": "User 5",
+          "user_6": "User 6"
+        }
       }
     },
     "sensor": {
@@ -156,7 +182,7 @@
           "hdr10": "HDR10",
           "hdr10-ll": "HDR10 LL",
           "hdr2": "HDR2",
-          "last-setting": "Last Setting",
+          "last-setting": "Last setting",
           "pana-pq": "Pana PQ",
           "user-4": "User 4",
           "user-5": "User 5",
@@ -182,5 +208,15 @@
         "name": "Low latency mode"
       }
     }
+  },
+  "issues": {
+    "deprecated_sensor": {
+      "description": "The sensor {entity_name} (`{entity_id}`) is deprecated because it has been replaced with `{replacement_entity_id}`.\n\nUpdate your dashboards, templates, automations and scripts to use the replacement entity, then disable the deprecated sensor to have it removed after the next restart.",
+      "title": "Deprecated sensor detected"
+    },
+    "deprecated_sensor_scripts": {
+      "description": "The sensor {entity_name} (`{entity_id}`) is deprecated because it has been replaced with `{replacement_entity_id}`.\n\nThe sensor was used in the following automations or scripts:\n{items}\n\nUpdate the above automations or scripts to use the replacement entity, then disable the deprecated sensor to have it removed after the next restart.",
+      "title": "[%key:component::jvc_projector::issues::deprecated_sensor::title%]"
+    }
   }
 }

homeassistant/components/jvc_projector/util.py

@@ -0,0 +1,104 @@
+"""Utility helpers for the jvc_projector integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.automation import automations_with_entity
+from homeassistant.components.script import scripts_with_entity
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
+
+from .const import DOMAIN
+
+
+def deprecate_entity(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    platform_domain: str,
+    entity_unique_id: str,
+    issue_id: str,
+    issue_string: str,
+    replacement_entity_unique_id: str,
+    replacement_entity_id: str,
+    version: str = "2026.9.0",
+) -> bool:
+    """Create an issue for deprecated entities."""
+    if entity_id := entity_registry.async_get_entity_id(
+        platform_domain, DOMAIN, entity_unique_id
+    ):
+        entity_entry = entity_registry.async_get(entity_id)
+        if not entity_entry:
+            async_delete_issue(hass, DOMAIN, issue_id)
+            return False
+
+        items = get_automations_and_scripts_using_entity(hass, entity_id)
+        if entity_entry.disabled and not items:
+            entity_registry.async_remove(entity_id)
+            async_delete_issue(hass, DOMAIN, issue_id)
+            return False
+
+        translation_key = issue_string
+        placeholders = {
+            "entity_id": entity_id,
+            "entity_name": entity_entry.name or entity_entry.original_name or "Unknown",
+            "replacement_entity_id": (
+                entity_registry.async_get_entity_id(
+                    Platform.SELECT, DOMAIN, replacement_entity_unique_id
+                )
+                or replacement_entity_id
+            ),
+        }
+        if items:
+            translation_key = f"{translation_key}_scripts"
+            placeholders["items"] = "\n".join(items)
+
+        async_create_issue(
+            hass,
+            DOMAIN,
+            issue_id,
+            breaks_in_ha_version=version,
+            is_fixable=False,
+            severity=IssueSeverity.WARNING,
+            translation_key=translation_key,
+            translation_placeholders=placeholders,
+        )
+        return True
+
+    async_delete_issue(hass, DOMAIN, issue_id)
+    return False
+
+
+def get_automations_and_scripts_using_entity(
+    hass: HomeAssistant,
+    entity_id: str,
+) -> list[str]:
+    """Get automations and scripts using an entity."""
+    # These helpers return referencing automation/script entity IDs.
+    automations = automations_with_entity(hass, entity_id)
+    scripts = scripts_with_entity(hass, entity_id)
+    if not automations and not scripts:
+        return []
+
+    entity_registry = er.async_get(hass)
+    items: list[str] = []
+
+    for integration, entities in (
+        ("automation", automations),
+        ("script", scripts),
+    ):
+        for used_entity_id in entities:
+            # Prefer entity-registry metadata so we can render edit links.
+            if item := entity_registry.async_get(used_entity_id):
+                items.append(
+                    f"- [{item.original_name}](/config/{integration}/edit/{item.unique_id})"
+                )
+            else:
+                # Keep unresolved references as plain text so they still count as usage.
+                items.append(f"- `{used_entity_id}`")
+
+    return items

homeassistant/components/motion/condition.py

@@ -0,0 +1,25 @@
+"""Provides conditions for motion."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+_MOTION_DOMAIN_SPECS = {
+    BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.MOTION)
+}
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_detected": make_entity_state_condition(_MOTION_DOMAIN_SPECS, STATE_ON),
+    "is_not_detected": make_entity_state_condition(_MOTION_DOMAIN_SPECS, STATE_OFF),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for motion."""
+    return CONDITIONS

homeassistant/components/motion/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: motion
+
+is_not_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: motion

homeassistant/components/motion/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_detected": {
+      "condition": "mdi:motion-sensor"
+    },
+    "is_not_detected": {
+      "condition": "mdi:motion-sensor-off"
+    }
+  },
   "triggers": {
     "cleared": {
       "trigger": "mdi:motion-sensor-off"

homeassistant/components/motion/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted motion sensors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted motion sensors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_detected": {
+      "description": "Tests if one or more motion sensors are detecting motion.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::motion::common::condition_behavior_description%]",
+          "name": "[%key:component::motion::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Motion is detected"
+    },
+    "is_not_detected": {
+      "description": "Tests if one or more motion sensors are not detecting motion.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::motion::common::condition_behavior_description%]",
+          "name": "[%key:component::motion::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Motion is not detected"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/mqtt/abbreviations.py

@@ -18,6 +18,8 @@ ABBREVIATIONS = {
     "bri_stat_t": "brightness_state_topic",
     "bri_tpl": "brightness_template",
     "bri_val_tpl": "brightness_value_template",
+    "cln_segmnts_cmd_t": "clean_segments_command_topic",
+    "cln_segmnts_cmd_tpl": "clean_segments_command_template",
     "clr_temp_cmd_tpl": "color_temp_command_template",
     "clrm_stat_t": "color_mode_state_topic",
     "clrm_val_tpl": "color_mode_value_template",
@@ -185,6 +187,7 @@ ABBREVIATIONS = {
     "rgbww_cmd_t": "rgbww_command_topic",
     "rgbww_stat_t": "rgbww_state_topic",
     "rgbww_val_tpl": "rgbww_value_template",
+    "segmnts": "segments",
     "send_cmd_t": "send_command_topic",
     "send_if_off": "send_if_off",
     "set_fan_spd_t": "set_fan_speed_topic",

homeassistant/components/mqtt/entity.py

@@ -1484,6 +1484,7 @@ class MqttEntity(
         self._config = config
         self._setup_from_config(self._config)
         self._setup_common_attributes_from_config(self._config)
+        self._process_entity_update()
 
         # Prepare MQTT subscriptions
         self.attributes_prepare_discovery_update(config)
@@ -1586,6 +1587,10 @@ class MqttEntity(
     def _setup_from_config(self, config: ConfigType) -> None:
         """(Re)Setup the entity."""
 
+    @callback
+    def _process_entity_update(self) -> None:
+        """Process an entity discovery update."""
+
     @abstractmethod
     @callback
     def _prepare_subscribe_topics(self) -> None:

homeassistant/components/mqtt/vacuum.py

@@ -10,12 +10,13 @@ import voluptuous as vol
 from homeassistant.components import vacuum
 from homeassistant.components.vacuum import (
     ENTITY_ID_FORMAT,
+    Segment,
     StateVacuumEntity,
     VacuumActivity,
     VacuumEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_SUPPORTED_FEATURES, CONF_NAME
+from homeassistant.const import ATTR_SUPPORTED_FEATURES, CONF_NAME, CONF_UNIQUE_ID
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -27,7 +28,7 @@ from . import subscription
 from .config import MQTT_BASE_SCHEMA
 from .const import CONF_COMMAND_TOPIC, CONF_RETAIN, CONF_STATE_TOPIC
 from .entity import MqttEntity, async_setup_entity_entry_helper
-from .models import ReceiveMessage
+from .models import MqttCommandTemplate, ReceiveMessage
 from .schemas import MQTT_ENTITY_COMMON_SCHEMA
 from .util import valid_publish_topic
 
@@ -52,6 +53,9 @@ POSSIBLE_STATES: dict[str, VacuumActivity] = {
     STATE_CLEANING: VacuumActivity.CLEANING,
 }
 
+CONF_SEGMENTS = "segments"
+CONF_CLEAN_SEGMENTS_COMMAND_TOPIC = "clean_segments_command_topic"
+CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE = "clean_segments_command_template"
 CONF_SUPPORTED_FEATURES = ATTR_SUPPORTED_FEATURES
 CONF_PAYLOAD_TURN_ON = "payload_turn_on"
 CONF_PAYLOAD_TURN_OFF = "payload_turn_off"
@@ -137,8 +141,39 @@ MQTT_VACUUM_ATTRIBUTES_BLOCKED = frozenset(
 MQTT_VACUUM_DOCS_URL = "https://www.home-assistant.io/integrations/vacuum.mqtt/"
 
 
-PLATFORM_SCHEMA_MODERN = MQTT_BASE_SCHEMA.extend(
+def validate_clean_area_config(config: ConfigType) -> ConfigType:
+    """Check for a valid configuration and check segments."""
+    if (config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC not in config) or (
+        not config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC in config
+    ):
+        raise vol.Invalid(
+            f"Options `{CONF_SEGMENTS}` and "
+            f"`{CONF_CLEAN_SEGMENTS_COMMAND_TOPIC}` must be defined together"
+        )
+    segments: list[str]
+    if segments := config[CONF_SEGMENTS]:
+        if not config.get(CONF_UNIQUE_ID):
+            raise vol.Invalid(
+                f"Option `{CONF_SEGMENTS}` requires `{CONF_UNIQUE_ID}` to be configured"
+            )
+        unique_segments: set[str] = set()
+        for segment in segments:
+            segment_id, _, _ = segment.partition(".")
+            if not segment_id or segment_id in unique_segments:
+                raise vol.Invalid(
+                    f"The `{CONF_SEGMENTS}` option contains an invalid or non-"
+                    f"unique segment ID '{segment_id}'. Got {segments}"
+                )
+            unique_segments.add(segment_id)
+
+    return config
+
+
+_BASE_SCHEMA = MQTT_BASE_SCHEMA.extend(
     {
+        vol.Optional(CONF_SEGMENTS, default=[]): vol.All(cv.ensure_list, [cv.string]),
+        vol.Optional(CONF_CLEAN_SEGMENTS_COMMAND_TOPIC): valid_publish_topic,
+        vol.Optional(CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE): cv.template,
         vol.Optional(CONF_FAN_SPEED_LIST, default=[]): vol.All(
             cv.ensure_list, [cv.string]
         ),
@@ -164,7 +199,10 @@ PLATFORM_SCHEMA_MODERN = MQTT_BASE_SCHEMA.extend(
     }
 ).extend(MQTT_ENTITY_COMMON_SCHEMA.schema)
 
-DISCOVERY_SCHEMA = PLATFORM_SCHEMA_MODERN.extend({}, extra=vol.ALLOW_EXTRA)
+PLATFORM_SCHEMA_MODERN = vol.All(_BASE_SCHEMA, validate_clean_area_config)
+DISCOVERY_SCHEMA = vol.All(
+    _BASE_SCHEMA.extend({}, extra=vol.ALLOW_EXTRA), validate_clean_area_config
+)
 
 
 async def async_setup_entry(
@@ -191,9 +229,11 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
     _entity_id_format = ENTITY_ID_FORMAT
     _attributes_extra_blocked = MQTT_VACUUM_ATTRIBUTES_BLOCKED
 
+    _segments: list[Segment]
     _command_topic: str | None
     _set_fan_speed_topic: str | None
     _send_command_topic: str | None
+    _clean_segments_command_topic: str
     _payloads: dict[str, str | None]
 
     def __init__(
@@ -229,6 +269,23 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
         self._attr_supported_features = _strings_to_services(
             supported_feature_strings, STRING_TO_SERVICE
         )
+        if config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC in config:
+            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
+            segments: list[str] = config[CONF_SEGMENTS]
+            self._segments = [
+                Segment(id=segment_id, name=name or segment_id)
+                for segment_id, _, name in [
+                    segment.partition(".") for segment in segments
+                ]
+            ]
+            self._clean_segments_command_topic = config[
+                CONF_CLEAN_SEGMENTS_COMMAND_TOPIC
+            ]
+            self._clean_segments_command_template = MqttCommandTemplate(
+                config.get(CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE),
+                entity=self,
+            ).async_render
+
         self._attr_fan_speed_list = config[CONF_FAN_SPEED_LIST]
         self._command_topic = config.get(CONF_COMMAND_TOPIC)
         self._set_fan_speed_topic = config.get(CONF_SET_FAN_SPEED_TOPIC)
@@ -246,6 +303,20 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
             )
         }
 
+    @callback
+    def _process_entity_update(self) -> None:
+        """Check vacuum segments with registry entry."""
+        if (
+            self._attr_supported_features & VacuumEntityFeature.CLEAN_AREA
+            and (last_seen := self.last_seen_segments) is not None
+            and {s.id: s for s in last_seen} != {s.id: s for s in self._segments}
+        ):
+            self.async_create_segments_issue()
+
+    async def mqtt_async_added_to_hass(self) -> None:
+        """Check vacuum segments with registry entry."""
+        self._process_entity_update()
+
     def _update_state_attributes(self, payload: dict[str, Any]) -> None:
         """Update the entity state attributes."""
         self._state_attrs.update(payload)
@@ -277,6 +348,19 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
         """(Re)Subscribe to topics."""
         subscription.async_subscribe_topics_internal(self.hass, self._sub_state)
 
+    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
+        """Perform an area clean."""
+        await self.async_publish_with_config(
+            self._clean_segments_command_topic,
+            self._clean_segments_command_template(
+                json_dumps(segment_ids), {"value": segment_ids}
+            ),
+        )
+
+    async def async_get_segments(self) -> list[Segment]:
+        """Return the available segments."""
+        return self._segments
+
     async def _async_publish_command(self, feature: VacuumEntityFeature) -> None:
         """Publish a command."""
         if self._command_topic is None:

homeassistant/components/occupancy/condition.py

@@ -0,0 +1,25 @@
+"""Provides conditions for occupancy."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+_OCCUPANCY_DOMAIN_SPECS = {
+    BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.OCCUPANCY)
+}
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_detected": make_entity_state_condition(_OCCUPANCY_DOMAIN_SPECS, STATE_ON),
+    "is_not_detected": make_entity_state_condition(_OCCUPANCY_DOMAIN_SPECS, STATE_OFF),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for occupancy."""
+    return CONDITIONS

homeassistant/components/occupancy/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy
+
+is_not_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy

homeassistant/components/occupancy/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_detected": {
+      "condition": "mdi:home-account"
+    },
+    "is_not_detected": {
+      "condition": "mdi:home-outline"
+    }
+  },
   "triggers": {
     "cleared": {
       "trigger": "mdi:home-outline"

homeassistant/components/occupancy/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted occupancy sensors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted occupancy sensors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_detected": {
+      "description": "Tests if one or more occupancy sensors are detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::condition_behavior_description%]",
+          "name": "[%key:component::occupancy::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Occupancy is detected"
+    },
+    "is_not_detected": {
+      "description": "Tests if one or more occupancy sensors are not detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::condition_behavior_description%]",
+          "name": "[%key:component::occupancy::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Occupancy is not detected"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/opower/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["opower==0.17.0"]
 }

homeassistant/components/opower/quality_scale.yaml

@@ -58,7 +58,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
@@ -71,7 +71,7 @@ rules:
     status: exempt
     comment: The integration has no user-configurable options that are not authentication-related.
   repair-issues: done
-  stale-devices: todo
+  stale-devices: done
 
   # Platinum
   async-dependency: done

homeassistant/components/opower/sensor.py

@@ -15,7 +15,8 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import EntityCategory, UnitOfEnergy, UnitOfVolume
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -207,48 +208,102 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Opower sensor."""
-
     coordinator = entry.runtime_data
-    entities: list[OpowerSensor] = []
-    opower_data_list = coordinator.data.values()
-    for opower_data in opower_data_list:
-        account = opower_data.account
-        forecast = opower_data.forecast
-        device_id = (
-            f"{coordinator.api.utility.subdomain()}_{account.utility_account_id}"
-        )
-        device = DeviceInfo(
-            identifiers={(DOMAIN, device_id)},
-            name=f"{account.meter_type.name} account {account.utility_account_id}",
-            manufacturer="Opower",
-            model=coordinator.api.utility.name(),
-            entry_type=DeviceEntryType.SERVICE,
-        )
-        sensors: tuple[OpowerEntityDescription, ...] = COMMON_SENSORS
-        if (
-            account.meter_type == MeterType.ELEC
-            and forecast is not None
-            and forecast.unit_of_measure == UnitOfMeasure.KWH
-        ):
-            sensors += ELEC_SENSORS
-        elif (
-            account.meter_type == MeterType.GAS
-            and forecast is not None
-            and forecast.unit_of_measure in [UnitOfMeasure.THERM, UnitOfMeasure.CCF]
-        ):
-            sensors += GAS_SENSORS
-        entities.extend(
-            OpowerSensor(
-                coordinator,
-                sensor,
-                account.utility_account_id,
-                device,
-                device_id,
-            )
-            for sensor in sensors
-        )
+    created_sensors: set[tuple[str, str]] = set()
 
-    async_add_entities(entities)
+    @callback
+    def _update_entities() -> None:
+        """Update entities."""
+        new_entities: list[OpowerSensor] = []
+        current_account_device_ids: set[str] = set()
+        current_account_ids: set[str] = set()
+
+        for opower_data in coordinator.data.values():
+            account = opower_data.account
+            forecast = opower_data.forecast
+            device_id = (
+                f"{coordinator.api.utility.subdomain()}_{account.utility_account_id}"
+            )
+            current_account_device_ids.add(device_id)
+            current_account_ids.add(account.utility_account_id)
+            device = DeviceInfo(
+                identifiers={(DOMAIN, device_id)},
+                name=f"{account.meter_type.name} account {account.utility_account_id}",
+                manufacturer="Opower",
+                model=coordinator.api.utility.name(),
+                entry_type=DeviceEntryType.SERVICE,
+            )
+            sensors: tuple[OpowerEntityDescription, ...] = COMMON_SENSORS
+            if (
+                account.meter_type == MeterType.ELEC
+                and forecast is not None
+                and forecast.unit_of_measure == UnitOfMeasure.KWH
+            ):
+                sensors += ELEC_SENSORS
+            elif (
+                account.meter_type == MeterType.GAS
+                and forecast is not None
+                and forecast.unit_of_measure in [UnitOfMeasure.THERM, UnitOfMeasure.CCF]
+            ):
+                sensors += GAS_SENSORS
+            for sensor in sensors:
+                sensor_key = (account.utility_account_id, sensor.key)
+                if sensor_key in created_sensors:
+                    continue
+                created_sensors.add(sensor_key)
+                new_entities.append(
+                    OpowerSensor(
+                        coordinator,
+                        sensor,
+                        account.utility_account_id,
+                        device,
+                        device_id,
+                    )
+                )
+
+        if new_entities:
+            async_add_entities(new_entities)
+
+        # Remove any registered devices not in the current coordinator data
+        device_registry = dr.async_get(hass)
+        entity_registry = er.async_get(hass)
+        for device_entry in dr.async_entries_for_config_entry(
+            device_registry, entry.entry_id
+        ):
+            device_domain_ids = {
+                identifier[1]
+                for identifier in device_entry.identifiers
+                if identifier[0] == DOMAIN
+            }
+            if not device_domain_ids:
+                # This device has no Opower identifiers; it may be a merged/shared
+                # device owned by another integration. Do not alter it here.
+                continue
+            if not device_domain_ids.isdisjoint(current_account_device_ids):
+                continue  # device is still active
+            # Device is stale — remove its entities then detach it
+            for entity_entry in er.async_entries_for_device(
+                entity_registry, device_entry.id, include_disabled_entities=True
+            ):
+                if entity_entry.config_entry_id != entry.entry_id:
+                    continue
+                entity_registry.async_remove(entity_entry.entity_id)
+            device_registry.async_update_device(
+                device_entry.id, remove_config_entry_id=entry.entry_id
+            )
+
+        # Prune sensor tracking for accounts that are no longer present
+        if created_sensors:
+            stale_sensor_keys = {
+                sensor_key
+                for sensor_key in created_sensors
+                if sensor_key[0] not in current_account_ids
+            }
+            if stale_sensor_keys:
+                created_sensors.difference_update(stale_sensor_keys)
+
+    _update_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_update_entities))
 
 
 class OpowerSensor(CoordinatorEntity[OpowerCoordinator], SensorEntity):
@@ -272,6 +327,11 @@ class OpowerSensor(CoordinatorEntity[OpowerCoordinator], SensorEntity):
         self._attr_device_info = device
         self.utility_account_id = utility_account_id
 
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self.utility_account_id in self.coordinator.data
+
     @property
     def native_value(self) -> StateType | date | datetime:
         """Return the state."""

homeassistant/components/plugwise/coordinator.py

@@ -65,6 +65,7 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         )
         self._connected: bool = False
         self._current_devices: set[str] = set()
+        self._firmware_list: dict[str, str | None] = {}
         self._stored_devices: set[str] = set()
         self.new_devices: set[str] = set()
 
@@ -129,6 +130,7 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
             ) from err
 
         self._add_remove_devices(data)
+        self._update_device_firmware(data)
         return data
 
     def _add_remove_devices(self, data: dict[str, GwEntityData]) -> None:
@@ -138,6 +140,9 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         # 'new_devices' contains all devices present in 'data' at init ('self._current_devices' is empty)
         # this is required for the proper initialization of all the present platform entities.
         self.new_devices = set_of_data - self._current_devices
+        for device_id in self.new_devices:
+            self._firmware_list.setdefault(device_id, data[device_id].get("firmware"))
+
         current_devices = (
             self._stored_devices if not self._current_devices else self._current_devices
         )
@@ -149,21 +154,52 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         """Clean registries when removed devices found."""
         device_reg = dr.async_get(self.hass)
         for device_id in removed_devices:
-            device_entry = device_reg.async_get_device({(DOMAIN, device_id)})
-            if device_entry is None:
-                LOGGER.warning(
-                    "Failed to remove %s device/zone %s, not present in device_registry",
+            if (
+                device_entry := device_reg.async_get_device({(DOMAIN, device_id)})
+            ) is not None:
+                device_reg.async_update_device(
+                    device_entry.id, remove_config_entry_id=self.config_entry.entry_id
+                )
+                LOGGER.debug(
+                    "%s %s %s removed from device_registry",
                     DOMAIN,
+                    device_entry.model,
                     device_id,
                 )
-                continue  # pragma: no cover
 
-            device_reg.async_update_device(
-                device_entry.id, remove_config_entry_id=self.config_entry.entry_id
-            )
+            self._firmware_list.pop(device_id, None)
+
+    def _update_device_firmware(self, data: dict[str, GwEntityData]) -> None:
+        """Detect firmware changes and update the device registry."""
+        for device_id, device in data.items():
+            # Only update firmware when the key is present and not None, to avoid
+            # wiping stored firmware on partial or transient updates.
+            if "firmware" not in device:
+                continue
+            new_firmware = device.get("firmware")
+            if new_firmware is None:
+                continue
+            if (
+                device_id in self._firmware_list
+                and new_firmware != self._firmware_list[device_id]
+            ):
+                updated = self._update_firmware_in_dr(device_id, new_firmware)
+                if updated:
+                    self._firmware_list[device_id] = new_firmware
+
+    def _update_firmware_in_dr(self, device_id: str, firmware: str | None) -> bool:
+        """Update device sw_version in device_registry."""
+        device_reg = dr.async_get(self.hass)
+        if (
+            device_entry := device_reg.async_get_device({(DOMAIN, device_id)})
+        ) is not None:
+            device_reg.async_update_device(device_entry.id, sw_version=firmware)
             LOGGER.debug(
-                "%s %s %s removed from device_registry",
+                "Firmware in device_registry updated for %s %s %s",
                 DOMAIN,
                 device_entry.model,
                 device_id,
             )
+            return True
+
+        return False  # pragma: no cover

homeassistant/components/prana/__init__.py

@@ -14,7 +14,7 @@ from .coordinator import PranaConfigEntry, PranaCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORMS = [Platform.FAN, Platform.SENSOR, Platform.SWITCH]
+PLATFORMS = [Platform.FAN, Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: PranaConfigEntry) -> bool: