Fix test_unix_socket_started_with_supervisor pytest

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

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

CODEOWNERS

@@ -1616,6 +1616,8 @@ build.json @home-assistant/supervisor
 /tests/components/srp_energy/ @briglx
 /homeassistant/components/starline/ @anonym-tsk
 /tests/components/starline/ @anonym-tsk
+/homeassistant/components/starlink/ @boswelja
+/tests/components/starlink/ @boswelja
 /homeassistant/components/statistics/ @ThomDietrich @gjohansson-ST
 /tests/components/statistics/ @ThomDietrich @gjohansson-ST
 /homeassistant/components/steam_online/ @tkdrob

Dockerfile

@@ -10,6 +10,7 @@ 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

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

homeassistant/components/axis/manifest.json

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

homeassistant/components/backup/util.py

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

homeassistant/components/clementine/media_player.py

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

homeassistant/components/config/entity_registry.py

@@ -153,8 +153,8 @@ def websocket_get_entities(
     {
         vol.Required("type"): "config/entity_registry/update",
         vol.Required("entity_id"): cv.entity_id,
-        vol.Optional("aliases"): [vol.Any(str, None)],
         # If passed in, we update value. Passing None will remove old value.
+        vol.Optional("aliases"): list,
         vol.Optional("area_id"): vol.Any(str, None),
         # Categories is a mapping of key/value (scope/category_id) pairs.
         # If passed in, we update/adjust only the provided scope(s).
@@ -225,15 +225,10 @@ def websocket_update_entity(
             changes[key] = msg[key]
 
     if "aliases" in msg:
-        # Sanitize aliases by removing:
-        #   - Trailing and leading whitespace characters in the individual aliases
+        # Create a set for the aliases without:
         #   - Empty strings
-        changes["aliases"] = aliases = []
-        for alias in msg["aliases"]:
-            if alias is None:
-                aliases.append(er.COMPUTED_NAME)
-            elif alias := alias.strip():
-                aliases.append(alias)
+        #   - Trailing and leading whitespace characters in the individual aliases
+        changes["aliases"] = {s_strip for s in msg["aliases"] if (s_strip := s.strip())}
 
     if "labels" in msg:
         # Convert labels to a set

homeassistant/components/conversation/default_agent.py

@@ -992,11 +992,18 @@ class DefaultAgent(ConversationEntity):
                         continue
                     context[attr] = state.attributes[attr]
 
-            entity_entry = entity_registry.async_get(state.entity_id)
-            for name in intent.async_get_entity_aliases(
-                self.hass, entity_entry, state=state
-            ):
-                yield (name, name, context)
+            if (
+                entity := entity_registry.async_get(state.entity_id)
+            ) and entity.aliases:
+                for alias in entity.aliases:
+                    alias = alias.strip()
+                    if not alias:
+                        continue
+
+                    yield (alias, alias, context)
+
+            # Default name
+            yield (state.name, state.name, context)
 
     def _recognize_strict(
         self,

homeassistant/components/cover/__init__.py

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

homeassistant/components/cover/condition.py

@@ -5,7 +5,7 @@ from homeassistant.core import HomeAssistant, State, split_entity_id
 from homeassistant.helpers.condition import Condition, EntityConditionBase
 
 from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
-from .models import CoverDomainSpec
+from .trigger import CoverDomainSpec
 
 
 class CoverConditionBase(EntityConditionBase[CoverDomainSpec]):

homeassistant/components/cover/models.py

@@ -1,12 +0,0 @@
-"""Data models for the cover integration."""
-
-from dataclasses import dataclass
-
-from homeassistant.helpers.automation import DomainSpec
-
-
-@dataclass(frozen=True, slots=True)
-class CoverDomainSpec(DomainSpec):
-    """DomainSpec with a target value for comparison."""
-
-    target_value: str | bool | None = None

homeassistant/components/cover/trigger.py

@@ -1,11 +1,20 @@
 """Provides triggers for covers."""
 
+from dataclasses import dataclass
+
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State, split_entity_id
+from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import EntityTriggerBase, Trigger
 
 from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
-from .models import CoverDomainSpec
+
+
+@dataclass(frozen=True, slots=True)
+class CoverDomainSpec(DomainSpec):
+    """DomainSpec with a target value for comparison."""
+
+    target_value: str | bool | None = None
 
 
 class CoverTriggerBase(EntityTriggerBase[CoverDomainSpec]):

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/diagnostics/util.py

@@ -48,7 +48,7 @@ def async_redact_data[_T](data: _T, to_redact: Iterable[Any]) -> _T:
 
 
 def _entity_entry_filter(a: attr.Attribute, _: Any) -> bool:
-    return a.name not in ("_cache", "compat_aliases", "compat_name")
+    return a.name != "_cache"
 
 
 @callback

homeassistant/components/door/condition.py

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

homeassistant/components/door/conditions.yaml

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

homeassistant/components/door/icons.json

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

homeassistant/components/door/strings.json

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

homeassistant/components/freshr/config_flow.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
 from typing import Any
 
 from aiohttp import ClientError
@@ -57,42 +56,3 @@ class FreshrFlowHandler(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
-
-    async def async_step_reauth(
-        self, _user_input: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauthentication."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauthentication confirmation."""
-        errors: dict[str, str] = {}
-        reauth_entry = self._get_reauth_entry()
-
-        if user_input is not None:
-            client = FreshrClient(session=async_get_clientsession(self.hass))
-            try:
-                await client.login(
-                    reauth_entry.data[CONF_USERNAME], user_input[CONF_PASSWORD]
-                )
-            except LoginError:
-                errors["base"] = "invalid_auth"
-            except ClientError:
-                errors["base"] = "cannot_connect"
-            except Exception:  # noqa: BLE001
-                LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                return self.async_update_reload_and_abort(
-                    reauth_entry,
-                    data_updates={CONF_PASSWORD: user_input[CONF_PASSWORD]},
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema({vol.Required(CONF_PASSWORD): str}),
-            description_placeholders={CONF_USERNAME: reauth_entry.data[CONF_USERNAME]},
-            errors=errors,
-        )

homeassistant/components/freshr/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/freshr",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "quality_scale": "silver",
+  "quality_scale": "bronze",
   "requirements": ["pyfreshr==1.2.0"]
 }

homeassistant/components/freshr/quality_scale.yaml

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

homeassistant/components/freshr/strings.json

@@ -2,7 +2,9 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "wrong_account": "Cannot change the account username."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -10,15 +12,6 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::freshr::config::step::user::data_description::password%]"
-        },
-        "description": "Re-enter the password for your Fresh-r account `{username}`."
-      },
       "user": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",

homeassistant/components/fritz/services.yaml

@@ -4,9 +4,9 @@ set_guest_wifi_password:
       required: true
       selector:
         device:
+          integration: fritz
           entity:
-            integration: fritz
-            domain: update
+            device_class: connectivity
     password:
       required: false
       selector:
@@ -23,9 +23,9 @@ dial:
       required: true
       selector:
         device:
+          integration: fritz
           entity:
-            integration: fritz
-            domain: update
+            device_class: connectivity
     number:
       required: true
       selector:

homeassistant/components/fully_kiosk/sensor.py

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

homeassistant/components/fully_kiosk/strings.json

@@ -118,9 +118,6 @@
       }
     },
     "sensor": {
-      "battery_temperature": {
-        "name": "Battery temperature"
-      },
       "current_page": {
         "name": "Current page"
       },

homeassistant/components/garage_door/condition.py

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

homeassistant/components/garage_door/conditions.yaml

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

homeassistant/components/garage_door/icons.json

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

homeassistant/components/garage_door/strings.json

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

homeassistant/components/gate/condition.py

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

homeassistant/components/gate/conditions.yaml

@@ -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_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: gate
-
-is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: gate

homeassistant/components/gate/icons.json

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

homeassistant/components/gate/strings.json

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

homeassistant/components/google_assistant/helpers.py

@@ -29,7 +29,6 @@ from homeassistant.helpers import (
     area_registry as ar,
     device_registry as dr,
     entity_registry as er,
-    intent,
     start,
 )
 from homeassistant.helpers.event import async_call_later
@@ -598,6 +597,7 @@ class GoogleEntity:
         state = self.state
         traits = self.traits()
         entity_config = self.config.entity_config.get(state.entity_id, {})
+        name = (entity_config.get(CONF_NAME) or state.name).strip()
 
         # Find entity/device/area registry entries
         entity_entry, device_entry, area_entry = _get_registry_entries(
@@ -607,6 +607,7 @@ class GoogleEntity:
         # Build the device info
         device = {
             "id": state.entity_id,
+            "name": {"name": name},
             "attributes": {},
             "traits": [trait.name for trait in traits],
             "willReportState": self.config.should_report_state,
@@ -614,18 +615,13 @@ class GoogleEntity:
                 state.domain, state.attributes.get(ATTR_DEVICE_CLASS)
             ),
         }
-        # Add name and aliases.
-        # The entity's alias list is ordered: the first slot naturally serves
-        # as the primary name (set to the auto-generated full entity name by
-        # default), while the rest serve as alternative names (nicknames).
-        aliases = intent.async_get_entity_aliases(
-            self.hass, entity_entry, state=state, allow_empty=False
-        )
-        name, *aliases = aliases
-        name = entity_config.get(CONF_NAME) or name
-        device["name"] = {"name": name}
-        if (config_aliases := entity_config.get(CONF_ALIASES, [])) or aliases:
-            device["name"]["nicknames"] = [name, *config_aliases, *aliases]
+        # Add aliases
+        if (config_aliases := entity_config.get(CONF_ALIASES, [])) or (
+            entity_entry and entity_entry.aliases
+        ):
+            device["name"]["nicknames"] = [name, *config_aliases]
+            if entity_entry:
+                device["name"]["nicknames"].extend(entity_entry.aliases)
 
         # Add local SDK info if enabled
         if self.config.is_local_sdk_active and self.should_expose_local():

homeassistant/components/growatt_server/coordinator.py

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

homeassistant/components/growatt_server/icons.json

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

homeassistant/components/growatt_server/manifest.json

@@ -7,6 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["growattServer"],
-  "quality_scale": "silver",
   "requirements": ["growattServer==1.9.0"]
 }

homeassistant/components/growatt_server/number.py

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

homeassistant/components/growatt_server/quality_scale.yaml

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

homeassistant/components/growatt_server/sensor/__init__.py

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

homeassistant/components/growatt_server/sensor/inverter.py

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

homeassistant/components/growatt_server/sensor/sensor_entity_description.py

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

homeassistant/components/growatt_server/sensor/sph.py

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

homeassistant/components/growatt_server/sensor/storage.py

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

homeassistant/components/growatt_server/sensor/tlx.py

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

homeassistant/components/growatt_server/switch.py

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

homeassistant/components/habitica/strings.json

@@ -89,18 +89,18 @@
     "step": {
       "advanced": {
         "data": {
-          "api_key": "API token",
+          "api_key": "API Token",
           "api_user": "User ID",
           "url": "[%key:common::config_flow::data::url%]",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
         "data_description": {
-          "api_key": "API token of the Habitica account",
+          "api_key": "API Token of the Habitica account",
           "api_user": "User ID of your Habitica account",
           "url": "URL of the Habitica installation to connect to. Defaults to `{default_url}`",
           "verify_ssl": "Enable SSL certificate verification for secure connections. Disable only if connecting to a Habitica instance using a self-signed certificate"
         },
-        "description": "You can retrieve your 'User ID' and 'API token' from [**Settings -> Site Data**]({site_data}) on Habitica or the instance you want to connect to",
+        "description": "You can retrieve your `User ID` and `API Token` from [**Settings -> Site Data**]({site_data}) on Habitica or the instance you want to connect to",
         "title": "[%key:component::habitica::config::step::user::menu_options::advanced%]"
       },
       "login": {
@@ -126,7 +126,7 @@
               "api_key": "[%key:component::habitica::config::step::advanced::data_description::api_key%]"
             },
             "description": "Enter your new API token below. You can find it in Habitica under 'Settings -> Site Data'",
-            "name": "Re-authorize via API token"
+            "name": "Re-authorize via API Token"
           },
           "reauth_login": {
             "data": {

homeassistant/components/hassio/__init__.py

@@ -119,6 +119,7 @@ from .coordinator import (
     get_core_stats,
     get_host_info,
     get_info,
+    get_issues_info,
     get_network_info,
     get_os_info,
     get_store,
@@ -157,6 +158,7 @@ __all__ = [
     "get_core_stats",
     "get_host_info",
     "get_info",
+    "get_issues_info",
     "get_network_info",
     "get_os_info",
     "get_store",

homeassistant/components/hassio/const.py

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

homeassistant/components/hassio/issues.py

@@ -47,7 +47,6 @@ from .const import (
     EVENT_SUPPORTED_CHANGED,
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
-    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     ISSUE_KEY_ADDON_DETACHED_ADDON_MISSING,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
@@ -91,7 +90,6 @@ ISSUE_KEYS_FOR_REPAIRS = {
     "issue_system_disk_lifetime",
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_KEY_ADDON_PWNED,
-    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
 }
 
 _LOGGER = logging.getLogger(__name__)
@@ -255,10 +253,9 @@ class SupervisorIssues:
     def add_issue(self, issue: Issue) -> None:
         """Add or update an issue in the list. Create or update a repair if necessary."""
         if issue.key in ISSUE_KEYS_FOR_REPAIRS:
+            placeholders: dict[str, str] = {}
             if not issue.suggestions and issue.key in EXTRA_PLACEHOLDERS:
-                placeholders: dict[str, str] = EXTRA_PLACEHOLDERS[issue.key].copy()
-            else:
-                placeholders = {}
+                placeholders |= EXTRA_PLACEHOLDERS[issue.key]
 
             if issue.reference:
                 placeholders[PLACEHOLDER_KEY_REFERENCE] = issue.reference

homeassistant/components/hassio/manifest.json

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

homeassistant/components/hassio/repairs.py

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

homeassistant/components/hassio/strings.json

@@ -85,19 +85,6 @@
       },
       "title": "Installed app is deprecated"
     },
-    "issue_addon_deprecated_arch_addon": {
-      "fix_flow": {
-        "abort": {
-          "apply_suggestion_fail": "Could not uninstall the app. Check the Supervisor logs for more details."
-        },
-        "step": {
-          "addon_execute_remove": {
-            "description": "App {addon} only supports architectures and/or machines which are no longer supported by Home Assistant. It will stop working in a future release.\n\nSelecting **Submit** will uninstall this deprecated app. Alternatively, you can check [Home Assistant help]({help_url}) and the [community forum]({community_url}) for alternatives to migrate to."
-          }
-        }
-      },
-      "title": "Installed app is built for unsupported architectures and/or machines"
-    },
     "issue_addon_detached_addon_missing": {
       "description": "Repository for app {addon} is missing. This means it will not get updates, and backups may not be restored correctly as the Home Assistant Supervisor may not be able to build/download the resources required.\n\nPlease check the [app's documentation]({addon_url}) for installation instructions and add the repository to the store.",
       "title": "Missing repository for an installed app"

homeassistant/components/homekit_controller/connection.py

@@ -965,7 +965,7 @@ class HKDevice:
                     # visible on the network.
                     self.async_set_available_state(False)
                     return
-                except AccessoryDisconnectedError, EncryptionError, TimeoutError:
+                except AccessoryDisconnectedError, EncryptionError:
                     # Temporary connection failure. Device may still available but our
                     # connection was dropped or we are reconnecting
                     self._poll_failures += 1

homeassistant/components/http/__init__.py

@@ -10,6 +10,7 @@ from functools import partial
 from ipaddress import IPv4Network, IPv6Network, ip_network
 import logging
 import os
+from pathlib import Path
 import socket
 import ssl
 from tempfile import NamedTemporaryFile
@@ -33,6 +34,7 @@ from homeassistant.components.network import async_get_source_ip
 from homeassistant.const import (
     EVENT_HOMEASSISTANT_START,
     EVENT_HOMEASSISTANT_STOP,
+    HASSIO_USER_NAME,
     SERVER_PORT,
 )
 from homeassistant.core import Event, HomeAssistant, callback
@@ -69,7 +71,7 @@ from .headers import setup_headers
 from .request_context import setup_request_context
 from .security_filter import setup_security_filter
 from .static import CACHE_HEADERS, CachingStaticResource
-from .web_runner import HomeAssistantTCPSite
+from .web_runner import HomeAssistantTCPSite, HomeAssistantUnixSite
 
 CONF_SERVER_HOST: Final = "server_host"
 CONF_SERVER_PORT: Final = "server_port"
@@ -235,6 +237,16 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     source_ip_task = create_eager_task(async_get_source_ip(hass))
 
+    unix_socket_path: Path | None = None
+    if socket_env := os.environ.get("SUPERVISOR_CORE_API_SOCKET"):
+        socket_path = Path(socket_env)
+        if socket_path.is_absolute():
+            unix_socket_path = socket_path
+        else:
+            _LOGGER.error(
+                "Invalid unix socket path %s: path must be absolute", socket_env
+            )
+
     server = HomeAssistantHTTP(
         hass,
         server_host=server_host,
@@ -244,6 +256,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         ssl_key=ssl_key,
         trusted_proxies=trusted_proxies,
         ssl_profile=ssl_profile,
+        unix_socket_path=unix_socket_path,
     )
     await server.async_initialize(
         cors_origins=cors_origins,
@@ -267,6 +280,21 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async_when_setup_or_start(hass, "frontend", start_server)
 
+    if server.unix_socket_path is not None:
+
+        async def start_unix_socket(*_: Any) -> None:
+            """Start the Unix socket after the Supervisor user is available."""
+            if any(
+                user
+                for user in await hass.auth.async_get_users()
+                if user.system_generated and user.name == HASSIO_USER_NAME
+            ):
+                await server.async_start_unix_socket()
+            else:
+                _LOGGER.error("Supervisor user not found; not starting Unix socket")
+
+        async_when_setup_or_start(hass, "hassio", start_unix_socket)
+
     hass.http = server
 
     local_ip = await source_ip_task
@@ -366,6 +394,7 @@ class HomeAssistantHTTP:
         server_port: int,
         trusted_proxies: list[IPv4Network | IPv6Network],
         ssl_profile: str,
+        unix_socket_path: Path | None = None,
     ) -> None:
         """Initialize the HTTP Home Assistant server."""
         self.app = HomeAssistantApplication(
@@ -384,8 +413,10 @@ class HomeAssistantHTTP:
         self.server_port = server_port
         self.trusted_proxies = trusted_proxies
         self.ssl_profile = ssl_profile
+        self.unix_socket_path = unix_socket_path
         self.runner: web.AppRunner | None = None
         self.site: HomeAssistantTCPSite | None = None
+        self.unix_site: HomeAssistantUnixSite | None = None
         self.context: ssl.SSLContext | None = None
 
     async def async_initialize(
@@ -610,6 +641,29 @@ class HomeAssistantHTTP:
             context.load_cert_chain(cert_pem.name, key_pem.name)
         return context
 
+    async def async_start_unix_socket(self) -> None:
+        """Start listening on the Unix socket.
+
+        This is called separately from start() to delay serving the Unix
+        socket until the Supervisor user exists (created by the hassio
+        integration).  Without this delay, Supervisor could connect before
+        its user is available and receive 401 responses it won't retry.
+        """
+        if self.unix_socket_path is None or self.runner is None:
+            return
+        self.unix_site = HomeAssistantUnixSite(self.runner, self.unix_socket_path)
+        try:
+            await self.unix_site.start()
+        except OSError as error:
+            _LOGGER.error(
+                "Failed to create HTTP server on unix socket %s: %s",
+                self.unix_socket_path,
+                error,
+            )
+            self.unix_site = None
+        else:
+            _LOGGER.info("Now listening on unix socket %s", self.unix_socket_path)
+
     async def start(self) -> None:
         """Start the aiohttp server."""
         # Aiohttp freezes apps after start so that no changes can be made.
@@ -637,6 +691,19 @@ class HomeAssistantHTTP:
 
     async def stop(self) -> None:
         """Stop the aiohttp server."""
+        if self.unix_site is not None:
+            await self.unix_site.stop()
+            if self.unix_socket_path is not None:
+                try:
+                    await self.hass.async_add_executor_job(
+                        self.unix_socket_path.unlink, True
+                    )
+                except OSError as err:
+                    _LOGGER.warning(
+                        "Could not remove unix socket %s: %s",
+                        self.unix_socket_path,
+                        err,
+                    )
         if self.site is not None:
             await self.site.stop()
         if self.runner is not None:

homeassistant/components/http/auth.py

@@ -11,7 +11,13 @@ import time
 from typing import Any, Final
 
 from aiohttp import hdrs
-from aiohttp.web import Application, Request, StreamResponse, middleware
+from aiohttp.web import (
+    Application,
+    HTTPInternalServerError,
+    Request,
+    StreamResponse,
+    middleware,
+)
 import jwt
 from jwt import api_jws
 from yarl import URL
@@ -20,6 +26,7 @@ from homeassistant.auth import jwt_wrapper
 from homeassistant.auth.const import GROUP_ID_READ_ONLY
 from homeassistant.auth.models import User
 from homeassistant.components import websocket_api
+from homeassistant.const import HASSIO_USER_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.http import current_request
 from homeassistant.helpers.json import json_bytes
@@ -27,7 +34,12 @@ from homeassistant.helpers.network import is_cloud_connection
 from homeassistant.helpers.storage import Store
 from homeassistant.util.network import is_local
 
-from .const import KEY_AUTHENTICATED, KEY_HASS_REFRESH_TOKEN_ID, KEY_HASS_USER
+from .const import (
+    KEY_AUTHENTICATED,
+    KEY_HASS_REFRESH_TOKEN_ID,
+    KEY_HASS_USER,
+    is_unix_socket_request,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -117,7 +129,7 @@ def async_user_not_allowed_do_auth(
     return "User cannot authenticate remotely"
 
 
-async def async_setup_auth(
+async def async_setup_auth(  # noqa: C901
     hass: HomeAssistant,
     app: Application,
 ) -> None:
@@ -207,6 +219,41 @@ async def async_setup_auth(
         request[KEY_HASS_REFRESH_TOKEN_ID] = refresh_token.id
         return True
 
+    supervisor_user_id: str | None = None
+
+    async def async_authenticate_unix_socket(request: Request) -> bool:
+        """Authenticate a request from a Unix socket as the Supervisor user.
+
+        The Unix Socket is dedicated and only available to Supervisor. To
+        avoid the extra overhead and round trips for the authentication and
+        refresh tokens, we directly authenticate requests from the socket as
+        the Supervisor user.
+        """
+        nonlocal supervisor_user_id
+
+        # Fast path: use cached user ID
+        if supervisor_user_id is not None:
+            if user := await hass.auth.async_get_user(supervisor_user_id):
+                request[KEY_HASS_USER] = user
+                return True
+            supervisor_user_id = None
+
+        # Slow path: find the Supervisor user by name
+        for user in await hass.auth.async_get_users():
+            if user.system_generated and user.name == HASSIO_USER_NAME:
+                supervisor_user_id = user.id
+                # Not setting KEY_HASS_REFRESH_TOKEN_ID since Supervisor user
+                # doesn't use refresh tokens.
+                request[KEY_HASS_USER] = user
+                return True
+
+        # The Unix socket should not be serving before the hassio integration
+        # has created the Supervisor user. If we get here, something is wrong.
+        _LOGGER.error(
+            "Supervisor user not found; cannot authenticate Unix socket request"
+        )
+        raise HTTPInternalServerError
+
     @middleware
     async def auth_middleware(
         request: Request, handler: Callable[[Request], Awaitable[StreamResponse]]
@@ -214,7 +261,11 @@ async def async_setup_auth(
         """Authenticate as middleware."""
         authenticated = False
 
-        if hdrs.AUTHORIZATION in request.headers and async_validate_auth_header(
+        if is_unix_socket_request(request):
+            authenticated = await async_authenticate_unix_socket(request)
+            auth_type = "unix socket"
+
+        elif hdrs.AUTHORIZATION in request.headers and async_validate_auth_header(
             request
         ):
             authenticated = True
@@ -233,7 +284,7 @@ async def async_setup_auth(
         if authenticated and _LOGGER.isEnabledFor(logging.DEBUG):
             _LOGGER.debug(
                 "Authenticated %s for %s using %s",
-                request.remote,
+                request.remote or "unknown",
                 request.path,
                 auth_type,
             )

homeassistant/components/http/ban.py

@@ -30,7 +30,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.hassio import get_supervisor_ip, is_hassio
 from homeassistant.util import dt as dt_util, yaml as yaml_util
 
-from .const import KEY_HASS
+from .const import KEY_HASS, is_unix_socket_request
 from .view import HomeAssistantView
 
 _LOGGER: Final = logging.getLogger(__name__)
@@ -72,6 +72,10 @@ async def ban_middleware(
     request: Request, handler: Callable[[Request], Awaitable[StreamResponse]]
 ) -> StreamResponse:
     """IP Ban middleware."""
+    # Unix socket connections are trusted, skip ban checks
+    if is_unix_socket_request(request):
+        return await handler(request)
+
     if (ban_manager := request.app.get(KEY_BAN_MANAGER)) is None:
         _LOGGER.error("IP Ban middleware loaded but banned IPs not loaded")
         return await handler(request)

homeassistant/components/http/const.py

@@ -1,10 +1,22 @@
 """HTTP specific constants."""
 
+import socket
 from typing import Final
 
+from aiohttp.web import Request
+
 from homeassistant.helpers.http import KEY_AUTHENTICATED, KEY_HASS  # noqa: F401
 
 DOMAIN: Final = "http"
 
 KEY_HASS_USER: Final = "hass_user"
 KEY_HASS_REFRESH_TOKEN_ID: Final = "hass_refresh_token_id"
+
+
+def is_unix_socket_request(request: Request) -> bool:
+    """Check if request arrived over a Unix socket."""
+    if (transport := request.transport) is None:
+        return False
+    if (sock := transport.get_extra_info("socket")) is None:
+        return False
+    return bool(sock.family == socket.AF_UNIX)

homeassistant/components/http/web_runner.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import asyncio
+from pathlib import Path
+import socket
 from ssl import SSLContext
 
 from aiohttp import web
@@ -68,3 +70,62 @@ class HomeAssistantTCPSite(web.BaseSite):
             reuse_address=self._reuse_address,
             reuse_port=self._reuse_port,
         )
+
+
+class HomeAssistantUnixSite(web.BaseSite):
+    """HomeAssistant specific aiohttp UnixSite.
+
+    Listens on a Unix socket for local inter-process communication,
+    used for Supervisor to Core communication.
+    """
+
+    __slots__ = ("_path",)
+
+    def __init__(
+        self,
+        runner: web.BaseRunner,
+        path: Path,
+        *,
+        backlog: int = 128,
+    ) -> None:
+        """Initialize HomeAssistantUnixSite."""
+        super().__init__(
+            runner,
+            backlog=backlog,
+        )
+        self._path = path
+
+    @property
+    def name(self) -> str:
+        """Return server URL."""
+        return f"http://unix:{self._path}:"
+
+    def _create_unix_socket(self) -> socket.socket:
+        """Create and bind a Unix domain socket.
+
+        Performs blocking filesystem I/O (mkdir, unlink, chmod) and is
+        intended to be run in an executor. Permissions are set after bind
+        but before the socket is handed to the event loop, so no
+        connections can arrive on an unrestricted socket.
+        """
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.unlink(missing_ok=True)
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        try:
+            sock.bind(str(self._path))
+        except OSError:
+            sock.close()
+            raise
+        self._path.chmod(0o600)
+        return sock
+
+    async def start(self) -> None:
+        """Start server."""
+        await super().start()
+        loop = asyncio.get_running_loop()
+        sock = await loop.run_in_executor(None, self._create_unix_socket)
+        server = self._runner.server
+        assert server is not None
+        self._server = await loop.create_unix_server(
+            server, sock=sock, backlog=self._backlog
+        )

homeassistant/components/huum/climate.py

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

homeassistant/components/huum/config_flow.py

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

homeassistant/components/huum/coordinator.py

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

homeassistant/components/huum/quality_scale.yaml

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

homeassistant/components/indevolt/__init__.py

@@ -8,7 +8,6 @@ from homeassistant.core import HomeAssistant
 from .coordinator import IndevoltConfigEntry, IndevoltCoordinator
 
 PLATFORMS: list[Platform] = [
-    Platform.BUTTON,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,

homeassistant/components/indevolt/button.py

@@ -1,70 +0,0 @@
-"""Button platform for Indevolt integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Final
-
-from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import IndevoltConfigEntry
-from .coordinator import IndevoltCoordinator
-from .entity import IndevoltEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class IndevoltButtonEntityDescription(ButtonEntityDescription):
-    """Custom entity description class for Indevolt button entities."""
-
-    generation: list[int] = field(default_factory=lambda: [1, 2])
-
-
-BUTTONS: Final = (
-    IndevoltButtonEntityDescription(
-        key="stop",
-        translation_key="stop",
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: IndevoltConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the button platform for Indevolt."""
-    coordinator = entry.runtime_data
-    device_gen = coordinator.generation
-
-    # Button initialization
-    async_add_entities(
-        IndevoltButtonEntity(coordinator=coordinator, description=description)
-        for description in BUTTONS
-        if device_gen in description.generation
-    )
-
-
-class IndevoltButtonEntity(IndevoltEntity, ButtonEntity):
-    """Represents a button entity for Indevolt devices."""
-
-    entity_description: IndevoltButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: IndevoltCoordinator,
-        description: IndevoltButtonEntityDescription,
-    ) -> None:
-        """Initialize the Indevolt button entity."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
-        self._attr_unique_id = f"{self.serial_number}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-
-        await self.coordinator.async_execute_realtime_action([0, 0, 0])

homeassistant/components/indevolt/const.py

@@ -1,27 +1,16 @@
 """Constants for the Indevolt integration."""
 
-from typing import Final
-
-DOMAIN: Final = "indevolt"
-
-# Default configurations
-DEFAULT_PORT: Final = 8080
+DOMAIN = "indevolt"
 
 # Config entry fields
-CONF_SERIAL_NUMBER: Final = "serial_number"
-CONF_GENERATION: Final = "generation"
+CONF_SERIAL_NUMBER = "serial_number"
+CONF_GENERATION = "generation"
 
-# API write/read keys for energy and value for outdoor/portable mode
-ENERGY_MODE_READ_KEY: Final = "7101"
-ENERGY_MODE_WRITE_KEY: Final = "47005"
-PORTABLE_MODE: Final = 0
-
-# API write key and value for real-time control mode
-REALTIME_ACTION_KEY: Final = "47015"
-REALTIME_ACTION_MODE: Final = 4
+# Default values
+DEFAULT_PORT = 8080
 
 # API key fields
-SENSOR_KEYS: Final[dict[int, list[str]]] = {
+SENSOR_KEYS = {
     1: [
         "606",
         "7101",

homeassistant/components/indevolt/coordinator.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from datetime import timedelta
 import logging
-from typing import Any, Final
+from typing import Any
 
 from aiohttp import ClientError
 from indevolt_api import IndevoltAPI, TimeOutException
@@ -21,37 +21,20 @@ from .const import (
     CONF_SERIAL_NUMBER,
     DEFAULT_PORT,
     DOMAIN,
-    ENERGY_MODE_READ_KEY,
-    ENERGY_MODE_WRITE_KEY,
-    PORTABLE_MODE,
-    REALTIME_ACTION_KEY,
-    REALTIME_ACTION_MODE,
     SENSOR_KEYS,
 )
 
 _LOGGER = logging.getLogger(__name__)
-SCAN_INTERVAL: Final = 30
+SCAN_INTERVAL = 30
 
 type IndevoltConfigEntry = ConfigEntry[IndevoltCoordinator]
 
 
-class DeviceTimeoutError(HomeAssistantError):
-    """Raised when device push times out."""
-
-
-class DeviceConnectionError(HomeAssistantError):
-    """Raised when device push fails due to connection issues."""
-
-
 class IndevoltCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Coordinator for fetching and pushing data to indevolt devices."""
 
-    friendly_name: str
     config_entry: IndevoltConfigEntry
     firmware_version: str | None
-    serial_number: str
-    device_model: str
-    generation: int
 
     def __init__(self, hass: HomeAssistant, entry: IndevoltConfigEntry) -> None:
         """Initialize the indevolt coordinator."""
@@ -70,7 +53,6 @@ class IndevoltCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             session=async_get_clientsession(hass),
         )
 
-        self.friendly_name = entry.title
         self.serial_number = entry.data[CONF_SERIAL_NUMBER]
         self.device_model = entry.data[CONF_MODEL]
         self.generation = entry.data[CONF_GENERATION]
@@ -103,67 +85,6 @@ class IndevoltCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         try:
             return await self.api.set_data(sensor_key, value)
         except TimeOutException as err:
-            raise DeviceTimeoutError(f"Device push timed out: {err}") from err
+            raise HomeAssistantError(f"Device push timed out: {err}") from err
         except (ClientError, ConnectionError, OSError) as err:
-            raise DeviceConnectionError(f"Device push failed: {err}") from err
-
-    async def async_switch_energy_mode(
-        self, target_mode: int, refresh: bool = True
-    ) -> None:
-        """Attempt to switch device to given energy mode."""
-        current_mode = self.data.get(ENERGY_MODE_READ_KEY)
-
-        # Ensure current energy mode is known
-        if current_mode is None:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="failed_to_retrieve_current_energy_mode",
-            )
-
-        # Ensure device is not in "Outdoor/Portable mode"
-        if current_mode == PORTABLE_MODE:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="energy_mode_change_unavailable_outdoor_portable",
-            )
-
-        # Switch energy mode if required
-        if current_mode != target_mode:
-            try:
-                success = await self.async_push_data(ENERGY_MODE_WRITE_KEY, target_mode)
-            except (DeviceTimeoutError, DeviceConnectionError) as err:
-                raise HomeAssistantError(
-                    translation_domain=DOMAIN,
-                    translation_key="failed_to_switch_energy_mode",
-                ) from err
-
-            if not success:
-                raise HomeAssistantError(
-                    translation_domain=DOMAIN,
-                    translation_key="failed_to_switch_energy_mode",
-                )
-
-            if refresh:
-                await self.async_request_refresh()
-
-    async def async_execute_realtime_action(self, action: list[int]) -> None:
-        """Switch mode, execute action, and refresh for real-time control."""
-
-        await self.async_switch_energy_mode(REALTIME_ACTION_MODE, refresh=False)
-
-        try:
-            success = await self.async_push_data(REALTIME_ACTION_KEY, action)
-
-        except (DeviceTimeoutError, DeviceConnectionError) as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="failed_to_execute_realtime_action",
-            ) from err
-
-        if not success:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="failed_to_execute_realtime_action",
-            )
-
-        await self.async_request_refresh()
+            raise HomeAssistantError(f"Device push failed: {err}") from err

homeassistant/components/indevolt/strings.json

@@ -35,11 +35,6 @@
     }
   },
   "entity": {
-    "button": {
-      "stop": {
-        "name": "Enable standby mode"
-      }
-    },
     "number": {
       "discharge_limit": {
         "name": "Discharge limit"
@@ -294,19 +289,5 @@
         "name": "LED indicator"
       }
     }
-  },
-  "exceptions": {
-    "energy_mode_change_unavailable_outdoor_portable": {
-      "message": "Energy mode cannot be changed when the device is in outdoor/portable mode"
-    },
-    "failed_to_execute_realtime_action": {
-      "message": "Failed to execute real-time action"
-    },
-    "failed_to_retrieve_current_energy_mode": {
-      "message": "Failed to retrieve current energy mode"
-    },
-    "failed_to_switch_energy_mode": {
-      "message": "Failed to switch to requested energy mode"
-    }
   }
 }

homeassistant/components/intellifire/strings.json

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

homeassistant/components/jellyfin/__init__.py

@@ -4,21 +4,11 @@ from typing import Any
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, device_registry as dr
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.helpers import device_registry as dr
 
 from .client_wrapper import CannotConnect, InvalidAuth, create_client, validate_input
 from .const import CONF_CLIENT_DEVICE_ID, DEFAULT_NAME, DOMAIN, PLATFORMS
 from .coordinator import JellyfinConfigEntry, JellyfinDataUpdateCoordinator
-from .services import async_setup_services
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Jellyfin component."""
-    await async_setup_services(hass)
-    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:

homeassistant/components/jellyfin/browse_media.py

@@ -38,8 +38,6 @@ PLAYABLE_MEDIA_TYPES = [
     MediaType.EPISODE,
     MediaType.MOVIE,
     MediaType.MUSIC,
-    MediaType.SEASON,
-    MediaType.TVSHOW,
 ]
 
 
@@ -100,8 +98,8 @@ async def build_item_response(
     media_content_id: str,
 ) -> BrowseMedia:
     """Create response payload for the provided media query."""
-    title, media, thumbnail, media_type = await get_media_info(
-        hass, client, user_id, media_content_id
+    title, media, thumbnail = await get_media_info(
+        hass, client, user_id, media_content_type, media_content_id
     )
 
     if title is None or media is None:
@@ -113,12 +111,12 @@ async def build_item_response(
 
     response = BrowseMedia(
         media_class=CONTAINER_TYPES_SPECIFIC_MEDIA_CLASS.get(
-            str(media_type), MediaClass.DIRECTORY
+            str(media_content_type), MediaClass.DIRECTORY
         ),
         media_content_id=media_content_id,
-        media_content_type=str(media_type),
+        media_content_type=str(media_content_type),
         title=title,
-        can_play=bool(media_type in PLAYABLE_MEDIA_TYPES and media_content_id),
+        can_play=bool(media_content_type in PLAYABLE_MEDIA_TYPES and media_content_id),
         can_expand=True,
         children=children,
         thumbnail=thumbnail,
@@ -209,18 +207,18 @@ async def get_media_info(
     hass: HomeAssistant,
     client: JellyfinClient,
     user_id: str,
+    media_content_type: str | None,
     media_content_id: str,
-) -> tuple[str | None, list[dict[str, Any]] | None, str | None, str | None]:
+) -> tuple[str | None, list[dict[str, Any]] | None, str | None]:
     """Fetch media info."""
     thumbnail: str | None = None
     title: str | None = None
     media: list[dict[str, Any]] | None = None
-    media_type: str | None = None
 
     item = await hass.async_add_executor_job(fetch_item, client, media_content_id)
 
     if item is None:
-        return None, None, None, None
+        return None, None, None
 
     title = item["Name"]
     thumbnail = get_artwork_url(client, item)
@@ -233,6 +231,4 @@ async def get_media_info(
     if not media or len(media) == 0:
         media = None
 
-    media_type = CONTENT_TYPE_MAP.get(item["Type"], MEDIA_TYPE_NONE)
-
-    return title, media, thumbnail, media_type
+    return title, media, thumbnail

homeassistant/components/jellyfin/const.py

@@ -74,10 +74,9 @@ MEDIA_CLASS_MAP = {
     "MusicAlbum": MediaClass.ALBUM,
     "MusicArtist": MediaClass.ARTIST,
     "Audio": MediaClass.MUSIC,
-    "Series": MediaClass.TV_SHOW,
+    "Series": MediaClass.DIRECTORY,
     "Movie": MediaClass.MOVIE,
     "CollectionFolder": MediaClass.DIRECTORY,
-    "AggregateFolder": MediaClass.DIRECTORY,
     "Folder": MediaClass.DIRECTORY,
     "BoxSet": MediaClass.DIRECTORY,
     "Episode": MediaClass.EPISODE,

homeassistant/components/jellyfin/icons.json

@@ -5,10 +5,5 @@
         "default": "mdi:television-play"
       }
     }
-  },
-  "services": {
-    "play_media_shuffle": {
-      "service": "mdi:shuffle-variant"
-    }
   }
 }

homeassistant/components/jellyfin/media_player.py

@@ -6,9 +6,7 @@ import logging
 from typing import Any
 
 from homeassistant.components.media_player import (
-    ATTR_MEDIA_ENQUEUE,
     BrowseMedia,
-    MediaPlayerEnqueue,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
     MediaPlayerState,
@@ -205,7 +203,6 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
                 | MediaPlayerEntityFeature.STOP
                 | MediaPlayerEntityFeature.SEEK
                 | MediaPlayerEntityFeature.SEARCH_MEDIA
-                | MediaPlayerEntityFeature.MEDIA_ENQUEUE
             )
 
             if "Mute" in commands and "Unmute" in commands:
@@ -248,20 +245,8 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         self, media_type: MediaType | str, media_id: str, **kwargs: Any
     ) -> None:
         """Play a piece of media."""
-        command = "PlayNow"
-        enqueue = kwargs.get(ATTR_MEDIA_ENQUEUE)
-        if enqueue == MediaPlayerEnqueue.NEXT:
-            command = "PlayNext"
-        elif enqueue == MediaPlayerEnqueue.ADD:
-            command = "PlayLast"
         self.coordinator.api_client.jellyfin.remote_play_media(
-            self.session_id, [media_id], command
-        )
-
-    def play_media_shuffle(self, media_content_id: str) -> None:
-        """Play a piece of media on shuffle."""
-        self.coordinator.api_client.jellyfin.remote_play_media(
-            self.session_id, [media_content_id], "PlayShuffle"
+            self.session_id, [media_id]
         )
 
     def set_volume_level(self, volume: float) -> None:

homeassistant/components/jellyfin/services.py

@@ -1,55 +0,0 @@
-"""Services for the Jellyfin integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.components.media_player import (
-    ATTR_MEDIA,
-    ATTR_MEDIA_CONTENT_ID,
-    DOMAIN as MP_DOMAIN,
-    MediaPlayerEntityFeature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, service
-
-from .const import DOMAIN
-
-JELLYFIN_PLAY_MEDIA_SHUFFLE_SCHEMA = {
-    vol.Required(ATTR_MEDIA_CONTENT_ID): cv.string,
-}
-
-
-def _promote_media_fields(data: dict[str, Any]) -> dict[str, Any]:
-    """If 'media' key exists, promote its fields to the top level."""
-    if ATTR_MEDIA in data and isinstance(data[ATTR_MEDIA], dict):
-        if ATTR_MEDIA_CONTENT_ID in data:
-            raise vol.Invalid(
-                f"Play media cannot contain both '{ATTR_MEDIA}' and '{ATTR_MEDIA_CONTENT_ID}'"
-            )
-        media_data = data[ATTR_MEDIA]
-
-        if ATTR_MEDIA_CONTENT_ID in media_data:
-            data[ATTR_MEDIA_CONTENT_ID] = media_data[ATTR_MEDIA_CONTENT_ID]
-
-        del data[ATTR_MEDIA]
-    return data
-
-
-async def async_setup_services(hass: HomeAssistant) -> None:
-    """Set up services for the Jellyfin component."""
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        "play_media_shuffle",
-        entity_domain=MP_DOMAIN,
-        schema=vol.All(
-            _promote_media_fields,
-            cv.make_entity_service_schema(JELLYFIN_PLAY_MEDIA_SHUFFLE_SCHEMA),
-        ),
-        func="play_media_shuffle",
-        required_features=MediaPlayerEntityFeature.PLAY_MEDIA,
-    )

homeassistant/components/jellyfin/services.yaml

@@ -1,11 +0,0 @@
-play_media_shuffle:
-  target:
-    entity:
-      integration: jellyfin
-      domain: media_player
-  fields:
-    media:
-      required: true
-      selector:
-        media:
-      example: '{"media_content_id": "a656b907eb3a73532e40e44b968d0225"}'

homeassistant/components/jellyfin/strings.json

@@ -42,17 +42,5 @@
         }
       }
     }
-  },
-  "services": {
-    "play_media_shuffle": {
-      "description": "Starts playing specified media shuffled. Overwrites current play queue.",
-      "fields": {
-        "media": {
-          "description": "The media selected to play.",
-          "name": "Media"
-        }
-      },
-      "name": "Play media shuffled"
-    }
   }
 }

homeassistant/components/jvc_projector/coordinator.py

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

homeassistant/components/jvc_projector/icons.json

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

homeassistant/components/jvc_projector/select.py

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

homeassistant/components/jvc_projector/sensor.py

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

homeassistant/components/jvc_projector/strings.json

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

homeassistant/components/jvc_projector/util.py

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

homeassistant/components/matter/light.py

@@ -47,14 +47,6 @@ COLOR_MODE_MAP = {
     clusters.ColorControl.Enums.ColorModeEnum.kColorTemperatureMireds: ColorMode.COLOR_TEMP,
 }
 
-# Maximum Mireds value per the Matter spec is 65279
-# Conversion between Kelvin and Mireds is 1,000,000 / Kelvin, so this corresponds to a minimum color temperature of ~15.3K
-# Which is shown in UI as 15 Kelvin due to rounding.
-# But converting 15 Kelvin back to Mireds gives 66666 which is above the maximum,
-# and causes Invoke error, so cap values over maximum when sending
-MATTER_MAX_MIREDS = 65279
-
-
 # there's a bug in (at least) Espressif's implementation of light transitions
 # on devices based on Matter 1.0. Mark potential devices with this issue.
 # https://github.com/home-assistant/core/issues/113775
@@ -160,7 +152,7 @@ class MatterLight(MatterEntity, LightEntity):
         )
         await self.send_device_command(
             clusters.ColorControl.Commands.MoveToColorTemperature(
-                colorTemperatureMireds=min(color_temp_mired, MATTER_MAX_MIREDS),
+                colorTemperatureMireds=color_temp_mired,
                 # transition in matter is measured in tenths of a second
                 transitionTime=int(transition * 10),
                 # allow setting the color while the light is off,

homeassistant/components/mold_indicator/sensor.py

@@ -203,80 +203,105 @@ class MoldIndicator(SensorEntity):
     def _async_setup_sensor(self) -> None:
         """Set up the sensor and start tracking state changes."""
 
-        self.async_on_remove(
+        @callback
+        def mold_indicator_sensors_state_listener(
+            event: Event[EventStateChangedData],
+        ) -> None:
+            """Handle for state changes for dependent sensors."""
+            new_state = event.data["new_state"]
+            old_state = event.data["old_state"]
+            entity = event.data["entity_id"]
+            _LOGGER.debug(
+                "Sensor state change for %s that had old state %s and new state %s",
+                entity,
+                old_state,
+                new_state,
+            )
+
+            if self._update_sensor(entity, old_state, new_state):
+                if self._preview_callback:
+                    calculated_state = self._async_calculate_state()
+                    self._preview_callback(
+                        calculated_state.state, calculated_state.attributes
+                    )
+                # only write state to the state machine if we are not in preview mode
+                else:
+                    self.async_schedule_update_ha_state(True)
+
+        @callback
+        def mold_indicator_startup() -> None:
+            """Add listeners and get 1st state."""
+            _LOGGER.debug("Startup for %s", self.entity_id)
+
             async_track_state_change_event(
                 self.hass,
-                self._entities.values(),
-                self._async_mold_indicator_sensor_state_listener,
-            )
-        )
-
-        # Replay current state of source entities
-        for entity_id in self._entities.values():
-            state = self.hass.states.get(entity_id)
-            state_event: Event[EventStateChangedData] = Event(
-                "", {"entity_id": entity_id, "new_state": state, "old_state": None}
-            )
-            self._async_mold_indicator_sensor_state_listener(
-                state_event, update_state=False
+                list(self._entities.values()),
+                mold_indicator_sensors_state_listener,
             )
 
-        self._recalculate()
+            # Read initial state
+            indoor_temp = self.hass.states.get(self._entities[CONF_INDOOR_TEMP])
+            outdoor_temp = self.hass.states.get(self._entities[CONF_OUTDOOR_TEMP])
+            indoor_hum = self.hass.states.get(self._entities[CONF_INDOOR_HUMIDITY])
 
-        if self._preview_callback:
-            calculated_state = self._async_calculate_state()
-            self._preview_callback(calculated_state.state, calculated_state.attributes)
+            schedule_update = self._update_sensor(
+                self._entities[CONF_INDOOR_TEMP], None, indoor_temp
+            )
 
-    @callback
-    def _async_mold_indicator_sensor_state_listener(
-        self, event: Event[EventStateChangedData], update_state: bool = True
-    ) -> None:
-        """Handle state changes for dependent sensors."""
-        entity_id = event.data["entity_id"]
-        new_state = event.data["new_state"]
+            schedule_update = (
+                False
+                if not self._update_sensor(
+                    self._entities[CONF_OUTDOOR_TEMP], None, outdoor_temp
+                )
+                else schedule_update
+            )
 
-        _LOGGER.debug(
-            "Sensor state change for %s that had old state %s and new state %s",
-            entity_id,
-            event.data["old_state"],
-            new_state,
-        )
+            schedule_update = (
+                False
+                if not self._update_sensor(
+                    self._entities[CONF_INDOOR_HUMIDITY], None, indoor_hum
+                )
+                else schedule_update
+            )
 
-        # update state depending on which sensor changed
-        if entity_id == self._entities[CONF_INDOOR_TEMP]:
+            if schedule_update and not self._preview_callback:
+                self.async_schedule_update_ha_state(True)
+            if self._preview_callback:
+                # re-calculate dewpoint and mold indicator
+                self._calc_dewpoint()
+                self._calc_moldindicator()
+                if self._attr_native_value is None:
+                    self._attr_available = False
+                else:
+                    self._attr_available = True
+                calculated_state = self._async_calculate_state()
+                self._preview_callback(
+                    calculated_state.state, calculated_state.attributes
+                )
+
+        mold_indicator_startup()
+
+    def _update_sensor(
+        self, entity: str, old_state: State | None, new_state: State | None
+    ) -> bool:
+        """Update information based on new sensor states."""
+        _LOGGER.debug("Sensor update for %s", entity)
+        if new_state is None:
+            return False
+
+        # If old_state is not set and new state is unknown then it means
+        # that the sensor just started up
+        if old_state is None and new_state.state == STATE_UNKNOWN:
+            return False
+
+        if entity == self._entities[CONF_INDOOR_TEMP]:
             self._indoor_temp = self._get_temperature_from_state(new_state)
-        elif entity_id == self._entities[CONF_OUTDOOR_TEMP]:
+        elif entity == self._entities[CONF_OUTDOOR_TEMP]:
             self._outdoor_temp = self._get_temperature_from_state(new_state)
-        elif entity_id == self._entities[CONF_INDOOR_HUMIDITY]:
+        elif entity == self._entities[CONF_INDOOR_HUMIDITY]:
             self._indoor_hum = self._get_humidity_from_state(new_state)
 
-        if not update_state:
-            return
-
-        self._recalculate()
-
-        if self._preview_callback:
-            calculated_state = self._async_calculate_state()
-            self._preview_callback(calculated_state.state, calculated_state.attributes)
-        # only write state to the state machine if we are not in preview mode
-        else:
-            self.async_write_ha_state()
-
-    @callback
-    def _recalculate(self) -> None:
-        """Recalculate mold indicator from cached sensor values."""
-        # Check if all sensors are available
-        if None in (self._indoor_temp, self._indoor_hum, self._outdoor_temp):
-            self._attr_available = False
-            self._attr_native_value = None
-            self._dewpoint = None
-            self._crit_temp = None
-            return
-
-        # Calculate dewpoint and mold indicator
-        self._calc_dewpoint()
-        self._calc_moldindicator()
-        self._attr_available = self._attr_native_value is not None
+        return True
 
     def _get_value_from_state(
         self,
@@ -351,6 +376,26 @@ class MoldIndicator(SensorEntity):
 
         return self._get_value_from_state(state, validate_humidity)
 
+    async def async_update(self) -> None:
+        """Calculate latest state."""
+        _LOGGER.debug("Update state for %s", self.entity_id)
+        # check all sensors
+        if None in (self._indoor_temp, self._indoor_hum, self._outdoor_temp):
+            self._attr_available = False
+            self._dewpoint = None
+            self._crit_temp = None
+            return
+
+        # re-calculate dewpoint and mold indicator
+        self._calc_dewpoint()
+        self._calc_moldindicator()
+        if self._attr_native_value is None:
+            self._attr_available = False
+            self._dewpoint = None
+            self._crit_temp = None
+        else:
+            self._attr_available = True
+
     def _calc_dewpoint(self) -> None:
         """Calculate the dewpoint for the indoor air."""
         # Use magnus approximation to calculate the dew point

homeassistant/components/motion/condition.py

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

homeassistant/components/motion/conditions.yaml

@@ -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: motion
-
-is_not_detected:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: binary_sensor
-        device_class: motion

homeassistant/components/motion/icons.json

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

homeassistant/components/motion/strings.json

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

homeassistant/components/mqtt/abbreviations.py

@@ -18,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",