Fix

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

.github/workflows/builder.yml

@@ -27,7 +27,7 @@ jobs:
       publish: ${{ steps.version.outputs.publish }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           fetch-depth: 0
 
@@ -94,7 +94,7 @@ jobs:
           - arch: i386
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Set build additional args
         run: |
@@ -265,7 +265,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:python"

.github/workflows/translations.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - 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/.+/(conditions|quality_scale|services|triggers)\.yaml|homeassistant/brands/.*\.json|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
+        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(quality_scale)\.yaml|homeassistant/brands/.*\.json|homeassistant/.+/services\.yaml|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

@@ -231,7 +231,6 @@ homeassistant.components.google_cloud.*
 homeassistant.components.google_drive.*
 homeassistant.components.google_photos.*
 homeassistant.components.google_sheets.*
-homeassistant.components.google_weather.*
 homeassistant.components.govee_ble.*
 homeassistant.components.gpsd.*
 homeassistant.components.greeneye_monitor.*
@@ -579,7 +578,6 @@ 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

@@ -516,6 +516,8 @@ build.json @home-assistant/supervisor
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
+/homeassistant/components/fluss/ @fluss
+/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -607,8 +609,6 @@ build.json @home-assistant/supervisor
 /tests/components/google_tasks/ @allenporter
 /homeassistant/components/google_travel_time/ @eifinger
 /tests/components/google_travel_time/ @eifinger
-/homeassistant/components/google_weather/ @tronikos
-/tests/components/google_weather/ @tronikos
 /homeassistant/components/govee_ble/ @bdraco
 /tests/components/govee_ble/ @bdraco
 /homeassistant/components/govee_light_local/ @Galorhallen
@@ -1376,8 +1376,6 @@ build.json @home-assistant/supervisor
 /tests/components/sanix/ @tomaszsluszniak
 /homeassistant/components/satel_integra/ @Tommatheussen
 /tests/components/satel_integra/ @Tommatheussen
-/homeassistant/components/saunum/ @mettolen
-/tests/components/saunum/ @mettolen
 /homeassistant/components/scene/ @home-assistant/core
 /tests/components/scene/ @home-assistant/core
 /homeassistant/components/schedule/ @home-assistant/core

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.11.0
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.11.0
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.11.0
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.11.0
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.11.0
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/brands/google.json

@@ -15,7 +15,6 @@
     "google_tasks",
     "google_translate",
     "google_travel_time",
-    "google_weather",
     "google_wifi",
     "google",
     "nest",

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, Platform.UPDATE]
+PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
 type AdGuardConfigEntry = ConfigEntry[AdGuardData]
 
 

homeassistant/components/adguard/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "loggers": ["adguardhome"],
-  "requirements": ["adguardhome==0.8.1"]
+  "requirements": ["adguardhome==0.7.0"]
 }

homeassistant/components/adguard/update.py

@@ -1,71 +0,0 @@
-"""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/alexa_devices/coordinator.py

@@ -16,7 +16,6 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
@@ -44,9 +43,6 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             name=entry.title,
             config_entry=entry,
             update_interval=timedelta(seconds=SCAN_INTERVAL),
-            request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=30, immediate=False
-            ),
         )
         self.api = AmazonEchoApi(
             session,

homeassistant/components/anthropic/config_flow.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from functools import partial
 import json
 import logging
-import re
 from typing import Any
 
 import anthropic
@@ -284,11 +283,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             vol.Optional(
                 CONF_CHAT_MODEL,
                 default=RECOMMENDED_CHAT_MODEL,
-            ): SelectSelector(
-                SelectSelectorConfig(
-                    options=await self._get_model_list(), custom_value=True
-                )
-            ),
+            ): str,
             vol.Optional(
                 CONF_MAX_TOKENS,
                 default=RECOMMENDED_MAX_TOKENS,
@@ -399,39 +394,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             last_step=True,
         )
 
-    async def _get_model_list(self) -> list[SelectOptionDict]:
-        """Get list of available models."""
-        try:
-            client = await self.hass.async_add_executor_job(
-                partial(
-                    anthropic.AsyncAnthropic,
-                    api_key=self._get_entry().data[CONF_API_KEY],
-                )
-            )
-            models = (await client.models.list()).data
-        except anthropic.AnthropicError:
-            models = []
-        _LOGGER.debug("Available models: %s", models)
-        model_options: list[SelectOptionDict] = []
-        short_form = re.compile(r"[^\d]-\d$")
-        for model_info in models:
-            # Resolve alias from versioned model name:
-            model_alias = (
-                model_info.id[:-9]
-                if model_info.id
-                not in ("claude-3-haiku-20240307", "claude-3-opus-20240229")
-                else model_info.id
-            )
-            if short_form.search(model_alias):
-                model_alias += "-0"
-            model_options.append(
-                SelectOptionDict(
-                    label=model_info.display_name,
-                    value=model_alias,
-                )
-            )
-        return model_options
-
     async def _get_location_data(self) -> dict[str, str]:
         """Get approximate location data of the user."""
         location_data: dict[str, str] = {}

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.73.0"]
+  "requirements": ["anthropic==0.69.0"]
 }

homeassistant/components/asuswrt/bridge.py

@@ -111,6 +111,8 @@ def handle_errors_and_zip[_AsusWrtBridgeT: AsusWrtBridge](
 
             if isinstance(data, dict):
                 return dict(zip(keys, list(data.values()), strict=False))
+            if not isinstance(data, (list, tuple)):
+                raise UpdateFailed("Received invalid data type")
             return dict(zip(keys, data, strict=False))
 
         return _wrapper

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==3.0.0",
+    "dbus-fast==2.45.0",
     "habluetooth==5.7.0"
   ]
 }

homeassistant/components/bsblan/climate.py

@@ -74,11 +74,8 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         super().__init__(data.fast_coordinator, data)
         self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"
 
-        # Set temperature range if available, otherwise use Home Assistant defaults
-        if data.static.min_temp is not None and data.static.min_temp.value is not None:
-            self._attr_min_temp = data.static.min_temp.value
-        if data.static.max_temp is not None and data.static.max_temp.value is not None:
-            self._attr_max_temp = data.static.max_temp.value
+        self._attr_min_temp = data.static.min_temp.value
+        self._attr_max_temp = data.static.max_temp.value
         self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
 
     @property

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.1"],
+  "requirements": ["python-bsblan==3.1.0"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/cloud/__init__.py

@@ -55,7 +55,6 @@ from .const import (
     CONF_ALIASES,
     CONF_API_SERVER,
     CONF_COGNITO_CLIENT_ID,
-    CONF_DISCOVERY_SERVICE_ACTIONS,
     CONF_ENTITY_CONFIG,
     CONF_FILTER,
     CONF_GOOGLE_ACTIONS,
@@ -140,7 +139,6 @@ CONFIG_SCHEMA = vol.Schema(
                 {
                     vol.Required(CONF_MODE): vol.In([MODE_DEV]),
                     vol.Required(CONF_API_SERVER): str,
-                    vol.Optional(CONF_DISCOVERY_SERVICE_ACTIONS): {str: cv.url},
                 }
             ),
             _BASE_CONFIG_SCHEMA.extend(

homeassistant/components/cloud/const.py

@@ -79,7 +79,6 @@ CONF_ACCOUNT_LINK_SERVER = "account_link_server"
 CONF_ACCOUNTS_SERVER = "accounts_server"
 CONF_ACME_SERVER = "acme_server"
 CONF_API_SERVER = "api_server"
-CONF_DISCOVERY_SERVICE_ACTIONS = "discovery_service_actions"
 CONF_RELAYER_SERVER = "relayer_server"
 CONF_REMOTESTATE_SERVER = "remotestate_server"
 CONF_SERVICEHANDLERS_SERVER = "servicehandlers_server"

homeassistant/components/cosori/__init__.py

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

homeassistant/components/cosori/manifest.json

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

homeassistant/components/cync/__init__.py

@@ -9,7 +9,6 @@ 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,
@@ -32,13 +31,9 @@ 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(
-            auth=cync_auth,
-            ssl_context=ssl_context,
-        )
+        cync = await Cync.create(cync_auth)
     except AuthFailedError as ex:
         raise ConfigEntryAuthFailed("User token invalid") from ex
     except CyncError as ex:

homeassistant/components/dlna_dmr/manifest.json

@@ -8,7 +8,7 @@
   "documentation": "https://www.home-assistant.io/integrations/dlna_dmr",
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
-  "requirements": ["async-upnp-client==0.46.0", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.45.0", "getmac==0.9.5"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/dlna_dms/manifest.json

@@ -7,7 +7,7 @@
   "dependencies": ["ssdp"],
   "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
   "iot_class": "local_polling",
-  "requirements": ["async-upnp-client==0.46.0"],
+  "requirements": ["async-upnp-client==0.45.0"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",

homeassistant/components/fluss/__init__.py

@@ -0,0 +1,31 @@
+"""The Fluss+ integration."""
+
+from __future__ import annotations
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import FlussDataUpdateCoordinator
+
+PLATFORMS: list[Platform] = [Platform.BUTTON]
+
+
+type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FlussConfigEntry,
+) -> bool:
+    """Set up Fluss+ from a config entry."""
+    coordinator = FlussDataUpdateCoordinator(hass, entry, entry.data[CONF_API_KEY])
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: FlussConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/fluss/button.py

@@ -0,0 +1,38 @@
+"""Support for Fluss Devices."""
+
+from homeassistant.components.button import ButtonEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import FlussApiClientError, FlussDataUpdateCoordinator
+from .entity import FlussEntity
+
+type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FlussConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Fluss Devices, filtering out any invalid payloads."""
+    coordinator = entry.runtime_data
+    devices = coordinator.data
+
+    async_add_entities(
+        FlussButton(coordinator, device_id, device)
+        for device_id, device in devices.items()
+    )
+
+
+class FlussButton(FlussEntity, ButtonEntity):
+    """Representation of a Fluss button device."""
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        try:
+            await self.coordinator.api.async_trigger_device(self.device_id)
+        except FlussApiClientError as err:
+            raise HomeAssistantError(f"Failed to trigger device: {err}") from err

homeassistant/components/fluss/config_flow.py

@@ -0,0 +1,54 @@
+"""Config flow for Fluss+ integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fluss_api import (
+    FlussApiClient,
+    FlussApiClientAuthenticationError,
+    FlussApiClientCommunicationError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN, LOGGER
+
+STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): cv.string})
+
+
+class FlussConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Fluss+."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            api_key = user_input[CONF_API_KEY]
+            self._async_abort_entries_match({CONF_API_KEY: api_key})
+            try:
+                FlussApiClient(
+                    user_input[CONF_API_KEY], session=async_get_clientsession(self.hass)
+                )
+            except FlussApiClientCommunicationError:
+                errors["base"] = "cannot_connect"
+            except FlussApiClientAuthenticationError:
+                errors["base"] = "invalid_auth"
+            except Exception:  # noqa: BLE001
+                LOGGER.exception("Unexpected exception occurred")
+                errors["base"] = "unknown"
+            if not errors:
+                return self.async_create_entry(
+                    title="My Fluss+ Devices", data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        )

homeassistant/components/fluss/const.py

@@ -0,0 +1,9 @@
+"""Constants for the Fluss+ integration."""
+
+from datetime import timedelta
+import logging
+
+DOMAIN = "fluss"
+LOGGER = logging.getLogger(__name__)
+UPDATE_INTERVAL = 60  # seconds
+UPDATE_INTERVAL_TIMEDELTA = timedelta(seconds=UPDATE_INTERVAL)

homeassistant/components/fluss/coordinator.py

@@ -0,0 +1,50 @@
+"""DataUpdateCoordinator for Fluss+ integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fluss_api import (
+    FlussApiClient,
+    FlussApiClientAuthenticationError,
+    FlussApiClientError,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util import slugify
+
+from .const import LOGGER, UPDATE_INTERVAL_TIMEDELTA
+
+type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
+
+
+class FlussDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Manages fetching Fluss device data on a schedule."""
+
+    def __init__(
+        self, hass: HomeAssistant, config_entry: FlussConfigEntry, api_key: str
+    ) -> None:
+        """Initialize the coordinator."""
+        self.api = FlussApiClient(api_key, session=async_get_clientsession(hass))
+        super().__init__(
+            hass,
+            LOGGER,
+            name=f"Fluss+ ({slugify(api_key[:8])})",
+            config_entry=config_entry,
+            update_interval=UPDATE_INTERVAL_TIMEDELTA,
+        )
+
+    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
+        """Fetch data from the Fluss API and return as a dictionary keyed by deviceId."""
+        try:
+            devices = await self.api.async_get_devices()
+        except FlussApiClientAuthenticationError as err:
+            raise ConfigEntryAuthFailed(f"Authentication failed: {err}") from err
+        except FlussApiClientError as err:
+            raise UpdateFailed(f"Error fetching Fluss devices: {err}") from err
+
+        return {device["deviceId"]: device for device in devices.get("devices", [])}

homeassistant/components/fluss/entity.py

@@ -0,0 +1,36 @@
+"""Base entities for the Fluss+ integration."""
+
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .coordinator import FlussDataUpdateCoordinator
+
+
+class FlussEntity(CoordinatorEntity[FlussDataUpdateCoordinator]):
+    """Base class for Fluss entities."""
+
+    _attr_has_entity_name = True
+    _attr_name = None
+
+    def __init__(
+        self,
+        coordinator: FlussDataUpdateCoordinator,
+        device_id: str,
+        device: dict,
+    ) -> None:
+        """Initialize the entity with a device ID and device data."""
+        super().__init__(coordinator)
+        self.device_id = device_id
+        self._device = device
+        self._attr_unique_id = f"{device_id}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={("fluss", device_id)},
+            name=device.get("deviceName"),
+            manufacturer="Fluss",
+            model="Fluss+ Device",
+        )
+
+    @property
+    def device(self) -> dict:
+        """Return the stored device data."""
+        return self._device

homeassistant/components/fluss/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "fluss",
+  "name": "Fluss+",
+  "codeowners": ["@fluss"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/fluss",
+  "iot_class": "cloud_polling",
+  "loggers": ["fluss-api"],
+  "quality_scale": "bronze",
+  "requirements": ["fluss-api==0.1.9.17"]
+}

homeassistant/components/fluss/quality_scale.yaml

@@ -2,81 +2,68 @@ rules:
   # Bronze
   action-setup:
     status: exempt
-    comment: No actions.
+    comment: |
+      No actions present
   appropriate-polling: done
   brands: done
   common-modules: done
   config-flow-test-coverage: done
   config-flow: done
   dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: No actions.
+  docs-actions: done
   docs-high-level-description: done
   docs-installation-instructions: done
   docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: No events subscribed.
+  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: done
-
   # Silver
-  action-exceptions:
-    status: exempt
-    comment: No actions.
+  action-exceptions: todo
   config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: No configuration options.
+  docs-configuration-parameters: done
   docs-installation-parameters: done
-  entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates: done
+  parallel-updates: todo
   reauthentication-flow: todo
-  test-coverage: done
-
+  test-coverage: todo
   # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: No discovery.
-  discovery:
-    status: exempt
-    comment: No discovery.
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices:
-    status: exempt
-    comment: No physical devices.
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: N/A
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: done
   entity-translations: done
+  entity-device-class: done
+  devices: done
+  entity-category: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: |
+      Not needed
+  discovery: todo
+  stale-devices: todo
+  diagnostics: todo
   exception-translations: todo
-  icon-translations: done
+  icon-translations:
+    status: exempt
+    comment: |
+      No icons used
   reconfiguration-flow: todo
+  dynamic-devices: todo
+  discovery-update-info: todo
   repair-issues:
     status: exempt
-    comment: No repairs.
-  stale-devices:
-    status: exempt
-    comment: N/A
+    comment: |
+      No issues to repair
+  docs-use-cases: done
+  docs-supported-devices: todo
+  docs-supported-functions: done
+  docs-data-update: todo
+  docs-known-limitations: done
+  docs-troubleshooting: todo
+  docs-examples: todo
 
   # Platinum
   async-dependency: done
   inject-websession: done
-  strict-typing: done
+  strict-typing: todo

homeassistant/components/fluss/strings.json

@@ -0,0 +1,20 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "description": "Your Fluss API key, available in the profile page of the Fluss+ app",
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "The API key found in the profile page of the Fluss+ app."
+        }
+      }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    }
+  }
+}

homeassistant/components/frontend/__init__.py

@@ -777,9 +777,7 @@ class ManifestJSONView(HomeAssistantView):
 @websocket_api.websocket_command(
     {
         "type": "frontend/get_icons",
-        vol.Required("category"): vol.In(
-            {"entity", "entity_component", "services", "triggers", "conditions"}
-        ),
+        vol.Required("category"): vol.In({"entity", "entity_component", "services"}),
         vol.Optional("integration"): vol.All(cv.ensure_list, [str]),
     }
 )

homeassistant/components/goodwe/__init__.py

@@ -1,14 +1,13 @@
 """The Goodwe inverter component."""
 
-from goodwe import Inverter, InverterError, connect
-from goodwe.const import GOODWE_UDP_PORT
+from goodwe import InverterError, connect
+from goodwe.const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
 
-from homeassistant.const import CONF_HOST, CONF_PORT
+from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.device_registry import DeviceInfo
 
-from .config_flow import GoodweFlowHandler
 from .const import CONF_MODEL_FAMILY, DOMAIN, PLATFORMS
 from .coordinator import GoodweConfigEntry, GoodweRuntimeData, GoodweUpdateCoordinator
 
@@ -16,22 +15,28 @@ from .coordinator import GoodweConfigEntry, GoodweRuntimeData, GoodweUpdateCoord
 async def async_setup_entry(hass: HomeAssistant, entry: GoodweConfigEntry) -> bool:
     """Set up the Goodwe components from a config entry."""
     host = entry.data[CONF_HOST]
-    port = entry.data.get(CONF_PORT, GOODWE_UDP_PORT)
     model_family = entry.data[CONF_MODEL_FAMILY]
 
     # Connect to Goodwe inverter
     try:
         inverter = await connect(
             host=host,
-            port=port,
+            port=GOODWE_UDP_PORT,
             family=model_family,
             retries=10,
         )
-    except InverterError as err:
+    except InverterError as err_udp:
+        # First try with UDP failed, trying with the TCP port
         try:
-            inverter = await async_check_port(hass, entry, host)
+            inverter = await connect(
+                host=host,
+                port=GOODWE_TCP_PORT,
+                family=model_family,
+                retries=10,
+            )
         except InverterError:
-            raise ConfigEntryNotReady from err
+            # Both ports are unavailable
+            raise ConfigEntryNotReady from err_udp
 
     device_info = DeviceInfo(
         configuration_url="https://www.semsportal.com",
@@ -61,23 +66,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoodweConfigEntry) -> bo
     return True
 
 
-async def async_check_port(
-    hass: HomeAssistant, entry: GoodweConfigEntry, host: str
-) -> Inverter:
-    """Check the communication port of the inverter, it may have changed after a firmware update."""
-    inverter, port = await GoodweFlowHandler.async_detect_inverter_port(host=host)
-    family = type(inverter).__name__
-    hass.config_entries.async_update_entry(
-        entry,
-        data={
-            CONF_HOST: host,
-            CONF_PORT: port,
-            CONF_MODEL_FAMILY: family,
-        },
-    )
-    return inverter
-
-
 async def async_unload_entry(
     hass: HomeAssistant, config_entry: GoodweConfigEntry
 ) -> bool:
@@ -88,31 +76,3 @@ async def async_unload_entry(
 async def update_listener(hass: HomeAssistant, config_entry: GoodweConfigEntry) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(config_entry.entry_id)
-
-
-async def async_migrate_entry(
-    hass: HomeAssistant, config_entry: GoodweConfigEntry
-) -> bool:
-    """Migrate old config entries."""
-
-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
-    if config_entry.version == 1:
-        # Update from version 1 to version 2 adding the PROTOCOL to the config entry
-        host = config_entry.data[CONF_HOST]
-        try:
-            inverter, port = await GoodweFlowHandler.async_detect_inverter_port(
-                host=host
-            )
-        except InverterError as err:
-            raise ConfigEntryNotReady from err
-        new_data = {
-            CONF_HOST: host,
-            CONF_PORT: port,
-            CONF_MODEL_FAMILY: type(inverter).__name__,
-        }
-        hass.config_entries.async_update_entry(config_entry, data=new_data, version=2)
-
-    return True

homeassistant/components/goodwe/config_flow.py

@@ -5,12 +5,12 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from goodwe import Inverter, InverterError, connect
+from goodwe import InverterError, connect
 from goodwe.const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_PORT
+from homeassistant.const import CONF_HOST
 
 from .const import CONF_MODEL_FAMILY, DEFAULT_NAME, DOMAIN
 
@@ -26,15 +26,9 @@ _LOGGER = logging.getLogger(__name__)
 class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Goodwe config flow."""
 
-    MINOR_VERSION = 2
+    VERSION = 1
 
-    async def async_handle_successful_connection(
-        self,
-        inverter: Inverter,
-        host: str,
-        port: int,
-    ) -> ConfigFlowResult:
-        """Handle a successful connection storing it's values on the entry data."""
+    async def _handle_successful_connection(self, inverter, host):
         await self.async_set_unique_id(inverter.serial_number)
         self._abort_if_unique_id_configured()
 
@@ -42,7 +36,6 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
             title=DEFAULT_NAME,
             data={
                 CONF_HOST: host,
-                CONF_PORT: port,
                 CONF_MODEL_FAMILY: type(inverter).__name__,
             },
         )
@@ -55,26 +48,19 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             host = user_input[CONF_HOST]
             try:
-                inverter, port = await self.async_detect_inverter_port(host=host)
+                inverter = await connect(host=host, port=GOODWE_UDP_PORT, retries=10)
             except InverterError:
-                errors[CONF_HOST] = "connection_error"
+                try:
+                    inverter = await connect(
+                        host=host, port=GOODWE_TCP_PORT, retries=10
+                    )
+                except InverterError:
+                    errors[CONF_HOST] = "connection_error"
+                else:
+                    return await self._handle_successful_connection(inverter, host)
             else:
-                return await self.async_handle_successful_connection(
-                    inverter, host, port
-                )
+                return await self._handle_successful_connection(inverter, host)
+
         return self.async_show_form(
             step_id="user", data_schema=CONFIG_SCHEMA, errors=errors
         )
-
-    @staticmethod
-    async def async_detect_inverter_port(
-        host: str,
-    ) -> tuple[Inverter, int]:
-        """Detects the port of the Inverter."""
-        port = GOODWE_UDP_PORT
-        try:
-            inverter = await connect(host=host, port=port, retries=10)
-        except InverterError:
-            port = GOODWE_TCP_PORT
-            inverter = await connect(host=host, port=port, retries=10)
-        return inverter, port

homeassistant/components/google_assistant_sdk/manifest.json

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

@@ -1,98 +0,0 @@
-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,9 +56,6 @@
       "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,7 +31,6 @@ 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"
@@ -44,7 +43,6 @@ 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]),
     },
 )
@@ -71,11 +69,10 @@ 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) if add_created_column else d
+        row_data = {"created": now} | 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,11 +9,6 @@ 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,10 +45,6 @@
     "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/google_tasks/todo.py

@@ -53,9 +53,6 @@ def _convert_api_item(item: dict[str, str]) -> TodoItem:
         # Due dates are returned always in UTC so we only need to
         # parse the date portion which will be interpreted as a a local date.
         due = datetime.fromisoformat(due_str).date()
-    completed: datetime | None = None
-    if (completed_str := item.get("completed")) is not None:
-        completed = datetime.fromisoformat(completed_str)
     return TodoItem(
         summary=item["title"],
         uid=item["id"],
@@ -64,7 +61,6 @@ def _convert_api_item(item: dict[str, str]) -> TodoItem:
             TodoItemStatus.NEEDS_ACTION,
         ),
         due=due,
-        completed=completed,
         description=item.get("notes"),
     )
 

homeassistant/components/google_weather/__init__.py

@@ -1,84 +0,0 @@
-"""The Google Weather integration."""
-
-from __future__ import annotations
-
-import asyncio
-
-from google_weather_api import GoogleWeatherApi
-
-from homeassistant.const import CONF_API_KEY, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import CONF_REFERRER
-from .coordinator import (
-    GoogleWeatherConfigEntry,
-    GoogleWeatherCurrentConditionsCoordinator,
-    GoogleWeatherDailyForecastCoordinator,
-    GoogleWeatherHourlyForecastCoordinator,
-    GoogleWeatherRuntimeData,
-    GoogleWeatherSubEntryRuntimeData,
-)
-
-_PLATFORMS: list[Platform] = [Platform.WEATHER]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
-) -> bool:
-    """Set up Google Weather from a config entry."""
-
-    api = GoogleWeatherApi(
-        session=async_get_clientsession(hass),
-        api_key=entry.data[CONF_API_KEY],
-        referrer=entry.data.get(CONF_REFERRER),
-        language_code=hass.config.language,
-    )
-    subentries_runtime_data: dict[str, GoogleWeatherSubEntryRuntimeData] = {}
-    for subentry in entry.subentries.values():
-        subentry_runtime_data = GoogleWeatherSubEntryRuntimeData(
-            coordinator_observation=GoogleWeatherCurrentConditionsCoordinator(
-                hass, entry, subentry, api
-            ),
-            coordinator_daily_forecast=GoogleWeatherDailyForecastCoordinator(
-                hass, entry, subentry, api
-            ),
-            coordinator_hourly_forecast=GoogleWeatherHourlyForecastCoordinator(
-                hass, entry, subentry, api
-            ),
-        )
-        subentries_runtime_data[subentry.subentry_id] = subentry_runtime_data
-    tasks = [
-        coro
-        for subentry_runtime_data in subentries_runtime_data.values()
-        for coro in (
-            subentry_runtime_data.coordinator_observation.async_config_entry_first_refresh(),
-            subentry_runtime_data.coordinator_daily_forecast.async_config_entry_first_refresh(),
-            subentry_runtime_data.coordinator_hourly_forecast.async_config_entry_first_refresh(),
-        )
-    ]
-    await asyncio.gather(*tasks)
-    entry.runtime_data = GoogleWeatherRuntimeData(
-        api=api,
-        subentries_runtime_data=subentries_runtime_data,
-    )
-
-    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
-
-    entry.async_on_unload(entry.add_update_listener(async_update_options))
-
-    return True
-
-
-async def async_unload_entry(
-    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
-) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)
-
-
-async def async_update_options(
-    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
-) -> None:
-    """Update options."""
-    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/google_weather/config_flow.py

@@ -1,198 +0,0 @@
-"""Config flow for the Google Weather integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from google_weather_api import GoogleWeatherApi, GoogleWeatherApiError
-import voluptuous as vol
-
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigEntryState,
-    ConfigFlow,
-    ConfigFlowResult,
-    ConfigSubentryFlow,
-    SubentryFlowResult,
-)
-from homeassistant.const import (
-    CONF_API_KEY,
-    CONF_LATITUDE,
-    CONF_LOCATION,
-    CONF_LONGITUDE,
-    CONF_NAME,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.data_entry_flow import section
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import LocationSelector, LocationSelectorConfig
-
-from .const import CONF_REFERRER, DOMAIN, SECTION_API_KEY_OPTIONS
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_API_KEY): str,
-        vol.Optional(SECTION_API_KEY_OPTIONS): section(
-            vol.Schema({vol.Optional(CONF_REFERRER): str}), {"collapsed": True}
-        ),
-    }
-)
-
-
-async def _validate_input(
-    user_input: dict[str, Any],
-    api: GoogleWeatherApi,
-    errors: dict[str, str],
-    description_placeholders: dict[str, str],
-) -> bool:
-    try:
-        await api.async_get_current_conditions(
-            latitude=user_input[CONF_LOCATION][CONF_LATITUDE],
-            longitude=user_input[CONF_LOCATION][CONF_LONGITUDE],
-        )
-    except GoogleWeatherApiError as err:
-        errors["base"] = "cannot_connect"
-        description_placeholders["error_message"] = str(err)
-    except Exception:
-        _LOGGER.exception("Unexpected exception")
-        errors["base"] = "unknown"
-    else:
-        return True
-    return False
-
-
-def _get_location_schema(hass: HomeAssistant) -> vol.Schema:
-    """Return the schema for a location with default values from the hass config."""
-    return vol.Schema(
-        {
-            vol.Required(CONF_NAME, default=hass.config.location_name): str,
-            vol.Required(
-                CONF_LOCATION,
-                default={
-                    CONF_LATITUDE: hass.config.latitude,
-                    CONF_LONGITUDE: hass.config.longitude,
-                },
-            ): LocationSelector(LocationSelectorConfig(radius=False)),
-        }
-    )
-
-
-def _is_location_already_configured(
-    hass: HomeAssistant, new_data: dict[str, float], epsilon: float = 1e-4
-) -> bool:
-    """Check if the location is already configured."""
-    for entry in hass.config_entries.async_entries(DOMAIN):
-        for subentry in entry.subentries.values():
-            # A more accurate way is to use the haversine formula, but for simplicity
-            # we use a simple distance check. The epsilon value is small anyway.
-            # This is mostly to capture cases where the user has slightly moved the location pin.
-            if (
-                abs(subentry.data[CONF_LATITUDE] - new_data[CONF_LATITUDE]) <= epsilon
-                and abs(subentry.data[CONF_LONGITUDE] - new_data[CONF_LONGITUDE])
-                <= epsilon
-            ):
-                return True
-    return False
-
-
-class GoogleWeatherConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Google Weather."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        description_placeholders: dict[str, str] = {
-            "api_key_url": "https://developers.google.com/maps/documentation/weather/get-api-key",
-            "restricting_api_keys_url": "https://developers.google.com/maps/api-security-best-practices#restricting-api-keys",
-        }
-        if user_input is not None:
-            api_key = user_input[CONF_API_KEY]
-            referrer = user_input.get(SECTION_API_KEY_OPTIONS, {}).get(CONF_REFERRER)
-            self._async_abort_entries_match({CONF_API_KEY: api_key})
-            if _is_location_already_configured(self.hass, user_input[CONF_LOCATION]):
-                return self.async_abort(reason="already_configured")
-            api = GoogleWeatherApi(
-                session=async_get_clientsession(self.hass),
-                api_key=api_key,
-                referrer=referrer,
-                language_code=self.hass.config.language,
-            )
-            if await _validate_input(user_input, api, errors, description_placeholders):
-                return self.async_create_entry(
-                    title="Google Weather",
-                    data={
-                        CONF_API_KEY: api_key,
-                        CONF_REFERRER: referrer,
-                    },
-                    subentries=[
-                        {
-                            "subentry_type": "location",
-                            "data": user_input[CONF_LOCATION],
-                            "title": user_input[CONF_NAME],
-                            "unique_id": None,
-                        },
-                    ],
-                )
-        else:
-            user_input = {}
-        schema = STEP_USER_DATA_SCHEMA.schema.copy()
-        schema.update(_get_location_schema(self.hass).schema)
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                vol.Schema(schema), user_input
-            ),
-            errors=errors,
-            description_placeholders=description_placeholders,
-        )
-
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type[ConfigSubentryFlow]]:
-        """Return subentries supported by this integration."""
-        return {"location": LocationSubentryFlowHandler}
-
-
-class LocationSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle a subentry flow for location."""
-
-    async def async_step_location(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> SubentryFlowResult:
-        """Handle the location step."""
-        if self._get_entry().state != ConfigEntryState.LOADED:
-            return self.async_abort(reason="entry_not_loaded")
-
-        errors: dict[str, str] = {}
-        description_placeholders: dict[str, str] = {}
-        if user_input is not None:
-            if _is_location_already_configured(self.hass, user_input[CONF_LOCATION]):
-                return self.async_abort(reason="already_configured")
-            api: GoogleWeatherApi = self._get_entry().runtime_data.api
-            if await _validate_input(user_input, api, errors, description_placeholders):
-                return self.async_create_entry(
-                    title=user_input[CONF_NAME],
-                    data=user_input[CONF_LOCATION],
-                )
-        else:
-            user_input = {}
-        return self.async_show_form(
-            step_id="location",
-            data_schema=self.add_suggested_values_to_schema(
-                _get_location_schema(self.hass), user_input
-            ),
-            errors=errors,
-            description_placeholders=description_placeholders,
-        )
-
-    async_step_user = async_step_location

homeassistant/components/google_weather/const.py

@@ -1,8 +0,0 @@
-"""Constants for the Google Weather integration."""
-
-from typing import Final
-
-DOMAIN = "google_weather"
-
-SECTION_API_KEY_OPTIONS: Final = "api_key_options"
-CONF_REFERRER: Final = "referrer"

homeassistant/components/google_weather/coordinator.py

@@ -1,169 +0,0 @@
-"""The Google Weather coordinator."""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
-from datetime import timedelta
-import logging
-from typing import TypeVar
-
-from google_weather_api import (
-    CurrentConditionsResponse,
-    DailyForecastResponse,
-    GoogleWeatherApi,
-    GoogleWeatherApiError,
-    HourlyForecastResponse,
-)
-
-from homeassistant.config_entries import ConfigEntry, ConfigSubentry
-from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import (
-    TimestampDataUpdateCoordinator,
-    UpdateFailed,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-T = TypeVar(
-    "T",
-    bound=(
-        CurrentConditionsResponse
-        | DailyForecastResponse
-        | HourlyForecastResponse
-        | None
-    ),
-)
-
-
-@dataclass
-class GoogleWeatherSubEntryRuntimeData:
-    """Runtime data for a Google Weather sub-entry."""
-
-    coordinator_observation: GoogleWeatherCurrentConditionsCoordinator
-    coordinator_daily_forecast: GoogleWeatherDailyForecastCoordinator
-    coordinator_hourly_forecast: GoogleWeatherHourlyForecastCoordinator
-
-
-@dataclass
-class GoogleWeatherRuntimeData:
-    """Runtime data for the Google Weather integration."""
-
-    api: GoogleWeatherApi
-    subentries_runtime_data: dict[str, GoogleWeatherSubEntryRuntimeData]
-
-
-type GoogleWeatherConfigEntry = ConfigEntry[GoogleWeatherRuntimeData]
-
-
-class GoogleWeatherBaseCoordinator(TimestampDataUpdateCoordinator[T]):
-    """Base class for Google Weather coordinators."""
-
-    config_entry: GoogleWeatherConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: GoogleWeatherConfigEntry,
-        subentry: ConfigSubentry,
-        data_type_name: str,
-        update_interval: timedelta,
-        api_method: Callable[..., Awaitable[T]],
-    ) -> None:
-        """Initialize the data updater."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=f"Google Weather {data_type_name} coordinator for {subentry.title}",
-            update_interval=update_interval,
-        )
-        self.subentry = subentry
-        self._data_type_name = data_type_name
-        self._api_method = api_method
-
-    async def _async_update_data(self) -> T:
-        """Fetch data from API and handle errors."""
-        try:
-            return await self._api_method(
-                self.subentry.data[CONF_LATITUDE],
-                self.subentry.data[CONF_LONGITUDE],
-            )
-        except GoogleWeatherApiError as err:
-            _LOGGER.error(
-                "Error fetching %s for %s: %s",
-                self._data_type_name,
-                self.subentry.title,
-                err,
-            )
-            raise UpdateFailed(f"Error fetching {self._data_type_name}") from err
-
-
-class GoogleWeatherCurrentConditionsCoordinator(
-    GoogleWeatherBaseCoordinator[CurrentConditionsResponse]
-):
-    """Handle fetching current weather conditions."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: GoogleWeatherConfigEntry,
-        subentry: ConfigSubentry,
-        api: GoogleWeatherApi,
-    ) -> None:
-        """Initialize the data updater."""
-        super().__init__(
-            hass,
-            config_entry,
-            subentry,
-            "current weather conditions",
-            timedelta(minutes=15),
-            api.async_get_current_conditions,
-        )
-
-
-class GoogleWeatherDailyForecastCoordinator(
-    GoogleWeatherBaseCoordinator[DailyForecastResponse]
-):
-    """Handle fetching daily weather forecast."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: GoogleWeatherConfigEntry,
-        subentry: ConfigSubentry,
-        api: GoogleWeatherApi,
-    ) -> None:
-        """Initialize the data updater."""
-        super().__init__(
-            hass,
-            config_entry,
-            subentry,
-            "daily weather forecast",
-            timedelta(hours=1),
-            api.async_get_daily_forecast,
-        )
-
-
-class GoogleWeatherHourlyForecastCoordinator(
-    GoogleWeatherBaseCoordinator[HourlyForecastResponse]
-):
-    """Handle fetching hourly weather forecast."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: GoogleWeatherConfigEntry,
-        subentry: ConfigSubentry,
-        api: GoogleWeatherApi,
-    ) -> None:
-        """Initialize the data updater."""
-        super().__init__(
-            hass,
-            config_entry,
-            subentry,
-            "hourly weather forecast",
-            timedelta(hours=1),
-            api.async_get_hourly_forecast,
-        )

homeassistant/components/google_weather/entity.py

@@ -1,28 +0,0 @@
-"""Base entity for Google Weather."""
-
-from __future__ import annotations
-
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity import Entity
-
-from .const import DOMAIN
-from .coordinator import GoogleWeatherConfigEntry
-
-
-class GoogleWeatherBaseEntity(Entity):
-    """Base entity for all Google Weather entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self, config_entry: GoogleWeatherConfigEntry, subentry: ConfigSubentry
-    ) -> None:
-        """Initialize base entity."""
-        self._attr_unique_id = subentry.subentry_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, subentry.subentry_id)},
-            name=subentry.title,
-            manufacturer="Google",
-            entry_type=DeviceEntryType.SERVICE,
-        )

homeassistant/components/google_weather/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "google_weather",
-  "name": "Google Weather",
-  "codeowners": ["@tronikos"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/google_weather",
-  "integration_type": "service",
-  "iot_class": "cloud_polling",
-  "loggers": ["google_weather_api"],
-  "quality_scale": "bronze",
-  "requirements": ["python-google-weather-api==0.0.4"]
-}

homeassistant/components/google_weather/strings.json

@@ -1,65 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
-    },
-    "error": {
-      "cannot_connect": "Unable to connect to the Google Weather API:\n\n{error_message}",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "location": "[%key:common::config_flow::data::location%]",
-          "name": "[%key:common::config_flow::data::name%]"
-        },
-        "data_description": {
-          "api_key": "A unique alphanumeric string that associates your Google billing account with Google Weather API",
-          "location": "Location coordinates",
-          "name": "Location name"
-        },
-        "description": "Get your API key from [here]({api_key_url}).",
-        "sections": {
-          "api_key_options": {
-            "data": {
-              "referrer": "HTTP referrer"
-            },
-            "data_description": {
-              "referrer": "Specify this only if the API key has a [website application restriction]({restricting_api_keys_url})"
-            },
-            "name": "Optional API key options"
-          }
-        }
-      }
-    }
-  },
-  "config_subentries": {
-    "location": {
-      "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_location%]",
-        "entry_not_loaded": "Cannot add things while the configuration is disabled."
-      },
-      "entry_type": "Location",
-      "error": {
-        "cannot_connect": "[%key:component::google_weather::config::error::cannot_connect%]",
-        "unknown": "[%key:common::config_flow::error::unknown%]"
-      },
-      "initiate_flow": {
-        "user": "Add location"
-      },
-      "step": {
-        "location": {
-          "data": {
-            "location": "[%key:common::config_flow::data::location%]",
-            "name": "[%key:common::config_flow::data::name%]"
-          },
-          "data_description": {
-            "location": "[%key:component::google_weather::config::step::user::data_description::location%]",
-            "name": "[%key:component::google_weather::config::step::user::data_description::name%]"
-          }
-        }
-      }
-    }
-  }
-}

homeassistant/components/google_weather/weather.py

@@ -1,366 +0,0 @@
-"""Weather entity."""
-
-from __future__ import annotations
-
-from google_weather_api import (
-    DailyForecastResponse,
-    HourlyForecastResponse,
-    WeatherCondition,
-)
-
-from homeassistant.components.weather import (
-    ATTR_CONDITION_CLEAR_NIGHT,
-    ATTR_CONDITION_CLOUDY,
-    ATTR_CONDITION_HAIL,
-    ATTR_CONDITION_LIGHTNING_RAINY,
-    ATTR_CONDITION_PARTLYCLOUDY,
-    ATTR_CONDITION_POURING,
-    ATTR_CONDITION_RAINY,
-    ATTR_CONDITION_SNOWY,
-    ATTR_CONDITION_SNOWY_RAINY,
-    ATTR_CONDITION_SUNNY,
-    ATTR_CONDITION_WINDY,
-    ATTR_FORECAST_CLOUD_COVERAGE,
-    ATTR_FORECAST_CONDITION,
-    ATTR_FORECAST_HUMIDITY,
-    ATTR_FORECAST_IS_DAYTIME,
-    ATTR_FORECAST_NATIVE_APPARENT_TEMP,
-    ATTR_FORECAST_NATIVE_DEW_POINT,
-    ATTR_FORECAST_NATIVE_PRECIPITATION,
-    ATTR_FORECAST_NATIVE_PRESSURE,
-    ATTR_FORECAST_NATIVE_TEMP,
-    ATTR_FORECAST_NATIVE_TEMP_LOW,
-    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED,
-    ATTR_FORECAST_NATIVE_WIND_SPEED,
-    ATTR_FORECAST_PRECIPITATION_PROBABILITY,
-    ATTR_FORECAST_TIME,
-    ATTR_FORECAST_UV_INDEX,
-    ATTR_FORECAST_WIND_BEARING,
-    CoordinatorWeatherEntity,
-    Forecast,
-    WeatherEntityFeature,
-)
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import (
-    UnitOfLength,
-    UnitOfPrecipitationDepth,
-    UnitOfPressure,
-    UnitOfSpeed,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import (
-    GoogleWeatherConfigEntry,
-    GoogleWeatherCurrentConditionsCoordinator,
-    GoogleWeatherDailyForecastCoordinator,
-    GoogleWeatherHourlyForecastCoordinator,
-)
-from .entity import GoogleWeatherBaseEntity
-
-PARALLEL_UPDATES = 0
-
-# Maps https://developers.google.com/maps/documentation/weather/weather-condition-icons
-# to https://developers.home-assistant.io/docs/core/entity/weather/#recommended-values-for-state-and-condition
-_CONDITION_MAP: dict[WeatherCondition.Type, str | None] = {
-    WeatherCondition.Type.TYPE_UNSPECIFIED: None,
-    WeatherCondition.Type.CLEAR: ATTR_CONDITION_SUNNY,
-    WeatherCondition.Type.MOSTLY_CLEAR: ATTR_CONDITION_PARTLYCLOUDY,
-    WeatherCondition.Type.PARTLY_CLOUDY: ATTR_CONDITION_PARTLYCLOUDY,
-    WeatherCondition.Type.MOSTLY_CLOUDY: ATTR_CONDITION_CLOUDY,
-    WeatherCondition.Type.CLOUDY: ATTR_CONDITION_CLOUDY,
-    WeatherCondition.Type.WINDY: ATTR_CONDITION_WINDY,
-    WeatherCondition.Type.WIND_AND_RAIN: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.LIGHT_RAIN_SHOWERS: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.CHANCE_OF_SHOWERS: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.SCATTERED_SHOWERS: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.RAIN_SHOWERS: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.HEAVY_RAIN_SHOWERS: ATTR_CONDITION_POURING,
-    WeatherCondition.Type.LIGHT_TO_MODERATE_RAIN: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.MODERATE_TO_HEAVY_RAIN: ATTR_CONDITION_POURING,
-    WeatherCondition.Type.RAIN: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.LIGHT_RAIN: ATTR_CONDITION_RAINY,
-    WeatherCondition.Type.HEAVY_RAIN: ATTR_CONDITION_POURING,
-    WeatherCondition.Type.RAIN_PERIODICALLY_HEAVY: ATTR_CONDITION_POURING,
-    WeatherCondition.Type.LIGHT_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.CHANCE_OF_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.SCATTERED_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.HEAVY_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.LIGHT_TO_MODERATE_SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.MODERATE_TO_HEAVY_SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.LIGHT_SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.HEAVY_SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.SNOWSTORM: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.SNOW_PERIODICALLY_HEAVY: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.HEAVY_SNOW_STORM: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.BLOWING_SNOW: ATTR_CONDITION_SNOWY,
-    WeatherCondition.Type.RAIN_AND_SNOW: ATTR_CONDITION_SNOWY_RAINY,
-    WeatherCondition.Type.HAIL: ATTR_CONDITION_HAIL,
-    WeatherCondition.Type.HAIL_SHOWERS: ATTR_CONDITION_HAIL,
-    WeatherCondition.Type.THUNDERSTORM: ATTR_CONDITION_LIGHTNING_RAINY,
-    WeatherCondition.Type.THUNDERSHOWER: ATTR_CONDITION_LIGHTNING_RAINY,
-    WeatherCondition.Type.LIGHT_THUNDERSTORM_RAIN: ATTR_CONDITION_LIGHTNING_RAINY,
-    WeatherCondition.Type.SCATTERED_THUNDERSTORMS: ATTR_CONDITION_LIGHTNING_RAINY,
-    WeatherCondition.Type.HEAVY_THUNDERSTORM: ATTR_CONDITION_LIGHTNING_RAINY,
-}
-
-
-def _get_condition(
-    api_condition: WeatherCondition.Type, is_daytime: bool
-) -> str | None:
-    """Map Google Weather condition to Home Assistant condition."""
-    cond = _CONDITION_MAP[api_condition]
-    if cond == ATTR_CONDITION_SUNNY and not is_daytime:
-        return ATTR_CONDITION_CLEAR_NIGHT
-    return cond
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: GoogleWeatherConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Add a weather entity from a config_entry."""
-    for subentry in entry.subentries.values():
-        async_add_entities(
-            [GoogleWeatherEntity(entry, subentry)],
-            config_subentry_id=subentry.subentry_id,
-        )
-
-
-class GoogleWeatherEntity(
-    CoordinatorWeatherEntity[
-        GoogleWeatherCurrentConditionsCoordinator,
-        GoogleWeatherDailyForecastCoordinator,
-        GoogleWeatherHourlyForecastCoordinator,
-        GoogleWeatherDailyForecastCoordinator,
-    ],
-    GoogleWeatherBaseEntity,
-):
-    """Representation of a Google Weather entity."""
-
-    _attr_attribution = "Data from Google Weather"
-
-    _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_native_pressure_unit = UnitOfPressure.MBAR
-    _attr_native_wind_speed_unit = UnitOfSpeed.KILOMETERS_PER_HOUR
-    _attr_native_visibility_unit = UnitOfLength.KILOMETERS
-    _attr_native_precipitation_unit = UnitOfPrecipitationDepth.MILLIMETERS
-
-    _attr_name = None
-
-    _attr_supported_features = (
-        WeatherEntityFeature.FORECAST_DAILY
-        | WeatherEntityFeature.FORECAST_HOURLY
-        | WeatherEntityFeature.FORECAST_TWICE_DAILY
-    )
-
-    def __init__(
-        self,
-        entry: GoogleWeatherConfigEntry,
-        subentry: ConfigSubentry,
-    ) -> None:
-        """Initialize the weather entity."""
-        subentry_runtime_data = entry.runtime_data.subentries_runtime_data[
-            subentry.subentry_id
-        ]
-        super().__init__(
-            observation_coordinator=subentry_runtime_data.coordinator_observation,
-            daily_coordinator=subentry_runtime_data.coordinator_daily_forecast,
-            hourly_coordinator=subentry_runtime_data.coordinator_hourly_forecast,
-            twice_daily_coordinator=subentry_runtime_data.coordinator_daily_forecast,
-        )
-        GoogleWeatherBaseEntity.__init__(self, entry, subentry)
-
-    @property
-    def condition(self) -> str | None:
-        """Return the current condition."""
-        return _get_condition(
-            self.coordinator.data.weather_condition.type,
-            self.coordinator.data.is_daytime,
-        )
-
-    @property
-    def native_temperature(self) -> float:
-        """Return the temperature."""
-        return self.coordinator.data.temperature.degrees
-
-    @property
-    def native_apparent_temperature(self) -> float:
-        """Return the apparent temperature."""
-        return self.coordinator.data.feels_like_temperature.degrees
-
-    @property
-    def native_dew_point(self) -> float:
-        """Return the dew point."""
-        return self.coordinator.data.dew_point.degrees
-
-    @property
-    def humidity(self) -> int:
-        """Return the humidity."""
-        return self.coordinator.data.relative_humidity
-
-    @property
-    def uv_index(self) -> float:
-        """Return the UV index."""
-        return float(self.coordinator.data.uv_index)
-
-    @property
-    def native_pressure(self) -> float:
-        """Return the pressure."""
-        return self.coordinator.data.air_pressure.mean_sea_level_millibars
-
-    @property
-    def native_wind_gust_speed(self) -> float:
-        """Return the wind gust speed."""
-        return self.coordinator.data.wind.gust.value
-
-    @property
-    def native_wind_speed(self) -> float:
-        """Return the wind speed."""
-        return self.coordinator.data.wind.speed.value
-
-    @property
-    def wind_bearing(self) -> int:
-        """Return the wind bearing."""
-        return self.coordinator.data.wind.direction.degrees
-
-    @property
-    def native_visibility(self) -> float:
-        """Return the visibility."""
-        return self.coordinator.data.visibility.distance
-
-    @property
-    def cloud_coverage(self) -> float:
-        """Return the Cloud coverage in %."""
-        return float(self.coordinator.data.cloud_cover)
-
-    @callback
-    def _async_forecast_daily(self) -> list[Forecast] | None:
-        """Return the daily forecast in native units."""
-        coordinator = self.forecast_coordinators["daily"]
-        assert coordinator
-        daily_data = coordinator.data
-        assert isinstance(daily_data, DailyForecastResponse)
-        return [
-            {
-                ATTR_FORECAST_CONDITION: _get_condition(
-                    item.daytime_forecast.weather_condition.type, is_daytime=True
-                ),
-                ATTR_FORECAST_TIME: item.interval.start_time,
-                ATTR_FORECAST_HUMIDITY: item.daytime_forecast.relative_humidity,
-                ATTR_FORECAST_PRECIPITATION_PROBABILITY: max(
-                    item.daytime_forecast.precipitation.probability.percent,
-                    item.nighttime_forecast.precipitation.probability.percent,
-                ),
-                ATTR_FORECAST_CLOUD_COVERAGE: item.daytime_forecast.cloud_cover,
-                ATTR_FORECAST_NATIVE_PRECIPITATION: (
-                    item.daytime_forecast.precipitation.qpf.quantity
-                    + item.nighttime_forecast.precipitation.qpf.quantity
-                ),
-                ATTR_FORECAST_NATIVE_TEMP: item.max_temperature.degrees,
-                ATTR_FORECAST_NATIVE_TEMP_LOW: item.min_temperature.degrees,
-                ATTR_FORECAST_NATIVE_APPARENT_TEMP: (
-                    item.feels_like_max_temperature.degrees
-                ),
-                ATTR_FORECAST_WIND_BEARING: item.daytime_forecast.wind.direction.degrees,
-                ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: max(
-                    item.daytime_forecast.wind.gust.value,
-                    item.nighttime_forecast.wind.gust.value,
-                ),
-                ATTR_FORECAST_NATIVE_WIND_SPEED: max(
-                    item.daytime_forecast.wind.speed.value,
-                    item.nighttime_forecast.wind.speed.value,
-                ),
-                ATTR_FORECAST_UV_INDEX: item.daytime_forecast.uv_index,
-            }
-            for item in daily_data.forecast_days
-        ]
-
-    @callback
-    def _async_forecast_hourly(self) -> list[Forecast] | None:
-        """Return the hourly forecast in native units."""
-        coordinator = self.forecast_coordinators["hourly"]
-        assert coordinator
-        hourly_data = coordinator.data
-        assert isinstance(hourly_data, HourlyForecastResponse)
-        return [
-            {
-                ATTR_FORECAST_CONDITION: _get_condition(
-                    item.weather_condition.type, item.is_daytime
-                ),
-                ATTR_FORECAST_TIME: item.interval.start_time,
-                ATTR_FORECAST_HUMIDITY: item.relative_humidity,
-                ATTR_FORECAST_PRECIPITATION_PROBABILITY: item.precipitation.probability.percent,
-                ATTR_FORECAST_CLOUD_COVERAGE: item.cloud_cover,
-                ATTR_FORECAST_NATIVE_PRECIPITATION: item.precipitation.qpf.quantity,
-                ATTR_FORECAST_NATIVE_PRESSURE: item.air_pressure.mean_sea_level_millibars,
-                ATTR_FORECAST_NATIVE_TEMP: item.temperature.degrees,
-                ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_temperature.degrees,
-                ATTR_FORECAST_WIND_BEARING: item.wind.direction.degrees,
-                ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: item.wind.gust.value,
-                ATTR_FORECAST_NATIVE_WIND_SPEED: item.wind.speed.value,
-                ATTR_FORECAST_NATIVE_DEW_POINT: item.dew_point.degrees,
-                ATTR_FORECAST_UV_INDEX: item.uv_index,
-                ATTR_FORECAST_IS_DAYTIME: item.is_daytime,
-            }
-            for item in hourly_data.forecast_hours
-        ]
-
-    @callback
-    def _async_forecast_twice_daily(self) -> list[Forecast] | None:
-        """Return the twice daily forecast in native units."""
-        coordinator = self.forecast_coordinators["twice_daily"]
-        assert coordinator
-        daily_data = coordinator.data
-        assert isinstance(daily_data, DailyForecastResponse)
-        forecasts: list[Forecast] = []
-        for item in daily_data.forecast_days:
-            # Process daytime forecast
-            day_forecast = item.daytime_forecast
-            forecasts.append(
-                {
-                    ATTR_FORECAST_CONDITION: _get_condition(
-                        day_forecast.weather_condition.type, is_daytime=True
-                    ),
-                    ATTR_FORECAST_TIME: day_forecast.interval.start_time,
-                    ATTR_FORECAST_HUMIDITY: day_forecast.relative_humidity,
-                    ATTR_FORECAST_PRECIPITATION_PROBABILITY: day_forecast.precipitation.probability.percent,
-                    ATTR_FORECAST_CLOUD_COVERAGE: day_forecast.cloud_cover,
-                    ATTR_FORECAST_NATIVE_PRECIPITATION: day_forecast.precipitation.qpf.quantity,
-                    ATTR_FORECAST_NATIVE_TEMP: item.max_temperature.degrees,
-                    ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_max_temperature.degrees,
-                    ATTR_FORECAST_WIND_BEARING: day_forecast.wind.direction.degrees,
-                    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: day_forecast.wind.gust.value,
-                    ATTR_FORECAST_NATIVE_WIND_SPEED: day_forecast.wind.speed.value,
-                    ATTR_FORECAST_UV_INDEX: day_forecast.uv_index,
-                    ATTR_FORECAST_IS_DAYTIME: True,
-                }
-            )
-
-            # Process nighttime forecast
-            night_forecast = item.nighttime_forecast
-            forecasts.append(
-                {
-                    ATTR_FORECAST_CONDITION: _get_condition(
-                        night_forecast.weather_condition.type, is_daytime=False
-                    ),
-                    ATTR_FORECAST_TIME: night_forecast.interval.start_time,
-                    ATTR_FORECAST_HUMIDITY: night_forecast.relative_humidity,
-                    ATTR_FORECAST_PRECIPITATION_PROBABILITY: night_forecast.precipitation.probability.percent,
-                    ATTR_FORECAST_CLOUD_COVERAGE: night_forecast.cloud_cover,
-                    ATTR_FORECAST_NATIVE_PRECIPITATION: night_forecast.precipitation.qpf.quantity,
-                    ATTR_FORECAST_NATIVE_TEMP: item.min_temperature.degrees,
-                    ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_min_temperature.degrees,
-                    ATTR_FORECAST_WIND_BEARING: night_forecast.wind.direction.degrees,
-                    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: night_forecast.wind.gust.value,
-                    ATTR_FORECAST_NATIVE_WIND_SPEED: night_forecast.wind.speed.value,
-                    ATTR_FORECAST_UV_INDEX: night_forecast.uv_index,
-                    ATTR_FORECAST_IS_DAYTIME: False,
-                }
-            )
-
-        return forecasts

homeassistant/components/home_connect/coordinator.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from collections.abc import Callable
 from dataclasses import dataclass
 import logging
-from typing import Any
+from typing import Any, cast
 
 from aiohomeconnect.client import Client as HomeConnectClient
 from aiohomeconnect.model import (
@@ -247,15 +247,14 @@ class HomeConnectCoordinator(
                                             value=event.value,
                                         )
                                 else:
-                                    event_value = event.value
                                     if event_key in (
                                         EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
                                         EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
-                                    ) and isinstance(event_value, str):
+                                    ):
                                         await self.update_options(
                                             event_message_ha_id,
                                             event_key,
-                                            ProgramKey(event_value),
+                                            ProgramKey(cast(str, event.value)),
                                         )
                                     events[event_key] = event
                             self._call_event_listener(event_message)

homeassistant/components/home_connect/entity.py

@@ -14,6 +14,7 @@ from aiohomeconnect.model.error import (
     TooManyRequestsError,
 )
 
+from homeassistant.const import STATE_UNAVAILABLE
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -61,8 +62,10 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
         self.update_native_value()
+        available = self._attr_available = self.appliance.info.connected
         self.async_write_ha_state()
-        _LOGGER.debug("Updated %s", self)
+        state = STATE_UNAVAILABLE if not available else self.state
+        _LOGGER.debug("Updated %s, new state: %s", self.entity_id, state)
 
     @property
     def bsh_key(self) -> str:
@@ -77,7 +80,7 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
         as event updates should take precedence over the coordinator
         refresh.
         """
-        return self.appliance.info.connected and self._attr_available
+        return self._attr_available
 
 
 class HomeConnectOptionEntity(HomeConnectEntity):

homeassistant/components/husqvarna_automower/entity.py

@@ -121,15 +121,12 @@ class AutomowerBaseEntity(CoordinatorEntity[AutomowerDataUpdateCoordinator]):
         """Initialize AutomowerEntity."""
         super().__init__(coordinator)
         self.mower_id = mower_id
-        model_witout_manufacturer = self.mower_attributes.system.model.removeprefix(
-            "Husqvarna "
-        ).removeprefix("HUSQVARNA ")
-        parts = model_witout_manufacturer.split(maxsplit=1)
+        parts = self.mower_attributes.system.model.split(maxsplit=2)
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, mower_id)},
-            manufacturer="Husqvarna",
-            model=parts[0].capitalize().removesuffix("®"),
-            model_id=parts[1],
+            manufacturer=parts[0],
+            model=parts[1],
+            model_id=parts[2],
             name=self.mower_attributes.system.name,
             serial_number=self.mower_attributes.system.serial_number,
             suggested_area="Garden",

homeassistant/components/hvv_departures/binary_sensor.py

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

homeassistant/components/kostal_plenticore/coordinator.py

@@ -237,23 +237,14 @@ class SettingDataUpdateCoordinator(
     """Implementation of PlenticoreUpdateCoordinator for settings data."""
 
     async def _async_update_data(self) -> Mapping[str, Mapping[str, str]]:
-        if (client := self._plenticore.client) is None:
+        client = self._plenticore.client
+
+        if not self._fetch or client is None:
             return {}
 
-        fetch = defaultdict(set)
+        _LOGGER.debug("Fetching %s for %s", self.name, 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)
+        return await client.get_setting_values(self._fetch)
 
 
 class PlenticoreSelectUpdateCoordinator[_DataT](DataUpdateCoordinator[_DataT]):

homeassistant/components/kostal_plenticore/diagnostics.py

@@ -34,29 +34,6 @@ 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,13 +5,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
-from typing import Any, Final
+from typing import Any
 
 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
 
@@ -67,7 +66,7 @@ async def async_setup_entry(
     """Add kostal plenticore Switch."""
     plenticore = entry.runtime_data
 
-    entities: list[Entity] = []
+    entities = []
 
     available_settings_data = await plenticore.client.get_settings()
     settings_data_update_coordinator = SettingDataUpdateCoordinator(
@@ -104,57 +103,6 @@ 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)
 
 
@@ -188,6 +136,7 @@ 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
@@ -240,98 +189,3 @@ 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/binary_sensor.py

@@ -1,7 +1,6 @@
 """Support for LCN binary sensors."""
 
 from collections.abc import Iterable
-from datetime import timedelta
 from functools import partial
 
 import pypck
@@ -20,7 +19,6 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
-SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -71,11 +69,21 @@ class LcnBinarySensor(LcnEntity, BinarySensorEntity):
             config[CONF_DOMAIN_DATA][CONF_SOURCE]
         ]
 
-    async def async_update(self) -> None:
-        """Update the state of the entity."""
-        await self.device_connection.request_status_binary_sensors(
-            SCAN_INTERVAL.seconds
-        )
+    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
+            )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""

homeassistant/components/lcn/climate.py

@@ -1,8 +1,6 @@
 """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
 
@@ -38,7 +36,6 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
-SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -113,6 +110,20 @@ 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."""
@@ -181,17 +192,6 @@ class LcnClimate(LcnEntity, ClimateEntity):
         self._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):

homeassistant/components/lcn/cover.py

@@ -1,8 +1,6 @@
 """Support for LCN covers."""
 
-import asyncio
 from collections.abc import Iterable
-from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -29,7 +27,6 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
-SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -76,7 +73,7 @@ async def async_setup_entry(
 class LcnOutputsCover(LcnEntity, CoverEntity):
     """Representation of a LCN cover connected to output ports."""
 
-    _attr_is_closed = True
+    _attr_is_closed = False
     _attr_is_closing = False
     _attr_is_opening = False
     _attr_assumed_state = True
@@ -96,6 +93,28 @@ 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
@@ -128,18 +147,6 @@ 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 (
@@ -168,7 +175,7 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
 class LcnRelayCover(LcnEntity, CoverEntity):
     """Representation of a LCN cover connected to relays."""
 
-    _attr_is_closed = True
+    _attr_is_closed = False
     _attr_is_closing = False
     _attr_is_opening = False
     _attr_assumed_state = True
@@ -199,6 +206,20 @@ 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(
@@ -253,17 +274,6 @@ class LcnRelayCover(LcnEntity, CoverEntity):
 
         self.async_write_ha_state()
 
-    async def async_update(self) -> None:
-        """Update the state of the entity."""
-        coros = [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):

homeassistant/components/lcn/entity.py

@@ -2,8 +2,6 @@
 
 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
@@ -12,6 +10,7 @@ from homeassistant.helpers.typing import ConfigType
 from .const import CONF_DOMAIN_DATA, DOMAIN
 from .helpers import (
     AddressType,
+    DeviceConnectionType,
     InputType,
     LcnConfigEntry,
     generate_unique_id,
@@ -23,8 +22,9 @@ 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: DeviceConnection
+    device_connection: DeviceConnectionType
 
     def __init__(
         self,
@@ -57,24 +57,15 @@ 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 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)
+        if not self.device_connection.is_group:
+            self._unregister_for_inputs = self.device_connection.register_for_inputs(
+                self.input_received
+            )
 
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""

homeassistant/components/lcn/helpers.py

@@ -11,7 +11,6 @@ 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 (
@@ -49,7 +48,7 @@ class LcnRuntimeData:
     connection: PchkConnectionManager
     """Connection to PCHK host."""
 
-    device_connections: dict[str, DeviceConnection]
+    device_connections: dict[str, DeviceConnectionType]
     """Logical addresses of devices connected to the host."""
 
     add_entities_callbacks: dict[str, Callable[[Iterable[ConfigType]], None]]
@@ -60,6 +59,7 @@ 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]
 
@@ -82,11 +82,11 @@ DOMAIN_LOOKUP = {
 
 def get_device_connection(
     hass: HomeAssistant, address: AddressType, config_entry: LcnConfigEntry
-) -> DeviceConnection:
+) -> DeviceConnectionType:
     """Return a lcn device_connection."""
     host_connection = config_entry.runtime_data.connection
     addr = pypck.lcn_addr.LcnAddr(*address)
-    return host_connection.get_device_connection(addr)
+    return host_connection.get_address_conn(addr)
 
 
 def get_resource(domain_name: str, domain_data: ConfigType) -> str:
@@ -246,24 +246,18 @@ def register_lcn_address_devices(
 
 
 async def async_update_device_config(
-    device_connection: DeviceConnection, device_config: ConfigType
+    device_connection: DeviceConnectionType, 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.serials_known()
+        await device_connection.serial_known
         if device_config[CONF_HARDWARE_SERIAL] == -1:
-            device_config[CONF_HARDWARE_SERIAL] = (
-                device_connection.serials.hardware_serial
-            )
+            device_config[CONF_HARDWARE_SERIAL] = device_connection.hardware_serial
         if device_config[CONF_SOFTWARE_SERIAL] == -1:
-            device_config[CONF_SOFTWARE_SERIAL] = (
-                device_connection.serials.software_serial
-            )
+            device_config[CONF_SOFTWARE_SERIAL] = device_connection.software_serial
         if device_config[CONF_HARDWARE_TYPE] == -1:
-            device_config[CONF_HARDWARE_TYPE] = (
-                device_connection.serials.hardware_type.value
-            )
+            device_config[CONF_HARDWARE_TYPE] = device_connection.hardware_type.value
 
     # fetch name if device is module
     if device_config[CONF_NAME] != "":

homeassistant/components/lcn/light.py

@@ -1,7 +1,6 @@
 """Support for LCN lights."""
 
 from collections.abc import Iterable
-from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -34,7 +33,6 @@ from .helpers import InputType, LcnConfigEntry
 BRIGHTNESS_SCALE = (1, 100)
 
 PARALLEL_UPDATES = 0
-SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_entities(
@@ -102,6 +100,18 @@ 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:
@@ -147,12 +157,6 @@ 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 (
@@ -180,6 +184,18 @@ 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
@@ -198,10 +214,6 @@ 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_polling",
+  "iot_class": "local_push",
   "loggers": ["pypck"],
   "quality_scale": "bronze",
-  "requirements": ["pypck==0.9.3", "lcn-frontend==0.2.7"]
+  "requirements": ["pypck==0.8.12", "lcn-frontend==0.2.7"]
 }

homeassistant/components/lcn/sensor.py

@@ -1,7 +1,6 @@
 """Support for LCN sensors."""
 
 from collections.abc import Iterable
-from datetime import timedelta
 from functools import partial
 from itertools import chain
 
@@ -41,8 +40,6 @@ 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,
@@ -131,11 +128,17 @@ class LcnVariableSensor(LcnEntity, SensorEntity):
         )
         self._attr_device_class = DEVICE_CLASS_MAPPING.get(self.unit)
 
-    async def async_update(self) -> None:
-        """Update the state of the entity."""
-        await self.device_connection.request_status_variable(
-            self.variable, SCAN_INTERVAL.seconds
-        )
+    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)
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
@@ -167,11 +170,17 @@ class LcnLedLogicSensor(LcnEntity, SensorEntity):
                 config[CONF_DOMAIN_DATA][CONF_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
-        )
+    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)
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""

homeassistant/components/lcn/services.py

@@ -3,7 +3,6 @@
 from enum import StrEnum, auto
 
 import pypck
-from pypck.device import DeviceConnection
 import voluptuous as vol
 
 from homeassistant.const import (
@@ -49,7 +48,7 @@ from .const import (
     VAR_UNITS,
     VARIABLES,
 )
-from .helpers import LcnConfigEntry, is_states_string
+from .helpers import DeviceConnectionType, LcnConfigEntry, is_states_string
 
 
 class LcnServiceCall:
@@ -66,7 +65,7 @@ class LcnServiceCall:
         """Initialize service call."""
         self.hass = hass
 
-    def get_device_connection(self, service: ServiceCall) -> DeviceConnection:
+    def get_device_connection(self, service: ServiceCall) -> DeviceConnectionType:
         """Get address connection object."""
         entries: list[LcnConfigEntry] = self.hass.config_entries.async_loaded_entries(
             DOMAIN
@@ -381,6 +380,9 @@ 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,7 +1,6 @@
 """Support for LCN switches."""
 
 from collections.abc import Iterable
-from datetime import timedelta
 from functools import partial
 from typing import Any
 
@@ -18,7 +17,6 @@ from .entity import LcnEntity
 from .helpers import InputType, LcnConfigEntry
 
 PARALLEL_UPDATES = 0
-SCAN_INTERVAL = timedelta(minutes=1)
 
 
 def add_lcn_switch_entities(
@@ -79,6 +77,18 @@ 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):
@@ -93,12 +103,6 @@ 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 (
@@ -122,6 +126,18 @@ 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
@@ -140,10 +156,6 @@ 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):
@@ -167,6 +179,22 @@ 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):
@@ -181,12 +209,6 @@ 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 (
@@ -212,6 +234,18 @@ 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
@@ -234,10 +268,6 @@ 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,7 +7,6 @@ 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
@@ -38,6 +37,7 @@ from .const import (
     DOMAIN,
 )
 from .helpers import (
+    DeviceConnectionType,
     LcnConfigEntry,
     async_update_device_config,
     generate_unique_id,
@@ -182,7 +182,7 @@ async def websocket_scan_devices(
     host_connection = config_entry.runtime_data.connection
     await host_connection.scan_modules()
 
-    for device_connection in host_connection.device_connections.values():
+    for device_connection in host_connection.address_conns.values():
         if not device_connection.is_group:
             await async_create_or_update_device_in_config_entry(
                 hass, device_connection, config_entry
@@ -421,7 +421,7 @@ async def websocket_delete_entity(
 
 async def async_create_or_update_device_in_config_entry(
     hass: HomeAssistant,
-    device_connection: DeviceConnection,
+    device_connection: DeviceConnectionType,
     config_entry: LcnConfigEntry,
 ) -> None:
     """Create or update device in config_entry according to given device_connection."""

homeassistant/components/local_todo/todo.py

@@ -154,7 +154,6 @@ class LocalTodoListEntity(TodoListEntity):
                     ),
                     due=due,
                     description=item.description,
-                    completed=item.completed,
                 )
             )
         self._attr_todo_items = todo_items

homeassistant/components/matter/sensor.py

@@ -183,13 +183,6 @@ PUMP_CONTROL_MODE_MAP = {
     clusters.PumpConfigurationAndControl.Enums.ControlModeEnum.kUnknownEnumValue: None,
 }
 
-SETPOINT_CHANGE_SOURCE_MAP = {
-    clusters.Thermostat.Enums.SetpointChangeSourceEnum.kManual: "manual",
-    clusters.Thermostat.Enums.SetpointChangeSourceEnum.kSchedule: "schedule",
-    clusters.Thermostat.Enums.SetpointChangeSourceEnum.kExternal: "external",
-    clusters.Thermostat.Enums.SetpointChangeSourceEnum.kUnknownEnumValue: None,
-}
-
 HUMIDITY_SCALING_FACTOR = 100
 TEMPERATURE_SCALING_FACTOR = 100
 
@@ -1495,47 +1488,4 @@ DISCOVERY_SCHEMAS = [
         entity_class=MatterSensor,
         required_attributes=(clusters.ServiceArea.Attributes.EstimatedEndTime,),
     ),
-    MatterDiscoverySchema(
-        platform=Platform.SENSOR,
-        entity_description=MatterSensorEntityDescription(
-            key="SetpointChangeSource",
-            translation_key="setpoint_change_source",
-            device_class=SensorDeviceClass.ENUM,
-            state_class=None,
-            # convert to set first to remove the duplicate unknown value
-            options=[x for x in SETPOINT_CHANGE_SOURCE_MAP.values() if x is not None],
-            device_to_ha=lambda x: SETPOINT_CHANGE_SOURCE_MAP[x],
-        ),
-        entity_class=MatterSensor,
-        required_attributes=(clusters.Thermostat.Attributes.SetpointChangeSource,),
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.SENSOR,
-        entity_description=MatterSensorEntityDescription(
-            key="SetpointChangeSourceTimestamp",
-            translation_key="setpoint_change_timestamp",
-            device_class=SensorDeviceClass.TIMESTAMP,
-            state_class=None,
-            device_to_ha=(lambda x: dt_util.utc_from_timestamp(x) if x > 0 else None),
-        ),
-        entity_class=MatterSensor,
-        required_attributes=(
-            clusters.Thermostat.Attributes.SetpointChangeSourceTimestamp,
-        ),
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.SENSOR,
-        entity_description=MatterSensorEntityDescription(
-            key="ThermostatSetpointChangeAmount",
-            translation_key="setpoint_change_amount",
-            native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-            suggested_display_precision=1,
-            device_class=SensorDeviceClass.TEMPERATURE,
-            device_to_ha=lambda x: x / TEMPERATURE_SCALING_FACTOR,
-            state_class=SensorStateClass.MEASUREMENT,
-        ),
-        entity_class=MatterSensor,
-        required_attributes=(clusters.Thermostat.Attributes.SetpointChangeAmount,),
-        device_type=(device_types.Thermostat,),
-    ),
 ]

homeassistant/components/matter/strings.json

@@ -194,7 +194,7 @@
         "name": "Altitude above sea level"
       },
       "auto_relock_timer": {
-        "name": "Auto-relock time"
+        "name": "Autorelock time"
       },
       "cook_time": {
         "name": "Cooking time"
@@ -223,9 +223,6 @@
       "pump_setpoint": {
         "name": "Setpoint"
       },
-      "setpoint_change_source_timestamp": {
-        "name": "Last change"
-      },
       "temperature_offset": {
         "name": "Temperature offset"
       },
@@ -521,20 +518,6 @@
       "rms_voltage": {
         "name": "Effective voltage"
       },
-      "setpoint_change_amount": {
-        "name": "Last change amount"
-      },
-      "setpoint_change_source": {
-        "name": "Last change source",
-        "state": {
-          "external": "External",
-          "manual": "Manual",
-          "schedule": "Schedule"
-        }
-      },
-      "setpoint_change_timestamp": {
-        "name": "Last change"
-      },
       "switch_current_position": {
         "name": "Current switch position"
       },

homeassistant/components/meteo_lt/weather.py

@@ -139,7 +139,7 @@ class MeteoLtWeatherEntity(CoordinatorEntity[MeteoLtUpdateCoordinator], WeatherE
             forecasts_by_date[date].append(timestamp)
 
         daily_forecasts = []
-        for date in sorted(forecasts_by_date.keys()):
+        for date in sorted(forecasts_by_date.keys())[:5]:
             day_forecasts = forecasts_by_date[date]
             if not day_forecasts:
                 continue
@@ -186,5 +186,5 @@ class MeteoLtWeatherEntity(CoordinatorEntity[MeteoLtUpdateCoordinator], WeatherE
             return None
         return [
             self._convert_forecast_data(forecast_data)
-            for forecast_data in self.coordinator.data.forecast_timestamps
+            for forecast_data in self.coordinator.data.forecast_timestamps[:24]
         ]

homeassistant/components/miele/button.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 import logging
 from typing import Final
 
-from aiohttp import ClientResponseError
+import aiohttp
 
 from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
 from homeassistant.core import HomeAssistant
@@ -153,12 +153,11 @@ class MieleButton(MieleEntity, ButtonEntity):
                 self._device_id,
                 {PROCESS_ACTION: self.entity_description.press_data},
             )
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting button state for %s: %s", self.entity_id, err)
+        except aiohttp.ClientResponseError as ex:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
                 },
-            ) from err
+            ) from ex

homeassistant/components/miele/climate.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final, cast
 
-from aiohttp import ClientResponseError
+import aiohttp
 from pymiele import MieleDevice, MieleTemperature
 
 from homeassistant.components.climate import (
@@ -250,8 +250,7 @@ class MieleClimate(MieleEntity, ClimateEntity):
                 cast(float, kwargs.get(ATTR_TEMPERATURE)),
                 self.entity_description.zone,
             )
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting climate state for %s: %s", self.entity_id, err)
+        except aiohttp.ClientError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/coordinator.py

@@ -73,7 +73,7 @@ class MieleDataUpdateCoordinator(DataUpdateCoordinator[MieleCoordinatorData]):
                     _LOGGER.debug(
                         "Error fetching actions for device %s: Status: %s, Message: %s",
                         device_id,
-                        str(err.status),
+                        err.status,
                         err.message,
                     )
                     actions_json = {}

homeassistant/components/miele/fan.py

@@ -142,15 +142,14 @@ class MieleFan(MieleEntity, FanEntity):
                 await self.api.send_action(
                     self._device_id, {VENTILATION_STEP: ventilation_step}
                 )
-            except ClientResponseError as err:
-                _LOGGER.debug("Error setting fan state for %s: %s", self.entity_id, err)
+            except ClientResponseError as ex:
                 raise HomeAssistantError(
                     translation_domain=DOMAIN,
                     translation_key="set_state_error",
                     translation_placeholders={
                         "entity": self.entity_id,
                     },
-                ) from err
+                ) from ex
             self.device.state_ventilation_step = ventilation_step
             self.async_write_ha_state()
 
@@ -172,7 +171,6 @@ class MieleFan(MieleEntity, FanEntity):
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
-                    "err_status": str(ex.status),
                 },
             ) from ex
 
@@ -190,7 +188,6 @@ class MieleFan(MieleEntity, FanEntity):
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
-                    "err_status": str(ex.status),
                 },
             ) from ex
 

homeassistant/components/miele/light.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final
 
-from aiohttp import ClientResponseError
+import aiohttp
 
 from homeassistant.components.light import (
     ColorMode,
@@ -131,8 +131,7 @@ class MieleLight(MieleEntity, LightEntity):
             await self.api.send_action(
                 self._device_id, {self.entity_description.light_type: mode}
             )
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting light state for %s: %s", self.entity_id, err)
+        except aiohttp.ClientError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/services.py

@@ -4,7 +4,7 @@ from datetime import timedelta
 import logging
 from typing import cast
 
-from aiohttp import ClientResponseError
+import aiohttp
 import voluptuous as vol
 
 from homeassistant.const import ATTR_DEVICE_ID, ATTR_TEMPERATURE
@@ -107,7 +107,7 @@ async def set_program(call: ServiceCall) -> None:
     data = {"programId": call.data[ATTR_PROGRAM_ID]}
     try:
         await api.set_program(serial_number, data)
-    except ClientResponseError as ex:
+    except aiohttp.ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="set_program_error",
@@ -137,7 +137,7 @@ async def set_program_oven(call: ServiceCall) -> None:
         data["temperature"] = call.data[ATTR_TEMPERATURE]
     try:
         await api.set_program(serial_number, data)
-    except ClientResponseError as ex:
+    except aiohttp.ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="set_program_oven_error",
@@ -157,7 +157,7 @@ async def get_programs(call: ServiceCall) -> ServiceResponse:
 
     try:
         programs = await api.get_programs(serial_number)
-    except ClientResponseError as ex:
+    except aiohttp.ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="get_programs_error",

homeassistant/components/miele/switch.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final, cast
 
-from aiohttp import ClientResponseError
+import aiohttp
 from pymiele import MieleDevice
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
@@ -165,8 +165,7 @@ class MieleSwitch(MieleEntity, SwitchEntity):
         """Set switch to mode."""
         try:
             await self.api.send_action(self._device_id, mode)
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting switch state for %s: %s", self.entity_id, err)
+        except aiohttp.ClientError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
@@ -198,8 +197,7 @@ class MielePowerSwitch(MieleSwitch):
         """Set switch to mode."""
         try:
             await self.api.send_action(self._device_id, mode)
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting switch state for %s: %s", self.entity_id, err)
+        except aiohttp.ClientError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/vacuum.py

@@ -189,15 +189,14 @@ class MieleVacuum(MieleEntity, StateVacuumEntity):
         """Send action to the device."""
         try:
             await self.api.send_action(device_id, action)
-        except ClientResponseError as err:
-            _LOGGER.debug("Error setting vacuum state for %s: %s", self.entity_id, err)
+        except ClientResponseError as ex:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
                 },
-            ) from err
+            ) from ex
 
     async def async_clean_spot(self, **kwargs: Any) -> None:
         """Clean spot."""

homeassistant/components/mobile_app/__init__.py

@@ -41,11 +41,9 @@ 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,
 )
@@ -77,7 +75,6 @@ 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, STATE_UNKNOWN
+from homeassistant.const import CONF_WEBHOOK_ID, STATE_ON
 from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -75,9 +75,8 @@ class MobileAppBinarySensor(MobileAppEntity, BinarySensorEntity):
 
     async def async_restore_last_state(self, last_state: State) -> None:
         """Restore previous state."""
-        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
+        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,7 +20,6 @@ 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"
@@ -95,5 +94,3 @@ 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,16 +2,10 @@
 
 from __future__ import annotations
 
-import logging
+from typing import Any
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_ICON,
-    CONF_NAME,
-    CONF_UNIQUE_ID,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
+from homeassistant.const import ATTR_ICON, CONF_NAME, CONF_UNIQUE_ID, STATE_UNAVAILABLE
 from homeassistant.core import State, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.restore_state import RestoreEntity
@@ -24,15 +18,10 @@ 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."""
@@ -67,14 +56,11 @@ class MobileAppEntity(RestoreEntity):
         self.async_on_remove(
             async_dispatcher_connect(
                 self.hass,
-                f"{SIGNAL_SENSOR_UPDATE}-{self._config[ATTR_SENSOR_TYPE]}-{self._attr_unique_id}",
+                f"{SIGNAL_SENSOR_UPDATE}-{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
 
@@ -83,16 +69,13 @@ class MobileAppEntity(RestoreEntity):
     async def async_restore_last_state(self, last_state: State) -> None:
         """Restore previous state."""
         config = self._config
-
-        # 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]
+        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):
@@ -100,21 +83,8 @@ class MobileAppEntity(RestoreEntity):
         return device_info(self._registration)
 
     @callback
-    def _handle_update(self) -> None:
+    def _handle_update(self, data: dict[str, Any]) -> None:
         """Handle async event updates."""
-        self._apply_pending_update()
+        self._config.update(data)
         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,26 +86,24 @@ 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 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
+        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,6 +79,7 @@ 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,
@@ -97,14 +98,12 @@ 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,
 )
@@ -126,6 +125,8 @@ 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(
         {
@@ -600,16 +601,14 @@ async def webhook_register_sensor(
         if changes:
             entity_registry.async_update_entity(existing_sensor, **changes)
 
-        _async_update_sensor_entity(
-            hass, entity_type=entity_type, unique_store_key=unique_store_key, data=data
-        )
+        async_dispatcher_send(hass, f"{SIGNAL_SENSOR_UPDATE}-{unique_store_key}", 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}_{entity_type}_register"
+        register_signal = f"{DOMAIN}_{data[ATTR_SENSOR_TYPE]}_register"
         async_dispatcher_send(hass, register_signal, data)
 
     return webhook_response(
@@ -686,12 +685,10 @@ async def webhook_update_sensor_states(
             continue
 
         sensor[CONF_WEBHOOK_ID] = config_entry.data[CONF_WEBHOOK_ID]
-
-        _async_update_sensor_entity(
+        async_dispatcher_send(
             hass,
-            entity_type=entity_type,
-            unique_store_key=unique_store_key,
-            data=sensor,
+            f"{SIGNAL_SENSOR_UPDATE}-{unique_store_key}",
+            sensor,
         )
 
         resp[unique_id] = {"success": True}
@@ -700,26 +697,11 @@ 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/modbus/sensor.py

@@ -88,8 +88,6 @@ class ModbusRegisterSensor(ModbusStructEntity, RestoreSensor, SensorEntity):
         self._attr_device_class = entry.get(CONF_DEVICE_CLASS)
         if self._precision > 0 or self._scale != int(self._scale):
             self._value_is_int = False
-        if self._precision > 0 and self._data_type not in ["string", "custom"]:
-            self._attr_suggested_display_precision = self._precision
 
     async def async_setup_slaves(
         self, hass: HomeAssistant, slave_count: int, entry: dict[str, Any]

homeassistant/components/mqtt/config_flow.py

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

homeassistant/components/mqtt/strings.json

@@ -1312,7 +1312,6 @@
         "speed": "[%key:component::sensor::entity_component::speed::name%]",
         "sulphur_dioxide": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]",
         "temperature": "[%key:component::sensor::entity_component::temperature::name%]",
-        "temperature_delta": "[%key:component::sensor::entity_component::temperature_delta::name%]",
         "timestamp": "[%key:component::sensor::entity_component::timestamp::name%]",
         "volatile_organic_compounds": "[%key:component::sensor::entity_component::volatile_organic_compounds::name%]",
         "volatile_organic_compounds_parts": "[%key:component::sensor::entity_component::volatile_organic_compounds_parts::name%]",

homeassistant/components/music_assistant/__init__.py

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

homeassistant/components/music_assistant/helpers.py

@@ -4,18 +4,11 @@ from __future__ import annotations
 
 from collections.abc import Callable, Coroutine
 import functools
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from music_assistant_models.errors import MusicAssistantError
 
-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
+from homeassistant.exceptions import HomeAssistantError
 
 
 def catch_musicassistant_error[**_P, _R](
@@ -33,16 +26,3 @@ 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,9 +22,11 @@ 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,
@@ -39,26 +41,38 @@ 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
+from homeassistant.core import HomeAssistant, ServiceResponse, SupportsResponse
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+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.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
@@ -108,6 +122,11 @@ 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,
@@ -124,6 +143,44 @@ 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,13 +4,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from music_assistant_models.enums import MediaType, QueueOption
+from music_assistant_models.enums import MediaType
 import voluptuous as vol
 
-from homeassistant.components.media_player import (
-    ATTR_MEDIA_ENQUEUE,
-    DOMAIN as MEDIA_PLAYER_DOMAIN,
-)
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_CONFIG_ENTRY_ID
 from homeassistant.core import (
     HomeAssistant,
@@ -20,41 +17,31 @@ from homeassistant.core import (
     callback,
 )
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import config_validation as cv, service
+from homeassistant.helpers import config_validation as cv
 
 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,
@@ -62,6 +49,7 @@ from .schemas import (
 )
 
 if TYPE_CHECKING:
+    from music_assistant_client import MusicAssistantClient
     from music_assistant_models.media_items import (
         Album,
         Artist,
@@ -72,18 +60,28 @@ 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."""
@@ -126,55 +124,6 @@ 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."""