Revert "Return target in trigger description command (#156766)"

This reverts commit 343ea1b82d.

.github/workflows/builder.yml

@@ -27,7 +27,7 @@ jobs:
       publish: ${{ steps.version.outputs.publish }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           fetch-depth: 0
 
@@ -94,7 +94,7 @@ jobs:
           - arch: i386
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
@@ -227,7 +227,7 @@ jobs:
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set build additional args
         run: |
@@ -265,7 +265,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -309,7 +309,7 @@ jobs:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Install Cosign
         uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
@@ -418,7 +418,7 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
@@ -463,7 +463,7 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Login to GitHub Container Registry
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0

.github/workflows/ci.yaml

@@ -99,7 +99,7 @@ jobs:
     steps:
       - &checkout
         name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |

.github/workflows/codeql.yml

@@ -21,7 +21,7 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3

.github/workflows/translations.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0

.github/workflows/wheels.yml

@@ -33,7 +33,7 @@ jobs:
     steps:
       - &checkout
         name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python

.pre-commit-config.yaml

@@ -87,7 +87,7 @@ repos:
         pass_filenames: false
         language: script
         types: [text]
-        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(quality_scale)\.yaml|homeassistant/brands/.*\.json|homeassistant/.+/services\.yaml|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
+        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(conditions|quality_scale|services|triggers)\.yaml|homeassistant/brands/.*\.json|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
       - id: hassfest-metadata
         name: hassfest-metadata
         entry: script/run-in-env.sh python3 -m script.hassfest -p metadata,docker

.strict-typing

@@ -579,6 +579,7 @@ homeassistant.components.wiz.*
 homeassistant.components.wled.*
 homeassistant.components.workday.*
 homeassistant.components.worldclock.*
+homeassistant.components.xbox.*
 homeassistant.components.xiaomi_ble.*
 homeassistant.components.yale_smart_alarm.*
 homeassistant.components.yalexs_ble.*

CODEOWNERS

@@ -1736,6 +1736,8 @@ build.json @home-assistant/supervisor
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /homeassistant/components/vicare/ @CFenner
 /tests/components/vicare/ @CFenner
+/homeassistant/components/victron_ble/ @rajlaud
+/tests/components/victron_ble/ @rajlaud
 /homeassistant/components/victron_remote_monitoring/ @AndyTempel
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW

homeassistant/brands/victron.json

@@ -0,0 +1,5 @@
+{
+  "domain": "victron",
+  "name": "Victron",
+  "integrations": ["victron_ble", "victron_remote_monitoring"]
+}

homeassistant/components/adguard/__init__.py

@@ -45,7 +45,7 @@ SERVICE_REFRESH_SCHEMA = vol.Schema(
     {vol.Optional(CONF_FORCE, default=False): cv.boolean}
 )
 
-PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
+PLATFORMS = [Platform.SENSOR, Platform.SWITCH, Platform.UPDATE]
 type AdGuardConfigEntry = ConfigEntry[AdGuardData]
 
 

homeassistant/components/adguard/update.py

@@ -0,0 +1,71 @@
+"""AdGuard Home Update platform."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from adguardhome import AdGuardHomeError
+
+from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AdGuardConfigEntry, AdGuardData
+from .const import DOMAIN
+from .entity import AdGuardHomeEntity
+
+SCAN_INTERVAL = timedelta(seconds=300)
+PARALLEL_UPDATES = 1
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AdGuardConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AdGuard Home update entity based on a config entry."""
+    data = entry.runtime_data
+
+    if (await data.client.update.update_available()).disabled:
+        return
+
+    async_add_entities([AdGuardHomeUpdate(data, entry)], True)
+
+
+class AdGuardHomeUpdate(AdGuardHomeEntity, UpdateEntity):
+    """Defines an AdGuard Home update."""
+
+    _attr_supported_features = UpdateEntityFeature.INSTALL
+    _attr_name = None
+
+    def __init__(
+        self,
+        data: AdGuardData,
+        entry: AdGuardConfigEntry,
+    ) -> None:
+        """Initialize AdGuard Home update."""
+        super().__init__(data, entry)
+
+        self._attr_unique_id = "_".join(
+            [DOMAIN, self.adguard.host, str(self.adguard.port), "update"]
+        )
+
+    async def _adguard_update(self) -> None:
+        """Update AdGuard Home entity."""
+        value = await self.adguard.update.update_available()
+        self._attr_installed_version = self.data.version
+        self._attr_latest_version = value.new_version
+        self._attr_release_summary = value.announcement
+        self._attr_release_url = value.announcement_url
+
+    async def async_install(
+        self, version: str | None, backup: bool, **kwargs: Any
+    ) -> None:
+        """Install latest update."""
+        try:
+            await self.adguard.update.begin_update()
+        except AdGuardHomeError as err:
+            raise HomeAssistantError(f"Failed to install update: {err}") from err
+        self.hass.config_entries.async_schedule_reload(self._entry.entry_id)

homeassistant/components/analytics/__init__.py

@@ -6,9 +6,8 @@ import voluptuous as vol
 
 from homeassistant.components import websocket_api
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
-from homeassistant.core import Event, HassJob, HomeAssistant, callback
+from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.event import async_call_later, async_track_time_interval
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
@@ -20,7 +19,7 @@ from .analytics import (
     EntityAnalyticsModifications,
     async_devices_payload,
 )
-from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, INTERVAL, PREFERENCE_SCHEMA
+from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, PREFERENCE_SCHEMA
 from .http import AnalyticsDevicesView
 
 __all__ = [
@@ -43,28 +42,9 @@ async def async_setup(hass: HomeAssistant, _: ConfigType) -> bool:
     # Load stored data
     await analytics.load()
 
-    @callback
-    def start_schedule(_event: Event) -> None:
+    async def start_schedule(_event: Event) -> None:
         """Start the send schedule after the started event."""
-        # Wait 15 min after started
-        async_call_later(
-            hass,
-            900,
-            HassJob(
-                analytics.send_analytics,
-                name="analytics schedule",
-                cancel_on_shutdown=True,
-            ),
-        )
-
-        # Send every day
-        async_track_time_interval(
-            hass,
-            analytics.send_analytics,
-            INTERVAL,
-            name="analytics daily",
-            cancel_on_shutdown=True,
-        )
+        await analytics.async_schedule()
 
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, start_schedule)
 
@@ -111,7 +91,7 @@ async def websocket_analytics_preferences(
     analytics = hass.data[DATA_COMPONENT]
 
     await analytics.save_preferences(preferences)
-    await analytics.send_analytics()
+    await analytics.async_schedule()
 
     connection.send_result(
         msg["id"],

homeassistant/components/analytics/analytics.py

@@ -7,6 +7,8 @@ from asyncio import timeout
 from collections.abc import Awaitable, Callable, Iterable, Mapping
 from dataclasses import asdict as dataclass_asdict, dataclass, field
 from datetime import datetime
+import random
+import time
 from typing import Any, Protocol
 import uuid
 
@@ -31,10 +33,18 @@ from homeassistant.const import (
     BASE_PLATFORMS,
     __version__ as HA_VERSION,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import (
+    CALLBACK_TYPE,
+    HassJob,
+    HomeAssistant,
+    ReleaseChannel,
+    callback,
+    get_release_channel,
+)
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.event import async_call_later, async_track_time_interval
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.singleton import singleton
 from homeassistant.helpers.storage import Store
@@ -51,6 +61,7 @@ from homeassistant.setup import async_get_loaded_integrations
 from .const import (
     ANALYTICS_ENDPOINT_URL,
     ANALYTICS_ENDPOINT_URL_DEV,
+    ANALYTICS_SNAPSHOT_ENDPOINT_URL,
     ATTR_ADDON_COUNT,
     ATTR_ADDONS,
     ATTR_ARCH,
@@ -71,6 +82,7 @@ from .const import (
     ATTR_PROTECTED,
     ATTR_RECORDER,
     ATTR_SLUG,
+    ATTR_SNAPSHOTS,
     ATTR_STATE_COUNT,
     ATTR_STATISTICS,
     ATTR_SUPERVISOR,
@@ -80,8 +92,10 @@ from .const import (
     ATTR_UUID,
     ATTR_VERSION,
     DOMAIN,
+    INTERVAL,
     LOGGER,
     PREFERENCE_SCHEMA,
+    SNAPSHOT_VERSION,
     STORAGE_KEY,
     STORAGE_VERSION,
 )
@@ -194,13 +208,18 @@ def gen_uuid() -> str:
     return uuid.uuid4().hex
 
 
+RELEASE_CHANNEL = get_release_channel()
+
+
 @dataclass
 class AnalyticsData:
     """Analytics data."""
 
     onboarded: bool
     preferences: dict[str, bool]
-    uuid: str | None
+    uuid: str | None = None
+    submission_identifier: str | None = None
+    snapshot_submission_time: float | None = None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> AnalyticsData:
@@ -209,6 +228,8 @@ class AnalyticsData:
             data["onboarded"],
             data["preferences"],
             data["uuid"],
+            data.get("submission_identifier"),
+            data.get("snapshot_submission_time"),
         )
 
 
@@ -219,8 +240,10 @@ class Analytics:
         """Initialize the Analytics class."""
         self.hass: HomeAssistant = hass
         self.session = async_get_clientsession(hass)
-        self._data = AnalyticsData(False, {}, None)
+        self._data = AnalyticsData(False, {})
         self._store = Store[dict[str, Any]](hass, STORAGE_VERSION, STORAGE_KEY)
+        self._basic_scheduled: CALLBACK_TYPE | None = None
+        self._snapshot_scheduled: CALLBACK_TYPE | None = None
 
     @property
     def preferences(self) -> dict:
@@ -228,6 +251,7 @@ class Analytics:
         preferences = self._data.preferences
         return {
             ATTR_BASE: preferences.get(ATTR_BASE, False),
+            ATTR_SNAPSHOTS: preferences.get(ATTR_SNAPSHOTS, False),
             ATTR_DIAGNOSTICS: preferences.get(ATTR_DIAGNOSTICS, False),
             ATTR_USAGE: preferences.get(ATTR_USAGE, False),
             ATTR_STATISTICS: preferences.get(ATTR_STATISTICS, False),
@@ -244,9 +268,9 @@ class Analytics:
         return self._data.uuid
 
     @property
-    def endpoint(self) -> str:
+    def endpoint_basic(self) -> str:
         """Return the endpoint that will receive the payload."""
-        if HA_VERSION.endswith("0.dev0"):
+        if RELEASE_CHANNEL is ReleaseChannel.DEV:
             # dev installations will contact the dev analytics environment
             return ANALYTICS_ENDPOINT_URL_DEV
         return ANALYTICS_ENDPOINT_URL
@@ -277,13 +301,17 @@ class Analytics:
                 ):
                     self._data.preferences[ATTR_DIAGNOSTICS] = False
 
+    async def _save(self) -> None:
+        """Save data."""
+        await self._store.async_save(dataclass_asdict(self._data))
+
     async def save_preferences(self, preferences: dict) -> None:
         """Save preferences."""
         preferences = PREFERENCE_SCHEMA(preferences)
         self._data.preferences.update(preferences)
         self._data.onboarded = True
 
-        await self._store.async_save(dataclass_asdict(self._data))
+        await self._save()
 
         if self.supervisor:
             await hassio.async_update_diagnostics(
@@ -292,17 +320,16 @@ class Analytics:
 
     async def send_analytics(self, _: datetime | None = None) -> None:
         """Send analytics."""
+        if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
+            return
+
         hass = self.hass
         supervisor_info = None
         operating_system_info: dict[str, Any] = {}
 
-        if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
-            LOGGER.debug("Nothing to submit")
-            return
-
         if self._data.uuid is None:
             self._data.uuid = gen_uuid()
-            await self._store.async_save(dataclass_asdict(self._data))
+            await self._save()
 
         if self.supervisor:
             supervisor_info = hassio.get_supervisor_info(hass)
@@ -436,7 +463,7 @@ class Analytics:
 
         try:
             async with timeout(30):
-                response = await self.session.post(self.endpoint, json=payload)
+                response = await self.session.post(self.endpoint_basic, json=payload)
                 if response.status == 200:
                     LOGGER.info(
                         (
@@ -449,7 +476,7 @@ class Analytics:
                     LOGGER.warning(
                         "Sending analytics failed with statuscode %s from %s",
                         response.status,
-                        self.endpoint,
+                        self.endpoint_basic,
                     )
         except TimeoutError:
             LOGGER.error("Timeout sending analytics to %s", ANALYTICS_ENDPOINT_URL)
@@ -489,6 +516,182 @@ class Analytics:
             if entry.source != SOURCE_IGNORE and entry.disabled_by is None
         )
 
+    async def send_snapshot(self, _: datetime | None = None) -> None:
+        """Send a snapshot."""
+        if not self.onboarded or not self.preferences.get(ATTR_SNAPSHOTS, False):
+            return
+
+        payload = await _async_snapshot_payload(self.hass)
+
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": f"home-assistant/{HA_VERSION}",
+        }
+        if self._data.submission_identifier is not None:
+            headers["X-Device-Database-Submission-Identifier"] = (
+                self._data.submission_identifier
+            )
+
+        try:
+            async with timeout(30):
+                response = await self.session.post(
+                    ANALYTICS_SNAPSHOT_ENDPOINT_URL, json=payload, headers=headers
+                )
+
+                if response.status == 200:  # OK
+                    response_data = await response.json()
+                    new_identifier = response_data.get("submission_identifier")
+
+                    if (
+                        new_identifier is not None
+                        and new_identifier != self._data.submission_identifier
+                    ):
+                        self._data.submission_identifier = new_identifier
+                        await self._save()
+
+                    LOGGER.info(
+                        "Submitted snapshot analytics to Home Assistant servers"
+                    )
+
+                elif response.status == 400:  # Bad Request
+                    response_data = await response.json()
+                    error_kind = response_data.get("kind", "unknown")
+                    error_message = response_data.get("message", "Unknown error")
+
+                    if error_kind == "invalid-submission-identifier":
+                        # Clear the invalid identifier and retry on next cycle
+                        LOGGER.warning(
+                            "Invalid submission identifier to %s, clearing: %s",
+                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                            error_message,
+                        )
+                        self._data.submission_identifier = None
+                        await self._save()
+                    else:
+                        LOGGER.warning(
+                            "Malformed snapshot analytics submission (%s) to %s: %s",
+                            error_kind,
+                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                            error_message,
+                        )
+
+                elif response.status == 503:  # Service Unavailable
+                    response_text = await response.text()
+                    LOGGER.warning(
+                        "Snapshot analytics service %s unavailable: %s",
+                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                        response_text,
+                    )
+
+                else:
+                    LOGGER.warning(
+                        "Unexpected status code %s when submitting snapshot analytics to %s",
+                        response.status,
+                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                    )
+
+        except TimeoutError:
+            LOGGER.error(
+                "Timeout sending snapshot analytics to %s",
+                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+            )
+        except aiohttp.ClientError as err:
+            LOGGER.error(
+                "Error sending snapshot analytics to %s: %r",
+                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                err,
+            )
+
+    async def async_schedule(self) -> None:
+        """Schedule analytics."""
+        if not self.onboarded:
+            LOGGER.debug("Analytics not scheduled")
+            if self._basic_scheduled is not None:
+                self._basic_scheduled()
+                self._basic_scheduled = None
+            if self._snapshot_scheduled:
+                self._snapshot_scheduled()
+                self._snapshot_scheduled = None
+            return
+
+        if not self.preferences.get(ATTR_BASE, False):
+            LOGGER.debug("Basic analytics not scheduled")
+            if self._basic_scheduled is not None:
+                self._basic_scheduled()
+                self._basic_scheduled = None
+        elif self._basic_scheduled is None:
+            # Wait 15 min after started for basic analytics
+            self._basic_scheduled = async_call_later(
+                self.hass,
+                900,
+                HassJob(
+                    self._async_schedule_basic,
+                    name="basic analytics schedule",
+                    cancel_on_shutdown=True,
+                ),
+            )
+
+        if not self.preferences.get(ATTR_SNAPSHOTS, False) or RELEASE_CHANNEL not in (
+            ReleaseChannel.DEV,
+            ReleaseChannel.NIGHTLY,
+        ):
+            LOGGER.debug("Snapshot analytics not scheduled")
+            if self._snapshot_scheduled:
+                self._snapshot_scheduled()
+                self._snapshot_scheduled = None
+        elif self._snapshot_scheduled is None:
+            snapshot_submission_time = self._data.snapshot_submission_time
+
+            if snapshot_submission_time is None:
+                # Randomize the submission time within the 24 hours
+                snapshot_submission_time = random.uniform(0, 86400)
+                self._data.snapshot_submission_time = snapshot_submission_time
+                await self._save()
+                LOGGER.debug(
+                    "Initialized snapshot submission time to %s",
+                    snapshot_submission_time,
+                )
+
+            # Calculate delay until next submission
+            current_time = time.time()
+            delay = (snapshot_submission_time - current_time) % 86400
+
+            self._snapshot_scheduled = async_call_later(
+                self.hass,
+                delay,
+                HassJob(
+                    self._async_schedule_snapshots,
+                    name="snapshot analytics schedule",
+                    cancel_on_shutdown=True,
+                ),
+            )
+
+    async def _async_schedule_basic(self, _: datetime | None = None) -> None:
+        """Schedule basic analytics."""
+        await self.send_analytics()
+
+        # Send basic analytics every day
+        self._basic_scheduled = async_track_time_interval(
+            self.hass,
+            self.send_analytics,
+            INTERVAL,
+            name="basic analytics daily",
+            cancel_on_shutdown=True,
+        )
+
+    async def _async_schedule_snapshots(self, _: datetime | None = None) -> None:
+        """Schedule snapshot analytics."""
+        await self.send_snapshot()
+
+        # Send snapshot analytics every day
+        self._snapshot_scheduled = async_track_time_interval(
+            self.hass,
+            self.send_snapshot,
+            INTERVAL,
+            name="snapshot analytics daily",
+            cancel_on_shutdown=True,
+        )
+
 
 def _domains_from_yaml_config(yaml_configuration: dict[str, Any]) -> set[str]:
     """Extract domains from the YAML configuration."""
@@ -505,8 +708,8 @@ DEFAULT_DEVICE_ANALYTICS_CONFIG = DeviceAnalyticsModifications()
 DEFAULT_ENTITY_ANALYTICS_CONFIG = EntityAnalyticsModifications()
 
 
-async def async_devices_payload(hass: HomeAssistant) -> dict:  # noqa: C901
-    """Return detailed information about entities and devices."""
+async def _async_snapshot_payload(hass: HomeAssistant) -> dict:  # noqa: C901
+    """Return detailed information about entities and devices for a snapshot."""
     dev_reg = dr.async_get(hass)
     ent_reg = er.async_get(hass)
 
@@ -711,8 +914,13 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:  # noqa: C901
 
             entities_info.append(entity_info)
 
+    return integrations_info
+
+
+async def async_devices_payload(hass: HomeAssistant) -> dict:
+    """Return detailed information about entities and devices for a direct download."""
     return {
-        "version": "home-assistant:1",
+        "version": f"home-assistant:{SNAPSHOT_VERSION}",
         "home_assistant": HA_VERSION,
-        "integrations": integrations_info,
+        "integrations": await _async_snapshot_payload(hass),
     }

homeassistant/components/analytics/const.py

@@ -7,6 +7,8 @@ import voluptuous as vol
 
 ANALYTICS_ENDPOINT_URL = "https://analytics-api.home-assistant.io/v1"
 ANALYTICS_ENDPOINT_URL_DEV = "https://analytics-api-dev.home-assistant.io/v1"
+SNAPSHOT_VERSION = "1"
+ANALYTICS_SNAPSHOT_ENDPOINT_URL = f"https://device-database.eco-dev-aws.openhomefoundation.com/api/v1/snapshot/{SNAPSHOT_VERSION}"
 DOMAIN = "analytics"
 INTERVAL = timedelta(days=1)
 STORAGE_KEY = "core.analytics"
@@ -38,6 +40,7 @@ ATTR_PREFERENCES = "preferences"
 ATTR_PROTECTED = "protected"
 ATTR_RECORDER = "recorder"
 ATTR_SLUG = "slug"
+ATTR_SNAPSHOTS = "snapshots"
 ATTR_STATE_COUNT = "state_count"
 ATTR_STATISTICS = "statistics"
 ATTR_SUPERVISOR = "supervisor"
@@ -51,6 +54,7 @@ ATTR_VERSION = "version"
 PREFERENCE_SCHEMA = vol.Schema(
     {
         vol.Optional(ATTR_BASE): bool,
+        vol.Optional(ATTR_SNAPSHOTS): bool,
         vol.Optional(ATTR_DIAGNOSTICS): bool,
         vol.Optional(ATTR_STATISTICS): bool,
         vol.Optional(ATTR_USAGE): bool,

homeassistant/components/anthropic/entity.py

@@ -392,7 +392,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     type="tool_use",
                     id=response.content_block.id,
                     name=response.content_block.name,
-                    input="",
+                    input={},
                 )
                 current_tool_args = ""
                 if response.content_block.name == output_tool:
@@ -459,7 +459,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     type="server_tool_use",
                     id=response.content_block.id,
                     name=response.content_block.name,
-                    input="",
+                    input={},
                 )
                 current_tool_args = ""
             elif isinstance(response.content_block, WebSearchToolResultBlock):

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.69.0"]
+  "requirements": ["anthropic==0.73.0"]
 }

homeassistant/components/apcupsd/const.py

@@ -7,3 +7,26 @@ CONNECTION_TIMEOUT: int = 10
 
 # Field name of last self test retrieved from apcupsd.
 LAST_S_TEST: Final = "laststest"
+
+# Mapping of deprecated sensor keys (as reported by apcupsd, lower-cased) to their deprecation
+# repair issue translation keys.
+DEPRECATED_SENSORS: Final = {
+    "apc": "apc_deprecated",
+    "end apc": "date_deprecated",
+    "date": "date_deprecated",
+    "apcmodel": "available_via_device_info",
+    "model": "available_via_device_info",
+    "firmware": "available_via_device_info",
+    "version": "available_via_device_info",
+    "upsname": "available_via_device_info",
+    "serialno": "available_via_device_info",
+}
+
+AVAILABLE_VIA_DEVICE_ATTR: Final = {
+    "apcmodel": "model",
+    "model": "model",
+    "firmware": "hw_version",
+    "version": "sw_version",
+    "upsname": "name",
+    "serialno": "serial_number",
+}

homeassistant/components/apcupsd/sensor.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import logging
 
+from homeassistant.components.automation import automations_with_entity
+from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -22,9 +24,11 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+import homeassistant.helpers.issue_registry as ir
 
-from .const import LAST_S_TEST
+from .const import AVAILABLE_VIA_DEVICE_ATTR, DEPRECATED_SENSORS, DOMAIN, LAST_S_TEST
 from .coordinator import APCUPSdConfigEntry, APCUPSdCoordinator
 from .entity import APCUPSdEntity
 
@@ -528,3 +532,62 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
         self._attr_native_value, inferred_unit = infer_unit(self.coordinator.data[key])
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
+
+    async def async_added_to_hass(self) -> None:
+        """Handle when entity is added to Home Assistant.
+
+        If this is a deprecated sensor entity, create a repair issue to guide
+        the user to disable it.
+        """
+        await super().async_added_to_hass()
+
+        if not self.enabled:
+            return
+
+        reason = DEPRECATED_SENSORS.get(self.entity_description.key)
+        if not reason:
+            return
+
+        automations = automations_with_entity(self.hass, self.entity_id)
+        scripts = scripts_with_entity(self.hass, self.entity_id)
+        if not automations and not scripts:
+            return
+
+        entity_registry = er.async_get(self.hass)
+        items = [
+            f"- [{entry.name or entry.original_name or entity_id}]"
+            f"(/config/{integration}/edit/{entry.unique_id or entity_id.split('.', 1)[-1]})"
+            for integration, entities in (
+                ("automation", automations),
+                ("script", scripts),
+            )
+            for entity_id in entities
+            if (entry := entity_registry.async_get(entity_id))
+        ]
+        placeholders = {
+            "entity_name": str(self.name or self.entity_id),
+            "entity_id": self.entity_id,
+            "items": "\n".join(items),
+        }
+        if via_attr := AVAILABLE_VIA_DEVICE_ATTR.get(self.entity_description.key):
+            placeholders["available_via_device_attr"] = via_attr
+        if device_entry := self.device_entry:
+            placeholders["device_id"] = device_entry.id
+
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"{reason}_{self.entity_id}",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key=reason,
+            translation_placeholders=placeholders,
+        )
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle when entity will be removed from Home Assistant."""
+        await super().async_will_remove_from_hass()
+
+        if issue_key := DEPRECATED_SENSORS.get(self.entity_description.key):
+            ir.async_delete_issue(self.hass, DOMAIN, f"{issue_key}_{self.entity_id}")

homeassistant/components/apcupsd/strings.json

@@ -241,5 +241,19 @@
     "cannot_connect": {
       "message": "Cannot connect to APC UPS Daemon."
     }
+  },
+  "issues": {
+    "apc_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because it exposes internal details of the APC UPS Daemon response.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use supported APC UPS entities instead. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "available_via_device_info": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the same value is available from the device registry via `device_attr(\"{device_id}\", \"{available_via_device_attr}\")`.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use the `device_attr` helper instead of this sensor. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "date_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the timestamp is already available from other APC UPS sensors via their last updated time.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to reference any entity's `last_updated` attribute instead (for example, `states.binary_sensor.apcups_online_status.last_updated`). Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    }
   }
 }

homeassistant/components/bluetooth/manifest.json

@@ -20,7 +20,7 @@
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.28.4",
-    "dbus-fast==2.45.0",
+    "dbus-fast==3.0.0",
     "habluetooth==5.7.0"
   ]
 }

homeassistant/components/cosori/__init__.py

@@ -0,0 +1 @@
+"""Virtual integration: Cosori."""

homeassistant/components/cosori/manifest.json

@@ -0,0 +1,6 @@
+{
+  "domain": "cosori",
+  "name": "Cosori",
+  "integration_type": "virtual",
+  "supported_by": "vesync"
+}

homeassistant/components/cync/__init__.py

@@ -9,6 +9,7 @@ from homeassistant.const import CONF_ACCESS_TOKEN, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.util.ssl import get_default_context
 
 from .const import (
     CONF_AUTHORIZE_STRING,
@@ -31,9 +32,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: CyncConfigEntry) -> bool
         expires_at=entry.data[CONF_EXPIRES_AT],
     )
     cync_auth = Auth(async_get_clientsession(hass), user=user_info)
+    ssl_context = get_default_context()
 
     try:
-        cync = await Cync.create(cync_auth)
+        cync = await Cync.create(
+            auth=cync_auth,
+            ssl_context=ssl_context,
+        )
     except AuthFailedError as ex:
         raise ConfigEntryAuthFailed("User token invalid") from ex
     except CyncError as ex:

homeassistant/components/google_assistant_sdk/manifest.json

@@ -7,6 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/google_assistant_sdk",
   "integration_type": "service",
   "iot_class": "cloud_polling",
+  "quality_scale": "gold",
   "requirements": ["gassist-text==0.0.14"],
   "single_config_entry": true
 }

homeassistant/components/google_assistant_sdk/quality_scale.yaml

@@ -0,0 +1,98 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling:
+    status: exempt
+    comment: No polling.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions: done
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: No entities.
+  entity-unique-id:
+    status: exempt
+    comment: No entities.
+  has-entity-name:
+    status: exempt
+    comment: No entities.
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable:
+    status: exempt
+    comment: No entities.
+  integration-owner: done
+  log-when-unavailable:
+    status: exempt
+    comment: No entities.
+  parallel-updates:
+    status: exempt
+    comment: No entities to update.
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices:
+    status: exempt
+    comment: This integration acts as a service and does not represent physical devices.
+  diagnostics: done
+  discovery-update-info:
+    status: exempt
+    comment: No discovery.
+  discovery:
+    status: exempt
+    comment: This is a cloud service integration that cannot be discovered locally.
+  docs-data-update:
+    status: exempt
+    comment: No entities to update.
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: No devices.
+  entity-category:
+    status: exempt
+    comment: No entities.
+  entity-device-class:
+    status: exempt
+    comment: No entities.
+  entity-disabled-by-default:
+    status: exempt
+    comment: No entities.
+  entity-translations:
+    status: exempt
+    comment: No entities.
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: done
+  repair-issues:
+    status: exempt
+    comment: No repairs.
+  stale-devices:
+    status: exempt
+    comment: No devices.
+
+  # Platinum
+  async-dependency: todo
+  inject-websession:
+    status: exempt
+    comment: The underlying library uses gRPC, not aiohttp/httpx, for communication.
+  strict-typing: done

homeassistant/components/google_assistant_sdk/strings.json

@@ -56,6 +56,9 @@
       "init": {
         "data": {
           "language_code": "Language code"
+        },
+        "data_description": {
+          "language_code": "Language for the Google Assistant SDK requests and responses."
         }
       }
     }

homeassistant/components/google_sheets/services.py

@@ -31,6 +31,7 @@ from .const import DOMAIN
 if TYPE_CHECKING:
     from . import GoogleSheetsConfigEntry
 
+ADD_CREATED_COLUMN = "add_created_column"
 DATA = "data"
 DATA_CONFIG_ENTRY = "config_entry"
 ROWS = "rows"
@@ -43,6 +44,7 @@ SHEET_SERVICE_SCHEMA = vol.All(
     {
         vol.Required(DATA_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
         vol.Optional(WORKSHEET): cv.string,
+        vol.Optional(ADD_CREATED_COLUMN, default=True): cv.boolean,
         vol.Required(DATA): vol.Any(cv.ensure_list, [dict]),
     },
 )
@@ -69,10 +71,11 @@ def _append_to_sheet(call: ServiceCall, entry: GoogleSheetsConfigEntry) -> None:
 
     worksheet = sheet.worksheet(call.data.get(WORKSHEET, sheet.sheet1.title))
     columns: list[str] = next(iter(worksheet.get_values("A1:ZZ1")), [])
+    add_created_column = call.data[ADD_CREATED_COLUMN]
     now = str(datetime.now())
     rows = []
     for d in call.data[DATA]:
-        row_data = {"created": now} | d
+        row_data = ({"created": now} | d) if add_created_column else d
         row = [row_data.get(column, "") for column in columns]
         for key, value in row_data.items():
             if key not in columns:

homeassistant/components/google_sheets/services.yaml

@@ -9,6 +9,11 @@ append_sheet:
       example: "Sheet1"
       selector:
         text:
+    add_created_column:
+      required: false
+      default: true
+      selector:
+        boolean:
     data:
       required: true
       example: '{"hello": world, "cool": True, "count": 5}'

homeassistant/components/google_sheets/strings.json

@@ -45,6 +45,10 @@
     "append_sheet": {
       "description": "Appends data to a worksheet in Google Sheets.",
       "fields": {
+        "add_created_column": {
+          "description": "Add a \"created\" column with the current date-time to the appended data.",
+          "name": "Add created column"
+        },
         "config_entry": {
           "description": "The sheet to add data to.",
           "name": "Sheet"

homeassistant/components/husqvarna_automower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aioautomower"],
   "quality_scale": "silver",
-  "requirements": ["aioautomower==2.7.0"]
+  "requirements": ["aioautomower==2.7.1"]
 }

homeassistant/components/hvv_departures/binary_sensor.py

@@ -112,6 +112,7 @@ async def async_setup_entry(
         update_method=async_update_data,
         # Polling interval. Will only be polled if there are subscribers.
         update_interval=timedelta(hours=1),
+        config_entry=entry,
     )
 
     # Fetch initial data so we have data when entities subscribe

homeassistant/components/icloud/account.py

@@ -12,6 +12,7 @@ from pyicloud.exceptions import (
     PyiCloudFailedLoginException,
     PyiCloudNoDevicesException,
     PyiCloudServiceNotActivatedException,
+    PyiCloudServiceUnavailable,
 )
 from pyicloud.services.findmyiphone import AppleDevice
 
@@ -130,15 +131,21 @@ class IcloudAccount:
         except (
             PyiCloudServiceNotActivatedException,
             PyiCloudNoDevicesException,
+            PyiCloudServiceUnavailable,
         ) as err:
             _LOGGER.error("No iCloud device found")
             raise ConfigEntryNotReady from err
 
-        self._owner_fullname = f"{user_info['firstName']} {user_info['lastName']}"
+        if user_info is None:
+            raise ConfigEntryNotReady("No user info found in iCloud devices response")
+
+        self._owner_fullname = (
+            f"{user_info.get('firstName')} {user_info.get('lastName')}"
+        )
 
         self._family_members_fullname = {}
         if user_info.get("membersInfo") is not None:
-            for prs_id, member in user_info["membersInfo"].items():
+            for prs_id, member in user_info.get("membersInfo").items():
                 self._family_members_fullname[prs_id] = (
                     f"{member['firstName']} {member['lastName']}"
                 )

homeassistant/components/icloud/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/icloud",
   "iot_class": "cloud_polling",
   "loggers": ["keyrings.alt", "pyicloud"],
-  "requirements": ["pyicloud==2.1.0"]
+  "requirements": ["pyicloud==2.2.0"]
 }

homeassistant/components/kostal_plenticore/coordinator.py

@@ -237,14 +237,23 @@ class SettingDataUpdateCoordinator(
     """Implementation of PlenticoreUpdateCoordinator for settings data."""
 
     async def _async_update_data(self) -> Mapping[str, Mapping[str, str]]:
-        client = self._plenticore.client
-
-        if not self._fetch or client is None:
+        if (client := self._plenticore.client) is None:
             return {}
 
-        _LOGGER.debug("Fetching %s for %s", self.name, self._fetch)
+        fetch = defaultdict(set)
 
-        return await client.get_setting_values(self._fetch)
+        for module_id, data_ids in self._fetch.items():
+            fetch[module_id].update(data_ids)
+
+        for module_id, data_id in self.async_contexts():
+            fetch[module_id].add(data_id)
+
+        if not fetch:
+            return {}
+
+        _LOGGER.debug("Fetching %s for %s", self.name, fetch)
+
+        return await client.get_setting_values(fetch)
 
 
 class PlenticoreSelectUpdateCoordinator[_DataT](DataUpdateCoordinator[_DataT]):

homeassistant/components/kostal_plenticore/diagnostics.py

@@ -34,6 +34,29 @@ async def async_get_config_entry_diagnostics(
         },
     }
 
+    # Add important information how the inverter is configured
+    string_count_setting = await plenticore.client.get_setting_values(
+        "devices:local", "Properties:StringCnt"
+    )
+    try:
+        string_count = int(
+            string_count_setting["devices:local"]["Properties:StringCnt"]
+        )
+    except ValueError:
+        string_count = 0
+
+    configuration_settings = await plenticore.client.get_setting_values(
+        "devices:local",
+        (
+            "Properties:StringCnt",
+            *(f"Properties:String{idx}Features" for idx in range(string_count)),
+        ),
+    )
+
+    data["configuration"] = {
+        **configuration_settings,
+    }
+
     device_info = {**plenticore.device_info}
     device_info[ATTR_IDENTIFIERS] = REDACTED  # contains serial number
     data["device"] = device_info

homeassistant/components/kostal_plenticore/switch.py

@@ -5,12 +5,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
-from typing import Any
+from typing import Any, Final
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -66,7 +67,7 @@ async def async_setup_entry(
     """Add kostal plenticore Switch."""
     plenticore = entry.runtime_data
 
-    entities = []
+    entities: list[Entity] = []
 
     available_settings_data = await plenticore.client.get_settings()
     settings_data_update_coordinator = SettingDataUpdateCoordinator(
@@ -103,6 +104,57 @@ async def async_setup_entry(
             )
         )
 
+    # add shadow management switches for strings which support it
+    string_count_setting = await plenticore.client.get_setting_values(
+        "devices:local", "Properties:StringCnt"
+    )
+    try:
+        string_count = int(
+            string_count_setting["devices:local"]["Properties:StringCnt"]
+        )
+    except ValueError:
+        string_count = 0
+
+    dc_strings = tuple(range(string_count))
+    dc_string_feature_ids = tuple(
+        PlenticoreShadowMgmtSwitch.DC_STRING_FEATURE_DATA_ID % dc_string
+        for dc_string in dc_strings
+    )
+
+    dc_string_features = await plenticore.client.get_setting_values(
+        PlenticoreShadowMgmtSwitch.MODULE_ID,
+        dc_string_feature_ids,
+    )
+
+    for dc_string, dc_string_feature_id in zip(
+        dc_strings, dc_string_feature_ids, strict=True
+    ):
+        try:
+            dc_string_feature = int(
+                dc_string_features[PlenticoreShadowMgmtSwitch.MODULE_ID][
+                    dc_string_feature_id
+                ]
+            )
+        except ValueError:
+            dc_string_feature = 0
+
+        if dc_string_feature == PlenticoreShadowMgmtSwitch.SHADOW_MANAGEMENT_SUPPORT:
+            entities.append(
+                PlenticoreShadowMgmtSwitch(
+                    settings_data_update_coordinator,
+                    dc_string,
+                    entry.entry_id,
+                    entry.title,
+                    plenticore.device_info,
+                )
+            )
+        else:
+            _LOGGER.debug(
+                "Skipping shadow management for DC string %d, not supported (Feature: %d)",
+                dc_string + 1,
+                dc_string_feature,
+            )
+
     async_add_entities(entities)
 
 
@@ -136,7 +188,6 @@ class PlenticoreDataSwitch(
         self.off_value = description.off_value
         self.off_label = description.off_label
         self._attr_unique_id = f"{entry_id}_{description.module_id}_{description.key}"
-
         self._attr_device_info = device_info
 
     @property
@@ -189,3 +240,98 @@ class PlenticoreDataSwitch(
                 f"{self.platform_name} {self._name} {self.off_label}"
             )
         return bool(self.coordinator.data[self.module_id][self.data_id] == self._is_on)
+
+
+class PlenticoreShadowMgmtSwitch(
+    CoordinatorEntity[SettingDataUpdateCoordinator], SwitchEntity
+):
+    """Representation of a Plenticore Switch for shadow management.
+
+    The shadow management switch can be controlled for each DC string separately. The DC string is
+    coded as bit in a single settings value, bit 0 for DC string 1, bit 1 for DC string 2, etc.
+
+    Not all DC strings are available for shadown management, for example if one of them is used
+    for a battery.
+    """
+
+    _attr_entity_category = EntityCategory.CONFIG
+    entity_description: SwitchEntityDescription
+
+    MODULE_ID: Final = "devices:local"
+
+    SHADOW_DATA_ID: Final = "Generator:ShadowMgmt:Enable"
+    """Settings id for the bit coded shadow management."""
+
+    DC_STRING_FEATURE_DATA_ID: Final = "Properties:String%dFeatures"
+    """Settings id pattern for the DC string features."""
+
+    SHADOW_MANAGEMENT_SUPPORT: Final = 1
+    """Feature value for shadow management support in the DC string features."""
+
+    def __init__(
+        self,
+        coordinator: SettingDataUpdateCoordinator,
+        dc_string: int,
+        entry_id: str,
+        platform_name: str,
+        device_info: DeviceInfo,
+    ) -> None:
+        """Create a new Switch Entity for Plenticore shadow management."""
+        super().__init__(coordinator, context=(self.MODULE_ID, self.SHADOW_DATA_ID))
+
+        self._mask: Final = 1 << dc_string
+
+        self.entity_description = SwitchEntityDescription(
+            key=f"ShadowMgmt{dc_string}",
+            name=f"Shadow Management DC string {dc_string + 1}",
+            entity_registry_enabled_default=False,
+        )
+
+        self.platform_name = platform_name
+        self._attr_name = f"{platform_name} {self.entity_description.name}"
+        self._attr_unique_id = (
+            f"{entry_id}_{self.MODULE_ID}_{self.SHADOW_DATA_ID}_{dc_string}"
+        )
+        self._attr_device_info = device_info
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return (
+            super().available
+            and self.coordinator.data is not None
+            and self.MODULE_ID in self.coordinator.data
+            and self.SHADOW_DATA_ID in self.coordinator.data[self.MODULE_ID]
+        )
+
+    def _get_shadow_mgmt_value(self) -> int:
+        """Return the current shadow management value for all strings as integer."""
+        try:
+            return int(self.coordinator.data[self.MODULE_ID][self.SHADOW_DATA_ID])
+        except ValueError:
+            return 0
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn shadow management on."""
+        shadow_mgmt_value = self._get_shadow_mgmt_value()
+        shadow_mgmt_value |= self._mask
+
+        if await self.coordinator.async_write_data(
+            self.MODULE_ID, {self.SHADOW_DATA_ID: str(shadow_mgmt_value)}
+        ):
+            await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn shadow management off."""
+        shadow_mgmt_value = self._get_shadow_mgmt_value()
+        shadow_mgmt_value &= ~self._mask
+
+        if await self.coordinator.async_write_data(
+            self.MODULE_ID, {self.SHADOW_DATA_ID: str(shadow_mgmt_value)}
+        ):
+            await self.coordinator.async_request_refresh()
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if shadow management is on."""
+        return (self._get_shadow_mgmt_value() & self._mask) != 0

homeassistant/components/lcn/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from functools import partial
 import logging
+from typing import cast
 
 import pypck
 from pypck.connection import (
@@ -48,7 +49,6 @@ from .const import (
 )
 from .helpers import (
     AddressType,
-    InputType,
     LcnConfigEntry,
     LcnRuntimeData,
     async_update_config_entry,
@@ -285,7 +285,7 @@ def _async_fire_access_control_event(
     hass: HomeAssistant,
     device: dr.DeviceEntry | None,
     address: AddressType,
-    inp: InputType,
+    inp: pypck.inputs.ModStatusAccessControl,
 ) -> None:
     """Fire access control event (transponder, transmitter, fingerprint, codelock)."""
     event_data = {
@@ -299,7 +299,11 @@ def _async_fire_access_control_event(
 
     if inp.periphery == pypck.lcn_defs.AccessControlPeriphery.TRANSMITTER:
         event_data.update(
-            {"level": inp.level, "key": inp.key, "action": inp.action.value}
+            {
+                "level": inp.level,
+                "key": inp.key,
+                "action": cast(pypck.lcn_defs.KeyAction, inp.action).value,
+            }
         )
 
     event_name = f"lcn_{inp.periphery.value.lower()}"
@@ -310,7 +314,7 @@ def _async_fire_send_keys_event(
     hass: HomeAssistant,
     device: dr.DeviceEntry | None,
     address: AddressType,
-    inp: InputType,
+    inp: pypck.inputs.ModSendKeysHost,
 ) -> None:
     """Fire send_keys event."""
     for table, action in enumerate(inp.actions):

homeassistant/components/lcn/binary_sensor.py

@@ -1,6 +1,7 @@
 """Support for LCN binary sensors."""
 
 from collections.abc import Iterable
+from datetime import timedelta
 from functools import partial
 
 import pypck
@@ -19,6 +20,7 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -69,21 +71,11 @@ class LcnBinarySensor(LcnEntity, BinarySensorEntity):
             config[CONF_DOMAIN_DATA][CONF_SOURCE]
         ]
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(
-                self.bin_sensor_port
-            )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(
-                self.bin_sensor_port
-            )
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_binary_sensors(
+            SCAN_INTERVAL.seconds
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""

homeassistant/components/lcn/climate.py

@@ -1,6 +1,8 @@
 """Support for LCN climate control."""
 
+import asyncio
 from collections.abc import Iterable
+from datetime import timedelta
 from functools import partial
 from typing import Any, cast
 
@@ -36,6 +38,7 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -97,8 +100,6 @@ class LcnClimate(LcnEntity, ClimateEntity):
         self._max_temp = config[CONF_DOMAIN_DATA][CONF_MAX_TEMP]
         self._min_temp = config[CONF_DOMAIN_DATA][CONF_MIN_TEMP]
 
-        self._current_temperature = None
-        self._target_temperature = None
         self._is_on = True
 
         self._attr_hvac_modes = [HVACMode.HEAT]
@@ -110,20 +111,6 @@ class LcnClimate(LcnEntity, ClimateEntity):
                 ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
             )
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.variable)
-            await self.device_connection.activate_status_request_handler(self.setpoint)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.variable)
-            await self.device_connection.cancel_status_request_handler(self.setpoint)
-
     @property
     def temperature_unit(self) -> str:
         """Return the unit of measurement."""
@@ -132,16 +119,6 @@ class LcnClimate(LcnEntity, ClimateEntity):
             return UnitOfTemperature.FAHRENHEIT
         return UnitOfTemperature.CELSIUS
 
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._current_temperature
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the temperature we try to reach."""
-        return self._target_temperature
-
     @property
     def hvac_mode(self) -> HVACMode:
         """Return hvac operation ie. heat, cool mode.
@@ -177,7 +154,7 @@ class LcnClimate(LcnEntity, ClimateEntity):
             ):
                 return
             self._is_on = False
-            self._target_temperature = None
+            self._attr_target_temperature = None
             self.async_write_ha_state()
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
@@ -189,19 +166,34 @@ class LcnClimate(LcnEntity, ClimateEntity):
             self.setpoint, temperature, self.unit
         ):
             return
-        self._target_temperature = temperature
+        self._attr_target_temperature = temperature
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await asyncio.gather(
+            self.device_connection.request_status_variable(
+                self.variable, SCAN_INTERVAL.seconds
+            ),
+            self.device_connection.request_status_variable(
+                self.setpoint, SCAN_INTERVAL.seconds
+            ),
+        )
+
     def input_received(self, input_obj: InputType) -> None:
         """Set temperature value when LCN input object is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusVar):
             return
 
         if input_obj.get_var() == self.variable:
-            self._current_temperature = input_obj.get_value().to_var_unit(self.unit)
+            self._attr_current_temperature = float(
+                input_obj.get_value().to_var_unit(self.unit)
+            )
         elif input_obj.get_var() == self.setpoint:
             self._is_on = not input_obj.get_value().is_locked_regulator()
             if self._is_on:
-                self._target_temperature = input_obj.get_value().to_var_unit(self.unit)
+                self._attr_target_temperature = float(
+                    input_obj.get_value().to_var_unit(self.unit)
+                )
 
         self.async_write_ha_state()

homeassistant/components/lcn/config_flow.py

@@ -120,7 +120,7 @@ class LcnFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
                 errors={CONF_BASE: error},
             )
 
-        data: dict = {
+        data: dict[str, Any] = {
             **user_input,
             CONF_DEVICES: [],
             CONF_ENTITIES: [],

homeassistant/components/lcn/cover.py

@@ -1,6 +1,8 @@
 """Support for LCN covers."""
 
-from collections.abc import Iterable
+import asyncio
+from collections.abc import Coroutine, Iterable
+from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -27,6 +29,7 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -73,11 +76,13 @@ async def async_setup_entry(
 class LcnOutputsCover(LcnEntity, CoverEntity):
     """Representation of a LCN cover connected to output ports."""
 
-    _attr_is_closed = False
+    _attr_is_closed = True
     _attr_is_closing = False
     _attr_is_opening = False
     _attr_assumed_state = True
 
+    reverse_time: pypck.lcn_defs.MotorReverseTime | None
+
     def __init__(self, config: ConfigType, config_entry: LcnConfigEntry) -> None:
         """Initialize the LCN cover."""
         super().__init__(config, config_entry)
@@ -93,28 +98,6 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
         else:
             self.reverse_time = None
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(
-                pypck.lcn_defs.OutputPort["OUTPUTUP"]
-            )
-            await self.device_connection.activate_status_request_handler(
-                pypck.lcn_defs.OutputPort["OUTPUTDOWN"]
-            )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(
-                pypck.lcn_defs.OutputPort["OUTPUTUP"]
-            )
-            await self.device_connection.cancel_status_request_handler(
-                pypck.lcn_defs.OutputPort["OUTPUTDOWN"]
-            )
-
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
         state = pypck.lcn_defs.MotorStateModifier.DOWN
@@ -147,6 +130,18 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
         self._attr_is_opening = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        if not self.device_connection.is_group:
+            await asyncio.gather(
+                self.device_connection.request_status_output(
+                    pypck.lcn_defs.OutputPort["OUTPUTUP"], SCAN_INTERVAL.seconds
+                ),
+                self.device_connection.request_status_output(
+                    pypck.lcn_defs.OutputPort["OUTPUTDOWN"], SCAN_INTERVAL.seconds
+                ),
+            )
+
     def input_received(self, input_obj: InputType) -> None:
         """Set cover states when LCN input object (command) is received."""
         if (
@@ -175,7 +170,7 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
 class LcnRelayCover(LcnEntity, CoverEntity):
     """Representation of a LCN cover connected to relays."""
 
-    _attr_is_closed = False
+    _attr_is_closed = True
     _attr_is_closing = False
     _attr_is_opening = False
     _attr_assumed_state = True
@@ -206,20 +201,6 @@ class LcnRelayCover(LcnEntity, CoverEntity):
         self._is_closing = False
         self._is_opening = False
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(
-                self.motor, self.positioning_mode
-            )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.motor)
-
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
         if not await self.device_connection.control_motor_relays(
@@ -274,6 +255,25 @@ class LcnRelayCover(LcnEntity, CoverEntity):
 
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        coros: list[
+            Coroutine[
+                Any,
+                Any,
+                pypck.inputs.ModStatusRelays
+                | pypck.inputs.ModStatusMotorPositionBS4
+                | None,
+            ]
+        ] = [self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)]
+        if self.positioning_mode == pypck.lcn_defs.MotorPositioningMode.BS4:
+            coros.append(
+                self.device_connection.request_status_motor_position(
+                    self.motor, self.positioning_mode, SCAN_INTERVAL.seconds
+                )
+            )
+        await asyncio.gather(*coros)
+
     def input_received(self, input_obj: InputType) -> None:
         """Set cover states when LCN input object (command) is received."""
         if isinstance(input_obj, pypck.inputs.ModStatusRelays):
@@ -293,7 +293,7 @@ class LcnRelayCover(LcnEntity, CoverEntity):
             )
             and input_obj.motor == self.motor.value
         ):
-            self._attr_current_cover_position = input_obj.position
+            self._attr_current_cover_position = int(input_obj.position)
             if self._attr_current_cover_position in [0, 100]:
                 self._attr_is_opening = False
                 self._attr_is_closing = False

homeassistant/components/lcn/entity.py

@@ -2,6 +2,8 @@
 
 from collections.abc import Callable
 
+from pypck.device import DeviceConnection
+
 from homeassistant.const import CONF_ADDRESS, CONF_DOMAIN, CONF_NAME
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
@@ -10,7 +12,6 @@ from homeassistant.helpers.typing import ConfigType
 from .const import CONF_DOMAIN_DATA, DOMAIN
 from .helpers import (
     AddressType,
-    DeviceConnectionType,
     InputType,
     LcnConfigEntry,
     generate_unique_id,
@@ -22,9 +23,8 @@ from .helpers import (
 class LcnEntity(Entity):
     """Parent class for all entities associated with the LCN component."""
 
-    _attr_should_poll = False
     _attr_has_entity_name = True
-    device_connection: DeviceConnectionType
+    device_connection: DeviceConnection
 
     def __init__(
         self,
@@ -35,7 +35,7 @@ class LcnEntity(Entity):
         self.config = config
         self.config_entry = config_entry
         self.address: AddressType = config[CONF_ADDRESS]
-        self._unregister_for_inputs: Callable | None = None
+        self._unregister_for_inputs: Callable[[], None] | None = None
         self._name: str = config[CONF_NAME]
         self._attr_device_info = DeviceInfo(
             identifiers={
@@ -57,15 +57,24 @@ class LcnEntity(Entity):
             ).lower(),
         )
 
+    @property
+    def should_poll(self) -> bool:
+        """Groups may not poll for a status."""
+        return not self.device_connection.is_group
+
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
         self.device_connection = get_device_connection(
             self.hass, self.config[CONF_ADDRESS], self.config_entry
         )
-        if not self.device_connection.is_group:
-            self._unregister_for_inputs = self.device_connection.register_for_inputs(
-                self.input_received
-            )
+        if self.device_connection.is_group:
+            return
+
+        self._unregister_for_inputs = self.device_connection.register_for_inputs(
+            self.input_received
+        )
+
+        self.schedule_update_ha_state(force_refresh=True)
 
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""

homeassistant/components/lcn/helpers.py

@@ -11,6 +11,7 @@ from typing import cast
 
 import pypck
 from pypck.connection import PchkConnectionManager
+from pypck.device import DeviceConnection
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -48,7 +49,7 @@ class LcnRuntimeData:
     connection: PchkConnectionManager
     """Connection to PCHK host."""
 
-    device_connections: dict[str, DeviceConnectionType]
+    device_connections: dict[str, DeviceConnection]
     """Logical addresses of devices connected to the host."""
 
     add_entities_callbacks: dict[str, Callable[[Iterable[ConfigType]], None]]
@@ -59,9 +60,8 @@ class LcnRuntimeData:
 type LcnConfigEntry = ConfigEntry[LcnRuntimeData]
 
 type AddressType = tuple[int, int, bool]
-type DeviceConnectionType = pypck.module.ModuleConnection | pypck.module.GroupConnection
 
-type InputType = type[pypck.inputs.Input]
+type InputType = pypck.inputs.Input
 
 # Regex for address validation
 PATTERN_ADDRESS = re.compile(
@@ -82,11 +82,11 @@ DOMAIN_LOOKUP = {
 
 def get_device_connection(
     hass: HomeAssistant, address: AddressType, config_entry: LcnConfigEntry
-) -> DeviceConnectionType:
+) -> DeviceConnection:
     """Return a lcn device_connection."""
     host_connection = config_entry.runtime_data.connection
     addr = pypck.lcn_addr.LcnAddr(*address)
-    return host_connection.get_address_conn(addr)
+    return host_connection.get_device_connection(addr)
 
 
 def get_resource(domain_name: str, domain_data: ConfigType) -> str:
@@ -246,27 +246,33 @@ def register_lcn_address_devices(
 
 
 async def async_update_device_config(
-    device_connection: DeviceConnectionType, device_config: ConfigType
+    device_connection: DeviceConnection, device_config: ConfigType
 ) -> None:
     """Fill missing values in device_config with infos from LCN bus."""
     # fetch serial info if device is module
     if not (is_group := device_config[CONF_ADDRESS][2]):  # is module
-        await device_connection.serial_known
+        await device_connection.serials_known()
         if device_config[CONF_HARDWARE_SERIAL] == -1:
-            device_config[CONF_HARDWARE_SERIAL] = device_connection.hardware_serial
+            device_config[CONF_HARDWARE_SERIAL] = (
+                device_connection.serials.hardware_serial
+            )
         if device_config[CONF_SOFTWARE_SERIAL] == -1:
-            device_config[CONF_SOFTWARE_SERIAL] = device_connection.software_serial
+            device_config[CONF_SOFTWARE_SERIAL] = (
+                device_connection.serials.software_serial
+            )
         if device_config[CONF_HARDWARE_TYPE] == -1:
-            device_config[CONF_HARDWARE_TYPE] = device_connection.hardware_type.value
+            device_config[CONF_HARDWARE_TYPE] = (
+                device_connection.serials.hardware_type.value
+            )
 
     # fetch name if device is module
     if device_config[CONF_NAME] != "":
         return
 
-    device_name = ""
+    device_name: str | None = None
     if not is_group:
         device_name = await device_connection.request_name()
-    if is_group or device_name == "":
+    if is_group or device_name is None:
         module_type = "Group" if is_group else "Module"
         device_name = (
             f"{module_type} "

homeassistant/components/lcn/light.py

@@ -1,6 +1,7 @@
 """Support for LCN lights."""
 
 from collections.abc import Iterable
+from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -33,6 +34,7 @@ from .helpers import InputType, LcnConfigEntry
 BRIGHTNESS_SCALE = (1, 100)
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -100,18 +102,6 @@ class LcnOutputLight(LcnEntity, LightEntity):
             self._attr_color_mode = ColorMode.ONOFF
         self._attr_supported_color_modes = {self._attr_color_mode}
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.output)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.output)
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         if ATTR_TRANSITION in kwargs:
@@ -157,6 +147,12 @@ class LcnOutputLight(LcnEntity, LightEntity):
             self._attr_is_on = False
             self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_output(
+            self.output, SCAN_INTERVAL.seconds
+        )
+
     def input_received(self, input_obj: InputType) -> None:
         """Set light state when LCN input object (command) is received."""
         if (
@@ -184,18 +180,6 @@ class LcnRelayLight(LcnEntity, LightEntity):
 
         self.output = pypck.lcn_defs.RelayPort[config[CONF_DOMAIN_DATA][CONF_OUTPUT]]
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.output)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.output)
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         states = [pypck.lcn_defs.RelayStateModifier.NOCHANGE] * 8
@@ -214,6 +198,10 @@ class LcnRelayLight(LcnEntity, LightEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+
     def input_received(self, input_obj: InputType) -> None:
         """Set light state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):

homeassistant/components/lcn/manifest.json

@@ -6,8 +6,8 @@
   "config_flow": true,
   "dependencies": ["http", "websocket_api"],
   "documentation": "https://www.home-assistant.io/integrations/lcn",
-  "iot_class": "local_push",
+  "iot_class": "local_polling",
   "loggers": ["pypck"],
   "quality_scale": "bronze",
-  "requirements": ["pypck==0.8.12", "lcn-frontend==0.2.7"]
+  "requirements": ["pypck==0.9.5", "lcn-frontend==0.2.7"]
 }

homeassistant/components/lcn/quality_scale.yaml

@@ -74,4 +74,4 @@ rules:
     status: exempt
     comment: |
       Integration is not making any HTTP requests.
-  strict-typing: todo
+  strict-typing: done

homeassistant/components/lcn/sensor.py

@@ -1,6 +1,7 @@
 """Support for LCN sensors."""
 
 from collections.abc import Iterable
+from datetime import timedelta
 from functools import partial
 from itertools import chain
 
@@ -40,6 +41,8 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
+
 
 DEVICE_CLASS_MAPPING = {
     pypck.lcn_defs.VarUnit.CELSIUS: SensorDeviceClass.TEMPERATURE,
@@ -128,17 +131,11 @@ class LcnVariableSensor(LcnEntity, SensorEntity):
         )
         self._attr_device_class = DEVICE_CLASS_MAPPING.get(self.unit)
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.variable)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.variable)
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_variable(
+            self.variable, SCAN_INTERVAL.seconds
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
@@ -159,6 +156,8 @@ class LcnVariableSensor(LcnEntity, SensorEntity):
 class LcnLedLogicSensor(LcnEntity, SensorEntity):
     """Representation of a LCN sensor for leds and logicops."""
 
+    source: pypck.lcn_defs.LedPort | pypck.lcn_defs.LogicOpPort
+
     def __init__(self, config: ConfigType, config_entry: LcnConfigEntry) -> None:
         """Initialize the LCN sensor."""
         super().__init__(config, config_entry)
@@ -170,17 +169,11 @@ class LcnLedLogicSensor(LcnEntity, SensorEntity):
                 config[CONF_DOMAIN_DATA][CONF_SOURCE]
             ]
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.source)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.source)
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_led_and_logic_ops(
+            SCAN_INTERVAL.seconds
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""

homeassistant/components/lcn/services.py

@@ -3,6 +3,7 @@
 from enum import StrEnum, auto
 
 import pypck
+from pypck.device import DeviceConnection
 import voluptuous as vol
 
 from homeassistant.const import (
@@ -48,7 +49,7 @@ from .const import (
     VAR_UNITS,
     VARIABLES,
 )
-from .helpers import DeviceConnectionType, LcnConfigEntry, is_states_string
+from .helpers import LcnConfigEntry, is_states_string
 
 
 class LcnServiceCall:
@@ -65,7 +66,7 @@ class LcnServiceCall:
         """Initialize service call."""
         self.hass = hass
 
-    def get_device_connection(self, service: ServiceCall) -> DeviceConnectionType:
+    def get_device_connection(self, service: ServiceCall) -> DeviceConnection:
         """Get address connection object."""
         entries: list[LcnConfigEntry] = self.hass.config_entries.async_loaded_entries(
             DOMAIN
@@ -380,9 +381,6 @@ class LockKeys(LcnServiceCall):
         else:
             await device_connection.lock_keys(table_id, states)
 
-        handler = device_connection.status_requests_handler
-        await handler.request_status_locked_keys_timeout()
-
 
 class DynText(LcnServiceCall):
     """Send dynamic text to LCN-GTxD displays."""

homeassistant/components/lcn/switch.py

@@ -1,6 +1,7 @@
 """Support for LCN switches."""
 
 from collections.abc import Iterable
+from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -17,6 +18,7 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_switch_entities(
@@ -77,18 +79,6 @@ class LcnOutputSwitch(LcnEntity, SwitchEntity):
 
         self.output = pypck.lcn_defs.OutputPort[config[CONF_DOMAIN_DATA][CONF_OUTPUT]]
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.output)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.output)
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         if not await self.device_connection.dim_output(self.output.value, 100, 0):
@@ -103,6 +93,12 @@ class LcnOutputSwitch(LcnEntity, SwitchEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_output(
+            self.output, SCAN_INTERVAL.seconds
+        )
+
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if (
@@ -126,18 +122,6 @@ class LcnRelaySwitch(LcnEntity, SwitchEntity):
 
         self.output = pypck.lcn_defs.RelayPort[config[CONF_DOMAIN_DATA][CONF_OUTPUT]]
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.output)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.output)
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         states = [pypck.lcn_defs.RelayStateModifier.NOCHANGE] * 8
@@ -156,6 +140,10 @@ class LcnRelaySwitch(LcnEntity, SwitchEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):
@@ -179,22 +167,6 @@ class LcnRegulatorLockSwitch(LcnEntity, SwitchEntity):
         ]
         self.reg_id = pypck.lcn_defs.Var.to_set_point_id(self.setpoint_variable)
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(
-                self.setpoint_variable
-            )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(
-                self.setpoint_variable
-            )
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         if not await self.device_connection.lock_regulator(self.reg_id, True):
@@ -209,6 +181,12 @@ class LcnRegulatorLockSwitch(LcnEntity, SwitchEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_variable(
+            self.setpoint_variable, SCAN_INTERVAL.seconds
+        )
+
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if (
@@ -234,18 +212,6 @@ class LcnKeyLockSwitch(LcnEntity, SwitchEntity):
         self.table_id = ord(self.key.name[0]) - 65
         self.key_id = int(self.key.name[1]) - 1
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.activate_status_request_handler(self.key)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        await super().async_will_remove_from_hass()
-        if not self.device_connection.is_group:
-            await self.device_connection.cancel_status_request_handler(self.key)
-
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         states = [pypck.lcn_defs.KeyLockStateModifier.NOCHANGE] * 8
@@ -268,6 +234,10 @@ class LcnKeyLockSwitch(LcnEntity, SwitchEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
+    async def async_update(self) -> None:
+        """Update the state of the entity."""
+        await self.device_connection.request_status_locked_keys(SCAN_INTERVAL.seconds)
+
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if (

homeassistant/components/lcn/websocket.py

@@ -7,6 +7,7 @@ from functools import wraps
 from typing import Any, Final
 
 import lcn_frontend as lcn_panel
+from pypck.device import DeviceConnection
 import voluptuous as vol
 
 from homeassistant.components import panel_custom, websocket_api
@@ -37,7 +38,6 @@ from .const import (
     DOMAIN,
 )
 from .helpers import (
-    DeviceConnectionType,
     LcnConfigEntry,
     async_update_device_config,
     generate_unique_id,
@@ -104,7 +104,9 @@ def get_config_entry(
 
     @wraps(func)
     async def get_entry(
-        hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict
+        hass: HomeAssistant,
+        connection: websocket_api.ActiveConnection,
+        msg: dict[str, Any],
     ) -> None:
         """Get config_entry."""
         if not (config_entry := hass.config_entries.async_get_entry(msg["entry_id"])):
@@ -124,7 +126,7 @@ def get_config_entry(
 async def websocket_get_device_configs(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Get device configs."""
@@ -144,7 +146,7 @@ async def websocket_get_device_configs(
 async def websocket_get_entity_configs(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Get entities configs."""
@@ -175,14 +177,14 @@ async def websocket_get_entity_configs(
 async def websocket_scan_devices(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Scan for new devices."""
     host_connection = config_entry.runtime_data.connection
     await host_connection.scan_modules()
 
-    for device_connection in host_connection.address_conns.values():
+    for device_connection in host_connection.device_connections.values():
         if not device_connection.is_group:
             await async_create_or_update_device_in_config_entry(
                 hass, device_connection, config_entry
@@ -207,7 +209,7 @@ async def websocket_scan_devices(
 async def websocket_add_device(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Add a device."""
@@ -253,7 +255,7 @@ async def websocket_add_device(
 async def websocket_delete_device(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Delete a device."""
@@ -315,7 +317,7 @@ async def websocket_delete_device(
 async def websocket_add_entity(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Add an entity."""
@@ -381,7 +383,7 @@ async def websocket_add_entity(
 async def websocket_delete_entity(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
-    msg: dict,
+    msg: dict[str, Any],
     config_entry: LcnConfigEntry,
 ) -> None:
     """Delete an entity."""
@@ -421,7 +423,7 @@ async def websocket_delete_entity(
 
 async def async_create_or_update_device_in_config_entry(
     hass: HomeAssistant,
-    device_connection: DeviceConnectionType,
+    device_connection: DeviceConnection,
     config_entry: LcnConfigEntry,
 ) -> None:
     """Create or update device in config_entry according to given device_connection."""
@@ -451,7 +453,7 @@ async def async_create_or_update_device_in_config_entry(
 
 
 def get_entity_entry(
-    hass: HomeAssistant, entity_config: dict, config_entry: LcnConfigEntry
+    hass: HomeAssistant, entity_config: dict[str, Any], config_entry: LcnConfigEntry
 ) -> er.RegistryEntry | None:
     """Get entity RegistryEntry from entity_config."""
     entity_registry = er.async_get(hass)

homeassistant/components/lutron_caseta/manifest.json

@@ -9,7 +9,7 @@
   },
   "iot_class": "local_push",
   "loggers": ["pylutron_caseta"],
-  "requirements": ["pylutron-caseta==0.25.0"],
+  "requirements": ["pylutron-caseta==0.26.0"],
   "zeroconf": [
     {
       "properties": {

homeassistant/components/mobile_app/__init__.py

@@ -41,9 +41,11 @@ from .const import (
     DATA_CONFIG_ENTRIES,
     DATA_DELETED_IDS,
     DATA_DEVICES,
+    DATA_PENDING_UPDATES,
     DATA_PUSH_CHANNEL,
     DATA_STORE,
     DOMAIN,
+    SENSOR_TYPES,
     STORAGE_KEY,
     STORAGE_VERSION,
 )
@@ -75,6 +77,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         DATA_DEVICES: {},
         DATA_PUSH_CHANNEL: {},
         DATA_STORE: store,
+        DATA_PENDING_UPDATES: {sensor_type: {} for sensor_type in SENSOR_TYPES},
     }
 
     hass.http.register_view(RegistrationsView())

homeassistant/components/mobile_app/binary_sensor.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_WEBHOOK_ID, STATE_ON
+from homeassistant.const import CONF_WEBHOOK_ID, STATE_ON, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -75,8 +75,9 @@ class MobileAppBinarySensor(MobileAppEntity, BinarySensorEntity):
 
     async def async_restore_last_state(self, last_state: State) -> None:
         """Restore previous state."""
-        await super().async_restore_last_state(last_state)
-        self._config[ATTR_SENSOR_STATE] = last_state.state == STATE_ON
+        if self._config[ATTR_SENSOR_STATE] in (None, STATE_UNKNOWN):
+            await super().async_restore_last_state(last_state)
+            self._config[ATTR_SENSOR_STATE] = last_state.state == STATE_ON
         self._async_update_attr_from_config()
 
     @callback

homeassistant/components/mobile_app/const.py

@@ -20,6 +20,7 @@ DATA_DEVICES = "devices"
 DATA_STORE = "store"
 DATA_NOTIFY = "notify"
 DATA_PUSH_CHANNEL = "push_channel"
+DATA_PENDING_UPDATES = "pending_updates"
 
 ATTR_APP_DATA = "app_data"
 ATTR_APP_ID = "app_id"
@@ -94,3 +95,5 @@ SCHEMA_APP_DATA = vol.Schema(
     },
     extra=vol.ALLOW_EXTRA,
 )
+
+SENSOR_TYPES = (ATTR_SENSOR_TYPE_BINARY_SENSOR, ATTR_SENSOR_TYPE_SENSOR)

homeassistant/components/mobile_app/entity.py

@@ -2,10 +2,16 @@
 
 from __future__ import annotations
 
-from typing import Any
+import logging
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ICON, CONF_NAME, CONF_UNIQUE_ID, STATE_UNAVAILABLE
+from homeassistant.const import (
+    ATTR_ICON,
+    CONF_NAME,
+    CONF_UNIQUE_ID,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
 from homeassistant.core import State, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.restore_state import RestoreEntity
@@ -18,10 +24,15 @@ from .const import (
     ATTR_SENSOR_ICON,
     ATTR_SENSOR_STATE,
     ATTR_SENSOR_STATE_CLASS,
+    ATTR_SENSOR_TYPE,
+    DATA_PENDING_UPDATES,
+    DOMAIN,
     SIGNAL_SENSOR_UPDATE,
 )
 from .helpers import device_info
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class MobileAppEntity(RestoreEntity):
     """Representation of a mobile app entity."""
@@ -56,11 +67,14 @@ class MobileAppEntity(RestoreEntity):
         self.async_on_remove(
             async_dispatcher_connect(
                 self.hass,
-                f"{SIGNAL_SENSOR_UPDATE}-{self._attr_unique_id}",
+                f"{SIGNAL_SENSOR_UPDATE}-{self._config[ATTR_SENSOR_TYPE]}-{self._attr_unique_id}",
                 self._handle_update,
             )
         )
 
+        # Apply any pending updates
+        self._handle_update()
+
         if (state := await self.async_get_last_state()) is None:
             return
 
@@ -69,13 +83,16 @@ class MobileAppEntity(RestoreEntity):
     async def async_restore_last_state(self, last_state: State) -> None:
         """Restore previous state."""
         config = self._config
-        config[ATTR_SENSOR_STATE] = last_state.state
-        config[ATTR_SENSOR_ATTRIBUTES] = {
-            **last_state.attributes,
-            **self._config[ATTR_SENSOR_ATTRIBUTES],
-        }
-        if ATTR_ICON in last_state.attributes:
-            config[ATTR_SENSOR_ICON] = last_state.attributes[ATTR_ICON]
+
+        # Only restore state if we don't have one already, since it can be set by a pending update
+        if config[ATTR_SENSOR_STATE] in (None, STATE_UNKNOWN):
+            config[ATTR_SENSOR_STATE] = last_state.state
+            config[ATTR_SENSOR_ATTRIBUTES] = {
+                **last_state.attributes,
+                **self._config[ATTR_SENSOR_ATTRIBUTES],
+            }
+            if ATTR_ICON in last_state.attributes:
+                config[ATTR_SENSOR_ICON] = last_state.attributes[ATTR_ICON]
 
     @property
     def device_info(self):
@@ -83,8 +100,21 @@ class MobileAppEntity(RestoreEntity):
         return device_info(self._registration)
 
     @callback
-    def _handle_update(self, data: dict[str, Any]) -> None:
+    def _handle_update(self) -> None:
         """Handle async event updates."""
-        self._config.update(data)
+        self._apply_pending_update()
         self._async_update_attr_from_config()
         self.async_write_ha_state()
+
+    def _apply_pending_update(self) -> None:
+        """Restore any pending update for this entity."""
+        entity_type = self._config[ATTR_SENSOR_TYPE]
+        pending_updates = self.hass.data[DOMAIN][DATA_PENDING_UPDATES][entity_type]
+        if update := pending_updates.pop(self._attr_unique_id, None):
+            _LOGGER.debug(
+                "Applying pending update for %s: %s",
+                self._attr_unique_id,
+                update,
+            )
+            # Apply the pending update
+            self._config.update(update)

homeassistant/components/mobile_app/sensor.py

@@ -86,24 +86,26 @@ class MobileAppSensor(MobileAppEntity, RestoreSensor):
 
     async def async_restore_last_state(self, last_state: State) -> None:
         """Restore previous state."""
-        await super().async_restore_last_state(last_state)
         config = self._config
-        if not (last_sensor_data := await self.async_get_last_sensor_data()):
-            # Workaround to handle migration to RestoreSensor, can be removed
-            # in HA Core 2023.4
-            config[ATTR_SENSOR_STATE] = None
-            webhook_id = self._entry.data[CONF_WEBHOOK_ID]
-            if TYPE_CHECKING:
-                assert self.unique_id is not None
-            sensor_unique_id = _extract_sensor_unique_id(webhook_id, self.unique_id)
-            if (
-                self.device_class == SensorDeviceClass.TEMPERATURE
-                and sensor_unique_id == "battery_temperature"
-            ):
-                config[ATTR_SENSOR_UOM] = UnitOfTemperature.CELSIUS
-        else:
-            config[ATTR_SENSOR_STATE] = last_sensor_data.native_value
-            config[ATTR_SENSOR_UOM] = last_sensor_data.native_unit_of_measurement
+        if config[ATTR_SENSOR_STATE] in (None, STATE_UNKNOWN):
+            await super().async_restore_last_state(last_state)
+
+            if not (last_sensor_data := await self.async_get_last_sensor_data()):
+                # Workaround to handle migration to RestoreSensor, can be removed
+                # in HA Core 2023.4
+                config[ATTR_SENSOR_STATE] = None
+                webhook_id = self._entry.data[CONF_WEBHOOK_ID]
+                if TYPE_CHECKING:
+                    assert self.unique_id is not None
+                sensor_unique_id = _extract_sensor_unique_id(webhook_id, self.unique_id)
+                if (
+                    self.device_class == SensorDeviceClass.TEMPERATURE
+                    and sensor_unique_id == "battery_temperature"
+                ):
+                    config[ATTR_SENSOR_UOM] = UnitOfTemperature.CELSIUS
+            else:
+                config[ATTR_SENSOR_STATE] = last_sensor_data.native_value
+                config[ATTR_SENSOR_UOM] = last_sensor_data.native_unit_of_measurement
 
         self._async_update_attr_from_config()
 

homeassistant/components/mobile_app/webhook.py

@@ -79,7 +79,6 @@ from .const import (
     ATTR_SENSOR_STATE,
     ATTR_SENSOR_STATE_CLASS,
     ATTR_SENSOR_TYPE,
-    ATTR_SENSOR_TYPE_BINARY_SENSOR,
     ATTR_SENSOR_TYPE_SENSOR,
     ATTR_SENSOR_UNIQUE_ID,
     ATTR_SENSOR_UOM,
@@ -98,12 +97,14 @@ from .const import (
     DATA_CONFIG_ENTRIES,
     DATA_DELETED_IDS,
     DATA_DEVICES,
+    DATA_PENDING_UPDATES,
     DOMAIN,
     ERR_ENCRYPTION_ALREADY_ENABLED,
     ERR_ENCRYPTION_REQUIRED,
     ERR_INVALID_FORMAT,
     ERR_SENSOR_NOT_REGISTERED,
     SCHEMA_APP_DATA,
+    SENSOR_TYPES,
     SIGNAL_LOCATION_UPDATE,
     SIGNAL_SENSOR_UPDATE,
 )
@@ -125,8 +126,6 @@ WEBHOOK_COMMANDS: Registry[
     str, Callable[[HomeAssistant, ConfigEntry, Any], Coroutine[Any, Any, Response]]
 ] = Registry()
 
-SENSOR_TYPES = (ATTR_SENSOR_TYPE_BINARY_SENSOR, ATTR_SENSOR_TYPE_SENSOR)
-
 WEBHOOK_PAYLOAD_SCHEMA = vol.Any(
     vol.Schema(
         {
@@ -601,14 +600,16 @@ async def webhook_register_sensor(
         if changes:
             entity_registry.async_update_entity(existing_sensor, **changes)
 
-        async_dispatcher_send(hass, f"{SIGNAL_SENSOR_UPDATE}-{unique_store_key}", data)
+        _async_update_sensor_entity(
+            hass, entity_type=entity_type, unique_store_key=unique_store_key, data=data
+        )
     else:
         data[CONF_UNIQUE_ID] = unique_store_key
         data[CONF_NAME] = (
             f"{config_entry.data[ATTR_DEVICE_NAME]} {data[ATTR_SENSOR_NAME]}"
         )
 
-        register_signal = f"{DOMAIN}_{data[ATTR_SENSOR_TYPE]}_register"
+        register_signal = f"{DOMAIN}_{entity_type}_register"
         async_dispatcher_send(hass, register_signal, data)
 
     return webhook_response(
@@ -685,10 +686,12 @@ async def webhook_update_sensor_states(
             continue
 
         sensor[CONF_WEBHOOK_ID] = config_entry.data[CONF_WEBHOOK_ID]
-        async_dispatcher_send(
+
+        _async_update_sensor_entity(
             hass,
-            f"{SIGNAL_SENSOR_UPDATE}-{unique_store_key}",
-            sensor,
+            entity_type=entity_type,
+            unique_store_key=unique_store_key,
+            data=sensor,
         )
 
         resp[unique_id] = {"success": True}
@@ -697,11 +700,26 @@ async def webhook_update_sensor_states(
         entry = entity_registry.async_get(entity_id)
 
         if entry and entry.disabled_by:
+            # Inform the app that the entity is disabled
             resp[unique_id]["is_disabled"] = True
 
     return webhook_response(resp, registration=config_entry.data)
 
 
+def _async_update_sensor_entity(
+    hass: HomeAssistant, entity_type: str, unique_store_key: str, data: dict[str, Any]
+) -> None:
+    """Update a sensor entity with new data."""
+    # Replace existing pending update with the latest sensor data.
+    hass.data[DOMAIN][DATA_PENDING_UPDATES][entity_type][unique_store_key] = data
+
+    # The signal might not be handled if the entity was just enabled, but the data is stored
+    # in pending updates and will be applied on entity initialization.
+    async_dispatcher_send(
+        hass, f"{SIGNAL_SENSOR_UPDATE}-{entity_type}-{unique_store_key}"
+    )
+
+
 @WEBHOOK_COMMANDS.register("get_zones")
 async def webhook_get_zones(
     hass: HomeAssistant, config_entry: ConfigEntry, data: Any

homeassistant/components/mqtt/config_flow.py

@@ -4237,7 +4237,8 @@ class MQTTSubentryFlowHandler(ConfigSubentryFlow):
         return self.async_show_form(
             step_id="entity",
             data_schema=data_schema,
-            description_placeholders={
+            description_placeholders=TRANSLATION_DESCRIPTION_PLACEHOLDERS
+            | {
                 "mqtt_device": device_name,
                 "entity_name_label": entity_name_label,
                 "platform_label": platform_label,

homeassistant/components/music_assistant/__init__.py

@@ -27,7 +27,8 @@ from homeassistant.helpers.issue_registry import (
 )
 
 from .const import ATTR_CONF_EXPOSE_PLAYER_TO_HA, DOMAIN, LOGGER
-from .services import get_music_assistant_client, register_actions
+from .helpers import get_music_assistant_client
+from .services import register_actions
 
 if TYPE_CHECKING:
     from music_assistant_models.event import MassEvent

homeassistant/components/music_assistant/helpers.py

@@ -4,11 +4,18 @@ from __future__ import annotations
 
 from collections.abc import Callable, Coroutine
 import functools
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from music_assistant_models.errors import MusicAssistantError
 
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+
+if TYPE_CHECKING:
+    from music_assistant_client import MusicAssistantClient
+
+    from . import MusicAssistantConfigEntry
 
 
 def catch_musicassistant_error[**_P, _R](
@@ -26,3 +33,16 @@ def catch_musicassistant_error[**_P, _R](
             raise HomeAssistantError(error_msg) from err
 
     return wrapper
+
+
+@callback
+def get_music_assistant_client(
+    hass: HomeAssistant, config_entry_id: str
+) -> MusicAssistantClient:
+    """Get the Music Assistant client for the given config entry."""
+    entry: MusicAssistantConfigEntry | None
+    if not (entry := hass.config_entries.async_get_entry(config_entry_id)):
+        raise ServiceValidationError("Entry not found")
+    if entry.state is not ConfigEntryState.LOADED:
+        raise ServiceValidationError("Entry not loaded")
+    return entry.runtime_data.mass

homeassistant/components/music_assistant/media_player.py

@@ -22,11 +22,9 @@ from music_assistant_models.errors import MediaNotFoundError
 from music_assistant_models.event import MassEvent
 from music_assistant_models.media_items import ItemMapping, MediaItemType, Track
 from music_assistant_models.player_queue import PlayerQueue
-import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
-    ATTR_MEDIA_ENQUEUE,
     ATTR_MEDIA_EXTRA,
     BrowseMedia,
     MediaPlayerDeviceClass,
@@ -41,38 +39,26 @@ from homeassistant.components.media_player import (
     async_process_play_media_url,
 )
 from homeassistant.const import ATTR_NAME, STATE_OFF, Platform
-from homeassistant.core import HomeAssistant, ServiceResponse, SupportsResponse
+from homeassistant.core import HomeAssistant, ServiceResponse
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    async_get_current_platform,
-)
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.dt import utc_from_timestamp
 
 from . import MusicAssistantConfigEntry
 from .const import (
     ATTR_ACTIVE,
     ATTR_ACTIVE_QUEUE,
-    ATTR_ALBUM,
-    ATTR_ANNOUNCE_VOLUME,
-    ATTR_ARTIST,
-    ATTR_AUTO_PLAY,
     ATTR_CURRENT_INDEX,
     ATTR_CURRENT_ITEM,
     ATTR_ELAPSED_TIME,
     ATTR_ITEMS,
     ATTR_MASS_PLAYER_TYPE,
-    ATTR_MEDIA_ID,
-    ATTR_MEDIA_TYPE,
     ATTR_NEXT_ITEM,
     ATTR_QUEUE_ID,
     ATTR_RADIO_MODE,
     ATTR_REPEAT_MODE,
     ATTR_SHUFFLE_ENABLED,
-    ATTR_SOURCE_PLAYER,
-    ATTR_URL,
-    ATTR_USE_PRE_ANNOUNCE,
     DOMAIN,
 )
 from .entity import MusicAssistantEntity
@@ -122,11 +108,6 @@ REPEAT_MODE_MAPPING_TO_HA = {
     # UNKNOWN is intentionally not mapped - will return None
 }
 
-SERVICE_PLAY_MEDIA_ADVANCED = "play_media"
-SERVICE_PLAY_ANNOUNCEMENT = "play_announcement"
-SERVICE_TRANSFER_QUEUE = "transfer_queue"
-SERVICE_GET_QUEUE = "get_queue"
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -143,44 +124,6 @@ async def async_setup_entry(
     # register callback to add players when they are discovered
     entry.runtime_data.platform_handlers.setdefault(Platform.MEDIA_PLAYER, add_player)
 
-    # add platform service for play_media with advanced options
-    platform = async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_PLAY_MEDIA_ADVANCED,
-        {
-            vol.Required(ATTR_MEDIA_ID): vol.All(cv.ensure_list, [cv.string]),
-            vol.Optional(ATTR_MEDIA_TYPE): vol.Coerce(MediaType),
-            vol.Optional(ATTR_MEDIA_ENQUEUE): vol.Coerce(QueueOption),
-            vol.Optional(ATTR_ARTIST): cv.string,
-            vol.Optional(ATTR_ALBUM): cv.string,
-            vol.Optional(ATTR_RADIO_MODE): vol.Coerce(bool),
-        },
-        "_async_handle_play_media",
-    )
-    platform.async_register_entity_service(
-        SERVICE_PLAY_ANNOUNCEMENT,
-        {
-            vol.Required(ATTR_URL): cv.string,
-            vol.Optional(ATTR_USE_PRE_ANNOUNCE): vol.Coerce(bool),
-            vol.Optional(ATTR_ANNOUNCE_VOLUME): vol.Coerce(int),
-        },
-        "_async_handle_play_announcement",
-    )
-    platform.async_register_entity_service(
-        SERVICE_TRANSFER_QUEUE,
-        {
-            vol.Optional(ATTR_SOURCE_PLAYER): cv.entity_id,
-            vol.Optional(ATTR_AUTO_PLAY): vol.Coerce(bool),
-        },
-        "_async_handle_transfer_queue",
-    )
-    platform.async_register_entity_service(
-        SERVICE_GET_QUEUE,
-        schema=None,
-        func="_async_handle_get_queue",
-        supports_response=SupportsResponse.ONLY,
-    )
-
 
 class MusicAssistantPlayer(MusicAssistantEntity, MediaPlayerEntity):
     """Representation of MediaPlayerEntity from Music Assistant Player."""

homeassistant/components/music_assistant/services.py

@@ -4,10 +4,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from music_assistant_models.enums import MediaType
+from music_assistant_models.enums import MediaType, QueueOption
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntryState
+from homeassistant.components.media_player import (
+    ATTR_MEDIA_ENQUEUE,
+    DOMAIN as MEDIA_PLAYER_DOMAIN,
+)
 from homeassistant.const import ATTR_CONFIG_ENTRY_ID
 from homeassistant.core import (
     HomeAssistant,
@@ -17,31 +20,41 @@ from homeassistant.core import (
     callback,
 )
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import config_validation as cv, service
 
 from .const import (
+    ATTR_ALBUM,
     ATTR_ALBUM_ARTISTS_ONLY,
     ATTR_ALBUM_TYPE,
     ATTR_ALBUMS,
+    ATTR_ANNOUNCE_VOLUME,
+    ATTR_ARTIST,
     ATTR_ARTISTS,
     ATTR_AUDIOBOOKS,
+    ATTR_AUTO_PLAY,
     ATTR_FAVORITE,
     ATTR_ITEMS,
     ATTR_LIBRARY_ONLY,
     ATTR_LIMIT,
+    ATTR_MEDIA_ID,
     ATTR_MEDIA_TYPE,
     ATTR_OFFSET,
     ATTR_ORDER_BY,
     ATTR_PLAYLISTS,
     ATTR_PODCASTS,
     ATTR_RADIO,
+    ATTR_RADIO_MODE,
     ATTR_SEARCH,
     ATTR_SEARCH_ALBUM,
     ATTR_SEARCH_ARTIST,
     ATTR_SEARCH_NAME,
+    ATTR_SOURCE_PLAYER,
     ATTR_TRACKS,
+    ATTR_URL,
+    ATTR_USE_PRE_ANNOUNCE,
     DOMAIN,
 )
+from .helpers import get_music_assistant_client
 from .schemas import (
     LIBRARY_RESULTS_SCHEMA,
     SEARCH_RESULT_SCHEMA,
@@ -49,7 +62,6 @@ from .schemas import (
 )
 
 if TYPE_CHECKING:
-    from music_assistant_client import MusicAssistantClient
     from music_assistant_models.media_items import (
         Album,
         Artist,
@@ -60,28 +72,18 @@ if TYPE_CHECKING:
         Track,
     )
 
-    from . import MusicAssistantConfigEntry
-
 SERVICE_SEARCH = "search"
 SERVICE_GET_LIBRARY = "get_library"
+SERVICE_PLAY_MEDIA_ADVANCED = "play_media"
+SERVICE_PLAY_ANNOUNCEMENT = "play_announcement"
+SERVICE_TRANSFER_QUEUE = "transfer_queue"
+SERVICE_GET_QUEUE = "get_queue"
+
 DEFAULT_OFFSET = 0
 DEFAULT_LIMIT = 25
 DEFAULT_SORT_ORDER = "name"
 
 
-@callback
-def get_music_assistant_client(
-    hass: HomeAssistant, config_entry_id: str
-) -> MusicAssistantClient:
-    """Get the Music Assistant client for the given config entry."""
-    entry: MusicAssistantConfigEntry | None
-    if not (entry := hass.config_entries.async_get_entry(config_entry_id)):
-        raise ServiceValidationError("Entry not found")
-    if entry.state is not ConfigEntryState.LOADED:
-        raise ServiceValidationError("Entry not loaded")
-    return entry.runtime_data.mass
-
-
 @callback
 def register_actions(hass: HomeAssistant) -> None:
     """Register custom actions."""
@@ -124,6 +126,55 @@ def register_actions(hass: HomeAssistant) -> None:
         supports_response=SupportsResponse.ONLY,
     )
 
+    # Platform entity services
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_PLAY_MEDIA_ADVANCED,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Required(ATTR_MEDIA_ID): vol.All(cv.ensure_list, [cv.string]),
+            vol.Optional(ATTR_MEDIA_TYPE): vol.Coerce(MediaType),
+            vol.Optional(ATTR_MEDIA_ENQUEUE): vol.Coerce(QueueOption),
+            vol.Optional(ATTR_ARTIST): cv.string,
+            vol.Optional(ATTR_ALBUM): cv.string,
+            vol.Optional(ATTR_RADIO_MODE): vol.Coerce(bool),
+        },
+        func="_async_handle_play_media",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_PLAY_ANNOUNCEMENT,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Required(ATTR_URL): cv.string,
+            vol.Optional(ATTR_USE_PRE_ANNOUNCE): vol.Coerce(bool),
+            vol.Optional(ATTR_ANNOUNCE_VOLUME): vol.Coerce(int),
+        },
+        func="_async_handle_play_announcement",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_TRANSFER_QUEUE,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Optional(ATTR_SOURCE_PLAYER): cv.entity_id,
+            vol.Optional(ATTR_AUTO_PLAY): vol.Coerce(bool),
+        },
+        func="_async_handle_transfer_queue",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_GET_QUEUE,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="_async_handle_get_queue",
+        supports_response=SupportsResponse.ONLY,
+    )
+
 
 async def handle_search(call: ServiceCall) -> ServiceResponse:
     """Handle queue_command action."""

homeassistant/components/nederlandse_spoorwegen/__init__.py

@@ -13,7 +13,7 @@ from .coordinator import NSConfigEntry, NSDataUpdateCoordinator
 _LOGGER = logging.getLogger(__name__)
 
 
-PLATFORMS = [Platform.SENSOR]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: NSConfigEntry) -> bool:

homeassistant/components/nederlandse_spoorwegen/binary_sensor.py

@@ -0,0 +1,120 @@
+"""Support for Nederlandse Spoorwegen public transport."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+import logging
+
+from ns_api import Trip
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, INTEGRATION_TITLE, ROUTE_MODEL
+from .coordinator import NSConfigEntry, NSDataUpdateCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 0  # since we use coordinator pattern
+
+
+@dataclass(frozen=True, kw_only=True)
+class NSBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Describes Nederlandse Spoorwegen sensor entity."""
+
+    value_fn: Callable[[Trip], bool]
+
+
+def get_delay(planned: datetime | None, actual: datetime | None) -> bool:
+    """Return True if delay is present, False otherwise."""
+    return bool(planned and actual and planned != actual)
+
+
+BINARY_SENSOR_DESCRIPTIONS = [
+    NSBinarySensorEntityDescription(
+        key="is_departure_delayed",
+        translation_key="is_departure_delayed",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda trip: get_delay(
+            trip.departure_time_planned, trip.departure_time_actual
+        ),
+        entity_registry_enabled_default=False,
+    ),
+    NSBinarySensorEntityDescription(
+        key="is_arrival_delayed",
+        translation_key="is_arrival_delayed",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda trip: get_delay(
+            trip.arrival_time_planned, trip.arrival_time_actual
+        ),
+        entity_registry_enabled_default=False,
+    ),
+    NSBinarySensorEntityDescription(
+        key="is_going",
+        translation_key="is_going",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda trip: trip.going,
+        entity_registry_enabled_default=False,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: NSConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the departure sensor from a config entry."""
+
+    coordinators = config_entry.runtime_data
+
+    for subentry_id, coordinator in coordinators.items():
+        async_add_entities(
+            (
+                NSBinarySensor(coordinator, subentry_id, description)
+                for description in BINARY_SENSOR_DESCRIPTIONS
+            ),
+            config_subentry_id=subentry_id,
+        )
+
+
+class NSBinarySensor(CoordinatorEntity[NSDataUpdateCoordinator], BinarySensorEntity):
+    """Generic NS binary sensor based on entity description."""
+
+    _attr_has_entity_name = True
+    _attr_attribution = "Data provided by NS"
+    entity_description: NSBinarySensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: NSDataUpdateCoordinator,
+        subentry_id: str,
+        description: NSBinarySensorEntityDescription,
+    ) -> None:
+        """Initialize the binary sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._subentry_id = subentry_id
+        self._attr_unique_id = f"{subentry_id}-{description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, subentry_id)},
+            name=coordinator.name,
+            manufacturer=INTEGRATION_TITLE,
+            model=ROUTE_MODEL,
+        )
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the binary sensor is on."""
+        if not (trip := self.coordinator.data.first_trip):
+            return None
+        return self.entity_description.value_fn(trip)

homeassistant/components/nederlandse_spoorwegen/icons.json

@@ -0,0 +1,15 @@
+{
+  "entity": {
+    "binary_sensor": {
+      "is_arrival_delayed": {
+        "default": "mdi:bell-alert-outline"
+      },
+      "is_departure_delayed": {
+        "default": "mdi:bell-alert-outline"
+      },
+      "is_going": {
+        "default": "mdi:bell-cancel-outline"
+      }
+    }
+  }
+}

homeassistant/components/nederlandse_spoorwegen/sensor.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import logging
 from typing import Any
 
+from ns_api import Trip
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
@@ -38,6 +39,33 @@ from .const import (
 )
 from .coordinator import NSConfigEntry, NSDataUpdateCoordinator
 
+
+def _get_departure_time(trip: Trip | None) -> datetime | None:
+    """Get next departure time from trip data."""
+    return trip.departure_time_actual or trip.departure_time_planned if trip else None
+
+
+def _get_time_str(time: datetime | None) -> str | None:
+    """Get time as string."""
+    return time.strftime("%H:%M") if time else None
+
+
+def _get_route(trip: Trip | None) -> list[str]:
+    """Get the route as a list of station names from trip data."""
+    if not trip or not (trip_parts := trip.trip_parts):
+        return []
+    route = []
+    if departure := trip.departure:
+        route.append(departure)
+    route.extend(part.destination for part in trip_parts)
+    return route
+
+
+def _get_delay(planned: datetime | None, actual: datetime | None) -> bool:
+    """Return True if delay is present, False otherwise."""
+    return bool(planned and actual and planned != actual)
+
+
 _LOGGER = logging.getLogger(__name__)
 
 ROUTE_SCHEMA = vol.Schema(
@@ -127,7 +155,7 @@ async def async_setup_entry(
 
 
 class NSDepartureSensor(CoordinatorEntity[NSDataUpdateCoordinator], SensorEntity):
-    """Implementation of a NS Departure Sensor."""
+    """Implementation of a NS Departure Sensor (legacy)."""
 
     _attr_device_class = SensorDeviceClass.TIMESTAMP
     _attr_attribution = "Data provided by NS"
@@ -163,94 +191,40 @@ class NSDepartureSensor(CoordinatorEntity[NSDataUpdateCoordinator], SensorEntity
             return None
 
         first_trip = route_data.first_trip
-        if first_trip.departure_time_actual:
-            return first_trip.departure_time_actual
-        return first_trip.departure_time_planned
+        return _get_departure_time(first_trip)
 
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:
         """Return the state attributes."""
-        route_data = self.coordinator.data
-        if not route_data:
-            return None
-
-        first_trip = route_data.first_trip
-        next_trip = route_data.next_trip
+        first_trip = self.coordinator.data.first_trip
+        next_trip = self.coordinator.data.next_trip
 
         if not first_trip:
             return None
 
-        route = []
-        if first_trip.trip_parts:
-            route = [first_trip.departure]
-            route.extend(k.destination for k in first_trip.trip_parts)
+        status = first_trip.status
 
-        # Static attributes
-        attributes = {
+        return {
             "going": first_trip.going,
-            "departure_time_planned": None,
-            "departure_time_actual": None,
-            "departure_delay": False,
+            "departure_time_planned": _get_time_str(first_trip.departure_time_planned),
+            "departure_time_actual": _get_time_str(first_trip.departure_time_actual),
+            "departure_delay": _get_delay(
+                first_trip.departure_time_planned,
+                first_trip.departure_time_actual,
+            ),
             "departure_platform_planned": first_trip.departure_platform_planned,
             "departure_platform_actual": first_trip.departure_platform_actual,
-            "arrival_time_planned": None,
-            "arrival_time_actual": None,
-            "arrival_delay": False,
+            "arrival_time_planned": _get_time_str(first_trip.arrival_time_planned),
+            "arrival_time_actual": _get_time_str(first_trip.arrival_time_actual),
+            "arrival_delay": _get_delay(
+                first_trip.arrival_time_planned,
+                first_trip.arrival_time_actual,
+            ),
             "arrival_platform_planned": first_trip.arrival_platform_planned,
             "arrival_platform_actual": first_trip.arrival_platform_actual,
-            "next": None,
-            "status": first_trip.status.lower() if first_trip.status else None,
+            "next": _get_time_str(_get_departure_time(next_trip)),
+            "status": status.lower() if status else None,
             "transfers": first_trip.nr_transfers,
-            "route": route,
+            "route": _get_route(first_trip),
             "remarks": None,
         }
-
-        # Planned departure attributes
-        if first_trip.departure_time_planned is not None:
-            attributes["departure_time_planned"] = (
-                first_trip.departure_time_planned.strftime("%H:%M")
-            )
-
-        # Actual departure attributes
-        if first_trip.departure_time_actual is not None:
-            attributes["departure_time_actual"] = (
-                first_trip.departure_time_actual.strftime("%H:%M")
-            )
-
-        # Delay departure attributes
-        if (
-            attributes["departure_time_planned"]
-            and attributes["departure_time_actual"]
-            and attributes["departure_time_planned"]
-            != attributes["departure_time_actual"]
-        ):
-            attributes["departure_delay"] = True
-
-        # Planned arrival attributes
-        if first_trip.arrival_time_planned is not None:
-            attributes["arrival_time_planned"] = (
-                first_trip.arrival_time_planned.strftime("%H:%M")
-            )
-
-        # Actual arrival attributes
-        if first_trip.arrival_time_actual is not None:
-            attributes["arrival_time_actual"] = first_trip.arrival_time_actual.strftime(
-                "%H:%M"
-            )
-
-        # Delay arrival attributes
-        if (
-            attributes["arrival_time_planned"]
-            and attributes["arrival_time_actual"]
-            and attributes["arrival_time_planned"] != attributes["arrival_time_actual"]
-        ):
-            attributes["arrival_delay"] = True
-
-        # Next trip attributes
-        if next_trip:
-            if next_trip.departure_time_actual is not None:
-                attributes["next"] = next_trip.departure_time_actual.strftime("%H:%M")
-            elif next_trip.departure_time_planned is not None:
-                attributes["next"] = next_trip.departure_time_planned.strftime("%H:%M")
-
-        return attributes

homeassistant/components/nederlandse_spoorwegen/strings.json

@@ -64,6 +64,19 @@
       }
     }
   },
+  "entity": {
+    "binary_sensor": {
+      "is_arrival_delayed": {
+        "name": "Arrival delayed"
+      },
+      "is_departure_delayed": {
+        "name": "Departure delayed"
+      },
+      "is_going": {
+        "name": "Going"
+      }
+    }
+  },
   "issues": {
     "deprecated_yaml_import_issue_cannot_connect": {
       "description": "Configuring Nederlandse Spoorwegen using YAML sensor platform is deprecated.\n\nWhile importing your configuration, Home Assistant could not connect to the NS API. Please check your internet connection and the status of the NS API, then restart Home Assistant to try again, or remove the existing YAML configuration and set the integration up via the UI.",

homeassistant/components/nest/manifest.json

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

homeassistant/components/nest/quality_scale.yaml

@@ -1,8 +1,6 @@
 rules:
   # Bronze
-  config-flow:
-    status: todo
-    comment: Some fields are missing a data_description
+  config-flow: done
   brands: done
   dependency-transparency: done
   common-modules:

homeassistant/components/nest/strings.json

@@ -34,6 +34,9 @@
         "data": {
           "cloud_project_id": "Google Cloud Project ID"
         },
+        "data_description": {
+          "cloud_project_id": "The Google Cloud Project ID which can be obtained from the Cloud Console"
+        },
         "description": "Enter the Cloud Project ID below e.g. *example-project-12345*. See the [Google Cloud Console]({cloud_console_url}) or the documentation for [more info]({more_info_url}).",
         "title": "Nest: Enter Cloud Project ID"
       },
@@ -45,6 +48,9 @@
         "data": {
           "project_id": "Device Access Project ID"
         },
+        "data_description": {
+          "project_id": "The Device Access Project ID which can be obtained from the Device Access Console"
+        },
         "description": "Create a Nest Device Access project which **requires paying Google a US $5 fee** to set up.\n1. Go to the [Device Access Console]({device_access_console_url}), and through the payment flow.\n1. Select on **Create project**\n1. Give your Device Access project a name and select **Next**.\n1. Enter your OAuth Client ID\n1. Skip enabling events for now and select **Create project**.\n\nEnter your Device Access Project ID below ([more info]({more_info_url})).",
         "title": "Nest: Create a Device Access Project"
       },
@@ -64,6 +70,9 @@
         "data": {
           "subscription_name": "Pub/Sub subscription name"
         },
+        "data_description": {
+          "subscription_name": "The Pub/Sub subscription name to receive Nest device updates"
+        },
         "description": "Home Assistant receives realtime Nest device updates with a Cloud Pub/Sub subscription for topic `{topic}`.\n\nSelect an existing subscription below if one already exists, or the next step will create a new one for you. See the integration documentation for [more info]({more_info_url}).",
         "title": "Configure Cloud Pub/Sub subscription"
       },
@@ -71,6 +80,9 @@
         "data": {
           "topic_name": "Pub/Sub topic name"
         },
+        "data_description": {
+          "topic_name": "The Pub/Sub topic name configured in the Device Access Console"
+        },
         "description": "Nest devices publish updates on a Cloud Pub/Sub topic. You can select an existing topic if one exists, or choose to create a new topic and the next step will create it for you with the necessary permissions. See the integration documentation for [more info]({more_info_url}).",
         "title": "Configure Cloud Pub/Sub topic"
       },

homeassistant/components/ohme/__init__.py

@@ -11,7 +11,6 @@ from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, PLATFORMS
 from .coordinator import (
-    OhmeAdvancedSettingsCoordinator,
     OhmeChargeSessionCoordinator,
     OhmeConfigEntry,
     OhmeDeviceInfoCoordinator,
@@ -56,7 +55,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: OhmeConfigEntry) -> bool
 
     coordinators = (
         OhmeChargeSessionCoordinator(hass, entry, client),
-        OhmeAdvancedSettingsCoordinator(hass, entry, client),
         OhmeDeviceInfoCoordinator(hass, entry, client),
     )
 

homeassistant/components/ohme/coordinator.py

@@ -10,7 +10,7 @@ import logging
 from ohme import ApiException, OhmeApiClient
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN
@@ -23,7 +23,6 @@ class OhmeRuntimeData:
     """Dataclass to hold ohme coordinators."""
 
     charge_session_coordinator: OhmeChargeSessionCoordinator
-    advanced_settings_coordinator: OhmeAdvancedSettingsCoordinator
     device_info_coordinator: OhmeDeviceInfoCoordinator
 
 
@@ -78,31 +77,6 @@ class OhmeChargeSessionCoordinator(OhmeBaseCoordinator):
         await self.client.async_get_charge_session()
 
 
-class OhmeAdvancedSettingsCoordinator(OhmeBaseCoordinator):
-    """Coordinator to pull settings and charger state from the API."""
-
-    coordinator_name = "Advanced Settings"
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: OhmeConfigEntry, client: OhmeApiClient
-    ) -> None:
-        """Initialise coordinator."""
-        super().__init__(hass, config_entry, client)
-
-        @callback
-        def _dummy_listener() -> None:
-            pass
-
-        # This coordinator is used by the API library to determine whether the
-        # charger is online and available. It is therefore required even if no
-        # entities are using it.
-        self.async_add_listener(_dummy_listener)
-
-    async def _internal_update_data(self) -> None:
-        """Fetch data from API endpoint."""
-        await self.client.async_get_advanced_settings()
-
-
 class OhmeDeviceInfoCoordinator(OhmeBaseCoordinator):
     """Coordinator to pull device info and charger settings from the API."""
 

homeassistant/components/ohme/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["ohme==1.5.2"]
+  "requirements": ["ohme==1.6.0"]
 }

homeassistant/components/ohme/sensor.py

@@ -37,7 +37,7 @@ class OhmeSensorDescription(OhmeEntityDescription, SensorEntityDescription):
     value_fn: Callable[[OhmeApiClient], str | int | float | None]
 
 
-SENSOR_CHARGE_SESSION = [
+SENSORS = [
     OhmeSensorDescription(
         key="status",
         translation_key="status",
@@ -91,18 +91,6 @@ SENSOR_CHARGE_SESSION = [
     ),
 ]
 
-SENSOR_ADVANCED_SETTINGS = [
-    OhmeSensorDescription(
-        key="ct_current",
-        translation_key="ct_current",
-        device_class=SensorDeviceClass.CURRENT,
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        value_fn=lambda client: client.power.ct_amps,
-        is_supported_fn=lambda client: client.ct_connected,
-        entity_registry_enabled_default=False,
-    ),
-]
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -110,16 +98,11 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up sensors."""
-    coordinators = config_entry.runtime_data
-    coordinator_map = [
-        (SENSOR_CHARGE_SESSION, coordinators.charge_session_coordinator),
-        (SENSOR_ADVANCED_SETTINGS, coordinators.advanced_settings_coordinator),
-    ]
+    coordinator = config_entry.runtime_data.charge_session_coordinator
 
     async_add_entities(
         OhmeSensor(coordinator, description)
-        for entities, coordinator in coordinator_map
-        for description in entities
+        for description in SENSORS
         if description.is_supported_fn(coordinator.client)
     )
 

homeassistant/components/plugwise/select.py

@@ -37,6 +37,7 @@ SELECT_TYPES = (
     PlugwiseSelectEntityDescription(
         key=SELECT_SCHEDULE,
         translation_key=SELECT_SCHEDULE,
+        entity_category=EntityCategory.CONFIG,
         options_key="available_schedules",
     ),
     PlugwiseSelectEntityDescription(

homeassistant/components/plugwise/sensor.py

@@ -48,7 +48,6 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     PlugwiseSensorEntityDescription(
         key="setpoint_high",
@@ -56,7 +55,6 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     PlugwiseSensorEntityDescription(
         key="setpoint_low",
@@ -64,13 +62,11 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     PlugwiseSensorEntityDescription(
         key="temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
@@ -94,6 +90,7 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
         translation_key="outdoor_temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
@@ -352,8 +349,8 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
         key="illuminance",
         native_unit_of_measurement=LIGHT_LUX,
         device_class=SensorDeviceClass.ILLUMINANCE,
-        state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
         key="modulation_level",
@@ -365,8 +362,8 @@ SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
     PlugwiseSensorEntityDescription(
         key="valve_position",
         translation_key="valve_position",
-        entity_category=EntityCategory.DIAGNOSTIC,
         native_unit_of_measurement=PERCENTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(

homeassistant/components/reolink/host.py

@@ -222,17 +222,13 @@ class ReolinkHost:
         enable_onvif = None
         enable_rtmp = None
 
-        if not self._api.rtsp_enabled and not self._api.baichuan_only:
+        if not self._api.rtsp_enabled and self._api.supported(None, "RTSP"):
             _LOGGER.debug(
                 "RTSP is disabled on %s, trying to enable it", self._api.nvr_name
             )
             enable_rtsp = True
 
-        if (
-            not self._api.onvif_enabled
-            and onvif_supported
-            and not self._api.baichuan_only
-        ):
+        if not self._api.onvif_enabled and onvif_supported:
             _LOGGER.debug(
                 "ONVIF is disabled on %s, trying to enable it", self._api.nvr_name
             )

homeassistant/components/rest_command/__init__.py

@@ -10,6 +10,7 @@ from typing import Any
 import aiohttp
 from aiohttp import hdrs
 import voluptuous as vol
+from yarl import URL
 
 from homeassistant.const import (
     CONF_AUTHENTICATION,
@@ -51,6 +52,7 @@ SUPPORT_REST_METHODS = ["get", "patch", "post", "put", "delete"]
 
 CONF_CONTENT_TYPE = "content_type"
 CONF_INSECURE_CIPHER = "insecure_cipher"
+CONF_SKIP_URL_ENCODING = "skip_url_encoding"
 
 COMMAND_SCHEMA = vol.Schema(
     {
@@ -69,6 +71,7 @@ COMMAND_SCHEMA = vol.Schema(
         vol.Optional(CONF_CONTENT_TYPE): cv.string,
         vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean,
         vol.Optional(CONF_INSECURE_CIPHER, default=False): cv.boolean,
+        vol.Optional(CONF_SKIP_URL_ENCODING, default=False): cv.boolean,
     }
 )
 
@@ -113,6 +116,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         method = command_config[CONF_METHOD]
 
         template_url = command_config[CONF_URL]
+        skip_url_encoding = command_config[CONF_SKIP_URL_ENCODING]
 
         auth = None
         digest_middleware = None
@@ -179,7 +183,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                     request_kwargs["middlewares"] = (digest_middleware,)
 
                 async with getattr(websession, method)(
-                    request_url,
+                    URL(request_url, encoded=skip_url_encoding),
                     **request_kwargs,
                 ) as response:
                     if response.status < HTTPStatus.BAD_REQUEST:

homeassistant/components/samsungtv/config_flow.py

@@ -441,7 +441,7 @@ class SamsungTVConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def is_matching(self, other_flow: Self) -> bool:
         """Return True if other_flow is matching this flow."""
-        return other_flow._host == self._host  # noqa: SLF001
+        return getattr(other_flow, "_host", None) == self._host
 
     @callback
     def _abort_if_manufacturer_is_not_samsung(self) -> None:

homeassistant/components/satel_integra/quality_scale.yaml

@@ -7,23 +7,23 @@ rules:
     status: exempt
     comment: This integration does not poll.
   brands: done
-  common-modules: todo
-  config-flow-test-coverage: todo
-  config-flow: todo
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
   dependency-transparency: todo
   docs-actions:
     status: exempt
     comment: This integration does not provide any service actions.
-  docs-high-level-description: todo
-  docs-installation-instructions: todo
-  docs-removal-instructions: todo
-  entity-event-setup: todo
-  entity-unique-id: todo
-  has-entity-name: todo
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
-  unique-config-entry: todo
+  unique-config-entry: done
 
   # Silver
   action-exceptions: todo

homeassistant/components/shelly/binary_sensor.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Final, cast
 
+from aioshelly.block_device import Block
 from aioshelly.const import RPC_GENERATIONS
 
 from homeassistant.components.binary_sensor import (
@@ -16,10 +17,11 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import STATE_ON, EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.entity_registry import RegistryEntry
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .const import CONF_SLEEP_PERIOD, MODEL_FRANKEVER_WATER_VALVE, ROLE_GENERIC
-from .coordinator import ShellyConfigEntry, ShellyRpcCoordinator
+from .coordinator import ShellyBlockCoordinator, ShellyConfigEntry, ShellyRpcCoordinator
 from .entity import (
     BlockEntityDescription,
     RestEntityDescription,
@@ -37,6 +39,10 @@ from .utils import (
     async_remove_orphaned_entities,
     get_blu_trv_device_info,
     get_device_entry_gen,
+    get_entity_translation_attributes,
+    get_rpc_channel_name,
+    get_rpc_custom_name,
+    get_rpc_key,
     is_block_momentary_input,
     is_rpc_momentary_input,
     is_view_for_platform,
@@ -67,6 +73,44 @@ class RpcBinarySensor(ShellyRpcAttributeEntity, BinarySensorEntity):
 
     entity_description: RpcBinarySensorDescription
 
+    def __init__(
+        self,
+        coordinator: ShellyRpcCoordinator,
+        key: str,
+        attribute: str,
+        description: RpcBinarySensorDescription,
+    ) -> None:
+        """Initialize sensor."""
+        super().__init__(coordinator, key, attribute, description)
+
+        if hasattr(self, "_attr_name") and description.role != ROLE_GENERIC:
+            if not description.role and description.key == "input":
+                _, component, component_id = get_rpc_key(key)
+                if not get_rpc_custom_name(coordinator.device, key) and (
+                    component.lower() == "input" and component_id.isnumeric()
+                ):
+                    self._attr_translation_placeholders = {"input_number": component_id}
+                    self._attr_translation_key = "input_with_number"
+                else:
+                    return
+
+            delattr(self, "_attr_name")
+
+        if not description.role and description.key != "input":
+            translation_placeholders, translation_key = (
+                get_entity_translation_attributes(
+                    get_rpc_channel_name(coordinator.device, key),
+                    description.translation_key,
+                    description.device_class,
+                    self._default_to_device_class_name(),
+                )
+            )
+
+            if translation_placeholders:
+                self._attr_translation_placeholders = translation_placeholders
+                if translation_key:
+                    self._attr_translation_key = translation_key
+
     @property
     def is_on(self) -> bool:
         """Return true if RPC sensor state is on."""
@@ -107,85 +151,84 @@ class RpcBluTrvBinarySensor(RpcBinarySensor):
 SENSORS: dict[tuple[str, str], BlockBinarySensorDescription] = {
     ("device", "overtemp"): BlockBinarySensorDescription(
         key="device|overtemp",
-        name="Overheating",
+        translation_key="overheating",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     ("device", "overpower"): BlockBinarySensorDescription(
         key="device|overpower",
-        name="Overpowering",
+        translation_key="overpowering",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     ("light", "overpower"): BlockBinarySensorDescription(
         key="light|overpower",
-        name="Overpowering",
+        translation_key="overpowering",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     ("relay", "overpower"): BlockBinarySensorDescription(
         key="relay|overpower",
-        name="Overpowering",
+        translation_key="overpowering",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     ("sensor", "dwIsOpened"): BlockBinarySensorDescription(
         key="sensor|dwIsOpened",
-        name="Door",
+        translation_key="door",
         device_class=BinarySensorDeviceClass.OPENING,
         available=lambda block: cast(int, block.dwIsOpened) != -1,
     ),
     ("sensor", "flood"): BlockBinarySensorDescription(
-        key="sensor|flood", name="Flood", device_class=BinarySensorDeviceClass.MOISTURE
+        key="sensor|flood",
+        translation_key="flood",
+        device_class=BinarySensorDeviceClass.MOISTURE,
     ),
     ("sensor", "gas"): BlockBinarySensorDescription(
         key="sensor|gas",
-        name="Gas",
         device_class=BinarySensorDeviceClass.GAS,
-        translation_key="gas",
         value=lambda value: value in ["mild", "heavy"],
     ),
     ("sensor", "smoke"): BlockBinarySensorDescription(
-        key="sensor|smoke", name="Smoke", device_class=BinarySensorDeviceClass.SMOKE
+        key="sensor|smoke", device_class=BinarySensorDeviceClass.SMOKE
     ),
     ("sensor", "vibration"): BlockBinarySensorDescription(
         key="sensor|vibration",
-        name="Vibration",
         device_class=BinarySensorDeviceClass.VIBRATION,
     ),
     ("input", "input"): BlockBinarySensorDescription(
         key="input|input",
-        name="Input",
+        translation_key="input",
         device_class=BinarySensorDeviceClass.POWER,
         removal_condition=is_block_momentary_input,
     ),
     ("relay", "input"): BlockBinarySensorDescription(
         key="relay|input",
-        name="Input",
+        translation_key="input",
         device_class=BinarySensorDeviceClass.POWER,
         removal_condition=is_block_momentary_input,
     ),
     ("device", "input"): BlockBinarySensorDescription(
         key="device|input",
-        name="Input",
+        translation_key="input",
         device_class=BinarySensorDeviceClass.POWER,
         removal_condition=is_block_momentary_input,
     ),
     ("sensor", "extInput"): BlockBinarySensorDescription(
         key="sensor|extInput",
-        name="External input",
+        translation_key="external_input",
         device_class=BinarySensorDeviceClass.POWER,
         entity_registry_enabled_default=False,
     ),
     ("sensor", "motion"): BlockBinarySensorDescription(
-        key="sensor|motion", name="Motion", device_class=BinarySensorDeviceClass.MOTION
+        key="sensor|motion", device_class=BinarySensorDeviceClass.MOTION
     ),
 }
 
 REST_SENSORS: Final = {
     "cloud": RestBinarySensorDescription(
         key="cloud",
-        name="Cloud",
+        translation_key="cloud",
         value=lambda status, _: status["cloud"]["connected"],
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_registry_enabled_default=False,
@@ -197,13 +240,14 @@ RPC_SENSORS: Final = {
     "input": RpcBinarySensorDescription(
         key="input",
         sub_key="state",
+        translation_key="input",
         device_class=BinarySensorDeviceClass.POWER,
         removal_condition=is_rpc_momentary_input,
     ),
     "cloud": RpcBinarySensorDescription(
         key="cloud",
         sub_key="connected",
-        name="Cloud",
+        translation_key="cloud",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -211,7 +255,7 @@ RPC_SENSORS: Final = {
     "external_power": RpcBinarySensorDescription(
         key="devicepower",
         sub_key="external",
-        name="External power",
+        translation_key="external_power",
         value=lambda status, _: status["present"],
         device_class=BinarySensorDeviceClass.POWER,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -219,7 +263,7 @@ RPC_SENSORS: Final = {
     "overtemp": RpcBinarySensorDescription(
         key="switch",
         sub_key="errors",
-        name="Overheating",
+        translation_key="overheating",
         device_class=BinarySensorDeviceClass.PROBLEM,
         value=lambda status, _: False if status is None else "overtemp" in status,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -228,7 +272,7 @@ RPC_SENSORS: Final = {
     "overpower": RpcBinarySensorDescription(
         key="switch",
         sub_key="errors",
-        name="Overpowering",
+        translation_key="overpowering",
         device_class=BinarySensorDeviceClass.PROBLEM,
         value=lambda status, _: False if status is None else "overpower" in status,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -237,7 +281,7 @@ RPC_SENSORS: Final = {
     "overvoltage": RpcBinarySensorDescription(
         key="switch",
         sub_key="errors",
-        name="Overvoltage",
+        translation_key="overvoltage",
         device_class=BinarySensorDeviceClass.PROBLEM,
         value=lambda status, _: False if status is None else "overvoltage" in status,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -246,7 +290,7 @@ RPC_SENSORS: Final = {
     "overcurrent": RpcBinarySensorDescription(
         key="switch",
         sub_key="errors",
-        name="Overcurrent",
+        translation_key="overcurrent",
         device_class=BinarySensorDeviceClass.PROBLEM,
         value=lambda status, _: False if status is None else "overcurrent" in status,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -255,13 +299,12 @@ RPC_SENSORS: Final = {
     "smoke": RpcBinarySensorDescription(
         key="smoke",
         sub_key="alarm",
-        name="Smoke",
         device_class=BinarySensorDeviceClass.SMOKE,
     ),
     "restart": RpcBinarySensorDescription(
         key="sys",
         sub_key="restart_required",
-        name="Restart required",
+        translation_key="restart_required",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -269,7 +312,7 @@ RPC_SENSORS: Final = {
     "boolean_generic": RpcBinarySensorDescription(
         key="boolean",
         sub_key="value",
-        removal_condition=lambda config, _status, key: not is_view_for_platform(
+        removal_condition=lambda config, _, key: not is_view_for_platform(
             config, key, BINARY_SENSOR_PLATFORM
         ),
         role=ROLE_GENERIC,
@@ -285,7 +328,7 @@ RPC_SENSORS: Final = {
     "calibration": RpcBinarySensorDescription(
         key="blutrv",
         sub_key="errors",
-        name="Calibration",
+        translation_key="calibration",
         device_class=BinarySensorDeviceClass.PROBLEM,
         value=lambda status, _: False if status is None else "not_calibrated" in status,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -294,13 +337,13 @@ RPC_SENSORS: Final = {
     "flood": RpcBinarySensorDescription(
         key="flood",
         sub_key="alarm",
-        name="Flood",
+        translation_key="flood",
         device_class=BinarySensorDeviceClass.MOISTURE,
     ),
     "mute": RpcBinarySensorDescription(
         key="flood",
         sub_key="mute",
-        name="Mute",
+        translation_key="mute",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "flood_cable_unplugged": RpcBinarySensorDescription(
@@ -309,7 +352,7 @@ RPC_SENSORS: Final = {
         value=lambda status, _: False
         if status is None
         else "cable_unplugged" in status,
-        name="Cable unplugged",
+        translation_key="cable_unplugged",
         device_class=BinarySensorDeviceClass.PROBLEM,
         entity_category=EntityCategory.DIAGNOSTIC,
         supported=lambda status: status.get("alarm") is not None,
@@ -318,14 +361,12 @@ RPC_SENSORS: Final = {
         key="presence",
         sub_key="num_objects",
         value=lambda status, _: bool(status),
-        name="Occupancy",
         device_class=BinarySensorDeviceClass.OCCUPANCY,
         entity_class=RpcPresenceBinarySensor,
     ),
     "presencezone_state": RpcBinarySensorDescription(
         key="presencezone",
         sub_key="value",
-        name="Occupancy",
         device_class=BinarySensorDeviceClass.OCCUPANCY,
         entity_class=RpcPresenceBinarySensor,
     ),
@@ -413,6 +454,19 @@ class BlockBinarySensor(ShellyBlockAttributeEntity, BinarySensorEntity):
 
     entity_description: BlockBinarySensorDescription
 
+    def __init__(
+        self,
+        coordinator: ShellyBlockCoordinator,
+        block: Block,
+        attribute: str,
+        description: BlockBinarySensorDescription,
+    ) -> None:
+        """Initialize sensor."""
+        super().__init__(coordinator, block, attribute, description)
+
+        if hasattr(self, "_attr_name"):
+            delattr(self, "_attr_name")
+
     @property
     def is_on(self) -> bool:
         """Return true if sensor state is on."""
@@ -424,6 +478,18 @@ class RestBinarySensor(ShellyRestAttributeEntity, BinarySensorEntity):
 
     entity_description: RestBinarySensorDescription
 
+    def __init__(
+        self,
+        coordinator: ShellyBlockCoordinator,
+        attribute: str,
+        description: RestBinarySensorDescription,
+    ) -> None:
+        """Initialize sensor."""
+        super().__init__(coordinator, attribute, description)
+
+        if hasattr(self, "_attr_name"):
+            delattr(self, "_attr_name")
+
     @property
     def is_on(self) -> bool:
         """Return true if REST sensor state is on."""
@@ -437,6 +503,20 @@ class BlockSleepingBinarySensor(
 
     entity_description: BlockBinarySensorDescription
 
+    def __init__(
+        self,
+        coordinator: ShellyBlockCoordinator,
+        block: Block | None,
+        attribute: str,
+        description: BlockBinarySensorDescription,
+        entry: RegistryEntry | None = None,
+    ) -> None:
+        """Initialize the sleeping sensor."""
+        super().__init__(coordinator, block, attribute, description, entry)
+
+        if hasattr(self, "_attr_name"):
+            delattr(self, "_attr_name")
+
     async def async_added_to_hass(self) -> None:
         """Handle entity which will be added."""
         await super().async_added_to_hass()
@@ -461,6 +541,35 @@ class RpcSleepingBinarySensor(
 
     entity_description: RpcBinarySensorDescription
 
+    def __init__(
+        self,
+        coordinator: ShellyRpcCoordinator,
+        key: str,
+        attribute: str,
+        description: RpcBinarySensorDescription,
+        entry: RegistryEntry | None = None,
+    ) -> None:
+        """Initialize the sleeping sensor."""
+        super().__init__(coordinator, key, attribute, description, entry)
+
+        if coordinator.device.initialized:
+            if hasattr(self, "_attr_name"):
+                delattr(self, "_attr_name")
+
+            translation_placeholders, translation_key = (
+                get_entity_translation_attributes(
+                    get_rpc_channel_name(coordinator.device, key),
+                    description.translation_key,
+                    description.device_class,
+                    self._default_to_device_class_name(),
+                )
+            )
+
+            if translation_placeholders:
+                self._attr_translation_placeholders = translation_placeholders
+                if translation_key:
+                    self._attr_translation_key = translation_key
+
     async def async_added_to_hass(self) -> None:
         """Handle entity which will be added."""
         await super().async_added_to_hass()

homeassistant/components/shelly/sensor.py

@@ -1919,8 +1919,23 @@ class RpcSleepingSensor(ShellySleepingRpcAttributeEntity, RestoreSensor):
         super().__init__(coordinator, key, attribute, description, entry)
         self.restored_data: SensorExtraStoredData | None = None
 
-        if hasattr(self, "_attr_name"):
-            delattr(self, "_attr_name")
+        if coordinator.device.initialized:
+            if hasattr(self, "_attr_name"):
+                delattr(self, "_attr_name")
+
+            translation_placeholders, translation_key = (
+                get_entity_translation_attributes(
+                    get_rpc_channel_name(coordinator.device, key),
+                    description.translation_key,
+                    description.device_class,
+                    self._default_to_device_class_name(),
+                )
+            )
+
+            if translation_placeholders:
+                self._attr_translation_placeholders = translation_placeholders
+                if translation_key:
+                    self._attr_translation_key = translation_key
 
     async def async_added_to_hass(self) -> None:
         """Handle entity which will be added."""

homeassistant/components/shelly/strings.json

@@ -129,6 +129,80 @@
     }
   },
   "entity": {
+    "binary_sensor": {
+      "cable_unplugged": {
+        "name": "Cable unplugged"
+      },
+      "cable_unplugged_with_channel_name": {
+        "name": "{channel_name} cable unplugged"
+      },
+      "calibration": {
+        "name": "Calibration"
+      },
+      "cloud": {
+        "name": "Cloud"
+      },
+      "door": {
+        "name": "Door"
+      },
+      "external_input": {
+        "name": "External input"
+      },
+      "external_power": {
+        "name": "External power"
+      },
+      "flood": {
+        "name": "Flood"
+      },
+      "flood_with_channel_name": {
+        "name": "{channel_name} flood"
+      },
+      "input": {
+        "name": "Input"
+      },
+      "input_with_number": {
+        "name": "Input {input_number}"
+      },
+      "mute": {
+        "name": "Mute"
+      },
+      "mute_with_channel_name": {
+        "name": "{channel_name} mute"
+      },
+      "occupancy_with_channel_name": {
+        "name": "{channel_name} occupancy"
+      },
+      "overcurrent": {
+        "name": "Overcurrent"
+      },
+      "overcurrent_with_channel_name": {
+        "name": "{channel_name} overcurrent"
+      },
+      "overheating": {
+        "name": "Overheating"
+      },
+      "overheating_with_channel_name": {
+        "name": "{channel_name} overheating"
+      },
+      "overpowering": {
+        "name": "Overpowering"
+      },
+      "overpowering_with_channel_name": {
+        "name": "{channel_name} overpowering"
+      },
+      "overvoltage": {
+        "name": "Overvoltage"
+      },
+      "overvoltage_with_channel_name": {
+        "name": "{channel_name} overvoltage"
+      },
+      "restart_required": {
+        "name": "Restart required"
+      },
+      "smoke_with_channel_name": {
+        "name": "{channel_name} smoke"
+      }
+    },
     "button": {
       "calibrate": {
         "name": "Calibrate"

homeassistant/components/shelly/utils.py

@@ -391,7 +391,13 @@ def get_shelly_model_name(
     return cast(str, MODEL_NAMES.get(model))
 
 
-def get_rpc_component_name(device: RpcDevice, key: str) -> str | None:
+def get_rpc_key(value: str) -> tuple[bool, str, str]:
+    """Get split device key."""
+    parts = value.split(":")
+    return len(parts) > 1, parts[0], parts[-1]
+
+
+def get_rpc_custom_name(device: RpcDevice, key: str) -> str | None:
     """Get component name from device config."""
     if (
         key in device.config
@@ -403,6 +409,11 @@ def get_rpc_component_name(device: RpcDevice, key: str) -> str | None:
     return None
 
 
+def get_rpc_component_name(device: RpcDevice, key: str) -> str | None:
+    """Get component name from device config."""
+    return get_rpc_custom_name(device, key)
+
+
 def get_rpc_channel_name(device: RpcDevice, key: str) -> str | None:
     """Get name based on device and channel name."""
     if BLU_TRV_IDENTIFIER in key:
@@ -414,11 +425,11 @@ def get_rpc_channel_name(device: RpcDevice, key: str) -> str | None:
     component = key.split(":")[0]
     component_id = key.split(":")[-1]
 
-    if component_name := get_rpc_component_name(device, key):
+    if custom_name := get_rpc_custom_name(device, key):
         if component in (*VIRTUAL_COMPONENTS, "input", "presencezone", "script"):
-            return component_name
+            return custom_name
 
-        return component_name if instances == 1 else None
+        return custom_name if instances == 1 else None
 
     if component in (*VIRTUAL_COMPONENTS, "input"):
         return f"{component.title()} {component_id}"

homeassistant/components/sonos/manifest.json

@@ -9,7 +9,11 @@
   "iot_class": "local_push",
   "loggers": ["soco", "sonos_websocket"],
   "quality_scale": "bronze",
-  "requirements": ["soco==0.30.12", "sonos-websocket==0.1.3"],
+  "requirements": [
+    "defusedxml==0.7.1",
+    "soco==0.30.12",
+    "sonos-websocket==0.1.3"
+  ],
   "ssdp": [
     {
       "st": "urn:schemas-upnp-org:device:ZonePlayer:1"

homeassistant/components/tuya/binary_sensor.py

@@ -372,7 +372,7 @@ class _CustomDPCodeWrapper(DPCodeWrapper):
     _valid_values: set[bool | float | int | str]
 
     def __init__(
-        self, dpcode: str, valid_values: set[bool | float | int | str]
+        self, dpcode: DPCode, valid_values: set[bool | float | int | str]
     ) -> None:
         """Init CustomDPCodeBooleanWrapper."""
         super().__init__(dpcode)
@@ -390,7 +390,7 @@ def _get_dpcode_wrapper(
     description: TuyaBinarySensorEntityDescription,
 ) -> DPCodeWrapper | None:
     """Get DPCode wrapper for an entity description."""
-    dpcode = description.dpcode or description.key
+    dpcode = description.dpcode or DPCode(description.key)
     if description.bitmap_key is not None:
         return DPCodeBitmapBitWrapper.find_dpcode(
             device, dpcode, bitmap_key=description.bitmap_key

homeassistant/components/tuya/light.py

@@ -32,12 +32,110 @@ from .entity import TuyaEntity
 from .models import (
     DPCodeBooleanWrapper,
     DPCodeEnumWrapper,
+    DPCodeIntegerWrapper,
     IntegerTypeData,
-    find_dpcode,
 )
 from .util import get_dpcode, get_dptype, remap_value
 
 
+class _BrightnessWrapper(DPCodeIntegerWrapper):
+    """Wrapper for brightness DP code.
+
+    Handles brightness value conversion between device scale and Home Assistant's
+    0-255 scale. Supports optional dynamic brightness_min and brightness_max
+    wrappers that allow the device to specify runtime brightness range limits.
+    """
+
+    brightness_min: DPCodeIntegerWrapper | None = None
+    brightness_max: DPCodeIntegerWrapper | None = None
+
+    def read_device_status(self, device: CustomerDevice) -> Any | None:
+        """Return the brightness of this light between 0..255."""
+        if (brightness := self._read_device_status_raw(device)) is None:
+            return None
+
+        # Remap value to our scale
+        brightness = self.type_information.remap_value_to(brightness)
+
+        # If there is a min/max value, the brightness is actually limited.
+        # Meaning it is actually not on a 0-255 scale.
+        if (
+            self.brightness_max is not None
+            and self.brightness_min is not None
+            and (brightness_max := device.status.get(self.brightness_max.dpcode))
+            is not None
+            and (brightness_min := device.status.get(self.brightness_min.dpcode))
+            is not None
+        ):
+            # Remap values onto our scale
+            brightness_max = self.brightness_max.type_information.remap_value_to(
+                brightness_max
+            )
+            brightness_min = self.brightness_min.type_information.remap_value_to(
+                brightness_min
+            )
+
+            # Remap the brightness value from their min-max to our 0-255 scale
+            brightness = remap_value(
+                brightness, from_min=brightness_min, from_max=brightness_max
+            )
+
+        return round(brightness)
+
+    def _convert_value_to_raw_value(self, device: CustomerDevice, value: Any) -> Any:
+        """Convert a Home Assistant value (0..255) back to a raw device value."""
+        # If there is a min/max value, the brightness is actually limited.
+        # Meaning it is actually not on a 0-255 scale.
+        if (
+            self.brightness_max is not None
+            and self.brightness_min is not None
+            and (brightness_max := device.status.get(self.brightness_max.dpcode))
+            is not None
+            and (brightness_min := device.status.get(self.brightness_min.dpcode))
+            is not None
+        ):
+            # Remap values onto our scale
+            brightness_max = self.brightness_max.type_information.remap_value_to(
+                brightness_max
+            )
+            brightness_min = self.brightness_min.type_information.remap_value_to(
+                brightness_min
+            )
+
+            # Remap the brightness value from our 0-255 scale to their min-max
+            value = remap_value(value, to_min=brightness_min, to_max=brightness_max)
+        return round(self.type_information.remap_value_from(value))
+
+
+class _ColorTempWrapper(DPCodeIntegerWrapper):
+    """Wrapper for color temperature DP code."""
+
+    def read_device_status(self, device: CustomerDevice) -> Any | None:
+        """Return the color temperature value in Kelvin."""
+        if (temperature := self._read_device_status_raw(device)) is None:
+            return None
+
+        return color_util.color_temperature_mired_to_kelvin(
+            self.type_information.remap_value_to(
+                temperature,
+                MIN_MIREDS,
+                MAX_MIREDS,
+                reverse=True,
+            )
+        )
+
+    def _convert_value_to_raw_value(self, device: CustomerDevice, value: Any) -> Any:
+        """Convert a Home Assistant value (Kelvin) back to a raw device value."""
+        return round(
+            self.type_information.remap_value_from(
+                color_util.color_temperature_kelvin_to_mired(value),
+                MIN_MIREDS,
+                MAX_MIREDS,
+                reverse=True,
+            )
+        )
+
+
 @dataclass
 class ColorTypeData:
     """Color Type Data."""
@@ -48,15 +146,27 @@ class ColorTypeData:
 
 
 DEFAULT_COLOR_TYPE_DATA = ColorTypeData(
-    h_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1),
-    s_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1),
-    v_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1),
+    h_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1
+    ),
+    s_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1
+    ),
+    v_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1
+    ),
 )
 
 DEFAULT_COLOR_TYPE_DATA_V2 = ColorTypeData(
-    h_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1),
-    s_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1),
-    v_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1),
+    h_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1
+    ),
+    s_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1
+    ),
+    v_type=IntegerTypeData(
+        dpcode=DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1
+    ),
 )
 
 MAX_MIREDS = 500  # 2000 K
@@ -417,6 +527,24 @@ class ColorData:
         return round(self.type_data.v_type.remap_value_to(self.v_value, 0, 255))
 
 
+def _get_brightness_wrapper(
+    device: CustomerDevice, description: TuyaLightEntityDescription
+) -> _BrightnessWrapper | None:
+    if (
+        brightness_wrapper := _BrightnessWrapper.find_dpcode(
+            device, description.brightness, prefer_function=True
+        )
+    ) is None:
+        return None
+    brightness_wrapper.brightness_max = DPCodeIntegerWrapper.find_dpcode(
+        device, description.brightness_max, prefer_function=True
+    )
+    brightness_wrapper.brightness_min = DPCodeIntegerWrapper.find_dpcode(
+        device, description.brightness_min, prefer_function=True
+    )
+    return brightness_wrapper
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: TuyaConfigEntry,
@@ -437,9 +565,13 @@ async def async_setup_entry(
                         device,
                         manager,
                         description,
+                        brightness_wrapper=_get_brightness_wrapper(device, description),
                         color_mode_wrapper=DPCodeEnumWrapper.find_dpcode(
                             device, description.color_mode, prefer_function=True
                         ),
+                        color_temp_wrapper=_ColorTempWrapper.find_dpcode(
+                            device, description.color_temp, prefer_function=True
+                        ),
                         switch_wrapper=switch_wrapper,
                     )
                     for description in descriptions
@@ -464,12 +596,8 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
 
     entity_description: TuyaLightEntityDescription
 
-    _brightness_max: IntegerTypeData | None = None
-    _brightness_min: IntegerTypeData | None = None
-    _brightness: IntegerTypeData | None = None
     _color_data_dpcode: DPCode | None = None
     _color_data_type: ColorTypeData | None = None
-    _color_temp: IntegerTypeData | None = None
     _white_color_mode = ColorMode.COLOR_TEMP
     _fixed_color_mode: ColorMode | None = None
     _attr_min_color_temp_kelvin = 2000  # 500 Mireds
@@ -481,32 +609,24 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
         device_manager: Manager,
         description: TuyaLightEntityDescription,
         *,
+        brightness_wrapper: _BrightnessWrapper | None,
         color_mode_wrapper: DPCodeEnumWrapper | None,
+        color_temp_wrapper: _ColorTempWrapper | None,
         switch_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init TuyaHaLight."""
         super().__init__(device, device_manager)
         self.entity_description = description
         self._attr_unique_id = f"{super().unique_id}{description.key}"
+        self._brightness_wrapper = brightness_wrapper
         self._color_mode_wrapper = color_mode_wrapper
+        self._color_temp_wrapper = color_temp_wrapper
         self._switch_wrapper = switch_wrapper
 
         color_modes: set[ColorMode] = {ColorMode.ONOFF}
 
-        if int_type := find_dpcode(
-            self.device,
-            description.brightness,
-            dptype=DPType.INTEGER,
-            prefer_function=True,
-        ):
-            self._brightness = int_type
+        if brightness_wrapper:
             color_modes.add(ColorMode.BRIGHTNESS)
-            self._brightness_max = find_dpcode(
-                self.device, description.brightness_max, dptype=DPType.INTEGER
-            )
-            self._brightness_min = find_dpcode(
-                self.device, description.brightness_min, dptype=DPType.INTEGER
-            )
 
         if (dpcode := get_dpcode(self.device, description.color_data)) and (
             get_dptype(self.device, dpcode, prefer_function=True) == DPType.JSON
@@ -521,26 +641,27 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
             # Fetch color data type information
             if function_data := json_loads_object(values):
                 self._color_data_type = ColorTypeData(
-                    h_type=IntegerTypeData(dpcode, **cast(dict, function_data["h"])),
-                    s_type=IntegerTypeData(dpcode, **cast(dict, function_data["s"])),
-                    v_type=IntegerTypeData(dpcode, **cast(dict, function_data["v"])),
+                    h_type=IntegerTypeData(
+                        dpcode=dpcode, **cast(dict, function_data["h"])
+                    ),
+                    s_type=IntegerTypeData(
+                        dpcode=dpcode, **cast(dict, function_data["s"])
+                    ),
+                    v_type=IntegerTypeData(
+                        dpcode=dpcode, **cast(dict, function_data["v"])
+                    ),
                 )
             else:
                 # If no type is found, use a default one
                 self._color_data_type = self.entity_description.default_color_type
                 if self._color_data_dpcode == DPCode.COLOUR_DATA_V2 or (
-                    self._brightness and self._brightness.max > 255
+                    self._brightness_wrapper
+                    and self._brightness_wrapper.type_information.max > 255
                 ):
                     self._color_data_type = DEFAULT_COLOR_TYPE_DATA_V2
 
         # Check if the light has color temperature
-        if int_type := find_dpcode(
-            self.device,
-            description.color_temp,
-            dptype=DPType.INTEGER,
-            prefer_function=True,
-        ):
-            self._color_temp = int_type
+        if color_temp_wrapper:
             color_modes.add(ColorMode.COLOR_TEMP)
         # If light has color but does not have color_temp, check if it has
         # work_mode "white"
@@ -577,21 +698,11 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
                 ),
             ]
 
-        if self._color_temp and ATTR_COLOR_TEMP_KELVIN in kwargs:
+        if self._color_temp_wrapper and ATTR_COLOR_TEMP_KELVIN in kwargs:
             commands += [
-                {
-                    "code": self._color_temp.dpcode,
-                    "value": round(
-                        self._color_temp.remap_value_from(
-                            color_util.color_temperature_kelvin_to_mired(
-                                kwargs[ATTR_COLOR_TEMP_KELVIN]
-                            ),
-                            MIN_MIREDS,
-                            MAX_MIREDS,
-                            reverse=True,
-                        )
-                    ),
-                },
+                self._color_temp_wrapper.get_update_command(
+                    self.device, kwargs[ATTR_COLOR_TEMP_KELVIN]
+                )
             ]
 
         if self._color_data_type and (
@@ -641,46 +752,16 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
                 },
             ]
 
-        elif self._brightness and (ATTR_BRIGHTNESS in kwargs or ATTR_WHITE in kwargs):
+        elif self._brightness_wrapper and (
+            ATTR_BRIGHTNESS in kwargs or ATTR_WHITE in kwargs
+        ):
             if ATTR_BRIGHTNESS in kwargs:
                 brightness = kwargs[ATTR_BRIGHTNESS]
             else:
                 brightness = kwargs[ATTR_WHITE]
 
-            # If there is a min/max value, the brightness is actually limited.
-            # Meaning it is actually not on a 0-255 scale.
-            if (
-                self._brightness_max is not None
-                and self._brightness_min is not None
-                and (
-                    brightness_max := self.device.status.get(
-                        self._brightness_max.dpcode
-                    )
-                )
-                is not None
-                and (
-                    brightness_min := self.device.status.get(
-                        self._brightness_min.dpcode
-                    )
-                )
-                is not None
-            ):
-                # Remap values onto our scale
-                brightness_max = self._brightness_max.remap_value_to(brightness_max)
-                brightness_min = self._brightness_min.remap_value_to(brightness_min)
-
-                # Remap the brightness value from their min-max to our 0-255 scale
-                brightness = remap_value(
-                    brightness,
-                    to_min=brightness_min,
-                    to_max=brightness_max,
-                )
-
             commands += [
-                {
-                    "code": self._brightness.dpcode,
-                    "value": round(self._brightness.remap_value_from(brightness)),
-                },
+                self._brightness_wrapper.get_update_command(self.device, brightness),
             ]
 
         self._send_command(commands)
@@ -691,59 +772,17 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
 
     @property
     def brightness(self) -> int | None:
-        """Return the brightness of the light."""
+        """Return the brightness of this light between 0..255."""
         # If the light is currently in color mode, extract the brightness from the color data
         if self.color_mode == ColorMode.HS and (color_data := self._get_color_data()):
             return color_data.brightness
 
-        if not self._brightness:
-            return None
-
-        brightness = self.device.status.get(self._brightness.dpcode)
-        if brightness is None:
-            return None
-
-        # Remap value to our scale
-        brightness = self._brightness.remap_value_to(brightness)
-
-        # If there is a min/max value, the brightness is actually limited.
-        # Meaning it is actually not on a 0-255 scale.
-        if (
-            self._brightness_max is not None
-            and self._brightness_min is not None
-            and (brightness_max := self.device.status.get(self._brightness_max.dpcode))
-            is not None
-            and (brightness_min := self.device.status.get(self._brightness_min.dpcode))
-            is not None
-        ):
-            # Remap values onto our scale
-            brightness_max = self._brightness_max.remap_value_to(brightness_max)
-            brightness_min = self._brightness_min.remap_value_to(brightness_min)
-
-            # Remap the brightness value from their min-max to our 0-255 scale
-            brightness = remap_value(
-                brightness,
-                from_min=brightness_min,
-                from_max=brightness_max,
-            )
-
-        return round(brightness)
+        return self._read_wrapper(self._brightness_wrapper)
 
     @property
     def color_temp_kelvin(self) -> int | None:
         """Return the color temperature value in Kelvin."""
-        if not self._color_temp:
-            return None
-
-        temperature = self.device.status.get(self._color_temp.dpcode)
-        if temperature is None:
-            return None
-
-        return color_util.color_temperature_mired_to_kelvin(
-            self._color_temp.remap_value_to(
-                temperature, MIN_MIREDS, MAX_MIREDS, reverse=True
-            )
-        )
+        return self._read_wrapper(self._color_temp_wrapper)
 
     @property
     def hs_color(self) -> tuple[float, float] | None:

homeassistant/components/tuya/models.py

@@ -15,7 +15,7 @@ from .const import DPCode, DPType
 from .util import parse_dptype, remap_value
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TypeInformation:
     """Type information.
 
@@ -23,14 +23,15 @@ class TypeInformation:
     """
 
     dpcode: DPCode
+    type_data: str | None = None
 
     @classmethod
-    def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
+    def from_json(cls, dpcode: DPCode, type_data: str) -> Self | None:
         """Load JSON string and return a TypeInformation object."""
-        return cls(dpcode)
+        return cls(dpcode=dpcode, type_data=type_data)
 
 
-@dataclass
+@dataclass(kw_only=True)
 class IntegerTypeData(TypeInformation):
     """Integer Type Data."""
 
@@ -84,13 +85,14 @@ class IntegerTypeData(TypeInformation):
         return remap_value(value, from_min, from_max, self.min, self.max, reverse)
 
     @classmethod
-    def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
+    def from_json(cls, dpcode: DPCode, type_data: str) -> Self | None:
         """Load JSON string and return a IntegerTypeData object."""
-        if not (parsed := cast(dict[str, Any] | None, json_loads_object(data))):
+        if not (parsed := cast(dict[str, Any] | None, json_loads_object(type_data))):
             return None
 
         return cls(
-            dpcode,
+            dpcode=dpcode,
+            type_data=type_data,
             min=int(parsed["min"]),
             max=int(parsed["max"]),
             scale=int(parsed["scale"]),
@@ -99,32 +101,40 @@ class IntegerTypeData(TypeInformation):
         )
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BitmapTypeInformation(TypeInformation):
     """Bitmap type information."""
 
     label: list[str]
 
     @classmethod
-    def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
+    def from_json(cls, dpcode: DPCode, type_data: str) -> Self | None:
         """Load JSON string and return a BitmapTypeInformation object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json_loads_object(type_data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(
+            dpcode=dpcode,
+            type_data=type_data,
+            **cast(dict[str, list[str]], parsed),
+        )
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnumTypeData(TypeInformation):
     """Enum Type Data."""
 
     range: list[str]
 
     @classmethod
-    def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
+    def from_json(cls, dpcode: DPCode, type_data: str) -> Self | None:
         """Load JSON string and return a EnumTypeData object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json_loads_object(type_data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(
+            dpcode=dpcode,
+            type_data=type_data,
+            **cast(dict[str, list[str]], parsed),
+        )
 
 
 _TYPE_INFORMATION_MAPPINGS: dict[DPType, type[TypeInformation]] = {
@@ -147,7 +157,7 @@ class DPCodeWrapper(ABC):
     native_unit: str | None = None
     suggested_unit: str | None = None
 
-    def __init__(self, dpcode: str) -> None:
+    def __init__(self, dpcode: DPCode) -> None:
         """Init DPCodeWrapper."""
         self.dpcode = dpcode
 
@@ -190,7 +200,7 @@ class DPCodeTypeInformationWrapper[T: TypeInformation](DPCodeWrapper):
     DPTYPE: DPType
     type_information: T
 
-    def __init__(self, dpcode: str, type_information: T) -> None:
+    def __init__(self, dpcode: DPCode, type_information: T) -> None:
         """Init DPCodeWrapper."""
         super().__init__(dpcode)
         self.type_information = type_information
@@ -297,7 +307,7 @@ class DPCodeIntegerWrapper(DPCodeTypeInformationWrapper[IntegerTypeData]):
 
     DPTYPE = DPType.INTEGER
 
-    def __init__(self, dpcode: str, type_information: IntegerTypeData) -> None:
+    def __init__(self, dpcode: DPCode, type_information: IntegerTypeData) -> None:
         """Init DPCodeIntegerWrapper."""
         super().__init__(dpcode, type_information)
         self.native_unit = type_information.unit
@@ -327,7 +337,7 @@ class DPCodeIntegerWrapper(DPCodeTypeInformationWrapper[IntegerTypeData]):
 class DPCodeBitmapBitWrapper(DPCodeWrapper):
     """Simple wrapper for a specific bit in bitmap values."""
 
-    def __init__(self, dpcode: str, mask: int) -> None:
+    def __init__(self, dpcode: DPCode, mask: int) -> None:
         """Init DPCodeBitmapWrapper."""
         super().__init__(dpcode)
         self._mask = mask
@@ -428,7 +438,7 @@ def find_dpcode(
                 and parse_dptype(current_definition.type) is dptype
                 and (
                     type_information := type_information_cls.from_json(
-                        dpcode, current_definition.values
+                        dpcode=dpcode, type_data=current_definition.values
                     )
                 )
             ):

homeassistant/components/vagner_pool/__init__.py

@@ -0,0 +1 @@
+"""Virtual integration: VÁGNER POOL."""

homeassistant/components/vagner_pool/manifest.json

@@ -0,0 +1,6 @@
+{
+  "domain": "vagner_pool",
+  "name": "V\u00c1GNER POOL",
+  "integration_type": "virtual",
+  "supported_by": "pooldose"
+}

homeassistant/components/victron_ble/__init__.py

@@ -0,0 +1,54 @@
+"""The Victron Bluetooth Low Energy integration."""
+
+from __future__ import annotations
+
+import logging
+
+from victron_ble_ha_parser import VictronBluetoothDeviceData
+
+from homeassistant.components.bluetooth import (
+    BluetoothScanningMode,
+    async_rediscover_address,
+)
+from homeassistant.components.bluetooth.passive_update_processor import (
+    PassiveBluetoothProcessorCoordinator,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_ACCESS_TOKEN, Platform
+from homeassistant.core import HomeAssistant
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Victron BLE device from a config entry."""
+    address = entry.unique_id
+    assert address is not None
+    key = entry.data[CONF_ACCESS_TOKEN]
+    data = VictronBluetoothDeviceData(key)
+    coordinator = PassiveBluetoothProcessorCoordinator(
+        hass,
+        _LOGGER,
+        address=address,
+        mode=BluetoothScanningMode.ACTIVE,
+        update_method=data.update,
+    )
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, [Platform.SENSOR])
+    entry.async_on_unload(coordinator.async_start())
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+
+    unload_ok = await hass.config_entries.async_unload_platforms(
+        entry, [Platform.SENSOR]
+    )
+
+    if unload_ok:
+        async_rediscover_address(hass, entry.entry_id)
+
+    return unload_ok

homeassistant/components/victron_ble/config_flow.py

@@ -0,0 +1,123 @@
+"""Config flow for Victron Bluetooth Low Energy integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from victron_ble_ha_parser import VictronBluetoothDeviceData
+import voluptuous as vol
+
+from homeassistant.components.bluetooth import (
+    BluetoothServiceInfoBleak,
+    async_discovered_service_info,
+)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_ADDRESS
+
+from .const import DOMAIN, VICTRON_IDENTIFIER
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_ACCESS_TOKEN_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_ACCESS_TOKEN): str,
+    }
+)
+
+
+class VictronBLEConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Victron Bluetooth Low Energy."""
+
+    VERSION = 1
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovered_device: str | None = None
+        self._discovered_devices: dict[str, str] = {}
+        self._discovered_devices_info: dict[str, BluetoothServiceInfoBleak] = {}
+
+    async def async_step_bluetooth(
+        self, discovery_info: BluetoothServiceInfoBleak
+    ) -> ConfigFlowResult:
+        """Handle the bluetooth discovery step."""
+        _LOGGER.debug("async_step_bluetooth: %s", discovery_info.address)
+        await self.async_set_unique_id(discovery_info.address)
+        self._abort_if_unique_id_configured()
+        device = VictronBluetoothDeviceData()
+        if not device.supported(discovery_info):
+            _LOGGER.debug("device %s not supported", discovery_info.address)
+            return self.async_abort(reason="not_supported")
+
+        self._discovered_device = discovery_info.address
+        self._discovered_devices_info[discovery_info.address] = discovery_info
+        self._discovered_devices[discovery_info.address] = discovery_info.name
+
+        self.context["title_placeholders"] = {"title": discovery_info.name}
+
+        return await self.async_step_access_token()
+
+    async def async_step_access_token(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle advertisement key input."""
+        # should only be called if there are discovered devices
+        assert self._discovered_device is not None
+        discovery_info = self._discovered_devices_info[self._discovered_device]
+        title = discovery_info.name
+
+        if user_input is not None:
+            # see if we can create a device with the access token
+            device = VictronBluetoothDeviceData(user_input[CONF_ACCESS_TOKEN])
+            if device.validate_advertisement_key(
+                discovery_info.manufacturer_data[VICTRON_IDENTIFIER]
+            ):
+                return self.async_create_entry(
+                    title=title,
+                    data=user_input,
+                )
+            return self.async_abort(reason="invalid_access_token")
+
+        return self.async_show_form(
+            step_id="access_token",
+            data_schema=STEP_ACCESS_TOKEN_DATA_SCHEMA,
+            description_placeholders={"title": title},
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle select a device to set up."""
+        if user_input is not None:
+            address = user_input[CONF_ADDRESS]
+            await self.async_set_unique_id(address, raise_on_progress=False)
+            self._abort_if_unique_id_configured()
+            self._discovered_device = address
+            title = self._discovered_devices_info[address].name
+            return self.async_show_form(
+                step_id="access_token",
+                data_schema=STEP_ACCESS_TOKEN_DATA_SCHEMA,
+                description_placeholders={"title": title},
+            )
+
+        current_addresses = self._async_current_ids()
+        for discovery_info in async_discovered_service_info(self.hass, False):
+            address = discovery_info.address
+            if address in current_addresses or address in self._discovered_devices:
+                continue
+            device = VictronBluetoothDeviceData()
+            if device.supported(discovery_info):
+                self._discovered_devices_info[address] = discovery_info
+                self._discovered_devices[address] = discovery_info.name
+
+        if len(self._discovered_devices) < 1:
+            return self.async_abort(reason="no_devices_found")
+
+        _LOGGER.debug("Discovered %s devices", len(self._discovered_devices))
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {vol.Required(CONF_ADDRESS): vol.In(self._discovered_devices)}
+            ),
+        )

homeassistant/components/victron_ble/const.py

@@ -0,0 +1,4 @@
+"""Constants for the Victron Bluetooth Low Energy integration."""
+
+DOMAIN = "victron_ble"
+VICTRON_IDENTIFIER = 0x02E1

homeassistant/components/victron_ble/manifest.json

@@ -0,0 +1,19 @@
+{
+  "domain": "victron_ble",
+  "name": "Victron BLE",
+  "bluetooth": [
+    {
+      "connectable": false,
+      "manufacturer_data_start": [16],
+      "manufacturer_id": 737
+    }
+  ],
+  "codeowners": ["@rajlaud"],
+  "config_flow": true,
+  "dependencies": ["bluetooth_adapters"],
+  "documentation": "https://www.home-assistant.io/integrations/victron_ble",
+  "integration_type": "device",
+  "iot_class": "local_push",
+  "quality_scale": "bronze",
+  "requirements": ["victron-ble-ha-parser==0.4.9"]
+}

homeassistant/components/victron_ble/quality_scale.yaml

@@ -0,0 +1,85 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  appropriate-polling:
+    status: exempt
+    comment: |
+      This integration does not poll.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup:
+    status: exempt
+    comment: |
+      There is nothing to test, the integration just passively receives BLE advertisements.
+  unique-config-entry: done
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: This integration does not provide additional actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options to configure
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates:
+    status: done
+  reauthentication-flow:
+    status: todo
+  test-coverage: done
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: |
+      This integration does not use IP addresses. Bluetooth MAC addresses do not change.
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: |
+      This integration has a fixed single device per instance, and each device needs a user-supplied encryption key to set up.
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices:
+    status: exempt
+    comment: |
+      This integration has a fixed single device.
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/victron_ble/sensor.py

@@ -0,0 +1,474 @@
+"""Sensor platform for Victron BLE."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+import logging
+from typing import Any
+
+from sensor_state_data import DeviceKey
+from victron_ble_ha_parser import Keys, Units
+
+from homeassistant.components.bluetooth.passive_update_processor import (
+    PassiveBluetoothDataProcessor,
+    PassiveBluetoothDataUpdate,
+    PassiveBluetoothEntityKey,
+    PassiveBluetoothProcessorEntity,
+)
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    PERCENTAGE,
+    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+    UnitOfElectricCurrent,
+    UnitOfElectricPotential,
+    UnitOfEnergy,
+    UnitOfPower,
+    UnitOfTemperature,
+    UnitOfTime,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.sensor import sensor_device_info_to_hass_device_info
+
+LOGGER = logging.getLogger(__name__)
+
+AC_IN_OPTIONS = [
+    "ac_in_1",
+    "ac_in_2",
+    "not_connected",
+]
+
+ALARM_OPTIONS = [
+    "low_voltage",
+    "high_voltage",
+    "low_soc",
+    "low_starter_voltage",
+    "high_starter_voltage",
+    "low_temperature",
+    "high_temperature",
+    "mid_voltage",
+    "overload",
+    "dc_ripple",
+    "low_v_ac_out",
+    "high_v_ac_out",
+    "short_circuit",
+    "bms_lockout",
+]
+
+CHARGER_ERROR_OPTIONS = [
+    "no_error",
+    "temperature_battery_high",
+    "voltage_high",
+    "remote_temperature_auto_reset",
+    "remote_temperature_not_auto_reset",
+    "remote_battery",
+    "high_ripple",
+    "temperature_battery_low",
+    "temperature_charger",
+    "over_current",
+    "bulk_time",
+    "current_sensor",
+    "internal_temperature",
+    "fan",
+    "overheated",
+    "short_circuit",
+    "converter_issue",
+    "over_charge",
+    "input_voltage",
+    "input_current",
+    "input_power",
+    "input_shutdown_voltage",
+    "input_shutdown_current",
+    "input_shutdown_failure",
+    "inverter_shutdown_pv_isolation",
+    "inverter_shutdown_ground_fault",
+    "inverter_overload",
+    "inverter_temperature",
+    "inverter_peak_current",
+    "inverter_output_voltage",
+    "inverter_self_test",
+    "inverter_ac",
+    "communication",
+    "synchronisation",
+    "bms",
+    "network",
+    "pv_input_shutdown",
+    "cpu_temperature",
+    "calibration_lost",
+    "firmware",
+    "settings",
+    "tester_fail",
+    "internal_dc_voltage",
+    "self_test",
+    "internal_supply",
+]
+
+
+def error_to_state(value: float | str | None) -> str | None:
+    """Convert error code to state string."""
+    value_map: dict[Any, str] = {
+        "internal_supply_a": "internal_supply",
+        "internal_supply_b": "internal_supply",
+        "internal_supply_c": "internal_supply",
+        "internal_supply_d": "internal_supply",
+        "inverter_shutdown_41": "inverter_shutdown_pv_isolation",
+        "inverter_shutdown_42": "inverter_shutdown_pv_isolation",
+        "inverter_shutdown_43": "inverter_shutdown_ground_fault",
+        "internal_temperature_a": "internal_temperature",
+        "internal_temperature_b": "internal_temperature",
+        "inverter_output_voltage_a": "inverter_output_voltage",
+        "inverter_output_voltage_b": "inverter_output_voltage",
+        "internal_dc_voltage_a": "internal_dc_voltage",
+        "internal_dc_voltage_b": "internal_dc_voltage",
+        "remote_temperature_a": "remote_temperature_auto_reset",
+        "remote_temperature_b": "remote_temperature_auto_reset",
+        "remote_temperature_c": "remote_temperature_not_auto_reset",
+        "remote_battery_a": "remote_battery",
+        "remote_battery_b": "remote_battery",
+        "remote_battery_c": "remote_battery",
+        "pv_input_shutdown_80": "pv_input_shutdown",
+        "pv_input_shutdown_81": "pv_input_shutdown",
+        "pv_input_shutdown_82": "pv_input_shutdown",
+        "pv_input_shutdown_83": "pv_input_shutdown",
+        "pv_input_shutdown_84": "pv_input_shutdown",
+        "pv_input_shutdown_85": "pv_input_shutdown",
+        "pv_input_shutdown_86": "pv_input_shutdown",
+        "pv_input_shutdown_87": "pv_input_shutdown",
+        "inverter_self_test_a": "inverter_self_test",
+        "inverter_self_test_b": "inverter_self_test",
+        "inverter_self_test_c": "inverter_self_test",
+        "network_a": "network",
+        "network_b": "network",
+        "network_c": "network",
+        "network_d": "network",
+    }
+    return value_map.get(value)
+
+
+DEVICE_STATE_OPTIONS = [
+    "off",
+    "low_power",
+    "fault",
+    "bulk",
+    "absorption",
+    "float",
+    "storage",
+    "equalize_manual",
+    "inverting",
+    "power_supply",
+    "starting_up",
+    "repeated_absorption",
+    "recondition",
+    "battery_safe",
+    "active",
+    "external_control",
+    "not_available",
+]
+
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class VictronBLESensorEntityDescription(SensorEntityDescription):
+    """Describes Victron BLE sensor entity."""
+
+    value_fn: Callable[[float | int | str | None], float | int | str | None] = (
+        lambda x: x
+    )
+
+
+SENSOR_DESCRIPTIONS = {
+    Keys.AC_IN_POWER: VictronBLESensorEntityDescription(
+        key=Keys.AC_IN_POWER,
+        translation_key=Keys.AC_IN_POWER,
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.AC_IN_STATE: VictronBLESensorEntityDescription(
+        key=Keys.AC_IN_STATE,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="ac_in_state",
+        options=AC_IN_OPTIONS,
+    ),
+    Keys.AC_OUT_POWER: VictronBLESensorEntityDescription(
+        key=Keys.AC_OUT_POWER,
+        translation_key=Keys.AC_OUT_POWER,
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.AC_OUT_STATE: VictronBLESensorEntityDescription(
+        key=Keys.AC_OUT_STATE,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="device_state",
+        options=DEVICE_STATE_OPTIONS,
+    ),
+    Keys.ALARM: VictronBLESensorEntityDescription(
+        key=Keys.ALARM,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="alarm",
+        options=ALARM_OPTIONS,
+    ),
+    Keys.BALANCER_STATUS: VictronBLESensorEntityDescription(
+        key=Keys.BALANCER_STATUS,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="balancer_status",
+        options=["balanced", "balancing", "imbalance"],
+    ),
+    Keys.BATTERY_CURRENT: VictronBLESensorEntityDescription(
+        key=Keys.BATTERY_CURRENT,
+        translation_key=Keys.BATTERY_CURRENT,
+        device_class=SensorDeviceClass.CURRENT,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.BATTERY_TEMPERATURE: VictronBLESensorEntityDescription(
+        key=Keys.BATTERY_TEMPERATURE,
+        translation_key=Keys.BATTERY_TEMPERATURE,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.BATTERY_VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.BATTERY_VOLTAGE,
+        translation_key=Keys.BATTERY_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.CHARGER_ERROR: VictronBLESensorEntityDescription(
+        key=Keys.CHARGER_ERROR,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="charger_error",
+        options=CHARGER_ERROR_OPTIONS,
+        value_fn=error_to_state,
+    ),
+    Keys.CONSUMED_AMPERE_HOURS: VictronBLESensorEntityDescription(
+        key=Keys.CONSUMED_AMPERE_HOURS,
+        translation_key=Keys.CONSUMED_AMPERE_HOURS,
+        native_unit_of_measurement=Units.ELECTRIC_CURRENT_FLOW_AMPERE_HOUR,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.CURRENT: VictronBLESensorEntityDescription(
+        key=Keys.CURRENT,
+        device_class=SensorDeviceClass.CURRENT,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.DEVICE_STATE: VictronBLESensorEntityDescription(
+        key=Keys.DEVICE_STATE,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="device_state",
+        options=DEVICE_STATE_OPTIONS,
+    ),
+    Keys.ERROR_CODE: VictronBLESensorEntityDescription(
+        key=Keys.ERROR_CODE,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="charger_error",
+        options=CHARGER_ERROR_OPTIONS,
+    ),
+    Keys.EXTERNAL_DEVICE_LOAD: VictronBLESensorEntityDescription(
+        key=Keys.EXTERNAL_DEVICE_LOAD,
+        translation_key=Keys.EXTERNAL_DEVICE_LOAD,
+        device_class=SensorDeviceClass.CURRENT,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.INPUT_VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.INPUT_VOLTAGE,
+        translation_key=Keys.INPUT_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.METER_TYPE: VictronBLESensorEntityDescription(
+        key=Keys.METER_TYPE,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="meter_type",
+        options=[
+            "solar_charger",
+            "wind_charger",
+            "shaft_generator",
+            "alternator",
+            "fuel_cell",
+            "water_generator",
+            "dc_dc_charger",
+            "ac_charger",
+            "generic_source",
+            "generic_load",
+            "electric_drive",
+            "fridge",
+            "water_pump",
+            "bilge_pump",
+            "dc_system",
+            "inverter",
+            "water_heater",
+        ],
+    ),
+    Keys.MIDPOINT_VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.MIDPOINT_VOLTAGE,
+        translation_key=Keys.MIDPOINT_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.OFF_REASON: VictronBLESensorEntityDescription(
+        key=Keys.OFF_REASON,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="off_reason",
+        options=[
+            "no_reason",
+            "no_input_power",
+            "switched_off_switch",
+            "switched_off_register",
+            "remote_input",
+            "protection_active",
+            "pay_as_you_go_out_of_credit",
+            "bms",
+            "engine_shutdown",
+            "analysing_input_voltage",
+        ],
+    ),
+    Keys.OUTPUT_VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.OUTPUT_VOLTAGE,
+        translation_key=Keys.OUTPUT_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.REMAINING_MINUTES: VictronBLESensorEntityDescription(
+        key=Keys.REMAINING_MINUTES,
+        translation_key=Keys.REMAINING_MINUTES,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.MINUTES,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorDeviceClass.SIGNAL_STRENGTH: VictronBLESensorEntityDescription(
+        key=SensorDeviceClass.SIGNAL_STRENGTH.value,
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.SOLAR_POWER: VictronBLESensorEntityDescription(
+        key=Keys.SOLAR_POWER,
+        translation_key=Keys.SOLAR_POWER,
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.STARTER_VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.STARTER_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.STATE_OF_CHARGE: VictronBLESensorEntityDescription(
+        key=Keys.STATE_OF_CHARGE,
+        device_class=SensorDeviceClass.BATTERY,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.TEMPERATURE: VictronBLESensorEntityDescription(
+        key=Keys.TEMPERATURE,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.VOLTAGE: VictronBLESensorEntityDescription(
+        key=Keys.VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    Keys.WARNING: VictronBLESensorEntityDescription(
+        key=Keys.WARNING,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="alarm",
+        options=ALARM_OPTIONS,
+    ),
+    Keys.YIELD_TODAY: VictronBLESensorEntityDescription(
+        key=Keys.YIELD_TODAY,
+        translation_key=Keys.YIELD_TODAY,
+        device_class=SensorDeviceClass.ENERGY,
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+    ),
+}
+
+for i in range(1, 8):
+    cell_key = getattr(Keys, f"CELL_{i}_VOLTAGE")
+    SENSOR_DESCRIPTIONS[cell_key] = VictronBLESensorEntityDescription(
+        key=cell_key,
+        translation_key="cell_voltage",
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    )
+
+
+def _device_key_to_bluetooth_entity_key(
+    device_key: DeviceKey,
+) -> PassiveBluetoothEntityKey:
+    """Convert a device key to an entity key."""
+    return PassiveBluetoothEntityKey(device_key.key, device_key.device_id)
+
+
+def sensor_update_to_bluetooth_data_update(
+    sensor_update,
+) -> PassiveBluetoothDataUpdate:
+    """Convert a sensor update to a bluetooth data update."""
+    return PassiveBluetoothDataUpdate(
+        devices={
+            device_id: sensor_device_info_to_hass_device_info(device_info)
+            for device_id, device_info in sensor_update.devices.items()
+        },
+        entity_descriptions={
+            _device_key_to_bluetooth_entity_key(device_key): SENSOR_DESCRIPTIONS[
+                device_key.key
+            ]
+            for device_key in sensor_update.entity_descriptions
+            if device_key.key in SENSOR_DESCRIPTIONS
+        },
+        entity_data={
+            _device_key_to_bluetooth_entity_key(device_key): sensor_values.native_value
+            for device_key, sensor_values in sensor_update.entity_values.items()
+            if device_key.key in SENSOR_DESCRIPTIONS
+        },
+        entity_names={},
+    )
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Victron BLE sensor."""
+    coordinator = entry.runtime_data
+    processor = PassiveBluetoothDataProcessor(sensor_update_to_bluetooth_data_update)
+    entry.async_on_unload(
+        processor.async_add_entities_listener(
+            VictronBLESensorEntity, async_add_entities
+        )
+    )
+    entry.async_on_unload(coordinator.async_register_processor(processor))
+
+
+class VictronBLESensorEntity(PassiveBluetoothProcessorEntity, SensorEntity):
+    """Representation of Victron BLE sensor."""
+
+    entity_description: VictronBLESensorEntityDescription
+
+    @property
+    def native_value(self) -> float | int | str | None:
+        """Return the state of the sensor."""
+        value = self.processor.entity_data.get(self.entity_key)
+
+        return self.entity_description.value_fn(value)

homeassistant/components/victron_ble/strings.json

@@ -0,0 +1,234 @@
+{
+  "common": {
+    "high_voltage": "High voltage",
+    "low_voltage": "Low voltage",
+    "midpoint_voltage": "Midpoint voltage",
+    "starter_voltage": "Starter voltage"
+  },
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "invalid_access_token": "Invalid encryption key for instant readout",
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
+    },
+    "flow_title": "{title}",
+    "step": {
+      "access_token": {
+        "data": {
+          "access_token": "The encryption key for instant readout of the Victron device."
+        },
+        "data_description": {
+          "access_token": "The encryption key for instant readout may be found in the VictronConnect app under Settings > Product info > Instant readout details > Encryption data > Encryption Key."
+        },
+        "title": "{title}"
+      },
+      "user": {
+        "data": {
+          "address": "The Bluetooth address of the Victron device."
+        },
+        "data_description": {
+          "address": "This Bluetooth address is automatically discovered. You may view a device's Bluetooth address in the VictronConnect app under Settings > Product info > Instant readout details > Encryption data > MAC Address."
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ac_in_power": {
+        "name": "AC-in power"
+      },
+      "ac_in_state": {
+        "name": "AC-in state",
+        "state": {
+          "ac_in_1": "AC-in 1",
+          "ac_in_2": "AC-in 2",
+          "not_connected": "Not connected"
+        }
+      },
+      "ac_out_power": {
+        "name": "AC-out power"
+      },
+      "alarm": {
+        "name": "Alarm",
+        "state": {
+          "bms_lockout": "Battery management system lockout",
+          "dc_ripple": "DC ripple",
+          "high_starter_voltage": "High starter voltage",
+          "high_temperature": "High temperature",
+          "high_v_ac_out": "AC-out overvoltage",
+          "high_voltage": "Overvoltage",
+          "low_soc": "Low state of charge",
+          "low_starter_voltage": "Low starter voltage",
+          "low_temperature": "Low temperature",
+          "low_v_ac_out": "AC-out undervoltage",
+          "low_voltage": "Undervoltage",
+          "mid_voltage": "[%key:component::victron_ble::common::midpoint_voltage%]",
+          "overload": "Overload",
+          "short_circuit": "Short circuit"
+        }
+      },
+      "balancer_status": {
+        "name": "Balancer status",
+        "state": {
+          "balanced": "Balanced",
+          "balancing": "Balancing",
+          "imbalance": "Imbalance"
+        }
+      },
+      "battery_current": {
+        "name": "Battery current"
+      },
+      "battery_temperature": {
+        "name": "Battery temperature"
+      },
+      "battery_voltage": {
+        "name": "Battery voltage"
+      },
+      "cell_voltage": {
+        "name": "Cell {cell} voltage"
+      },
+      "charger_error": {
+        "name": "Charger error",
+        "state": {
+          "bms": "BMS connection lost",
+          "bulk_time": "Bulk time limit exceeded",
+          "calibration_lost": "Factory calibration data lost",
+          "communication": "Communication warning",
+          "converter_issue": "Converter issue",
+          "cpu_temperature": "CPU temperature too high",
+          "current_sensor": "Current sensor issue",
+          "fan": "Fan failure",
+          "firmware": "Invalid or incompatible firmware",
+          "high_ripple": "Battery high ripple voltage",
+          "input_current": "Input overcurrent",
+          "input_power": "Input overpower",
+          "input_shutdown_current": "Input shutdown (current flow during off mode)",
+          "input_shutdown_failure": "PV input failed to shutdown",
+          "input_shutdown_voltage": "Input shutdown (battery overvoltage)",
+          "input_voltage": "Input overvoltage",
+          "internal_dc_voltage": "Internal DC voltage error",
+          "internal_supply": "Internal supply voltage error",
+          "internal_temperature": "Internal temperature sensor failure",
+          "inverter_ac": "Inverter AC voltage on output",
+          "inverter_output_voltage": "Inverter output voltage",
+          "inverter_overload": "Inverter overload",
+          "inverter_peak_current": "Inverter peak current",
+          "inverter_self_test": "Inverter self-test failed",
+          "inverter_shutdown_ground_fault": "Inverter shutdown (Ground fault)",
+          "inverter_shutdown_pv_isolation": "Inverter shutdown (PV isolation)",
+          "inverter_temperature": "Inverter temperature too high",
+          "network": "Network misconfigured",
+          "no_error": "No error",
+          "over_charge": "Overcharge protection",
+          "over_current": "Charger overcurrent",
+          "overheated": "Terminals overheated",
+          "pv_input_shutdown": "PV input shutdown",
+          "remote_battery": "Remote battery voltage sense failure",
+          "remote_temperature_auto_reset": "Remote temperature sensor failure (auto-reset)",
+          "remote_temperature_not_auto_reset": "Remote temperature sensor failure (not auto-reset)",
+          "self_test": "PV residual current sensor self-test failure",
+          "settings": "Settings data lost",
+          "short_circuit": "Charger short circuit",
+          "synchronisation": "Synchronized charging device configuration issue",
+          "temperature_battery_high": "Battery temperature too high",
+          "temperature_battery_low": "Battery temperature too low",
+          "temperature_charger": "Charger temperature too high",
+          "tester_fail": "Tester fail",
+          "voltage_high": "Battery overvoltage"
+        }
+      },
+      "consumed_ampere_hours": {
+        "name": "Consumed ampere hours"
+      },
+      "device_state": {
+        "name": "Device state",
+        "state": {
+          "absorption": "Absorption",
+          "active": "Active",
+          "battery_safe": "Battery safe",
+          "bulk": "Bulk",
+          "equalize_manual": "Equalize (manual)",
+          "external_control": "External control",
+          "fault": "Fault",
+          "float": "Float",
+          "inverting": "Inverting",
+          "low_power": "Low power",
+          "not_available": "Not available",
+          "off": "[%key:common::state::off%]",
+          "power_supply": "Power supply",
+          "recondition": "Recondition",
+          "repeated_absorption": "Repeated absorption",
+          "starting_up": "Starting up",
+          "storage": "Storage"
+        }
+      },
+      "error_code": {
+        "name": "Error code"
+      },
+      "external_device_load": {
+        "name": "External device load"
+      },
+      "input_voltage": {
+        "name": "Input voltage"
+      },
+      "meter_type": {
+        "name": "Meter type",
+        "state": {
+          "ac_charger": "AC charger",
+          "alternator": "Alternator",
+          "bilge_pump": "Bilge pump",
+          "dc_dc_charger": "DC-DC charger",
+          "dc_system": "DC system",
+          "electric_drive": "Electric drive",
+          "fridge": "Fridge",
+          "fuel_cell": "Fuel cell",
+          "generic_load": "Generic load",
+          "generic_source": "Generic source",
+          "inverter": "Inverter",
+          "shaft_generator": "Shaft generator",
+          "solar_charger": "Solar charger",
+          "water_generator": "Water generator",
+          "water_heater": "Water heater",
+          "water_pump": "Water pump",
+          "wind_charger": "Wind charger"
+        }
+      },
+      "midpoint_voltage": {
+        "name": "[%key:component::victron_ble::common::midpoint_voltage%]"
+      },
+      "off_reason": {
+        "name": "Off reason",
+        "state": {
+          "analysing_input_voltage": "Analyzing input voltage",
+          "bms": "Battery management system",
+          "engine_shutdown": "Engine shutdown",
+          "no_input_power": "No input power",
+          "no_reason": "No reason",
+          "pay_as_you_go_out_of_credit": "Pay-as-you-go out of credit",
+          "protection_active": "Protection active",
+          "remote_input": "Remote input",
+          "switched_off_register": "Switched off by register",
+          "switched_off_switch": "Switched off by switch"
+        }
+      },
+      "output_voltage": {
+        "name": "Output voltage"
+      },
+      "remaining_minutes": {
+        "name": "Remaining minutes"
+      },
+      "solar_power": {
+        "name": "Solar power"
+      },
+      "starter_voltage": {
+        "name": "[%key:component::victron_ble::common::starter_voltage%]"
+      },
+      "warning": {
+        "name": "Warning"
+      },
+      "yield_today": {
+        "name": "Yield today"
+      }
+    }
+  }
+}

homeassistant/components/voip/assist_satellite.py

@@ -492,6 +492,7 @@ class VoipAssistSatellite(VoIPEntity, AssistSatelliteEntity, RtpDatagramProtocol
                 await asyncio.sleep(_ANNOUNCEMENT_AFTER_DELAY)
         except Exception:
             _LOGGER.exception("Unexpected error while playing announcement")
+            self._announcement = None
             raise
         finally:
             self._run_pipeline_task = None

homeassistant/components/xbox/browse_media.py

@@ -130,7 +130,7 @@ async def build_item_response(
     )
 
 
-def item_payload(item: InstalledPackage, images: dict[str, list[Image]]):
+def item_payload(item: InstalledPackage, images: dict[str, list[Image]]) -> BrowseMedia:
     """Create response payload for a single media item."""
     thumbnail = None
     image = _find_media_image(images.get(item.one_store_product_id, []))  # type: ignore[arg-type]

homeassistant/components/xbox/sensor.py

@@ -335,7 +335,7 @@ class XboxStorageDeviceSensorEntity(
         )
 
     @property
-    def data(self):
+    def data(self) -> StorageDevice | None:
         """Storage device data."""
         consoles = self.coordinator.data.result
         console = next((c for c in consoles if c.id == self._console.id), None)