Remove redundant default "context: ."

This PR completely drops usage of the builder action in favor of new actions
introduced in home-assistant/builder#273. This results in faster builds with
better caching options and simple local builds using Docker BuildKit.

The image dependency chain currently still uses per-arch builds but once
docker-base and docker repositories start publishing multi-arch images, we can
simplify the action a bit further.

The idea to use composite actions comes from #162245 and this PR fully predates
it. There is minor difference that the files generated twice in per-arch builds
are now generated and archived by the init job.

.claude/skills/integrations/SKILL.md

@@ -620,14 +620,12 @@ 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
@@ -74,43 +75,8 @@ jobs:
         env:
           LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }} # zizmor: ignore[secrets-outside-env]
 
-      - name: Archive translations
-        shell: bash
-        run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
-
-      - name: Upload translations
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
-        with:
-          name: translations
-          path: translations.tar.gz
-          if-no-files-found: error
-
-  build_base:
-    name: Build ${{ matrix.arch }} base core image
-    if: github.repository_owner == 'home-assistant'
-    needs: init
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      id-token: write # For cosign signing
-    strategy:
-      fail-fast: false
-      matrix:
-        arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        include:
-          - arch: amd64
-            os: ubuntu-latest
-          - arch: aarch64
-            os: ubuntu-24.04-arm
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-
       - name: Download nightly wheels of frontend
-        if: needs.init.outputs.channel == 'dev'
+        if: steps.version.outputs.channel == 'dev'
         uses: dawidd6/action-download-artifact@2536c51d3d126276eb39f74d6bc9c72ac6ef30d3 # v16
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
@@ -121,7 +87,7 @@ jobs:
           name: wheels
 
       - name: Download nightly wheels of intents
-        if: needs.init.outputs.channel == 'dev'
+        if: steps.version.outputs.channel == 'dev'
         uses: dawidd6/action-download-artifact@2536c51d3d126276eb39f74d6bc9c72ac6ef30d3 # v16
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
@@ -131,18 +97,12 @@ jobs:
           workflow_conclusion: success
           name: package
 
-      - name: Set up Python
-        if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version-file: ".python-version"
-
       - name: Adjust nightly version
-        if: needs.init.outputs.channel == 'dev'
+        if: steps.version.outputs.channel == 'dev'
         shell: bash
         env:
           UV_PRERELEASE: allow
-          VERSION: ${{ needs.init.outputs.version }}
+          VERSION: ${{ steps.version.outputs.version }}
         run: |
           python3 -m pip install "$(grep '^uv' < requirements.txt)"
           uv pip install packaging tomli
@@ -180,92 +140,71 @@ jobs:
             sed -i "s|home-assistant-intents==.*||" requirements_all.txt requirements.txt
           fi
 
-      - name: Download translations
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
-        with:
-          name: translations
-
-      - name: Extract translations
-        run: |
-          tar xvf translations.tar.gz
-          rm translations.tar.gz
-
       - name: Write meta info file
         shell: bash
         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
+      - name: Upload build context overlay
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+          name: build-context
+          if-no-files-found: ignore
+          path: |
+            homeassistant/components/*/translations/
+            rootfs/OFFICIAL_IMAGE
+            home_assistant_frontend-*.whl
+            home_assistant_intents-*.whl
+            homeassistant/const.py
+            homeassistant/components/frontend/manifest.json
+            homeassistant/components/conversation/manifest.json
+            homeassistant/package_constraints.txt
+            requirements_all.txt
+            requirements.txt
+            pyproject.toml
 
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
+  build_base:
+    name: Build ${{ matrix.arch }} base core image
+    if: github.repository_owner == 'home-assistant'
+    needs: init
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read # To check out the repository
+      packages: write # To push to GHCR
+      id-token: write # For cosign signing
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            os: ubuntu-24.04
+          - arch: aarch64
+            os: ubuntu-24.04-arm
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          cosign-release: "v2.5.3"
+          persist-credentials: false
 
-      - 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: Download build context overlay
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        with:
+          name: build-context
 
       - 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 +253,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
@@ -542,15 +484,10 @@ jobs:
         with:
           python-version-file: ".python-version"
 
-      - name: Download translations
+      - name: Download build context overlay
         uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
-          name: translations
-
-      - name: Extract translations
-        run: |
-          tar xvf translations.tar.gz
-          rm translations.tar.gz
+          name: build-context
 
       - name: Build package
         shell: bash

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/aladdin_connect/__init__.py

@@ -46,10 +46,19 @@ async def async_setup_entry(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    coordinator = AladdinConnectCoordinator(hass, entry, client)
-    await coordinator.async_config_entry_first_refresh()
+    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
 
-    entry.runtime_data = coordinator
+    entry.runtime_data = {
+        door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)
+        for door in doors
+    }
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -91,7 +100,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.data)
+    all_device_ids = set(config_entry.runtime_data)
 
     for device_entry in device_entries:
         device_id: str | None = None

homeassistant/components/aladdin_connect/coordinator.py

@@ -11,24 +11,22 @@ 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[AladdinConnectCoordinator]
+type AladdinConnectConfigEntry = ConfigEntry[dict[str, AladdinConnectCoordinator]]
 SCAN_INTERVAL = timedelta(seconds=15)
 
 
-class AladdinConnectCoordinator(DataUpdateCoordinator[dict[str, GarageDoor]]):
+class AladdinConnectCoordinator(DataUpdateCoordinator[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__(
@@ -39,16 +37,18 @@ class AladdinConnectCoordinator(DataUpdateCoordinator[dict[str, GarageDoor]]):
             update_interval=SCAN_INTERVAL,
         )
         self.client = client
+        self.data = garage_door
 
-    async def _async_update_data(self) -> dict[str, GarageDoor]:
+    async def _async_update_data(self) -> GarageDoor:
         """Fetch data from the Aladdin Connect API."""
         try:
-            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
+            await self.client.update_door(self.data.device_id, self.data.door_number)
         except aiohttp.ClientError as err:
             raise UpdateFailed(f"Error communicating with API: {err}") from err
-
-        return {door.unique_id: door for door in doors}
+        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

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, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -24,22 +24,11 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the cover platform."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
+    coordinators = entry.runtime_data
 
-    @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))
+    async_add_entities(
+        AladdinCoverEntity(coordinator) for coordinator in coordinators.values()
+    )
 
 
 class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
@@ -49,10 +38,10 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     _attr_supported_features = SUPPORTED_FEATURES
     _attr_name = None
 
-    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
         """Initialize the Aladdin Connect cover."""
-        super().__init__(coordinator, door_id)
-        self._attr_unique_id = door_id
+        super().__init__(coordinator)
+        self._attr_unique_id = coordinator.data.unique_id
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Issue open command to cover."""
@@ -77,16 +66,16 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     @property
     def is_closed(self) -> bool | None:
         """Update is closed attribute."""
-        if (status := self.door.status) is None:
+        if (status := self.coordinator.data.status) is None:
             return None
         return status == "closed"
 
     @property
     def is_closing(self) -> bool | None:
         """Update is closing attribute."""
-        return self.door.status == "closing"
+        return self.coordinator.data.status == "closing"
 
     @property
     def is_opening(self) -> bool | None:
         """Update is opening attribute."""
-        return self.door.status == "opening"
+        return self.coordinator.data.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": door.device_id,
-                "door_number": door.door_number,
-                "name": door.name,
-                "status": door.status,
-                "link_status": door.link_status,
-                "battery_level": door.battery_level,
+                "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,
             }
-            for uid, door in config_entry.runtime_data.data.items()
+            for uid, coordinator in config_entry.runtime_data.items()
         },
     }

homeassistant/components/aladdin_connect/entity.py

@@ -1,7 +1,6 @@
 """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
@@ -15,28 +14,17 @@ class AladdinConnectEntity(CoordinatorEntity[AladdinConnectCoordinator]):
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
         """Initialize Aladdin Connect entity."""
         super().__init__(coordinator)
-        self._door_id = door_id
-        door = self.door
+        device = coordinator.data
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, door.unique_id)},
+            identifiers={(DOMAIN, device.unique_id)},
             manufacturer="Aladdin Connect",
-            name=door.name,
+            name=device.name,
         )
-        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]
+        self._device_id = device.device_id
+        self._number = device.door_number
 
     @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: done
+  dynamic-devices: todo
   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, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
@@ -49,24 +49,13 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Aladdin Connect sensor devices."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
+    coordinators = entry.runtime_data
 
-    @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))
+    async_add_entities(
+        AladdinConnectSensor(coordinator, description)
+        for coordinator in coordinators.values()
+        for description in SENSOR_TYPES
+    )
 
 
 class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
@@ -77,15 +66,14 @@ class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
     def __init__(
         self,
         coordinator: AladdinConnectCoordinator,
-        door_id: str,
         entity_description: AladdinConnectSensorEntityDescription,
     ) -> None:
         """Initialize the Aladdin Connect sensor."""
-        super().__init__(coordinator, door_id)
+        super().__init__(coordinator)
         self.entity_description = entity_description
-        self._attr_unique_id = f"{door_id}-{entity_description.key}"
+        self._attr_unique_id = f"{coordinator.data.unique_id}-{entity_description.key}"
 
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
-        return self.entity_description.value_fn(self.door)
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/automation/__init__.py

@@ -129,7 +129,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "light",
     "lock",
     "media_player",
-    "occupancy",
     "person",
     "siren",
     "switch",

homeassistant/components/demo/valve.py

@@ -9,12 +9,9 @@ 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
 
 
@@ -26,10 +23,10 @@ async def async_setup_entry(
     """Set up the Demo config entry."""
     async_add_entities(
         [
-            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),
+            DemoValve("Front Garden", ValveState.OPEN),
+            DemoValve("Orchard", ValveState.CLOSED),
+            DemoValve("Back Garden", ValveState.CLOSED, position=70),
+            DemoValve("Trees", ValveState.CLOSED, position=30),
         ]
     )
 
@@ -37,24 +34,17 @@ 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_unique_id = unique_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, unique_id)},
-            name=name,
-        )
+        self._attr_name = name
         if moveable:
             self._attr_supported_features = (
                 ValveEntityFeature.OPEN | ValveEntityFeature.CLOSE

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

homeassistant/components/mqtt/abbreviations.py

@@ -18,8 +18,6 @@ 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",
@@ -187,7 +185,6 @@ 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,7 +1484,6 @@ 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)
@@ -1587,10 +1586,6 @@ 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,13 +10,12 @@ 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, CONF_UNIQUE_ID
+from homeassistant.const import ATTR_SUPPORTED_FEATURES, CONF_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -28,7 +27,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 MqttCommandTemplate, ReceiveMessage
+from .models import ReceiveMessage
 from .schemas import MQTT_ENTITY_COMMON_SCHEMA
 from .util import valid_publish_topic
 
@@ -53,9 +52,6 @@ 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"
@@ -141,39 +137,8 @@ MQTT_VACUUM_ATTRIBUTES_BLOCKED = frozenset(
 MQTT_VACUUM_DOCS_URL = "https://www.home-assistant.io/integrations/vacuum.mqtt/"
 
 
-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(
+PLATFORM_SCHEMA_MODERN = 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]
         ),
@@ -199,10 +164,7 @@ _BASE_SCHEMA = MQTT_BASE_SCHEMA.extend(
     }
 ).extend(MQTT_ENTITY_COMMON_SCHEMA.schema)
 
-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
-)
+DISCOVERY_SCHEMA = PLATFORM_SCHEMA_MODERN.extend({}, extra=vol.ALLOW_EXTRA)
 
 
 async def async_setup_entry(
@@ -229,11 +191,9 @@ 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__(
@@ -269,23 +229,6 @@ 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)
@@ -303,20 +246,6 @@ 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)
@@ -348,19 +277,6 @@ 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

@@ -1,39 +0,0 @@
-"""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, EntityStateConditionBase
-
-
-class OccupancyIsDetectedCondition(EntityStateConditionBase):
-    """Condition for occupancy detected (binary sensor ON)."""
-
-    _domain_specs = {
-        BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.OCCUPANCY)
-    }
-    _states = {STATE_ON}
-
-
-class OccupancyIsNotDetectedCondition(EntityStateConditionBase):
-    """Condition for occupancy not detected (binary sensor OFF)."""
-
-    _domain_specs = {
-        BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.OCCUPANCY)
-    }
-    _states = {STATE_OFF}
-
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "is_detected": OccupancyIsDetectedCondition,
-    "is_not_detected": OccupancyIsNotDetectedCondition,
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the conditions for occupancy."""
-    return CONDITIONS

homeassistant/components/occupancy/conditions.yaml

@@ -1,24 +0,0 @@
-.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,12 +1,4 @@
 {
-  "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,39 +1,9 @@
 {
   "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": "platinum",
+  "quality_scale": "silver",
   "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: done
+  dynamic-devices: todo
   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: done
+  stale-devices: todo
 
   # Platinum
   async-dependency: done

homeassistant/components/opower/sensor.py

@@ -15,8 +15,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import EntityCategory, UnitOfEnergy, UnitOfVolume
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -208,102 +207,48 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Opower sensor."""
+
     coordinator = entry.runtime_data
-    created_sensors: set[tuple[str, str]] = set()
-
-    @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
+    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
         ):
-            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
+            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
+        )
 
-        # 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))
+    async_add_entities(entities)
 
 
 class OpowerSensor(CoordinatorEntity[OpowerCoordinator], SensorEntity):
@@ -327,11 +272,6 @@ 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/prana/__init__.py

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

homeassistant/components/prana/fan.py

@@ -21,8 +21,8 @@ from homeassistant.util.percentage import (
 )
 from homeassistant.util.scaling import int_states_in_range
 
-from .coordinator import PranaConfigEntry, PranaCoordinator
-from .entity import PranaBaseEntity
+from . import PranaConfigEntry
+from .entity import PranaBaseEntity, PranaCoordinator
 
 PARALLEL_UPDATES = 1
 

homeassistant/components/prana/icons.json

@@ -8,20 +8,6 @@
         "default": "mdi:arrow-expand-left"
       }
     },
-    "number": {
-      "display_brightness": {
-        "default": "mdi:brightness-6",
-        "state": {
-          "0": "mdi:brightness-2",
-          "1": "mdi:brightness-4",
-          "2": "mdi:brightness-4",
-          "3": "mdi:brightness-5",
-          "4": "mdi:brightness-5",
-          "5": "mdi:brightness-7",
-          "6": "mdi:brightness-7"
-        }
-      }
-    },
     "sensor": {
       "inside_temperature": {
         "default": "mdi:home-thermometer"

homeassistant/components/prana/number.py

@@ -1,80 +0,0 @@
-"""Number platform for Prana integration."""
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import Any
-
-from homeassistant.components.number import (
-    NumberEntity,
-    NumberEntityDescription,
-    NumberMode,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import PranaConfigEntry, PranaCoordinator
-from .entity import PranaBaseEntity
-
-PARALLEL_UPDATES = 1
-
-
-class PranaNumberType(StrEnum):
-    """Enumerates Prana number types exposed by the device API."""
-
-    DISPLAY_BRIGHTNESS = "display_brightness"
-
-
-@dataclass(frozen=True, kw_only=True)
-class PranaNumberEntityDescription(NumberEntityDescription):
-    """Description of a Prana number entity."""
-
-    key: PranaNumberType
-    value_fn: Callable[[PranaCoordinator], float | None]
-    set_value_fn: Callable[[Any, float], Any]
-
-
-ENTITIES: tuple[PranaNumberEntityDescription, ...] = (
-    PranaNumberEntityDescription(
-        key=PranaNumberType.DISPLAY_BRIGHTNESS,
-        translation_key="display_brightness",
-        native_min_value=0,
-        native_max_value=6,
-        native_step=1,
-        mode=NumberMode.SLIDER,
-        entity_category=EntityCategory.CONFIG,
-        value_fn=lambda coord: coord.data.brightness,
-        set_value_fn=lambda api, val: api.set_brightness(
-            0 if val == 0 else 2 ** (int(val) - 1)
-        ),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: PranaConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Prana number entities from a config entry."""
-    async_add_entities(
-        PranaNumber(entry.runtime_data, entity_description)
-        for entity_description in ENTITIES
-    )
-
-
-class PranaNumber(PranaBaseEntity, NumberEntity):
-    """Representation of a Prana number entity."""
-
-    entity_description: PranaNumberEntityDescription
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the entity value."""
-        return self.entity_description.value_fn(self.coordinator)
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set new value."""
-        await self.entity_description.set_value_fn(self.coordinator.api_client, value)
-        await self.coordinator.async_refresh()

homeassistant/components/prana/sensor.py

@@ -21,8 +21,8 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import PranaConfigEntry, PranaCoordinator
-from .entity import PranaBaseEntity
+from . import PranaConfigEntry
+from .entity import PranaBaseEntity, PranaCoordinator
 
 PARALLEL_UPDATES = 1
 

homeassistant/components/prana/strings.json

@@ -49,11 +49,6 @@
         }
       }
     },
-    "number": {
-      "display_brightness": {
-        "name": "Display brightness"
-      }
-    },
     "sensor": {
       "inside_temperature": {
         "name": "Inside temperature"

homeassistant/components/prana/switch.py

@@ -9,7 +9,7 @@ from homeassistant.components.switch import SwitchEntity, SwitchEntityDescriptio
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import PranaConfigEntry, PranaCoordinator
+from . import PranaConfigEntry, PranaCoordinator
 from .entity import PranaBaseEntity
 
 PARALLEL_UPDATES = 1

homeassistant/components/radio_browser/media_source.py

@@ -4,11 +4,10 @@ from __future__ import annotations
 
 import mimetypes
 
-from aiodns.error import DNSError
 import pycountry
-from radios import FilterBy, Order, RadioBrowser, RadioBrowserError, Station
+from radios import FilterBy, Order, RadioBrowser, Station
 
-from homeassistant.components.media_player import BrowseError, MediaClass, MediaType
+from homeassistant.components.media_player import MediaClass, MediaType
 from homeassistant.components.media_source import (
     BrowseMediaSource,
     MediaSource,
@@ -16,7 +15,6 @@ from homeassistant.components.media_source import (
     PlayMedia,
     Unresolvable,
 )
-from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.util.location import vincenty
 
@@ -57,20 +55,9 @@ class RadioMediaSource(MediaSource):
 
     async def async_resolve_media(self, item: MediaSourceItem) -> PlayMedia:
         """Resolve selected Radio station to a streaming URL."""
-
-        if self.entry.state != ConfigEntryState.LOADED:
-            raise Unresolvable(
-                translation_domain=DOMAIN,
-                translation_key="config_entry_not_ready",
-            )
         radios = self.radios
-        try:
-            station = await radios.station(uuid=item.identifier)
-        except (DNSError, RadioBrowserError) as e:
-            raise Unresolvable(
-                translation_domain=DOMAIN,
-                translation_key="radio_browser_error",
-            ) from e
+
+        station = await radios.station(uuid=item.identifier)
         if not station:
             raise Unresolvable("Radio station is no longer available")
 
@@ -87,37 +74,25 @@ class RadioMediaSource(MediaSource):
         item: MediaSourceItem,
     ) -> BrowseMediaSource:
         """Return media."""
-
-        if self.entry.state != ConfigEntryState.LOADED:
-            raise BrowseError(
-                translation_domain=DOMAIN,
-                translation_key="config_entry_not_ready",
-            )
         radios = self.radios
 
-        try:
-            return BrowseMediaSource(
-                domain=DOMAIN,
-                identifier=None,
-                media_class=MediaClass.CHANNEL,
-                media_content_type=MediaType.MUSIC,
-                title=self.entry.title,
-                can_play=False,
-                can_expand=True,
-                children_media_class=MediaClass.DIRECTORY,
-                children=[
-                    *await self._async_build_popular(radios, item),
-                    *await self._async_build_by_tag(radios, item),
-                    *await self._async_build_by_language(radios, item),
-                    *await self._async_build_local(radios, item),
-                    *await self._async_build_by_country(radios, item),
-                ],
-            )
-        except (DNSError, RadioBrowserError) as e:
-            raise BrowseError(
-                translation_domain=DOMAIN,
-                translation_key="radio_browser_error",
-            ) from e
+        return BrowseMediaSource(
+            domain=DOMAIN,
+            identifier=None,
+            media_class=MediaClass.CHANNEL,
+            media_content_type=MediaType.MUSIC,
+            title=self.entry.title,
+            can_play=False,
+            can_expand=True,
+            children_media_class=MediaClass.DIRECTORY,
+            children=[
+                *await self._async_build_popular(radios, item),
+                *await self._async_build_by_tag(radios, item),
+                *await self._async_build_by_language(radios, item),
+                *await self._async_build_local(radios, item),
+                *await self._async_build_by_country(radios, item),
+            ],
+        )
 
     @callback
     @staticmethod

homeassistant/components/radio_browser/strings.json

@@ -5,13 +5,5 @@
         "description": "Do you want to add Radio Browser to Home Assistant?"
       }
     }
-  },
-  "exceptions": {
-    "config_entry_not_ready": {
-      "message": "Radio Browser integration is not ready"
-    },
-    "radio_browser_error": {
-      "message": "Error occurred while communicating with Radio Browser"
-    }
   }
 }

homeassistant/components/roborock/manifest.json

@@ -20,7 +20,7 @@
   "loggers": ["roborock"],
   "quality_scale": "silver",
   "requirements": [
-    "python-roborock==4.25.0",
+    "python-roborock==4.20.0",
     "vacuum-map-parser-roborock==0.1.4"
   ]
 }

homeassistant/components/season/sensor.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import date, datetime
 
 import ephem
 
@@ -12,7 +12,7 @@ from homeassistant.const import CONF_TYPE
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util import dt as dt_util
+from homeassistant.util.dt import utcnow
 
 from .const import DOMAIN, TYPE_ASTRONOMICAL
 
@@ -50,7 +50,7 @@ async def async_setup_entry(
 
 
 def get_season(
-    current_datetime: datetime, hemisphere: str, season_tracking_type: str
+    current_date: date, hemisphere: str, season_tracking_type: str
 ) -> str | None:
     """Calculate the current season."""
 
@@ -58,36 +58,22 @@ def get_season(
         return None
 
     if season_tracking_type == TYPE_ASTRONOMICAL:
-        spring_start = (
-            ephem.next_equinox(str(current_datetime.year))
-            .datetime()
-            .replace(tzinfo=dt_util.UTC)
-        )
-        summer_start = (
-            ephem.next_solstice(str(current_datetime.year))
-            .datetime()
-            .replace(tzinfo=dt_util.UTC)
-        )
-        autumn_start = (
-            ephem.next_equinox(spring_start).datetime().replace(tzinfo=dt_util.UTC)
-        )
-        winter_start = (
-            ephem.next_solstice(summer_start).datetime().replace(tzinfo=dt_util.UTC)
-        )
+        spring_start = ephem.next_equinox(str(current_date.year)).datetime()
+        summer_start = ephem.next_solstice(str(current_date.year)).datetime()
+        autumn_start = ephem.next_equinox(spring_start).datetime()
+        winter_start = ephem.next_solstice(summer_start).datetime()
     else:
-        spring_start = current_datetime.replace(
-            month=3, day=1, hour=0, minute=0, second=0, microsecond=0
-        )
+        spring_start = datetime(2017, 3, 1).replace(year=current_date.year)
         summer_start = spring_start.replace(month=6)
         autumn_start = spring_start.replace(month=9)
         winter_start = spring_start.replace(month=12)
 
     season = STATE_WINTER
-    if spring_start <= current_datetime < summer_start:
+    if spring_start <= current_date < summer_start:
         season = STATE_SPRING
-    elif summer_start <= current_datetime < autumn_start:
+    elif summer_start <= current_date < autumn_start:
         season = STATE_SUMMER
-    elif autumn_start <= current_datetime < winter_start:
+    elif autumn_start <= current_date < winter_start:
         season = STATE_AUTUMN
 
     # If user is located in the southern hemisphere swap the season
@@ -118,4 +104,6 @@ class SeasonSensorEntity(SensorEntity):
 
     def update(self) -> None:
         """Update season."""
-        self._attr_native_value = get_season(dt_util.now(), self.hemisphere, self.type)
+        self._attr_native_value = get_season(
+            utcnow().replace(tzinfo=None), self.hemisphere, self.type
+        )

homeassistant/components/smartthings/manifest.json

@@ -38,5 +38,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==3.7.2"]
+  "requirements": ["pysmartthings==3.7.0"]
 }

homeassistant/components/todo/__init__.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable
-import copy
 import dataclasses
 import datetime
 import logging
@@ -29,6 +28,7 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
+from homeassistant.util.json import JsonValueType
 
 from .const import (
     ATTR_DESCRIPTION,
@@ -240,7 +240,7 @@ class TodoListEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     """An entity that represents a To-do list."""
 
     _attr_todo_items: list[TodoItem] | None = None
-    _update_listeners: list[Callable[[list[TodoItem]], None]] | None = None
+    _update_listeners: list[Callable[[list[JsonValueType] | None], None]] | None = None
 
     @property
     def state(self) -> int | None:
@@ -281,9 +281,13 @@ class TodoListEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     @final
     @callback
     def async_subscribe_updates(
-        self, listener: Callable[[list[TodoItem]], None]
+        self,
+        listener: Callable[[list[JsonValueType] | None], None],
     ) -> CALLBACK_TYPE:
-        """Subscribe to To-do list item updates."""
+        """Subscribe to To-do list item updates.
+
+        Called by websocket API.
+        """
         if self._update_listeners is None:
             self._update_listeners = []
         self._update_listeners.append(listener)
@@ -302,7 +306,9 @@ class TodoListEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         if not self._update_listeners:
             return
 
-        todo_items = [copy.copy(item) for item in self.todo_items or []]
+        todo_items: list[JsonValueType] = [
+            dataclasses.asdict(item) for item in self.todo_items or ()
+        ]
         for listener in self._update_listeners:
             listener(todo_items)
 
@@ -335,13 +341,13 @@ async def websocket_handle_subscribe_todo_items(
         return
 
     @callback
-    def todo_item_listener(todo_items: list[TodoItem]) -> None:
+    def todo_item_listener(todo_items: list[JsonValueType] | None) -> None:
         """Push updated To-do list items to websocket."""
         connection.send_message(
             websocket_api.event_message(
                 msg["id"],
                 {
-                    "items": [dataclasses.asdict(item) for item in todo_items],
+                    "items": todo_items,
                 },
             )
         )
@@ -351,7 +357,7 @@ async def websocket_handle_subscribe_todo_items(
     )
     connection.send_result(msg["id"])
 
-    # Push an initial list update
+    # Push an initial forecast update
     entity.async_update_listeners()
 
 

homeassistant/components/tuya/alarm_control_panel.py

@@ -35,13 +35,7 @@ ALARM: dict[DeviceCategory, tuple[AlarmControlPanelEntityDescription, ...]] = {
             key=DPCode.MASTER_MODE,
             name="Alarm",
         ),
-    ),
-    DeviceCategory.WG2: (
-        AlarmControlPanelEntityDescription(
-            key=DPCode.MASTER_MODE,
-            name="Alarm",
-        ),
-    ),
+    )
 }
 
 _TUYA_TO_HA_STATE_MAPPINGS = {

homeassistant/components/tuya/binary_sensor.py

@@ -317,11 +317,6 @@ BINARY_SENSORS: dict[DeviceCategory, tuple[TuyaBinarySensorEntityDescription, ..
             entity_category=EntityCategory.DIAGNOSTIC,
             on_value="alarm",
         ),
-        TuyaBinarySensorEntityDescription(
-            key=DPCode.CHARGE_STATE,
-            device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
-            entity_category=EntityCategory.DIAGNOSTIC,
-        ),
     ),
     DeviceCategory.WK: (
         TuyaBinarySensorEntityDescription(

homeassistant/components/tuya/sensor.py

@@ -1233,7 +1233,6 @@ SENSORS: dict[DeviceCategory, tuple[TuyaSensorEntityDescription, ...]] = {
         ),
         *BATTERY_SENSORS,
     ),
-    DeviceCategory.WG2: (*BATTERY_SENSORS,),
     DeviceCategory.WK: (*BATTERY_SENSORS,),
     DeviceCategory.WKCZ: (
         TuyaSensorEntityDescription(

homeassistant/components/vicare/__init__.py

@@ -6,6 +6,7 @@ from contextlib import suppress
 import logging
 import os
 
+from PyViCare.PyViCare import PyViCare
 from PyViCare.PyViCareDeviceConfig import PyViCareDeviceConfig
 from PyViCare.PyViCareUtils import (
     PyViCareInvalidConfigurationError,
@@ -67,7 +68,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ViCareConfigEntry) -> bo
     return True
 
 
-def setup_vicare_api(hass: HomeAssistant, entry: ViCareConfigEntry) -> ViCareData:
+def setup_vicare_api(hass: HomeAssistant, entry: ViCareConfigEntry) -> PyViCare:
     """Set up PyVicare API."""
     client = login(hass, entry.data)
 

homeassistant/components/victron_ble/sensor.py

@@ -148,10 +148,7 @@ def error_to_state(value: float | str | None) -> str | None:
         "network_c": "network",
         "network_d": "network",
     }
-    mapped = value_map.get(value)
-    if mapped is not None:
-        return mapped
-    return value if isinstance(value, str) and value in CHARGER_ERROR_OPTIONS else None
+    return value_map.get(value)
 
 
 DEVICE_STATE_OPTIONS = [

homeassistant/components/vizio/__init__.py

@@ -2,34 +2,20 @@
 
 from __future__ import annotations
 
-from pyvizio import VizioAsync
+from typing import Any
 
 from homeassistant.components.media_player import MediaPlayerDeviceClass
-from homeassistant.const import (
-    CONF_ACCESS_TOKEN,
-    CONF_DEVICE_CLASS,
-    CONF_HOST,
-    CONF_NAME,
-    Platform,
-)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_DEVICE_CLASS, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.storage import Store
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.util.hass_dict import HassKey
 
-from .const import DEFAULT_TIMEOUT, DEVICE_ID, DOMAIN, VIZIO_DEVICE_CLASSES
-from .coordinator import (
-    VizioAppsDataUpdateCoordinator,
-    VizioConfigEntry,
-    VizioDeviceCoordinator,
-    VizioRuntimeData,
-)
+from .const import CONF_APPS, DOMAIN
+from .coordinator import VizioAppsDataUpdateCoordinator
 from .services import async_setup_services
 
-DATA_APPS: HassKey[VizioAppsDataUpdateCoordinator] = HassKey(f"{DOMAIN}_apps")
-
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
@@ -40,54 +26,38 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: VizioConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Load the saved entities."""
-    host = entry.data[CONF_HOST]
-    token = entry.data.get(CONF_ACCESS_TOKEN)
-    device_class = entry.data[CONF_DEVICE_CLASS]
 
-    # Create device
-    device = VizioAsync(
-        DEVICE_ID,
-        host,
-        entry.data[CONF_NAME],
-        auth_token=token,
-        device_type=VIZIO_DEVICE_CLASSES[device_class],
-        session=async_get_clientsession(hass, False),
-        timeout=DEFAULT_TIMEOUT,
-    )
-
-    # Create device coordinator
-    device_coordinator = VizioDeviceCoordinator(hass, entry, device)
-    await device_coordinator.async_config_entry_first_refresh()
-
-    # Create apps coordinator for TVs (shared across entries)
-    if device_class == MediaPlayerDeviceClass.TV and DATA_APPS not in hass.data:
-        apps_coordinator = VizioAppsDataUpdateCoordinator(hass, Store(hass, 1, DOMAIN))
-        await apps_coordinator.async_setup()
-        hass.data[DATA_APPS] = apps_coordinator
-        await apps_coordinator.async_refresh()
-
-    entry.runtime_data = VizioRuntimeData(
-        device_coordinator=device_coordinator,
-    )
+    hass.data.setdefault(DOMAIN, {})
+    if (
+        CONF_APPS not in hass.data[DOMAIN]
+        and entry.data[CONF_DEVICE_CLASS] == MediaPlayerDeviceClass.TV
+    ):
+        store: Store[list[dict[str, Any]]] = Store(hass, 1, DOMAIN)
+        coordinator = VizioAppsDataUpdateCoordinator(hass, store)
+        await coordinator.async_setup()
+        hass.data[DOMAIN][CONF_APPS] = coordinator
+        await coordinator.async_refresh()
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: VizioConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-    # Clean up apps coordinator if no TV entries remain
-    if unload_ok and not any(
-        e.data[CONF_DEVICE_CLASS] == MediaPlayerDeviceClass.TV
-        for e in hass.config_entries.async_loaded_entries(DOMAIN)
-        if e.entry_id != entry.entry_id
+    unload_ok = await hass.config_entries.async_unload_platforms(
+        config_entry, PLATFORMS
+    )
+    if not any(
+        entry.data[CONF_DEVICE_CLASS] == MediaPlayerDeviceClass.TV
+        for entry in hass.config_entries.async_loaded_entries(DOMAIN)
     ):
-        if apps_coordinator := hass.data.pop(DATA_APPS, None):
-            await apps_coordinator.async_shutdown()
+        if coordinator := hass.data[DOMAIN].pop(CONF_APPS, None):
+            await coordinator.async_shutdown()
+
+    if not hass.data[DOMAIN]:
+        hass.data.pop(DOMAIN)
 
     return unload_ok

homeassistant/components/vizio/config_flow.py

@@ -8,12 +8,13 @@ import socket
 from typing import Any
 
 from pyvizio import VizioAsync, async_guess_device_type
-from pyvizio.const import APP_HOME, APPS
+from pyvizio.const import APP_HOME
 import voluptuous as vol
 
 from homeassistant.components.media_player import MediaPlayerDeviceClass
 from homeassistant.config_entries import (
     SOURCE_ZEROCONF,
+    ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
     OptionsFlow,
@@ -33,7 +34,6 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from homeassistant.util.network import is_ip_address
 
-from . import DATA_APPS
 from .const import (
     CONF_APPS,
     CONF_APPS_TO_INCLUDE_OR_EXCLUDE,
@@ -45,7 +45,6 @@ from .const import (
     DEVICE_ID,
     DOMAIN,
 )
-from .coordinator import VizioConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -107,14 +106,6 @@ def _host_is_same(host1: str, host2: str) -> bool:
 class VizioOptionsConfigFlow(OptionsFlow):
     """Handle Vizio options."""
 
-    def _get_app_list(self) -> list[dict[str, Any]]:
-        """Return the current apps list, falling back to defaults."""
-        if (
-            apps_coordinator := self.hass.data.get(DATA_APPS)
-        ) and apps_coordinator.data:
-            return apps_coordinator.data
-        return APPS
-
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -166,7 +157,10 @@ class VizioOptionsConfigFlow(OptionsFlow):
                     ): cv.multi_select(
                         [
                             APP_HOME["name"],
-                            *(app["name"] for app in self._get_app_list()),
+                            *(
+                                app["name"]
+                                for app in self.hass.data[DOMAIN][CONF_APPS].data
+                            ),
                         ]
                     ),
                 }
@@ -182,9 +176,7 @@ class VizioConfigFlow(ConfigFlow, domain=DOMAIN):
 
     @staticmethod
     @callback
-    def async_get_options_flow(
-        config_entry: VizioConfigEntry,
-    ) -> VizioOptionsConfigFlow:
+    def async_get_options_flow(config_entry: ConfigEntry) -> VizioOptionsConfigFlow:
         """Get the options flow for this handler."""
         return VizioOptionsConfigFlow()
 

homeassistant/components/vizio/coordinator.py

@@ -2,150 +2,22 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from datetime import timedelta
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
-from pyvizio import VizioAsync
-from pyvizio.api.apps import AppConfig
-from pyvizio.api.input import InputItem
-from pyvizio.const import APPS, INPUT_APPS
+from pyvizio.const import APPS
 from pyvizio.util import gen_apps_list_from_url
 
-from homeassistant.components.media_player import MediaPlayerDeviceClass
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_DEVICE_CLASS, CONF_HOST, CONF_NAME
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.storage import Store
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
-from .const import DOMAIN, VIZIO_AUDIO_SETTINGS, VIZIO_SOUND_MODE
-
-type VizioConfigEntry = ConfigEntry[VizioRuntimeData]
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-SCAN_INTERVAL = timedelta(seconds=30)
-
-
-@dataclass(frozen=True)
-class VizioRuntimeData:
-    """Runtime data for Vizio integration."""
-
-    device_coordinator: VizioDeviceCoordinator
-
-
-@dataclass(frozen=True)
-class VizioDeviceData:
-    """Raw data fetched from Vizio device."""
-
-    # Power state
-    is_on: bool
-
-    # Audio settings from get_all_settings("audio")
-    audio_settings: dict[str, Any] | None = None
-
-    # Sound mode options from get_setting_options("audio", "eq")
-    sound_mode_list: list[str] | None = None
-
-    # Current input from get_current_input()
-    current_input: str | None = None
-
-    # Available inputs from get_inputs_list()
-    input_list: list[InputItem] | None = None
-
-    # Current app config from get_current_app_config() (TVs only)
-    current_app_config: AppConfig | None = None
-
-
-class VizioDeviceCoordinator(DataUpdateCoordinator[VizioDeviceData]):
-    """Coordinator for Vizio device data."""
-
-    config_entry: VizioConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: VizioConfigEntry,
-        device: VizioAsync,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=SCAN_INTERVAL,
-        )
-        self.device = device
-
-    async def _async_setup(self) -> None:
-        """Fetch device info and update device registry."""
-        model = await self.device.get_model_name(log_api_exception=False)
-        version = await self.device.get_version(log_api_exception=False)
-
-        if TYPE_CHECKING:
-            assert self.config_entry.unique_id
-
-        device_registry = dr.async_get(self.hass)
-        device_registry.async_get_or_create(
-            config_entry_id=self.config_entry.entry_id,
-            identifiers={(DOMAIN, self.config_entry.unique_id)},
-            manufacturer="VIZIO",
-            name=self.config_entry.data[CONF_NAME],
-            model=model,
-            sw_version=version,
-        )
-
-    async def _async_update_data(self) -> VizioDeviceData:
-        """Fetch all device data."""
-        is_on = await self.device.get_power_state(log_api_exception=False)
-
-        if is_on is None:
-            raise UpdateFailed(
-                f"Unable to connect to {self.config_entry.data[CONF_HOST]}"
-            )
-
-        if not is_on:
-            return VizioDeviceData(is_on=False)
-
-        # Device is on - fetch all data
-        audio_settings = await self.device.get_all_settings(
-            VIZIO_AUDIO_SETTINGS, log_api_exception=False
-        )
-
-        sound_mode_list = None
-        if audio_settings and VIZIO_SOUND_MODE in audio_settings:
-            sound_mode_list = await self.device.get_setting_options(
-                VIZIO_AUDIO_SETTINGS, VIZIO_SOUND_MODE, log_api_exception=False
-            )
-
-        current_input = await self.device.get_current_input(log_api_exception=False)
-        input_list = await self.device.get_inputs_list(log_api_exception=False)
-
-        current_app_config = None
-        # Only attempt to fetch app config if the device is a TV and supports apps
-        if (
-            self.config_entry.data[CONF_DEVICE_CLASS] == MediaPlayerDeviceClass.TV
-            and input_list
-            and any(input_item.name in INPUT_APPS for input_item in input_list)
-        ):
-            current_app_config = await self.device.get_current_app_config(
-                log_api_exception=False
-            )
-
-        return VizioDeviceData(
-            is_on=True,
-            audio_settings=audio_settings,
-            sound_mode_list=sound_mode_list,
-            current_input=current_input,
-            input_list=input_list,
-            current_app_config=current_app_config,
-        )
-
 
 class VizioAppsDataUpdateCoordinator(DataUpdateCoordinator[list[dict[str, Any]]]):
     """Define an object to hold Vizio app config data."""

homeassistant/components/vizio/media_player.py

@@ -2,7 +2,11 @@
 
 from __future__ import annotations
 
-from pyvizio.api.apps import AppConfig, find_app_name
+from datetime import timedelta
+import logging
+
+from pyvizio import AppConfig, VizioAsync
+from pyvizio.api.apps import find_app_name
 from pyvizio.const import APP_HOME, INPUT_APPS, NO_APP_RUNNING, UNKNOWN_APP
 
 from homeassistant.components.media_player import (
@@ -11,45 +15,58 @@ from homeassistant.components.media_player import (
     MediaPlayerEntityFeature,
     MediaPlayerState,
 )
-from homeassistant.const import CONF_DEVICE_CLASS, CONF_EXCLUDE, CONF_INCLUDE
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    CONF_ACCESS_TOKEN,
+    CONF_DEVICE_CLASS,
+    CONF_EXCLUDE,
+    CONF_HOST,
+    CONF_INCLUDE,
+    CONF_NAME,
+)
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import (
     async_dispatcher_connect,
     async_dispatcher_send,
 )
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import DATA_APPS
 from .const import (
     CONF_ADDITIONAL_CONFIGS,
     CONF_APPS,
     CONF_VOLUME_STEP,
+    DEFAULT_TIMEOUT,
     DEFAULT_VOLUME_STEP,
+    DEVICE_ID,
     DOMAIN,
     SUPPORTED_COMMANDS,
     VIZIO_AUDIO_SETTINGS,
+    VIZIO_DEVICE_CLASSES,
     VIZIO_MUTE,
     VIZIO_MUTE_ON,
     VIZIO_SOUND_MODE,
     VIZIO_VOLUME,
 )
-from .coordinator import (
-    VizioAppsDataUpdateCoordinator,
-    VizioConfigEntry,
-    VizioDeviceCoordinator,
-)
+from .coordinator import VizioAppsDataUpdateCoordinator
 
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=30)
 PARALLEL_UPDATES = 0
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: VizioConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a Vizio media player entry."""
+    host = config_entry.data[CONF_HOST]
+    token = config_entry.data.get(CONF_ACCESS_TOKEN)
+    name = config_entry.data[CONF_NAME]
     device_class = config_entry.data[CONF_DEVICE_CLASS]
 
     # If config entry options not set up, set them up,
@@ -88,51 +105,59 @@ async def async_setup_entry(
             **params,  # type: ignore[arg-type]
         )
 
-    entity = VizioDevice(
-        config_entry,
-        device_class,
-        config_entry.runtime_data.device_coordinator,
-        hass.data.get(DATA_APPS) if device_class == MediaPlayerDeviceClass.TV else None,
+    device = VizioAsync(
+        DEVICE_ID,
+        host,
+        name,
+        auth_token=token,
+        device_type=VIZIO_DEVICE_CLASSES[device_class],
+        session=async_get_clientsession(hass, False),
+        timeout=DEFAULT_TIMEOUT,
     )
 
-    async_add_entities([entity])
+    apps_coordinator = hass.data[DOMAIN].get(CONF_APPS)
+
+    entity = VizioDevice(config_entry, device, name, device_class, apps_coordinator)
+
+    async_add_entities([entity], update_before_add=True)
 
 
-class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
+class VizioDevice(MediaPlayerEntity):
     """Media Player implementation which performs REST requests to device."""
 
     _attr_has_entity_name = True
     _attr_name = None
-    _current_input: str | None = None
-    _current_app_config: AppConfig | None = None
+    _received_device_info = False
 
     def __init__(
         self,
-        config_entry: VizioConfigEntry,
+        config_entry: ConfigEntry,
+        device: VizioAsync,
+        name: str,
         device_class: MediaPlayerDeviceClass,
-        coordinator: VizioDeviceCoordinator,
         apps_coordinator: VizioAppsDataUpdateCoordinator | None,
     ) -> None:
         """Initialize Vizio device."""
-        super().__init__(coordinator)
-
         self._config_entry = config_entry
         self._apps_coordinator = apps_coordinator
-        self._attr_sound_mode_list = []
-        self._available_inputs: list[str] = []
-        self._available_apps: list[str] = []
 
         self._volume_step = config_entry.options[CONF_VOLUME_STEP]
+        self._current_input: str | None = None
+        self._current_app_config: AppConfig | None = None
+        self._available_inputs: list[str] = []
+        self._available_apps: list[str] = []
         self._all_apps = apps_coordinator.data if apps_coordinator else None
         self._conf_apps = config_entry.options.get(CONF_APPS, {})
         self._additional_app_configs = config_entry.data.get(CONF_APPS, {}).get(
             CONF_ADDITIONAL_CONFIGS, []
         )
-        self._device = coordinator.device
-        self._max_volume = float(coordinator.device.get_max_volume())
+        self._device = device
+        self._max_volume = float(device.get_max_volume())
+        self._attr_assumed_state = True
 
         # Entity class attributes that will change with each update (we only include
         # the ones that are initialized differently from the defaults)
+        self._attr_sound_mode_list = []
         self._attr_supported_features = SUPPORTED_COMMANDS[device_class]
 
         # Entity class attributes that will not change
@@ -140,7 +165,11 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
         assert unique_id
         self._attr_unique_id = unique_id
         self._attr_device_class = device_class
-        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, unique_id)})
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, unique_id)},
+            manufacturer="VIZIO",
+            name=name,
+        )
 
     def _apps_list(self, apps: list[str]) -> list[str]:
         """Return process apps list based on configured filters."""
@@ -152,72 +181,112 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
 
         return apps
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        data = self.coordinator.data
+    async def async_update(self) -> None:
+        """Retrieve latest state of the device."""
+        if (
+            is_on := await self._device.get_power_state(log_api_exception=False)
+        ) is None:
+            if self._attr_available:
+                _LOGGER.warning(
+                    "Lost connection to %s", self._config_entry.data[CONF_HOST]
+                )
+                self._attr_available = False
+            return
 
-        # Handle device off
-        if not data.is_on:
+        if not self._attr_available:
+            _LOGGER.warning(
+                "Restored connection to %s", self._config_entry.data[CONF_HOST]
+            )
+            self._attr_available = True
+
+        if not self._received_device_info:
+            device_reg = dr.async_get(self.hass)
+            assert self._config_entry.unique_id
+            device = device_reg.async_get_device(
+                identifiers={(DOMAIN, self._config_entry.unique_id)}
+            )
+            if device:
+                device_reg.async_update_device(
+                    device.id,
+                    model=await self._device.get_model_name(log_api_exception=False),
+                    sw_version=await self._device.get_version(log_api_exception=False),
+                )
+                self._received_device_info = True
+
+        if not is_on:
             self._attr_state = MediaPlayerState.OFF
             self._attr_volume_level = None
             self._attr_is_volume_muted = None
-            self._attr_sound_mode = None
-            self._attr_app_name = None
             self._current_input = None
+            self._attr_app_name = None
             self._current_app_config = None
-            super()._handle_coordinator_update()
+            self._attr_sound_mode = None
             return
 
-        # Device is on - apply coordinator data
         self._attr_state = MediaPlayerState.ON
 
-        # Audio settings
-        if data.audio_settings:
+        if audio_settings := await self._device.get_all_settings(
+            VIZIO_AUDIO_SETTINGS, log_api_exception=False
+        ):
             self._attr_volume_level = (
-                float(data.audio_settings[VIZIO_VOLUME]) / self._max_volume
+                float(audio_settings[VIZIO_VOLUME]) / self._max_volume
             )
-            if VIZIO_MUTE in data.audio_settings:
+            if VIZIO_MUTE in audio_settings:
                 self._attr_is_volume_muted = (
-                    data.audio_settings[VIZIO_MUTE].lower() == VIZIO_MUTE_ON
+                    audio_settings[VIZIO_MUTE].lower() == VIZIO_MUTE_ON
                 )
             else:
                 self._attr_is_volume_muted = None
-            if VIZIO_SOUND_MODE in data.audio_settings:
+
+            if VIZIO_SOUND_MODE in audio_settings:
                 self._attr_supported_features |= (
                     MediaPlayerEntityFeature.SELECT_SOUND_MODE
                 )
-                self._attr_sound_mode = data.audio_settings[VIZIO_SOUND_MODE]
+                self._attr_sound_mode = audio_settings[VIZIO_SOUND_MODE]
                 if not self._attr_sound_mode_list:
-                    self._attr_sound_mode_list = data.sound_mode_list or []
+                    self._attr_sound_mode_list = await self._device.get_setting_options(
+                        VIZIO_AUDIO_SETTINGS,
+                        VIZIO_SOUND_MODE,
+                        log_api_exception=False,
+                    )
             else:
+                # Explicitly remove MediaPlayerEntityFeature.SELECT_SOUND_MODE from supported features
                 self._attr_supported_features &= (
                     ~MediaPlayerEntityFeature.SELECT_SOUND_MODE
                 )
 
-        # Input state
-        if data.current_input:
-            self._current_input = data.current_input
-        if data.input_list:
-            self._available_inputs = [i.name for i in data.input_list]
+        if input_ := await self._device.get_current_input(log_api_exception=False):
+            self._current_input = input_
 
-        # App state (TV only) - check if device supports apps
-        if (
-            self._attr_device_class == MediaPlayerDeviceClass.TV
-            and self._available_inputs
-            and any(app in self._available_inputs for app in INPUT_APPS)
+        # If no inputs returned, end update
+        if not (inputs := await self._device.get_inputs_list(log_api_exception=False)):
+            return
+
+        self._available_inputs = [input_.name for input_ in inputs]
+
+        # Return before setting app variables if INPUT_APPS isn't in available inputs
+        if self._attr_device_class == MediaPlayerDeviceClass.SPEAKER or not any(
+            app for app in INPUT_APPS if app in self._available_inputs
         ):
-            all_apps = self._all_apps or ()
-            self._available_apps = self._apps_list([app["name"] for app in all_apps])
-            self._current_app_config = data.current_app_config
-            self._attr_app_name = find_app_name(
-                self._current_app_config,
-                [APP_HOME, *all_apps, *self._additional_app_configs],
-            )
-            if self._attr_app_name == NO_APP_RUNNING:
-                self._attr_app_name = None
+            return
 
-        super()._handle_coordinator_update()
+        # Create list of available known apps from known app list after
+        # filtering by CONF_INCLUDE/CONF_EXCLUDE
+        self._available_apps = self._apps_list(
+            [app["name"] for app in self._all_apps or ()]
+        )
+
+        self._current_app_config = await self._device.get_current_app_config(
+            log_api_exception=False
+        )
+
+        self._attr_app_name = find_app_name(
+            self._current_app_config,
+            [APP_HOME, *(self._all_apps or ()), *self._additional_app_configs],
+        )
+
+        if self._attr_app_name == NO_APP_RUNNING:
+            self._attr_app_name = None
 
     def _get_additional_app_names(self) -> list[str]:
         """Return list of additional apps that were included in configuration.yaml."""
@@ -227,7 +296,7 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
 
     @staticmethod
     async def _async_send_update_options_signal(
-        hass: HomeAssistant, config_entry: VizioConfigEntry
+        hass: HomeAssistant, config_entry: ConfigEntry
     ) -> None:
         """Send update event when Vizio config entry is updated."""
         # Move this method to component level if another entity ever gets added for a
@@ -235,7 +304,7 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
         # See here: https://github.com/home-assistant/core/pull/30653#discussion_r366426121
         async_dispatcher_send(hass, config_entry.entry_id, config_entry)
 
-    async def _async_update_options(self, config_entry: VizioConfigEntry) -> None:
+    async def _async_update_options(self, config_entry: ConfigEntry) -> None:
         """Update options if the update signal comes from this entity."""
         self._volume_step = config_entry.options[CONF_VOLUME_STEP]
         # Update so that CONF_ADDITIONAL_CONFIGS gets retained for imports
@@ -254,11 +323,6 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks when entity is added."""
-        await super().async_added_to_hass()
-
-        # Process initial coordinator data
-        self._handle_coordinator_update()
-
         # Register callback for when config entry is updated.
         self.async_on_remove(
             self._config_entry.add_update_listener(
@@ -273,17 +337,21 @@ class VizioDevice(CoordinatorEntity[VizioDeviceCoordinator], MediaPlayerEntity):
             )
         )
 
-        if not (apps_coordinator := self._apps_coordinator):
+        if not self._apps_coordinator:
             return
 
         # Register callback for app list updates if device is a TV
         @callback
         def apps_list_update() -> None:
             """Update list of all apps."""
-            self._all_apps = apps_coordinator.data
+            if not self._apps_coordinator:
+                return
+            self._all_apps = self._apps_coordinator.data
             self.async_write_ha_state()
 
-        self.async_on_remove(apps_coordinator.async_add_listener(apps_list_update))
+        self.async_on_remove(
+            self._apps_coordinator.async_add_listener(apps_list_update)
+        )
 
     @property
     def source(self) -> str | None:

machine/build.yaml

@@ -1,10 +0,0 @@
-image: ghcr.io/home-assistant/{machine}-homeassistant
-build_from:
-  aarch64: "ghcr.io/home-assistant/aarch64-homeassistant:"
-  amd64: "ghcr.io/home-assistant/amd64-homeassistant:"
-cosign:
-  base_identity: https://github.com/home-assistant/core/.*
-  identity: https://github.com/home-assistant/core/.*
-labels:
-  io.hass.type: core
-  org.opencontainers.image.source: https://github.com/home-assistant/core

machine/generic-x86-64

@@ -1,7 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/amd64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
     libva-intel-driver
+
+LABEL io.hass.machine="generic-x86-64"

machine/green

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="green"

machine/intel-nuc

@@ -1,10 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
-
-# NOTE: intel-nuc will be replaced by generic-x86-64. Make sure to apply
-# changes in generic-x86-64 as well.
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/amd64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
     libva-intel-driver
+
+LABEL io.hass.machine="intel-nuc"

machine/khadas-vim3

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="khadas-vim3"

machine/odroid-c2

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="odroid-c2"

machine/odroid-c4

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="odroid-c4"

machine/odroid-m1

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="odroid-m1"

machine/odroid-n2

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="odroid-n2"

machine/qemuarm-64

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="qemuarm-64"

machine/qemux86-64

@@ -1,4 +1,7 @@
-ARG \
-    BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/amd64-homeassistant:latest
+FROM ${BUILD_FROM}
 
-FROM $BUILD_FROM
+LABEL io.hass.machine="qemux86-64"

machine/raspberrypi3-64

@@ -1,7 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
-        raspberrypi-utils
+    raspberrypi-utils
+
+LABEL io.hass.machine="raspberrypi3-64"

machine/raspberrypi4-64

@@ -1,7 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
-        raspberrypi-utils
+    raspberrypi-utils
+
+LABEL io.hass.machine="raspberrypi4-64"

machine/raspberrypi5-64

@@ -1,7 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
-        raspberrypi-utils
+    raspberrypi-utils
+
+LABEL io.hass.machine="raspberrypi5-64"

machine/yellow

@@ -1,7 +1,10 @@
-ARG \
-    BUILD_FROM
-
-FROM $BUILD_FROM
+# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/aarch64-homeassistant:latest
+FROM ${BUILD_FROM}
 
 RUN apk --no-cache add \
-        raspberrypi-utils
+    raspberrypi-utils
+
+LABEL io.hass.machine="yellow"

requirements_all.txt

@@ -276,7 +276,7 @@ aioguardian==2026.01.1
 aioharmony==0.5.3
 
 # homeassistant.components.hassio
-aiohasupervisor==0.4.2
+aiohasupervisor==0.4.1
 
 # homeassistant.components.home_connect
 aiohomeconnect==0.32.0
@@ -2494,7 +2494,7 @@ pysmappee==0.2.29
 pysmarlaapi==1.0.2
 
 # homeassistant.components.smartthings
-pysmartthings==3.7.2
+pysmartthings==3.7.0
 
 # homeassistant.components.smarty
 pysmarty2==0.10.3
@@ -2651,7 +2651,7 @@ python-rabbitair==0.0.8
 python-ripple-api==0.0.3
 
 # homeassistant.components.roborock
-python-roborock==4.25.0
+python-roborock==4.20.0
 
 # homeassistant.components.smarttub
 python-smarttub==0.0.47

requirements_test_all.txt

@@ -264,7 +264,7 @@ aioguardian==2026.01.1
 aioharmony==0.5.3
 
 # homeassistant.components.hassio
-aiohasupervisor==0.4.2
+aiohasupervisor==0.4.1
 
 # homeassistant.components.home_connect
 aiohomeconnect==0.32.0
@@ -2126,7 +2126,7 @@ pysmappee==0.2.29
 pysmarlaapi==1.0.2
 
 # homeassistant.components.smartthings
-pysmartthings==3.7.2
+pysmartthings==3.7.0
 
 # homeassistant.components.smarty
 pysmarty2==0.10.3
@@ -2247,7 +2247,7 @@ python-pooldose==0.8.6
 python-rabbitair==0.0.8
 
 # homeassistant.components.roborock
-python-roborock==4.25.0
+python-roborock==4.20.0
 
 # homeassistant.components.smarttub
 python-smarttub==0.0.47

script/hassfest/docker.py

@@ -25,7 +25,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/"
 
@@ -77,6 +76,59 @@ RUN \
 WORKDIR /config
 """
 
+
+@dataclass(frozen=True)
+class _MachineConfig:
+    """Machine-specific Dockerfile configuration."""
+
+    arch: str
+    packages: tuple[str, ...] = ()
+
+
+_MACHINES = {
+    "generic-x86-64": _MachineConfig(arch="amd64", packages=("libva-intel-driver",)),
+    "green": _MachineConfig(arch="aarch64"),
+    "intel-nuc": _MachineConfig(arch="amd64", packages=("libva-intel-driver",)),
+    "khadas-vim3": _MachineConfig(arch="aarch64"),
+    "odroid-c2": _MachineConfig(arch="aarch64"),
+    "odroid-c4": _MachineConfig(arch="aarch64"),
+    "odroid-m1": _MachineConfig(arch="aarch64"),
+    "odroid-n2": _MachineConfig(arch="aarch64"),
+    "qemuarm-64": _MachineConfig(arch="aarch64"),
+    "qemux86-64": _MachineConfig(arch="amd64"),
+    "raspberrypi3-64": _MachineConfig(arch="aarch64", packages=("raspberrypi-utils",)),
+    "raspberrypi4-64": _MachineConfig(arch="aarch64", packages=("raspberrypi-utils",)),
+    "raspberrypi5-64": _MachineConfig(arch="aarch64", packages=("raspberrypi-utils",)),
+    "yellow": _MachineConfig(arch="aarch64", packages=("raspberrypi-utils",)),
+}
+
+_MACHINE_DOCKERFILE_TEMPLATE = r"""# Automatically generated by hassfest.
+#
+# To update, run python3 -m script.hassfest -p docker
+ARG BUILD_FROM=ghcr.io/home-assistant/{arch}-homeassistant:latest
+FROM ${{BUILD_FROM}}
+{extra_packages}
+LABEL io.hass.machine="{machine}"
+"""
+
+
+def _generate_machine_dockerfile(
+    machine_name: str, machine_config: _MachineConfig
+) -> str:
+    """Generate a machine Dockerfile from configuration."""
+    if machine_config.packages:
+        pkg_lines = " \\\n    ".join(machine_config.packages)
+        extra_packages = f"\nRUN apk --no-cache add \\\n    {pkg_lines}\n"
+    else:
+        extra_packages = ""
+
+    return _MACHINE_DOCKERFILE_TEMPLATE.format(
+        arch=machine_config.arch,
+        extra_packages=extra_packages,
+        machine=machine_name,
+    )
+
+
 _HASSFEST_TEMPLATE = r"""# Automatically generated by hassfest.
 #
 # To update, run python3 -m script.hassfest -p docker
@@ -174,7 +226,7 @@ def _generate_files(config: Config) -> list[File]:
         config.root / "requirements_test_pre_commit.txt", {"ruff"}
     )
 
-    return [
+    files = [
         File(
             DOCKERFILE_TEMPLATE.format(
                 timeout=timeout,
@@ -192,6 +244,16 @@ def _generate_files(config: Config) -> list[File]:
         ),
     ]
 
+    for machine_name, machine_config in sorted(_MACHINES.items()):
+        files.append(
+            File(
+                _generate_machine_dockerfile(machine_name, machine_config),
+                config.root / "machine" / machine_name,
+            )
+        )
+
+    return files
+
 
 def validate(integrations: dict[str, Integration], config: Config) -> None:
     """Validate dockerfile."""

tests/components/aladdin_connect/test_cover.py

@@ -125,7 +125,7 @@ async def test_cover_unavailable(
     assert state is not None
     assert state.state != STATE_UNAVAILABLE
 
-    mock_aladdin_connect_api.get_doors.side_effect = aiohttp.ClientError()
+    mock_aladdin_connect_api.update_door.side_effect = aiohttp.ClientError()
     freezer.tick(15)
     async_fire_time_changed(hass)
     await hass.async_block_till_done()

tests/components/aladdin_connect/test_init.py

@@ -5,17 +5,16 @@ from unittest.mock import AsyncMock, patch
 
 from aiohttp import ClientConnectionError, RequestInfo
 from aiohttp.client_exceptions import ClientResponseError
-from freezegun.api import FrozenDateTimeFactory
 import pytest
 
 from homeassistant.components.aladdin_connect import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.helpers import device_registry as dr
 
 from . import init_integration
 
-from tests.common import MockConfigEntry, async_fire_time_changed
+from tests.common import MockConfigEntry
 
 
 async def test_setup_entry(
@@ -138,49 +137,3 @@ async def test_remove_stale_devices(
     )
     assert len(device_entries) == 1
     assert device_entries[0].identifiers == {(DOMAIN, "test_device_id-1")}
-
-
-async def test_dynamic_devices(
-    hass: HomeAssistant,
-    device_registry: dr.DeviceRegistry,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-    mock_aladdin_connect_api: AsyncMock,
-    freezer: FrozenDateTimeFactory,
-) -> None:
-    """Test new devices are automatically discovered on coordinator refresh."""
-    await init_integration(hass, mock_config_entry)
-
-    # Initially one door -> one cover entity + one sensor entity
-    device_entries = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    assert len(device_entries) == 1
-    assert hass.states.get("cover.test_door") is not None
-
-    # Simulate a new door appearing on the API
-    mock_door_2 = AsyncMock()
-    mock_door_2.device_id = "test_device_id_2"
-    mock_door_2.door_number = 1
-    mock_door_2.name = "Test Door 2"
-    mock_door_2.status = "open"
-    mock_door_2.link_status = "connected"
-    mock_door_2.battery_level = 80
-    mock_door_2.unique_id = f"{mock_door_2.device_id}-{mock_door_2.door_number}"
-
-    existing_door = mock_aladdin_connect_api.get_doors.return_value[0]
-    mock_aladdin_connect_api.get_doors.return_value = [existing_door, mock_door_2]
-
-    # Trigger coordinator refresh
-    freezer.tick(15)
-    async_fire_time_changed(hass)
-    await hass.async_block_till_done()
-
-    # Now two devices should exist
-    device_entries = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    assert len(device_entries) == 2
-
-    # New cover entity should exist
-    assert hass.states.get("cover.test_door_2") is not None

tests/components/aladdin_connect/test_sensor.py

@@ -49,7 +49,7 @@ async def test_sensor_unavailable(
     assert state is not None
     assert state.state != STATE_UNAVAILABLE
 
-    mock_aladdin_connect_api.get_doors.side_effect = aiohttp.ClientError()
+    mock_aladdin_connect_api.update_door.side_effect = aiohttp.ClientError()
     freezer.tick(15)
     async_fire_time_changed(hass)
     await hass.async_block_till_done()

tests/components/alarm_control_panel/test_condition.py

@@ -13,13 +13,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -129,17 +129,32 @@ async def test_alarm_control_panel_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the alarm_control_panel state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_alarm_control_panels["included"]) - {entity_id}
+
+    # Set all alarm_control_panels, including the tested alarm_control_panel, to the initial state
+    for eid in target_alarm_control_panels["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_alarm_control_panels,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other alarm_control_panels also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -221,13 +236,29 @@ async def test_alarm_control_panel_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the alarm_control_panel state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_alarm_control_panels["included"]) - {entity_id}
+
+    # Set all alarm_control_panels, including the tested alarm_control_panel, to the initial state
+    for eid in target_alarm_control_panels["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_alarm_control_panels,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/assist_satellite/test_condition.py

@@ -9,13 +9,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -83,17 +83,32 @@ async def test_assist_satellite_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the assist satellite state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_assist_satellites["included"]) - {entity_id}
+
+    # Set all assist satellites, including the tested one, to the initial state
+    for eid in target_assist_satellites["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_assist_satellites,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other assist satellites also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -136,13 +151,29 @@ async def test_assist_satellite_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the assist satellite state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_assist_satellites["included"]) - {entity_id}
+
+    # Set all assist satellites, including the tested one, to the initial state
+    for eid in target_assist_satellites["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_assist_satellites,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/button/test_trigger.py

@@ -127,7 +127,7 @@ async def test_button_triggers_gated_by_labs_flag(
         ),
     ],
 )
-async def test_button_state_trigger(
+async def test_button_state_trigger_behavior_any(
     hass: HomeAssistant,
     service_calls: list[ServiceCall],
     target_buttons: dict[str, list[str]],
@@ -137,7 +137,7 @@ async def test_button_state_trigger(
     trigger: str,
     states: list[TriggerStateDescription],
 ) -> None:
-    """Test that the button state trigger fires when targeted button state changes."""
+    """Test that the button state trigger fires when any button state changes to a specific state."""
     other_entity_ids = set(target_buttons["included"]) - {entity_id}
 
     # Set all buttons, including the tested button, to the initial state

tests/components/chess_com/snapshots/test_diagnostics.ambr

@@ -8,8 +8,8 @@
       'fide': None,
       'followers': 2,
       'is_streamer': False,
-      'joined': '2026-02-20T10:48:14',
-      'last_online': '2026-03-06T12:32:59',
+      'joined': '2026-02-20T11:48:14',
+      'last_online': '2026-03-06T13:32:59',
       'location': 'Utrecht',
       'name': 'Joost',
       'player_id': 532748851,

tests/components/climate/test_condition.py

@@ -13,13 +13,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -85,17 +85,32 @@ async def test_climate_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the climate state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_climates["included"]) - {entity_id}
+
+    # Set all climates, including the tested climate, to the initial state
+    for eid in target_climates["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_climates,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other climates also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -135,17 +150,33 @@ async def test_climate_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the climate state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_climates["included"]) - {entity_id}
+
+    # Set all climates, including the tested climate, to the initial state
+    for eid in target_climates["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_climates,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
 
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -183,17 +214,32 @@ async def test_climate_attribute_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the climate attribute condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_climates["included"]) - {entity_id}
+
+    # Set all climates, including the tested climate, to the initial state
+    for eid in target_climates["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_climates,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other climates also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -231,13 +277,29 @@ async def test_climate_attribute_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the climate attribute condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_climates["included"]) - {entity_id}
+
+    # Set all climates, including the tested climate, to the initial state
+    for eid in target_climates["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_climates,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/common.py

@@ -176,7 +176,7 @@ def parametrize_target_entities(domain: str) -> list[tuple[dict, str, int]]:
     ]
 
 
-class StateDescription(TypedDict):
+class _StateDescription(TypedDict):
     """Test state with attributes."""
 
     state: str | None
@@ -186,16 +186,16 @@ class StateDescription(TypedDict):
 class TriggerStateDescription(TypedDict):
     """Test state and expected service call count."""
 
-    included: StateDescription  # State for entities meant to be targeted
-    excluded: StateDescription  # State for entities not meant to be targeted
+    included: _StateDescription  # State for entities meant to be targeted
+    excluded: _StateDescription  # State for entities not meant to be targeted
     count: int  # Expected service call count
 
 
 class ConditionStateDescription(TypedDict):
     """Test state and expected condition evaluation."""
 
-    included: StateDescription  # State for entities meant to be targeted
-    excluded: StateDescription  # State for entities not meant to be targeted
+    included: _StateDescription  # State for entities meant to be targeted
+    excluded: _StateDescription  # State for entities not meant to be targeted
 
     condition_true: bool  # If the condition is expected to evaluate to true
     condition_true_first_entity: bool  # If the condition is expected to evaluate to true for the first targeted entity
@@ -235,7 +235,7 @@ def _parametrize_condition_states(
                     "attributes": additional_attributes,
                 },
                 "excluded": {
-                    "state": state if additional_attributes else None,
+                    "state": state,
                     "attributes": {},
                 },
                 "condition_true": condition_true,
@@ -247,7 +247,7 @@ def _parametrize_condition_states(
                 "attributes": state[1] | additional_attributes,
             },
             "excluded": {
-                "state": state[0] if additional_attributes else None,
+                "state": state[0],
                 "attributes": state[1],
             },
             "condition_true": condition_true,
@@ -791,7 +791,7 @@ async def create_target_condition(
 def set_or_remove_state(
     hass: HomeAssistant,
     entity_id: str,
-    state: StateDescription,
+    state: TriggerStateDescription,
 ) -> None:
     """Set or remove the state of an entity."""
     if state["state"] is None:
@@ -864,105 +864,6 @@ async def assert_trigger_gated_by_labs_flag(
     ) in caplog.text
 
 
-async def assert_condition_behavior_any(
-    hass: HomeAssistant,
-    *,
-    target_entities: dict[str, list[str]],
-    condition_target_config: dict,
-    entity_id: str,
-    entities_in_target: int,
-    condition: str,
-    condition_options: dict[str, Any],
-    states: list[ConditionStateDescription],
-) -> None:
-    """Test condition with the 'any' behavior."""
-    other_entity_ids = set(target_entities["included"]) - {entity_id}
-    excluded_entity_ids = set(target_entities["excluded"]) - {entity_id}
-
-    for eid in target_entities["included"]:
-        set_or_remove_state(hass, eid, states[0]["included"])
-        await hass.async_block_till_done()
-    for eid in excluded_entity_ids:
-        set_or_remove_state(hass, eid, states[0]["excluded"])
-        await hass.async_block_till_done()
-
-    condition = await create_target_condition(
-        hass,
-        condition=condition,
-        target=condition_target_config,
-        behavior="any",
-    )
-
-    for state in states:
-        included_state = state["included"]
-        excluded_state = state["excluded"]
-
-        # Set excluded entities first to verify that they don't make the
-        # condition evaluate to true
-        for excluded_entity_id in excluded_entity_ids:
-            set_or_remove_state(hass, excluded_entity_id, excluded_state)
-            await hass.async_block_till_done()
-        assert condition(hass) is False
-
-        set_or_remove_state(hass, entity_id, included_state)
-        await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true"]
-
-        # Set other included entities to the included state to verify that
-        # they don't change the condition evaluation
-        for other_entity_id in other_entity_ids:
-            set_or_remove_state(hass, other_entity_id, included_state)
-            await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true"]
-
-
-async def assert_condition_behavior_all(
-    hass: HomeAssistant,
-    *,
-    target_entities: dict[str, list[str]],
-    condition_target_config: dict,
-    entity_id: str,
-    entities_in_target: int,
-    condition: str,
-    condition_options: dict[str, Any],
-    states: list[ConditionStateDescription],
-) -> None:
-    """Test condition with the 'all' behavior."""
-    other_entity_ids = set(target_entities["included"]) - {entity_id}
-    excluded_entity_ids = set(target_entities["excluded"]) - {entity_id}
-
-    for eid in target_entities["included"]:
-        set_or_remove_state(hass, eid, states[0]["included"])
-        await hass.async_block_till_done()
-    for eid in excluded_entity_ids:
-        set_or_remove_state(hass, eid, states[0]["excluded"])
-        await hass.async_block_till_done()
-
-    condition = await create_target_condition(
-        hass,
-        condition=condition,
-        target=condition_target_config,
-        behavior="all",
-    )
-
-    for state in states:
-        included_state = state["included"]
-        excluded_state = state["excluded"]
-
-        set_or_remove_state(hass, entity_id, included_state)
-        await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true_first_entity"]
-
-        for other_entity_id in other_entity_ids:
-            set_or_remove_state(hass, other_entity_id, included_state)
-            await hass.async_block_till_done()
-        for excluded_entity_id in excluded_entity_ids:
-            set_or_remove_state(hass, excluded_entity_id, excluded_state)
-            await hass.async_block_till_done()
-
-        assert condition(hass) == state["condition_true"]
-
-
 async def assert_trigger_behavior_any(
     hass: HomeAssistant,
     *,

tests/components/cover/test_condition.py

@@ -10,13 +10,12 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
     create_target_condition,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -101,17 +100,38 @@ async def test_cover_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test cover condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_covers["included"]) - {entity_id}
+    excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
+
+    for eid in target_covers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_covers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        excluded_state = state["excluded"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -164,17 +184,40 @@ async def test_cover_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test cover condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_covers["included"]) - {entity_id}
+    excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
+
+    for eid in target_covers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_covers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
 
+    for state in states:
+        included_state = state["included"]
+        excluded_state = state["excluded"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(

tests/components/demo/test_valve.py

@@ -1,6 +1,5 @@
 """The tests for the Demo valve platform."""
 
-from collections.abc import Generator
 from datetime import timedelta
 from unittest.mock import patch
 
@@ -18,9 +17,10 @@ from homeassistant.components.valve import (
 )
 from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.setup import async_setup_component
 from homeassistant.util import dt as dt_util
 
-from tests.common import MockConfigEntry, async_capture_events, async_fire_time_changed
+from tests.common import async_capture_events, async_fire_time_changed
 
 FRONT_GARDEN = "valve.front_garden"
 ORCHARD = "valve.orchard"
@@ -28,7 +28,7 @@ BACK_GARDEN = "valve.back_garden"
 
 
 @pytest.fixture
-def valve_only() -> Generator[None]:
+async def valve_only() -> None:
     """Enable only the valve platform."""
     with patch(
         "homeassistant.components.demo.COMPONENTS_WITH_CONFIG_ENTRY_DEMO_PLATFORM",
@@ -38,12 +38,11 @@ def valve_only() -> Generator[None]:
 
 
 @pytest.fixture(autouse=True)
-async def setup_comp(hass: HomeAssistant, valve_only: None) -> None:
-    """Set up demo component from config entry."""
-    config_entry = MockConfigEntry(domain=DOMAIN)
-    config_entry.add_to_hass(hass)
-
-    assert await hass.config_entries.async_setup(config_entry.entry_id)
+async def setup_comp(hass: HomeAssistant, valve_only: None):
+    """Set up demo component."""
+    assert await async_setup_component(
+        hass, VALVE_DOMAIN, {VALVE_DOMAIN: {"platform": DOMAIN}}
+    )
     await hass.async_block_till_done()
 
 
@@ -51,7 +50,6 @@ async def setup_comp(hass: HomeAssistant, valve_only: None) -> None:
 async def test_closing(hass: HomeAssistant) -> None:
     """Test the closing of a valve."""
     state = hass.states.get(FRONT_GARDEN)
-    assert state is not None
     assert state.state == ValveState.OPEN
     await hass.async_block_till_done()
 
@@ -65,11 +63,9 @@ async def test_closing(hass: HomeAssistant) -> None:
     await hass.async_block_till_done()
 
     assert state_changes[0].data["entity_id"] == FRONT_GARDEN
-    assert state_changes[0].data["new_state"] is not None
     assert state_changes[0].data["new_state"].state == ValveState.CLOSING
 
     assert state_changes[1].data["entity_id"] == FRONT_GARDEN
-    assert state_changes[1].data["new_state"] is not None
     assert state_changes[1].data["new_state"].state == ValveState.CLOSED
 
 
@@ -77,7 +73,6 @@ async def test_closing(hass: HomeAssistant) -> None:
 async def test_opening(hass: HomeAssistant) -> None:
     """Test the opening of a valve."""
     state = hass.states.get(ORCHARD)
-    assert state is not None
     assert state.state == ValveState.CLOSED
     await hass.async_block_till_done()
 
@@ -88,18 +83,15 @@ async def test_opening(hass: HomeAssistant) -> None:
     await hass.async_block_till_done()
 
     assert state_changes[0].data["entity_id"] == ORCHARD
-    assert state_changes[0].data["new_state"] is not None
     assert state_changes[0].data["new_state"].state == ValveState.OPENING
 
     assert state_changes[1].data["entity_id"] == ORCHARD
-    assert state_changes[1].data["new_state"] is not None
     assert state_changes[1].data["new_state"].state == ValveState.OPEN
 
 
 async def test_set_valve_position(hass: HomeAssistant) -> None:
     """Test moving the valve to a specific position."""
     state = hass.states.get(BACK_GARDEN)
-    assert state is not None
     assert state.attributes[ATTR_CURRENT_POSITION] == 70
 
     # close to 10%
@@ -110,7 +102,6 @@ async def test_set_valve_position(hass: HomeAssistant) -> None:
         blocking=True,
     )
     state = hass.states.get(BACK_GARDEN)
-    assert state is not None
     assert state.state == ValveState.CLOSING
 
     for _ in range(6):
@@ -119,7 +110,6 @@ async def test_set_valve_position(hass: HomeAssistant) -> None:
         await hass.async_block_till_done()
 
     state = hass.states.get(BACK_GARDEN)
-    assert state is not None
     assert state.attributes[ATTR_CURRENT_POSITION] == 10
     assert state.state == ValveState.OPEN
 
@@ -131,7 +121,6 @@ async def test_set_valve_position(hass: HomeAssistant) -> None:
         blocking=True,
     )
     state = hass.states.get(BACK_GARDEN)
-    assert state is not None
     assert state.state == ValveState.OPENING
 
     for _ in range(7):
@@ -140,7 +129,6 @@ async def test_set_valve_position(hass: HomeAssistant) -> None:
         await hass.async_block_till_done()
 
     state = hass.states.get(BACK_GARDEN)
-    assert state is not None
     assert state.attributes[ATTR_CURRENT_POSITION] == 80
     assert state.state == ValveState.OPEN
 

tests/components/device_tracker/test_condition.py

@@ -9,12 +9,12 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -70,17 +70,32 @@ async def test_device_tracker_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the device tracker state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_device_trackers["included"]) - {entity_id}
+
+    # Set all device trackers, including the tested one, to the initial state
+    for eid in target_device_trackers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_device_trackers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other device trackers also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -113,13 +128,29 @@ async def test_device_tracker_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the device tracker state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_device_trackers["included"]) - {entity_id}
+
+    # Set all device trackers, including the tested one, to the initial state
+    for eid in target_device_trackers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_device_trackers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/humidifier/test_condition.py

@@ -10,12 +10,12 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -73,17 +73,32 @@ async def test_humidifier_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the humidifier state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_humidifiers["included"]) - {entity_id}
+
+    # Set all humidifiers, including the tested humidifier, to the initial state
+    for eid in target_humidifiers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_humidifiers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other humidifiers also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -116,17 +131,33 @@ async def test_humidifier_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the humidifier state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_humidifiers["included"]) - {entity_id}
+
+    # Set all humidifiers, including the tested humidifier, to the initial state
+    for eid in target_humidifiers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_humidifiers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
 
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -159,17 +190,32 @@ async def test_humidifier_attribute_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the humidifier attribute condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_humidifiers["included"]) - {entity_id}
+
+    # Set all humidifiers, including the tested humidifier, to the initial state
+    for eid in target_humidifiers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_humidifiers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other humidifiers also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -202,13 +248,29 @@ async def test_humidifier_attribute_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the humidifier attribute condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_humidifiers["included"]) - {entity_id}
+
+    # Set all humidifiers, including the tested humidifier, to the initial state
+    for eid in target_humidifiers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_humidifiers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/indevolt/snapshots/test_button.ambr

@@ -1,9 +1,8 @@
 # serializer version: 1
 # name: test_button[1][button.bk1600_enable_standby_mode-entry]
   EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
+    'aliases': set({
+    }),
     'area_id': None,
     'capabilities': None,
     'config_entry_id': <ANY>,
@@ -51,9 +50,8 @@
 # ---
 # name: test_button[2][button.cms_sf2000_enable_standby_mode-entry]
   EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
+    'aliases': set({
+    }),
     'area_id': None,
     'capabilities': None,
     'config_entry_id': <ANY>,

tests/components/lawn_mower/test_condition.py

@@ -9,13 +9,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -89,17 +89,32 @@ async def test_lawn_mower_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the lawn mower state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_lawn_mowers["included"]) - {entity_id}
+
+    # Set all lawn mowers, including the tested lawn mower, to the initial state
+    for eid in target_lawn_mowers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_lawn_mowers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other lawn mowers also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -147,13 +162,29 @@ async def test_lawn_mower_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the lawn mower state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_lawn_mowers["included"]) - {entity_id}
+
+    # Set all lawn mowers, including the tested lawn mower, to the initial state
+    for eid in target_lawn_mowers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_lawn_mowers,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/lock/test_condition.py

@@ -9,13 +9,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -83,17 +83,32 @@ async def test_lock_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the lock state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_locks["included"]) - {entity_id}
+
+    # Set all locks, including the tested lock, to the initial state
+    for eid in target_locks["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_locks,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other locks also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -136,13 +151,29 @@ async def test_lock_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the lock state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_locks["included"]) - {entity_id}
+
+    # Set all locks, including the tested lock, to the initial state
+    for eid in target_locks["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_locks,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/mastodon/snapshots/test_services.ambr

@@ -9,7 +9,7 @@
       'discoverable': True,
       'group': False,
       'locked': False,
-      'created_at': datetime.datetime(2016, 11, 24, 0, 0, tzinfo=tzlocal()),
+      'created_at': datetime.datetime(2016, 11, 24, 0, 0, tzinfo=tzutc()),
       'following_count': 328,
       'followers_count': 3169,
       'statuses_count': 69523,

tests/components/media_player/test_condition.py

@@ -9,13 +9,13 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     other_states,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -101,17 +101,32 @@ async def test_media_player_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the media player state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_media_players["included"]) - {entity_id}
+
+    # Set all media players, including the tested media player, to the initial state
+    for eid in target_media_players["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_media_players,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other media players also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -171,13 +186,29 @@ async def test_media_player_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the media player state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_media_players["included"]) - {entity_id}
+
+    # Set all media players, including the tested media player, to the initial state
+    for eid in target_media_players["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_media_players,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/mqtt/test_vacuum.py

@@ -3,7 +3,7 @@
 from copy import deepcopy
 import json
 from typing import Any
-from unittest.mock import call, patch
+from unittest.mock import patch
 
 import pytest
 
@@ -30,7 +30,6 @@ from homeassistant.components.vacuum import (
 from homeassistant.const import CONF_NAME, ENTITY_MATCH_ALL, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry as er, issue_registry as ir
 
 from .common import (
     help_custom_config,
@@ -64,11 +63,7 @@ from .common import (
 
 from tests.common import async_fire_mqtt_message
 from tests.components.vacuum import common
-from tests.typing import (
-    MqttMockHAClientGenerator,
-    MqttMockPahoClient,
-    WebSocketGenerator,
-)
+from tests.typing import MqttMockHAClientGenerator, MqttMockPahoClient
 
 COMMAND_TOPIC = "vacuum/command"
 SEND_COMMAND_TOPIC = "vacuum/send_command"
@@ -87,27 +82,6 @@ DEFAULT_CONFIG = {
     }
 }
 
-CONFIG_CLEAN_SEGMENTS_1 = {
-    mqtt.DOMAIN: {
-        vacuum.DOMAIN: {
-            "name": "test",
-            "unique_id": "veryunique",
-            "segments": ["Livingroom", "Kitchen"],
-            "clean_segments_command_topic": "vacuum/clean_segment",
-        }
-    }
-}
-CONFIG_CLEAN_SEGMENTS_2 = {
-    mqtt.DOMAIN: {
-        vacuum.DOMAIN: {
-            "name": "test",
-            "unique_id": "veryunique",
-            "segments": ["1.Livingroom", "2.Kitchen"],
-            "clean_segments_command_topic": "vacuum/clean_segment",
-        }
-    }
-}
-
 DEFAULT_CONFIG_2 = {mqtt.DOMAIN: {vacuum.DOMAIN: {"name": "test"}}}
 
 CONFIG_ALL_SERVICES = help_custom_config(
@@ -320,347 +294,6 @@ async def test_command_without_command_topic(
     mqtt_mock.async_publish.reset_mock()
 
 
-@pytest.mark.parametrize("hass_config", [CONFIG_CLEAN_SEGMENTS_1])
-async def test_clean_segments_initial_setup_without_repair_issue(
-    hass: HomeAssistant,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-) -> None:
-    """Test cleanable segments initial setup does not fire repair flow."""
-    await mqtt_mock_entry()
-    issue_registry = ir.async_get(hass)
-    assert len(issue_registry.issues) == 0
-
-
-@pytest.mark.parametrize("hass_config", [CONFIG_CLEAN_SEGMENTS_1])
-async def test_clean_segments_command_without_id(
-    hass: HomeAssistant,
-    hass_ws_client: WebSocketGenerator,
-    entity_registry: er.EntityRegistry,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-) -> None:
-    """Test cleanable segments without ID."""
-    config_entry = hass.config_entries.async_entries(mqtt.DOMAIN)[0]
-    entity_registry.async_get_or_create(
-        vacuum.DOMAIN,
-        mqtt.DOMAIN,
-        "veryunique",
-        config_entry=config_entry,
-        suggested_object_id="test",
-    )
-    entity_registry.async_update_entity_options(
-        "vacuum.test",
-        vacuum.DOMAIN,
-        {
-            "area_mapping": {"Nabu Casa": ["Kitchen", "Livingroom"]},
-            "last_seen_segments": [
-                {"id": "Livingroom", "name": "Livingroom"},
-                {"id": "Kitchen", "name": "Kitchen"},
-            ],
-        },
-    )
-    mqtt_mock = await mqtt_mock_entry()
-    await hass.async_block_till_done()
-    issue_registry = ir.async_get(hass)
-    # We do not expect a repair flow
-    assert len(issue_registry.issues) == 0
-
-    state = hass.states.get("vacuum.test")
-    assert state.state == STATE_UNKNOWN
-    await common.async_clean_area(hass, ["Nabu Casa"], entity_id="vacuum.test")
-    assert (
-        call("vacuum/clean_segment", '["Kitchen","Livingroom"]', 0, False)
-        in mqtt_mock.async_publish.mock_calls
-    )
-
-    client = await hass_ws_client(hass)
-    await client.send_json_auto_id(
-        {"type": "vacuum/get_segments", "entity_id": "vacuum.test"}
-    )
-    msg = await client.receive_json()
-    assert msg["success"]
-    assert msg["result"]["segments"] == [
-        {"id": "Livingroom", "name": "Livingroom", "group": None},
-        {"id": "Kitchen", "name": "Kitchen", "group": None},
-    ]
-
-
-@pytest.mark.parametrize("hass_config", [CONFIG_CLEAN_SEGMENTS_2])
-async def test_clean_segments_command_with_id(
-    hass: HomeAssistant,
-    hass_ws_client: WebSocketGenerator,
-    entity_registry: er.EntityRegistry,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-) -> None:
-    """Test cleanable segments with ID."""
-    mqtt_mock = await mqtt_mock_entry()
-    # Set the area mapping
-    entity_registry.async_update_entity_options(
-        "vacuum.test",
-        vacuum.DOMAIN,
-        {
-            "area_mapping": {"Livingroom": ["1"], "Kitchen": ["2"]},
-            "last_seen_segments": [
-                {"id": "1", "name": "Livingroom"},
-                {"id": "2", "name": "Kitchen"},
-            ],
-        },
-    )
-    await hass.async_block_till_done()
-
-    state = hass.states.get("vacuum.test")
-    assert state.state == STATE_UNKNOWN
-    await common.async_clean_area(hass, ["Kitchen"], entity_id="vacuum.test")
-    assert (
-        call("vacuum/clean_segment", '["2"]', 0, False)
-        in mqtt_mock.async_publish.mock_calls
-    )
-
-    client = await hass_ws_client(hass)
-    await client.send_json_auto_id(
-        {"type": "vacuum/get_segments", "entity_id": "vacuum.test"}
-    )
-    msg = await client.receive_json()
-    assert msg["success"]
-    assert msg["result"]["segments"] == [
-        {"id": "1", "name": "Livingroom", "group": None},
-        {"id": "2", "name": "Kitchen", "group": None},
-    ]
-
-
-async def test_clean_segments_command_update(
-    hass: HomeAssistant,
-    hass_ws_client: WebSocketGenerator,
-    entity_registry: er.EntityRegistry,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test cleanable segments update via discovery."""
-    # Prepare original entity config entry
-    config_entry = hass.config_entries.async_entries(mqtt.DOMAIN)[0]
-    entity_registry.async_get_or_create(
-        vacuum.DOMAIN,
-        mqtt.DOMAIN,
-        "veryunique",
-        config_entry=config_entry,
-        suggested_object_id="test",
-    )
-    entity_registry.async_update_entity_options(
-        "vacuum.test",
-        vacuum.DOMAIN,
-        {
-            "area_mapping": {"Livingroom": ["1"], "Kitchen": ["2"]},
-            "last_seen_segments": [
-                {"id": "1", "name": "Livingroom"},
-                {"id": "2", "name": "Kitchen"},
-            ],
-        },
-    )
-    await mqtt_mock_entry()
-    # Do initial discovery
-    config1 = CONFIG_CLEAN_SEGMENTS_2[mqtt.DOMAIN][vacuum.DOMAIN]
-    payload1 = json.dumps(config1)
-    config_topic = "homeassistant/vacuum/bla/config"
-    async_fire_mqtt_message(hass, config_topic, payload1)
-    await hass.async_block_till_done()
-    state = hass.states.get("vacuum.test")
-    assert state.state == STATE_UNKNOWN
-
-    issue_registry = ir.async_get(hass)
-    # We do not expect a repair flow
-    assert len(issue_registry.issues) == 0
-
-    # Update the segments
-    config2 = config1.copy()
-    config2["segments"] = ["1.Livingroom", "2.Kitchen", "3.Diningroom"]
-    payload2 = json.dumps(config2)
-    async_fire_mqtt_message(hass, config_topic, payload2)
-    await hass.async_block_till_done()
-
-    # A repair flow should start
-    assert len(issue_registry.issues) == 1
-
-    client = await hass_ws_client(hass)
-    await client.send_json_auto_id(
-        {"type": "vacuum/get_segments", "entity_id": "vacuum.test"}
-    )
-    msg = await client.receive_json()
-    assert msg["success"]
-    assert msg["result"]["segments"] == [
-        {"id": "1", "name": "Livingroom", "group": None},
-        {"id": "2", "name": "Kitchen", "group": None},
-        {"id": "3", "name": "Diningroom", "group": None},
-    ]
-
-    # Test update with a non-unique segment list fails
-    config3 = config1.copy()
-    config3["segments"] = ["1.Livingroom", "2.Kitchen", "2.Diningroom"]
-    payload3 = json.dumps(config3)
-    async_fire_mqtt_message(hass, config_topic, payload3)
-    await hass.async_block_till_done()
-    assert (
-        "Error 'The `segments` option contains an invalid or non-unique segment ID '2'"
-        in caplog.text
-    )
-
-
-@pytest.mark.parametrize(
-    "hass_config",
-    [
-        {
-            mqtt.DOMAIN: {
-                vacuum.DOMAIN: {
-                    "name": "test",
-                    "unique_id": "veryunique",
-                    "segments": ["Livingroom", "Kitchen", "Kitchen"],
-                    "clean_segments_command_topic": "vacuum/clean_segment",
-                }
-            }
-        },
-        {
-            mqtt.DOMAIN: {
-                vacuum.DOMAIN: {
-                    "name": "test",
-                    "unique_id": "veryunique",
-                    "segments": ["Livingroom", "Kitchen", ""],
-                    "clean_segments_command_topic": "vacuum/clean_segment",
-                }
-            }
-        },
-        {
-            mqtt.DOMAIN: {
-                vacuum.DOMAIN: {
-                    "name": "test",
-                    "unique_id": "veryunique",
-                    "segments": ["1.Livingroom", "1.Kitchen"],
-                    "clean_segments_command_topic": "vacuum/clean_segment",
-                }
-            }
-        },
-        {
-            mqtt.DOMAIN: {
-                vacuum.DOMAIN: {
-                    "name": "test",
-                    "unique_id": "veryunique",
-                    "segments": ["1.Livingroom", "1.Kitchen", ".Diningroom"],
-                    "clean_segments_command_topic": "vacuum/clean_segment",
-                }
-            }
-        },
-    ],
-)
-async def test_non_unique_segments(
-    hass: HomeAssistant,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test with non-unique list of cleanable segments with valid segment IDs."""
-    await mqtt_mock_entry()
-    assert (
-        "The `segments` option contains an invalid or non-unique segment ID"
-        in caplog.text
-    )
-
-
-@pytest.mark.usefixtures("hass")
-@pytest.mark.parametrize(
-    ("hass_config", "error_message"),
-    [
-        (
-            help_custom_config(
-                vacuum.DOMAIN,
-                DEFAULT_CONFIG,
-                ({"clean_segments_command_topic": "test-topic"},),
-            ),
-            "Options `segments` and "
-            "`clean_segments_command_topic` must be defined together",
-        ),
-        (
-            help_custom_config(
-                vacuum.DOMAIN,
-                DEFAULT_CONFIG,
-                ({"segments": ["Livingroom"]},),
-            ),
-            "Options `segments` and "
-            "`clean_segments_command_topic` must be defined together",
-        ),
-        (
-            help_custom_config(
-                vacuum.DOMAIN,
-                DEFAULT_CONFIG,
-                (
-                    {
-                        "segments": ["Livingroom"],
-                        "clean_segments_command_topic": "test-topic",
-                    },
-                ),
-            ),
-            "Option `segments` requires `unique_id` to be configured",
-        ),
-    ],
-)
-async def test_clean_segments_config_validation(
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-    error_message: str,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test status clean segment config validation."""
-    await mqtt_mock_entry()
-    assert error_message in caplog.text
-
-
-@pytest.mark.parametrize(
-    "hass_config",
-    [
-        help_custom_config(
-            vacuum.DOMAIN,
-            CONFIG_CLEAN_SEGMENTS_2,
-            ({"clean_segments_command_template": "{{ ';'.join(value) }}"},),
-        )
-    ],
-)
-async def test_clean_segments_command_with_id_and_command_template(
-    hass: HomeAssistant,
-    hass_ws_client: WebSocketGenerator,
-    entity_registry: er.EntityRegistry,
-    mqtt_mock_entry: MqttMockHAClientGenerator,
-) -> None:
-    """Test clean segments with command template."""
-    mqtt_mock = await mqtt_mock_entry()
-    entity_registry.async_update_entity_options(
-        "vacuum.test",
-        vacuum.DOMAIN,
-        {
-            "area_mapping": {"Livingroom": ["1"], "Kitchen": ["2"]},
-            "last_seen_segments": [
-                {"id": "1", "name": "Livingroom"},
-                {"id": "2", "name": "Kitchen"},
-            ],
-        },
-    )
-    await hass.async_block_till_done()
-
-    state = hass.states.get("vacuum.test")
-    assert state.state == STATE_UNKNOWN
-    await common.async_clean_area(
-        hass, ["Livingroom", "Kitchen"], entity_id="vacuum.test"
-    )
-    assert (
-        call("vacuum/clean_segment", "1;2", 0, False)
-        in mqtt_mock.async_publish.mock_calls
-    )
-
-    client = await hass_ws_client(hass)
-    await client.send_json_auto_id(
-        {"type": "vacuum/get_segments", "entity_id": "vacuum.test"}
-    )
-    msg = await client.receive_json()
-    assert msg["success"]
-    assert msg["result"]["segments"] == [
-        {"id": "1", "name": "Livingroom", "group": None},
-        {"id": "2", "name": "Kitchen", "group": None},
-    ]
-
-
 @pytest.mark.parametrize("hass_config", [CONFIG_ALL_SERVICES])
 async def test_status(
     hass: HomeAssistant, mqtt_mock_entry: MqttMockHAClientGenerator

tests/components/occupancy/test_condition.py

@@ -1,239 +0,0 @@
-"""Test occupancy conditions."""
-
-from typing import Any
-
-import pytest
-
-from homeassistant.const import ATTR_DEVICE_CLASS, CONF_ENTITY_ID, STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
-
-from tests.components import (
-    ConditionStateDescription,
-    assert_condition_gated_by_labs_flag,
-    create_target_condition,
-    parametrize_condition_states_all,
-    parametrize_condition_states_any,
-    parametrize_target_entities,
-    set_or_remove_state,
-    target_entities,
-)
-
-
-@pytest.fixture
-async def target_binary_sensors(hass: HomeAssistant) -> dict[str, list[str]]:
-    """Create multiple binary sensor entities associated with different targets."""
-    return await target_entities(hass, "binary_sensor")
-
-
-@pytest.mark.parametrize(
-    "condition",
-    [
-        "occupancy.is_detected",
-        "occupancy.is_not_detected",
-    ],
-)
-async def test_occupancy_conditions_gated_by_labs_flag(
-    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, condition: str
-) -> None:
-    """Test the occupancy conditions are gated by the labs flag."""
-    await assert_condition_gated_by_labs_flag(hass, caplog, condition)
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    ("condition_target_config", "entity_id", "entities_in_target"),
-    parametrize_target_entities("binary_sensor"),
-)
-@pytest.mark.parametrize(
-    ("condition", "condition_options", "states"),
-    [
-        *parametrize_condition_states_any(
-            condition="occupancy.is_detected",
-            target_states=[STATE_ON],
-            other_states=[STATE_OFF],
-            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
-        ),
-        *parametrize_condition_states_any(
-            condition="occupancy.is_not_detected",
-            target_states=[STATE_OFF],
-            other_states=[STATE_ON],
-            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
-        ),
-    ],
-)
-async def test_occupancy_binary_sensor_condition_behavior_any(
-    hass: HomeAssistant,
-    target_binary_sensors: dict[str, list[str]],
-    condition_target_config: dict,
-    entity_id: str,
-    entities_in_target: int,
-    condition: str,
-    condition_options: dict[str, Any],
-    states: list[ConditionStateDescription],
-) -> None:
-    """Test occupancy condition for binary_sensor with 'any' behavior."""
-    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
-    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
-
-    for eid in target_binary_sensors["included"]:
-        set_or_remove_state(hass, eid, states[0]["included"])
-        await hass.async_block_till_done()
-    for eid in excluded_entity_ids:
-        set_or_remove_state(hass, eid, states[0]["excluded"])
-        await hass.async_block_till_done()
-
-    condition = await create_target_condition(
-        hass,
-        condition=condition,
-        target=condition_target_config,
-        behavior="any",
-    )
-
-    for state in states:
-        included_state = state["included"]
-        excluded_state = state["excluded"]
-        set_or_remove_state(hass, entity_id, included_state)
-        await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true"]
-
-        for other_entity_id in other_entity_ids:
-            set_or_remove_state(hass, other_entity_id, included_state)
-            await hass.async_block_till_done()
-        for excluded_entity_id in excluded_entity_ids:
-            set_or_remove_state(hass, excluded_entity_id, excluded_state)
-            await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true"]
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    ("condition_target_config", "entity_id", "entities_in_target"),
-    parametrize_target_entities("binary_sensor"),
-)
-@pytest.mark.parametrize(
-    ("condition", "condition_options", "states"),
-    [
-        *parametrize_condition_states_all(
-            condition="occupancy.is_detected",
-            target_states=[STATE_ON],
-            other_states=[STATE_OFF],
-            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
-        ),
-        *parametrize_condition_states_all(
-            condition="occupancy.is_not_detected",
-            target_states=[STATE_OFF],
-            other_states=[STATE_ON],
-            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
-        ),
-    ],
-)
-async def test_occupancy_binary_sensor_condition_behavior_all(
-    hass: HomeAssistant,
-    target_binary_sensors: dict[str, list[str]],
-    condition_target_config: dict,
-    entity_id: str,
-    entities_in_target: int,
-    condition: str,
-    condition_options: dict[str, Any],
-    states: list[ConditionStateDescription],
-) -> None:
-    """Test occupancy condition for binary_sensor with 'all' behavior."""
-    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
-    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
-
-    for eid in target_binary_sensors["included"]:
-        set_or_remove_state(hass, eid, states[0]["included"])
-        await hass.async_block_till_done()
-    for eid in excluded_entity_ids:
-        set_or_remove_state(hass, eid, states[0]["excluded"])
-        await hass.async_block_till_done()
-
-    condition = await create_target_condition(
-        hass,
-        condition=condition,
-        target=condition_target_config,
-        behavior="all",
-    )
-
-    for state in states:
-        included_state = state["included"]
-        excluded_state = state["excluded"]
-
-        set_or_remove_state(hass, entity_id, included_state)
-        await hass.async_block_till_done()
-        assert condition(hass) == state["condition_true_first_entity"]
-
-        for other_entity_id in other_entity_ids:
-            set_or_remove_state(hass, other_entity_id, included_state)
-            await hass.async_block_till_done()
-        for excluded_entity_id in excluded_entity_ids:
-            set_or_remove_state(hass, excluded_entity_id, excluded_state)
-            await hass.async_block_till_done()
-
-        assert condition(hass) == state["condition_true"]
-
-
-# --- Device class exclusion test ---
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    (
-        "condition_key",
-        "binary_sensor_matching",
-        "binary_sensor_non_matching",
-    ),
-    [
-        (
-            "occupancy.is_detected",
-            STATE_ON,
-            STATE_OFF,
-        ),
-        (
-            "occupancy.is_not_detected",
-            STATE_OFF,
-            STATE_ON,
-        ),
-    ],
-)
-async def test_occupancy_condition_excludes_non_occupancy_device_class(
-    hass: HomeAssistant,
-    condition_key: str,
-    binary_sensor_matching: str,
-    binary_sensor_non_matching: str,
-) -> None:
-    """Test occupancy condition excludes entities without device_class occupancy."""
-    entity_id_occupancy = "binary_sensor.test_occupancy"
-    entity_id_motion = "binary_sensor.test_motion"
-
-    # Set matching states on all entities
-    hass.states.async_set(
-        entity_id_occupancy,
-        binary_sensor_matching,
-        {ATTR_DEVICE_CLASS: "occupancy"},
-    )
-    hass.states.async_set(
-        entity_id_motion, binary_sensor_matching, {ATTR_DEVICE_CLASS: "motion"}
-    )
-    await hass.async_block_till_done()
-
-    condition_any = await create_target_condition(
-        hass,
-        condition=condition_key,
-        target={CONF_ENTITY_ID: [entity_id_occupancy, entity_id_motion]},
-        behavior="any",
-    )
-
-    # Matching entity in matching state - condition should be True
-    assert condition_any(hass) is True
-
-    # Set matching entity to non-matching state
-    hass.states.async_set(
-        entity_id_occupancy,
-        binary_sensor_non_matching,
-        {ATTR_DEVICE_CLASS: "occupancy"},
-    )
-    await hass.async_block_till_done()
-
-    # Wrong device class entity still in matching state, but should be excluded
-    assert condition_any(hass) is False

tests/components/opower/test_sensor.py

@@ -6,11 +6,10 @@ from unittest.mock import AsyncMock, patch
 from opower import CostRead
 import pytest
 
-from homeassistant.components.opower.const import DOMAIN
 from homeassistant.components.recorder import Recorder
 from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, UnitOfEnergy, UnitOfVolume
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.helpers import entity_registry as er
 from homeassistant.util import dt as dt_util
 
 from tests.common import MockConfigEntry
@@ -115,111 +114,3 @@ async def test_sensors(
     state = hass.states.get("sensor.gas_account_222222_last_updated")
     assert state
     assert state.state == "2023-01-02T08:00:00+00:00"
-
-
-async def test_dynamic_and_stale_devices(
-    recorder_mock: Recorder,
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_opower_api: AsyncMock,
-    device_registry: dr.DeviceRegistry,
-    entity_registry: er.EntityRegistry,
-) -> None:
-    """Test the dynamic addition and removal of Opower devices."""
-    original_accounts = mock_opower_api.async_get_accounts.return_value
-    original_forecasts = mock_opower_api.async_get_forecast.return_value
-
-    await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
-
-    devices = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    entities = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    initial_device_ids = {device.id for device in devices}
-    initial_entity_ids = {entity.entity_id for entity in entities}
-    # Ensure we actually created some devices and entities for this entry
-    assert initial_device_ids
-    assert initial_entity_ids
-
-    # Remove the second account and update data
-    mock_opower_api.async_get_accounts.return_value = [original_accounts[0]]
-    mock_opower_api.async_get_forecast.return_value = [original_forecasts[0]]
-
-    coordinator = mock_config_entry.runtime_data
-    await coordinator.async_refresh()
-    await hass.async_block_till_done()
-
-    devices = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    entities = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    device_ids_after_removal = {device.id for device in devices}
-    entity_ids_after_removal = {entity.entity_id for entity in entities}
-    # After removing one account, we should have removed some devices/entities
-    # but not added any new ones.
-    assert device_ids_after_removal <= initial_device_ids
-    assert entity_ids_after_removal <= initial_entity_ids
-    assert device_ids_after_removal != initial_device_ids
-    assert entity_ids_after_removal != initial_entity_ids
-
-    # Add back the second account
-    mock_opower_api.async_get_accounts.return_value = original_accounts
-    mock_opower_api.async_get_forecast.return_value = original_forecasts
-
-    await coordinator.async_refresh()
-    await hass.async_block_till_done()
-
-    devices = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    entities = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    device_ids_after_restore = {device.id for device in devices}
-    entity_ids_after_restore = {entity.entity_id for entity in entities}
-    # After restoring the second account, we should be back to the original
-    # number of devices and entities (IDs themselves may change on re-create).
-    assert len(device_ids_after_restore) == len(initial_device_ids)
-    assert len(entity_ids_after_restore) == len(initial_entity_ids)
-
-
-async def test_stale_device_removed_on_load(
-    recorder_mock: Recorder,
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_opower_api: AsyncMock,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Test that a stale device present before setup is removed on first load."""
-    # Simulate a device that was created by a previous version / old account
-    # and is already registered before the integration sets up.
-    stale_device = device_registry.async_get_or_create(
-        config_entry_id=mock_config_entry.entry_id,
-        identifiers={(DOMAIN, "pge_stale_account_99999")},
-    )
-    assert device_registry.async_get(stale_device.id) is not None
-
-    await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
-
-    # Stale device should have been removed on first coordinator update
-    assert device_registry.async_get(stale_device.id) is None
-
-    # Active devices for known accounts should still be present,
-    # and the stale identifier should no longer be registered.
-    active_devices = dr.async_entries_for_config_entry(
-        device_registry, mock_config_entry.entry_id
-    )
-    active_identifiers = {
-        identifier
-        for device in active_devices
-        for (_domain, identifier) in device.identifiers
-    }
-    assert "pge_111111" in active_identifiers
-    assert "pge_222222" in active_identifiers
-    assert "pge_stale_account_99999" not in active_identifiers

tests/components/person/test_condition.py

@@ -9,12 +9,12 @@ from homeassistant.core import HomeAssistant
 
 from tests.components.common import (
     ConditionStateDescription,
-    assert_condition_behavior_all,
-    assert_condition_behavior_any,
     assert_condition_gated_by_labs_flag,
+    create_target_condition,
     parametrize_condition_states_all,
     parametrize_condition_states_any,
     parametrize_target_entities,
+    set_or_remove_state,
     target_entities,
 )
 
@@ -70,17 +70,32 @@ async def test_person_state_condition_behavior_any(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the person state condition with the 'any' behavior."""
-    await assert_condition_behavior_any(
+    other_entity_ids = set(target_persons["included"]) - {entity_id}
+
+    # Set all persons, including the tested person, to the initial state
+    for eid in target_persons["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_persons,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="any",
     )
 
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other persons also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
 
 @pytest.mark.usefixtures("enable_labs_preview_features")
 @pytest.mark.parametrize(
@@ -113,13 +128,29 @@ async def test_person_state_condition_behavior_all(
     states: list[ConditionStateDescription],
 ) -> None:
     """Test the person state condition with the 'all' behavior."""
-    await assert_condition_behavior_all(
+    other_entity_ids = set(target_persons["included"]) - {entity_id}
+
+    # Set all persons, including the tested person, to the initial state
+    for eid in target_persons["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
         hass,
-        target_entities=target_persons,
-        condition_target_config=condition_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
         condition=condition,
-        condition_options=condition_options,
-        states=states,
+        target=condition_target_config,
+        behavior="all",
     )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true_first_entity"]
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        assert condition(hass) == state["condition_true"]

tests/components/prana/snapshots/test_number.ambr

@@ -1,60 +0,0 @@
-# serializer version: 1
-# name: test_numbers[number.prana_recuperator_display_brightness-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': dict({
-      'max': 6,
-      'min': 0,
-      'mode': <NumberMode.SLIDER: 'slider'>,
-      'step': 1,
-    }),
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'number',
-    'entity_category': <EntityCategory.CONFIG: 'config'>,
-    'entity_id': 'number.prana_recuperator_display_brightness',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Display brightness',
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Display brightness',
-    'platform': 'prana',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'display_brightness',
-    'unique_id': 'ECC9FFE0E574_display_brightness',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_numbers[number.prana_recuperator_display_brightness-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'PRANA RECUPERATOR Display brightness',
-      'max': 6,
-      'min': 0,
-      'mode': <NumberMode.SLIDER: 'slider'>,
-      'step': 1,
-    }),
-    'context': <ANY>,
-    'entity_id': 'number.prana_recuperator_display_brightness',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': '6',
-  })
-# ---

tests/components/prana/test_number.py

@@ -1,76 +0,0 @@
-"""Integration-style tests for Prana numbers."""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.components.number import (
-    ATTR_VALUE,
-    DOMAIN as NUMBER_DOMAIN,
-    SERVICE_SET_VALUE,
-)
-from homeassistant.const import ATTR_ENTITY_ID, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
-
-from . import async_init_integration
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-
-async def test_numbers(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    entity_registry: er.EntityRegistry,
-    mock_prana_api: MagicMock,
-    snapshot: SnapshotAssertion,
-) -> None:
-    """Test the Prana numbers snapshot."""
-    with patch("homeassistant.components.prana.PLATFORMS", [Platform.NUMBER]):
-        await async_init_integration(hass, mock_config_entry)
-
-    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
-
-
-@pytest.mark.parametrize(
-    ("input_value", "expected_api_value"),
-    [
-        (0.0, 0),  # 0 -> 0
-        (1.0, 1),  # 2^(1-1) -> 1
-        (2.0, 2),  # 2^(2-1) -> 2
-        (3.0, 4),  # 2^(3-1) -> 4
-        (4.0, 8),  # 2^(4-1) -> 8
-        (5.0, 16),  # 2^(5-1) -> 16
-        (6.0, 32),  # 2^(6-1) -> 32
-    ],
-)
-async def test_number_actions(
-    hass: HomeAssistant,
-    mock_prana_api: MagicMock,
-    mock_config_entry: MockConfigEntry,
-    entity_registry: er.EntityRegistry,
-    input_value: float,
-    expected_api_value: int,
-) -> None:
-    """Test setting number values calls the API with correct math conversion."""
-    await async_init_integration(hass, mock_config_entry)
-
-    entries = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    assert entries
-
-    target = "number.prana_recuperator_display_brightness"
-
-    await hass.services.async_call(
-        NUMBER_DOMAIN,
-        SERVICE_SET_VALUE,
-        {
-            ATTR_ENTITY_ID: target,
-            ATTR_VALUE: input_value,
-        },
-        blocking=True,
-    )
-
-    mock_prana_api.set_brightness.assert_called_with(expected_api_value)

tests/components/radio_browser/conftest.py

@@ -8,7 +8,6 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 
 from homeassistant.components.radio_browser.const import DOMAIN
-from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 
 from tests.common import MockConfigEntry
@@ -40,14 +39,9 @@ async def init_integration(
 ) -> MockConfigEntry:
     """Set up the Radio Browser integration for testing."""
     mock_config_entry.add_to_hass(hass)
-    with patch(
-        "homeassistant.components.radio_browser.RadioBrowser",
-        autospec=True,
-    ):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
 
-    assert mock_config_entry.state == ConfigEntryState.LOADED
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
 
     return mock_config_entry
 

tests/components/radio_browser/test_media_source.py

@@ -1,20 +1,15 @@
 """Tests for radio_browser media_source."""
 
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
-from aiodns.error import DNSError
 import pytest
-from radios import FilterBy, Order, RadioBrowserError
+from radios import FilterBy, Order
 
 from homeassistant.components import media_source
-from homeassistant.components.media_player import BrowseError
 from homeassistant.components.radio_browser.media_source import async_get_media_source
-from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry
-
 DOMAIN = "radio_browser"
 
 
@@ -76,113 +71,3 @@ async def test_browsing_local(
     assert other_browse is not None
     assert other_browse.title == "My Radios"
     assert len(other_browse.children) == 0
-
-
-@pytest.mark.parametrize(
-    "exception",
-    [DNSError, RadioBrowserError],
-)
-async def test_browsing_exceptions(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    exception: Exception,
-) -> None:
-    """Test browsing exceptions."""
-
-    with patch(
-        "homeassistant.components.radio_browser.RadioBrowser",
-        autospec=True,
-    ) as mock_browser:
-        mock_config_entry.add_to_hass(hass)
-
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-        assert mock_config_entry.state == ConfigEntryState.LOADED
-
-        mock_browser.return_value.stations.side_effect = exception
-        with pytest.raises(BrowseError) as exc_info:
-            await media_source.async_browse_media(
-                hass, f"{media_source.URI_SCHEME}{DOMAIN}/popular"
-            )
-        assert exc_info.value.translation_key == "radio_browser_error"
-
-
-async def test_browsing_not_ready(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test browsing config entry not ready."""
-
-    with patch(
-        "homeassistant.components.radio_browser.RadioBrowser",
-        autospec=True,
-    ) as mock_browser:
-        mock_browser.return_value.stats.side_effect = RadioBrowserError
-        mock_config_entry.add_to_hass(hass)
-
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-        assert mock_config_entry.state == ConfigEntryState.SETUP_RETRY
-
-        with pytest.raises(BrowseError) as exc_info:
-            await media_source.async_browse_media(
-                hass, f"{media_source.URI_SCHEME}{DOMAIN}/popular"
-            )
-        assert exc_info.value.translation_key == "config_entry_not_ready"
-
-
-@pytest.mark.parametrize(
-    "exception",
-    [DNSError, RadioBrowserError],
-)
-async def test_resolve_media_exceptions(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    exception: Exception,
-) -> None:
-    """Test resolving media exceptions."""
-
-    with patch(
-        "homeassistant.components.radio_browser.RadioBrowser",
-        autospec=True,
-    ) as mock_browser:
-        mock_config_entry.add_to_hass(hass)
-
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-        assert mock_config_entry.state == ConfigEntryState.LOADED
-
-        mock_browser.return_value.station.side_effect = exception
-        with pytest.raises(media_source.Unresolvable) as exc_info:
-            await media_source.async_resolve_media(
-                hass, f"{media_source.URI_SCHEME}{DOMAIN}/123456", None
-            )
-        assert exc_info.value.translation_key == "radio_browser_error"
-
-
-async def test_resolve_media_not_ready(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test resolving media config entry not ready."""
-
-    with patch(
-        "homeassistant.components.radio_browser.RadioBrowser",
-        autospec=True,
-    ) as mock_browser:
-        mock_browser.return_value.stats.side_effect = RadioBrowserError
-        mock_config_entry.add_to_hass(hass)
-
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-        assert mock_config_entry.state == ConfigEntryState.SETUP_RETRY
-
-        with pytest.raises(media_source.Unresolvable) as exc_info:
-            await media_source.async_resolve_media(
-                hass, f"{media_source.URI_SCHEME}{DOMAIN}/123456", None
-            )
-        assert exc_info.value.translation_key == "config_entry_not_ready"

tests/components/scene/test_trigger.py

@@ -127,7 +127,7 @@ async def test_scene_triggers_gated_by_labs_flag(
         ),
     ],
 )
-async def test_scene_state_trigger(
+async def test_scene_state_trigger_behavior_any(
     hass: HomeAssistant,
     service_calls: list[ServiceCall],
     target_scenes: dict[str, list[str]],
@@ -137,7 +137,7 @@ async def test_scene_state_trigger(
     trigger: str,
     states: list[TriggerStateDescription],
 ) -> None:
-    """Test that the scene state trigger fires when targeted scene state changes."""
+    """Test that the scene state trigger fires when any scene state changes to a specific state."""
     other_entity_ids = set(target_scenes["included"]) - {entity_id}
 
     # Set all scenes, including the tested scene, to the initial state

tests/components/season/test_sensor.py

@@ -1,7 +1,6 @@
 """The tests for the Season integration."""
 
 from datetime import datetime
-from zoneinfo import ZoneInfo
 
 from freezegun import freeze_time
 import pytest
@@ -21,8 +20,6 @@ from homeassistant.components.sensor import ATTR_OPTIONS, SensorDeviceClass
 from homeassistant.const import ATTR_DEVICE_CLASS, CONF_TYPE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
-from homeassistant.helpers.entity_component import async_update_entity
-from homeassistant.util.dt import UTC
 
 from tests.common import MockConfigEntry
 
@@ -47,25 +44,25 @@ HEMISPHERE_EMPTY = {
 }
 
 NORTHERN_PARAMETERS = [
-    (TYPE_ASTRONOMICAL, datetime(2017, 9, 3, 0, 0, tzinfo=UTC), STATE_SUMMER),
-    (TYPE_METEOROLOGICAL, datetime(2017, 8, 13, 0, 0, tzinfo=UTC), STATE_SUMMER),
-    (TYPE_ASTRONOMICAL, datetime(2017, 9, 23, 0, 0, tzinfo=UTC), STATE_AUTUMN),
-    (TYPE_METEOROLOGICAL, datetime(2017, 9, 3, 0, 0, tzinfo=UTC), STATE_AUTUMN),
-    (TYPE_ASTRONOMICAL, datetime(2017, 12, 25, 0, 0, tzinfo=UTC), STATE_WINTER),
-    (TYPE_METEOROLOGICAL, datetime(2017, 12, 3, 0, 0, tzinfo=UTC), STATE_WINTER),
-    (TYPE_ASTRONOMICAL, datetime(2017, 4, 1, 0, 0, tzinfo=UTC), STATE_SPRING),
-    (TYPE_METEOROLOGICAL, datetime(2017, 3, 3, 0, 0, tzinfo=UTC), STATE_SPRING),
+    (TYPE_ASTRONOMICAL, datetime(2017, 9, 3, 0, 0), STATE_SUMMER),
+    (TYPE_METEOROLOGICAL, datetime(2017, 8, 13, 0, 0), STATE_SUMMER),
+    (TYPE_ASTRONOMICAL, datetime(2017, 9, 23, 0, 0), STATE_AUTUMN),
+    (TYPE_METEOROLOGICAL, datetime(2017, 9, 3, 0, 0), STATE_AUTUMN),
+    (TYPE_ASTRONOMICAL, datetime(2017, 12, 25, 0, 0), STATE_WINTER),
+    (TYPE_METEOROLOGICAL, datetime(2017, 12, 3, 0, 0), STATE_WINTER),
+    (TYPE_ASTRONOMICAL, datetime(2017, 4, 1, 0, 0), STATE_SPRING),
+    (TYPE_METEOROLOGICAL, datetime(2017, 3, 3, 0, 0), STATE_SPRING),
 ]
 
 SOUTHERN_PARAMETERS = [
-    (TYPE_ASTRONOMICAL, datetime(2017, 12, 25, 0, 0, tzinfo=UTC), STATE_SUMMER),
-    (TYPE_METEOROLOGICAL, datetime(2017, 12, 3, 0, 0, tzinfo=UTC), STATE_SUMMER),
-    (TYPE_ASTRONOMICAL, datetime(2017, 4, 1, 0, 0, tzinfo=UTC), STATE_AUTUMN),
-    (TYPE_METEOROLOGICAL, datetime(2017, 3, 3, 0, 0, tzinfo=UTC), STATE_AUTUMN),
-    (TYPE_ASTRONOMICAL, datetime(2017, 9, 3, 0, 0, tzinfo=UTC), STATE_WINTER),
-    (TYPE_METEOROLOGICAL, datetime(2017, 8, 13, 0, 0, tzinfo=UTC), STATE_WINTER),
-    (TYPE_ASTRONOMICAL, datetime(2017, 9, 23, 0, 0, tzinfo=UTC), STATE_SPRING),
-    (TYPE_METEOROLOGICAL, datetime(2017, 9, 3, 0, 0, tzinfo=UTC), STATE_SPRING),
+    (TYPE_ASTRONOMICAL, datetime(2017, 12, 25, 0, 0), STATE_SUMMER),
+    (TYPE_METEOROLOGICAL, datetime(2017, 12, 3, 0, 0), STATE_SUMMER),
+    (TYPE_ASTRONOMICAL, datetime(2017, 4, 1, 0, 0), STATE_AUTUMN),
+    (TYPE_METEOROLOGICAL, datetime(2017, 3, 3, 0, 0), STATE_AUTUMN),
+    (TYPE_ASTRONOMICAL, datetime(2017, 9, 3, 0, 0), STATE_WINTER),
+    (TYPE_METEOROLOGICAL, datetime(2017, 8, 13, 0, 0), STATE_WINTER),
+    (TYPE_ASTRONOMICAL, datetime(2017, 9, 23, 0, 0), STATE_SPRING),
+    (TYPE_METEOROLOGICAL, datetime(2017, 9, 3, 0, 0), STATE_SPRING),
 ]
 
 
@@ -157,7 +154,7 @@ async def test_season_equator(
     hass.config.latitude = HEMISPHERE_EQUATOR["homeassistant"]["latitude"]
     mock_config_entry.add_to_hass(hass)
 
-    with freeze_time(datetime(2017, 9, 3, 0, 0, tzinfo=UTC)):
+    with freeze_time(datetime(2017, 9, 3, 0, 0)):
         await hass.config_entries.async_setup(mock_config_entry.entry_id)
         await hass.async_block_till_done()
 
@@ -168,43 +165,3 @@ async def test_season_equator(
     entry = entity_registry.async_get("sensor.season")
     assert entry
     assert entry.unique_id == mock_config_entry.entry_id
-
-
-async def test_season_local_midnight(
-    hass: HomeAssistant,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test that season changes at local midnight, not UTC."""
-    await hass.config.async_set_time_zone("Australia/Sydney")
-    hass.config.latitude = HEMISPHERE_SOUTHERN["homeassistant"]["latitude"]
-    mock_config_entry.add_to_hass(hass)
-    hass.config_entries.async_update_entry(
-        mock_config_entry,
-        unique_id=TYPE_METEOROLOGICAL,
-        data={CONF_TYPE: TYPE_METEOROLOGICAL},
-    )
-
-    sydney_tz = ZoneInfo("Australia/Sydney")
-
-    # The day before autumn starts, at 23:59:59 local time (summer)
-    day_before = datetime(2017, 2, 28, 23, 59, 59, tzinfo=sydney_tz)
-
-    with freeze_time(day_before):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-    state = hass.states.get("sensor.season")
-    assert state
-    assert state.state == STATE_SUMMER
-
-    # Exactly midnight local time (autumn)
-    midnight = datetime(2017, 3, 1, 0, 0, 0, tzinfo=sydney_tz)
-
-    with freeze_time(midnight):
-        await async_update_entity(hass, "sensor.season")
-        await hass.async_block_till_done()
-
-    state = hass.states.get("sensor.season")
-    assert state
-    assert state.state == STATE_AUTUMN

tests/components/smartthings/__init__.py

@@ -68,7 +68,6 @@ DEVICE_FIXTURES = [
     "da_wm_wm_100002",
     "da_wm_wm_000001",
     "da_wm_wm_000001_1",
-    "da_wm_mf_01001",
     "da_wm_sc_000001",
     "da_wm_dw_01011",
     "da_rvc_normal_000001",

tests/components/smartthings/fixtures/device_status/da_wm_mf_01001.json

@@ -1,331 +0,0 @@
-{
-  "components": {
-    "main": {
-      "refresh": {},
-      "execute": {
-        "data": {
-          "value": null
-        }
-      },
-      "samsungce.deviceIdentification": {
-        "micomAssayCode": {
-          "value": "20349241",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "modelName": {
-          "value": null
-        },
-        "serialNumber": {
-          "value": null
-        },
-        "serialNumberExtra": {
-          "value": null
-        },
-        "releaseCountry": {
-          "value": null
-        },
-        "modelClassificationCode": {
-          "value": "3A000000001511000A90020200000000",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "description": {
-          "value": "AMF-WW-TP1-22-COMMON_FT-MF/DC92-03492A_0001",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "releaseYear": {
-          "value": 21,
-          "timestamp": "2025-06-16T00:39:32.549Z"
-        },
-        "binaryId": {
-          "value": "AMF-WW-TP1-22-COMMON",
-          "timestamp": "2026-03-17T09:56:51.547Z"
-        }
-      },
-      "switch": {
-        "switch": {
-          "value": "on",
-          "timestamp": "2026-03-17T09:56:51.608Z"
-        }
-      },
-      "sec.wifiConfiguration": {
-        "autoReconnection": {
-          "value": null
-        },
-        "minVersion": {
-          "value": null
-        },
-        "supportedWiFiFreq": {
-          "value": null
-        },
-        "supportedAuthType": {
-          "value": null
-        },
-        "protocolType": {
-          "value": null
-        }
-      },
-      "samsungce.microfiberFilterOperatingState": {
-        "operatingState": {
-          "value": "ready",
-          "timestamp": "2026-03-17T10:27:51.168Z"
-        },
-        "supportedJobStates": {
-          "value": [
-            "none",
-            "filtering",
-            "bypassing",
-            "waiting",
-            "stopping",
-            "sensing"
-          ],
-          "timestamp": "2026-03-17T07:49:18.985Z"
-        },
-        "supportedOperatingStates": {
-          "value": ["ready", "running", "paused"],
-          "timestamp": "2026-03-17T07:49:18.985Z"
-        },
-        "microfiberFilterJobState": {
-          "value": "waiting",
-          "timestamp": "2026-03-17T10:27:51.168Z"
-        }
-      },
-      "samsungce.selfCheck": {
-        "result": {
-          "value": null
-        },
-        "supportedActions": {
-          "value": null
-        },
-        "progress": {
-          "value": null
-        },
-        "errors": {
-          "value": null
-        },
-        "status": {
-          "value": null
-        }
-      },
-      "samsungce.softwareVersion": {
-        "versions": {
-          "value": [
-            {
-              "id": "0",
-              "swType": "Software",
-              "versionNumber": "03334A230323(A603)",
-              "description": "AMF-WW-TP1-22-COMMON|20349241|3A000000001511000A90020200000000"
-            },
-            {
-              "id": "1",
-              "swType": "Firmware",
-              "versionNumber": "23051057,FFFFFFFF",
-              "description": "Firmware_1_DB_20349241230510571FFFFFFFFFFFFFFFFFFFFFFFFFFE(018020349241FFFFFFFF_30000000)(FileDown:0)(Type:0)"
-            }
-          ],
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        }
-      },
-      "samsungce.microfiberFilterSettings": {
-        "bypassMode": {
-          "value": "disabled",
-          "timestamp": "2026-03-17T09:56:51.095Z"
-        }
-      },
-      "ocf": {
-        "st": {
-          "value": null
-        },
-        "mndt": {
-          "value": null
-        },
-        "mnfv": {
-          "value": "AMF-WW-TP1-22-COMMON_30230323",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnhw": {
-          "value": "Realtek",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "di": {
-          "value": "42e80b4d-24c4-a810-11b3-f90375c56a39",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnsl": {
-          "value": "http://www.samsung.com",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "dmv": {
-          "value": "res.1.1.0,sh.1.1.0",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "n": {
-          "value": "[microfiber] Samsung",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnmo": {
-          "value": "AMF-WW-TP1-22-COMMON|20349241|3A000000001511000A90020200000000",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "vid": {
-          "value": "DA-WM-MF-01001",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnmn": {
-          "value": "Samsung Electronics",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnml": {
-          "value": "http://www.samsung.com",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnpv": {
-          "value": "DAWIT 2.0",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "mnos": {
-          "value": "TizenRT 3.1",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "pi": {
-          "value": "42e80b4d-24c4-a810-11b3-f90375c56a39",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        },
-        "icv": {
-          "value": "core.1.1.0",
-          "timestamp": "2025-06-18T08:56:52.092Z"
-        }
-      },
-      "custom.disabledCapabilities": {
-        "disabledCapabilities": {
-          "value": [],
-          "timestamp": "2026-03-17T09:19:46.018Z"
-        }
-      },
-      "samsungce.driverVersion": {
-        "versionNumber": {
-          "value": 25040101,
-          "timestamp": "2025-06-16T01:24:28.272Z"
-        }
-      },
-      "samsungce.softwareUpdate": {
-        "targetModule": {
-          "value": {},
-          "timestamp": "2026-03-17T09:56:51.716Z"
-        },
-        "otnDUID": {
-          "value": "MTCHUODPC4IYE",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "lastUpdatedDate": {
-          "value": null
-        },
-        "availableModules": {
-          "value": [],
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "newVersionAvailable": {
-          "value": false,
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "operatingState": {
-          "value": null
-        },
-        "progress": {
-          "value": null
-        }
-      },
-      "sec.diagnosticsInformation": {
-        "logType": {
-          "value": ["errCode", "dump"],
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "endpoint": {
-          "value": "SSM",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "minVersion": {
-          "value": "1.0",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "signinPermission": {
-          "value": null
-        },
-        "setupId": {
-          "value": "WM0",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "protocolType": {
-          "value": "wifi_https",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "tsId": {
-          "value": null
-        },
-        "mnId": {
-          "value": "0AJT",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        },
-        "dumpType": {
-          "value": "file",
-          "timestamp": "2026-03-17T09:56:51.548Z"
-        }
-      },
-      "samsungce.bladeFilter": {
-        "bladeFilterStatus": {
-          "value": null
-        },
-        "bladeFilterLastResetDate": {
-          "value": null
-        },
-        "bladeFilterUsage": {
-          "value": null
-        },
-        "bladeFilterResetType": {
-          "value": null
-        },
-        "bladeFilterUsageStep": {
-          "value": null
-        },
-        "bladeFilterCapacity": {
-          "value": null
-        }
-      },
-      "samsungce.microfiberFilterStatus": {
-        "supportedStatus": {
-          "value": ["blockage", "normal"],
-          "timestamp": "2026-03-17T07:49:18.985Z"
-        },
-        "status": {
-          "value": "normal",
-          "timestamp": "2026-03-17T07:49:18.985Z"
-        }
-      },
-      "custom.waterFilter": {
-        "waterFilterUsageStep": {
-          "value": 1,
-          "timestamp": "2026-03-17T09:19:46.018Z"
-        },
-        "waterFilterResetType": {
-          "value": ["replaceable"],
-          "timestamp": "2026-03-17T09:19:46.018Z"
-        },
-        "waterFilterCapacity": {
-          "value": 12,
-          "unit": "Hour",
-          "timestamp": "2026-03-17T09:19:46.018Z"
-        },
-        "waterFilterLastResetDate": {
-          "value": null
-        },
-        "waterFilterUsage": {
-          "value": 78,
-          "timestamp": "2026-03-17T10:17:49.492Z"
-        },
-        "waterFilterStatus": {
-          "value": "normal",
-          "timestamp": "2026-03-17T09:19:46.018Z"
-        }
-      }
-    }
-  }
-}

tests/components/smartthings/fixtures/devices/da_wm_mf_01001.json

@@ -1,126 +0,0 @@
-{
-  "items": [
-    {
-      "deviceId": "42e80b4d-24c4-a810-11b3-f90375c56a39",
-      "name": "[microfiber] Samsung",
-      "label": "Filtro in microfibra",
-      "manufacturerName": "Samsung Electronics",
-      "presentationId": "DA-WM-MF-01001",
-      "deviceManufacturerCode": "Samsung Electronics",
-      "locationId": "dc3da2dd-adb0-41b9-9367-9dafc2637386",
-      "ownerId": "98f99f44-0f42-c20c-a48f-e53c911e27c7",
-      "roomId": "4696910e-f24d-4831-817b-b8b6b49ed885",
-      "deviceTypeName": "x.com.st.d.microfiberfilter",
-      "components": [
-        {
-          "id": "main",
-          "label": "main",
-          "capabilities": [
-            {
-              "id": "ocf",
-              "version": 1
-            },
-            {
-              "id": "execute",
-              "version": 1
-            },
-            {
-              "id": "refresh",
-              "version": 1
-            },
-            {
-              "id": "switch",
-              "version": 1
-            },
-            {
-              "id": "samsungce.bladeFilter",
-              "version": 1
-            },
-            {
-              "id": "samsungce.deviceIdentification",
-              "version": 1
-            },
-            {
-              "id": "samsungce.driverVersion",
-              "version": 1
-            },
-            {
-              "id": "samsungce.microfiberFilterOperatingState",
-              "version": 1
-            },
-            {
-              "id": "samsungce.microfiberFilterSettings",
-              "version": 1
-            },
-            {
-              "id": "samsungce.microfiberFilterStatus",
-              "version": 1
-            },
-            {
-              "id": "samsungce.selfCheck",
-              "version": 1
-            },
-            {
-              "id": "samsungce.softwareUpdate",
-              "version": 1
-            },
-            {
-              "id": "samsungce.softwareVersion",
-              "version": 1
-            },
-            {
-              "id": "sec.diagnosticsInformation",
-              "version": 1
-            },
-            {
-              "id": "sec.wifiConfiguration",
-              "version": 1
-            },
-            {
-              "id": "custom.disabledCapabilities",
-              "version": 1
-            },
-            {
-              "id": "custom.waterFilter",
-              "version": 1
-            }
-          ],
-          "categories": [
-            {
-              "name": "MicroFiberFilter",
-              "categoryType": "manufacturer"
-            }
-          ],
-          "optional": false
-        }
-      ],
-      "createTime": "2025-05-06T11:48:20.516Z",
-      "profile": {
-        "id": "b40c8b41-e933-334b-8597-d721a881e2ee"
-      },
-      "ocf": {
-        "ocfDeviceType": "x.com.st.d.microfiberfilter",
-        "name": "[microfiber] Samsung",
-        "specVersion": "core.1.1.0",
-        "verticalDomainSpecVersion": "res.1.1.0,sh.1.1.0",
-        "manufacturerName": "Samsung Electronics",
-        "modelNumber": "AMF-WW-TP1-22-COMMON|20349241|3A000000001511000A90020200000000",
-        "platformVersion": "DAWIT 2.0",
-        "platformOS": "TizenRT 3.1",
-        "hwVersion": "Realtek",
-        "firmwareVersion": "AMF-WW-TP1-22-COMMON_30230323",
-        "vendorId": "DA-WM-MF-01001",
-        "vendorResourceClientServerVersion": "Realtek Release 3.1.220727",
-        "lastSignupTime": "2025-05-06T11:48:20.456199900Z",
-        "transferCandidate": false,
-        "additionalAuthCodeRequired": false
-      },
-      "type": "OCF",
-      "restrictionTier": 0,
-      "allowed": null,
-      "executionContext": "CLOUD",
-      "relationships": []
-    }
-  ],
-  "_links": {}
-}

tests/components/smartthings/snapshots/test_binary_sensor.ambr

@@ -2325,57 +2325,6 @@
     'state': 'off',
   })
 # ---
-# name: test_all_entities[da_wm_mf_01001][binary_sensor.filtro_in_microfibra_filter_status-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': None,
-    'entity_id': 'binary_sensor.filtro_in_microfibra_filter_status',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Filter status',
-    'options': dict({
-    }),
-    'original_device_class': <BinarySensorDeviceClass.PROBLEM: 'problem'>,
-    'original_icon': None,
-    'original_name': 'Filter status',
-    'platform': 'smartthings',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'filter_status',
-    'unique_id': '42e80b4d-24c4-a810-11b3-f90375c56a39_main_custom.waterFilter_waterFilterStatus_waterFilterStatus',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[da_wm_mf_01001][binary_sensor.filtro_in_microfibra_filter_status-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'problem',
-      'friendly_name': 'Filtro in microfibra Filter status',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.filtro_in_microfibra_filter_status',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
 # name: test_all_entities[da_wm_sc_000001][binary_sensor.airdresser_child_lock-entry]
   EntityRegistryEntrySnapshot({
     'aliases': list([

tests/components/smartthings/snapshots/test_button.ambr

@@ -549,53 +549,3 @@
     'state': 'unknown',
   })
 # ---
-# name: test_all_entities[da_wm_mf_01001][button.filtro_in_microfibra_reset_water_filter-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'button',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'button.filtro_in_microfibra_reset_water_filter',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Reset water filter',
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Reset water filter',
-    'platform': 'smartthings',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'reset_water_filter',
-    'unique_id': '42e80b4d-24c4-a810-11b3-f90375c56a39_main_custom.waterFilter_resetWaterFilter',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[da_wm_mf_01001][button.filtro_in_microfibra_reset_water_filter-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'Filtro in microfibra Reset water filter',
-    }),
-    'context': <ANY>,
-    'entity_id': 'button.filtro_in_microfibra_reset_water_filter',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'unknown',
-  })
-# ---

tests/components/smartthings/snapshots/test_init.ambr

@@ -1270,37 +1270,6 @@
     'via_device_id': None,
   })
 # ---
-# name: test_devices[da_wm_mf_01001]
-  DeviceRegistryEntrySnapshot({
-    'area_id': None,
-    'config_entries': <ANY>,
-    'config_entries_subentries': <ANY>,
-    'configuration_url': 'https://account.smartthings.com',
-    'connections': set({
-    }),
-    'disabled_by': None,
-    'entry_type': None,
-    'hw_version': 'Realtek',
-    'id': <ANY>,
-    'identifiers': set({
-      tuple(
-        'smartthings',
-        '42e80b4d-24c4-a810-11b3-f90375c56a39',
-      ),
-    }),
-    'labels': set({
-    }),
-    'manufacturer': 'Samsung Electronics',
-    'model': 'AMF-WW-TP1-22-COMMON',
-    'model_id': None,
-    'name': 'Filtro in microfibra',
-    'name_by_user': None,
-    'primary_config_entry': <ANY>,
-    'serial_number': None,
-    'sw_version': 'AMF-WW-TP1-22-COMMON_30230323',
-    'via_device_id': None,
-  })
-# ---
 # name: test_devices[da_wm_sc_000001]
   DeviceRegistryEntrySnapshot({
     'area_id': None,

tests/components/smartthings/snapshots/test_select.ambr

@@ -727,9 +727,8 @@
 # ---
 # name: test_all_entities[da_rvc_map_01011][select.robot_vacuum_sound_mode-entry]
   EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
+    'aliases': set({
+    }),
     'area_id': None,
     'capabilities': dict({
       'options': list([

tests/components/smartthings/snapshots/test_sensor.ambr

@@ -14360,60 +14360,6 @@
     'state': '1336.2',
   })
 # ---
-# name: test_all_entities[da_wm_mf_01001][sensor.filtro_in_microfibra_water_filter_usage-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.filtro_in_microfibra_water_filter_usage',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Water filter usage',
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': None,
-    'original_name': 'Water filter usage',
-    'platform': 'smartthings',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'water_filter_usage',
-    'unique_id': '42e80b4d-24c4-a810-11b3-f90375c56a39_main_custom.waterFilter_waterFilterUsage_waterFilterUsage',
-    'unit_of_measurement': '%',
-  })
-# ---
-# name: test_all_entities[da_wm_mf_01001][sensor.filtro_in_microfibra_water_filter_usage-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'Filtro in microfibra Water filter usage',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': '%',
-    }),
-    'context': <ANY>,
-    'entity_id': 'sensor.filtro_in_microfibra_water_filter_usage',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': '78',
-  })
-# ---
 # name: test_all_entities[da_wm_sc_000001][sensor.airdresser_completion_time-entry]
   EntityRegistryEntrySnapshot({
     'aliases': list([