Move ENTITY_STATE_TRIGGER_SCHEMA close to EntityTriggerBase

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

.github/workflows/builder.yml

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

.github/workflows/ci.yaml

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

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0

.github/workflows/wheels.yml

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

.pre-commit-config.yaml

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

.strict-typing

@@ -231,6 +231,7 @@ 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.*
@@ -578,6 +579,7 @@ homeassistant.components.wiz.*
 homeassistant.components.wled.*
 homeassistant.components.workday.*
 homeassistant.components.worldclock.*
+homeassistant.components.xbox.*
 homeassistant.components.xiaomi_ble.*
 homeassistant.components.yale_smart_alarm.*
 homeassistant.components.yalexs_ble.*

CODEOWNERS

@@ -607,6 +607,8 @@ 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
@@ -1374,6 +1376,8 @@ 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
@@ -1732,6 +1736,8 @@ build.json @home-assistant/supervisor
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /homeassistant/components/vicare/ @CFenner
 /tests/components/vicare/ @CFenner
+/homeassistant/components/victron_ble/ @rajlaud
+/tests/components/victron_ble/ @rajlaud
 /homeassistant/components/victron_remote_monitoring/ @AndyTempel
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  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
+  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
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/brands/google.json

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

homeassistant/brands/victron.json

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

homeassistant/components/adguard/__init__.py

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

homeassistant/components/adguard/manifest.json

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

homeassistant/components/adguard/update.py

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

homeassistant/components/alarm_control_panel/icons.json

@@ -36,5 +36,13 @@
     "alarm_trigger": {
       "service": "mdi:bell-ring"
     }
+  },
+  "triggers": {
+    "disarmed": {
+      "trigger": "mdi:shield-off"
+    },
+    "triggered": {
+      "trigger": "mdi:bell-ring"
+    }
   }
 }

homeassistant/components/alarm_control_panel/strings.json

@@ -71,6 +71,15 @@
       "message": "Arming requires a code but none was given for {entity_id}."
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "alarm_arm_away": {
       "description": "Arms the alarm in the away mode.",
@@ -143,5 +152,29 @@
       "name": "Trigger"
     }
   },
-  "title": "Alarm control panel"
+  "title": "Alarm control panel",
+  "triggers": {
+    "disarmed": {
+      "description": "Triggers when an alarm is disarmed.",
+      "description_configured": "[%key:component::alarm_control_panel::triggers::disarmed::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted alarms to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When an alarm is disarmed"
+    },
+    "triggered": {
+      "description": "Triggers when an alarm is triggered.",
+      "description_configured": "[%key:component::alarm_control_panel::triggers::triggered::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::triggers::disarmed::fields::behavior::description%]",
+          "name": "[%key:component::alarm_control_panel::triggers::disarmed::fields::behavior::name%]"
+        }
+      },
+      "name": "When an alarm is triggered"
+    }
+  }
 }

homeassistant/components/alarm_control_panel/trigger.py

@@ -0,0 +1,16 @@
+"""Provides triggers for alarm control panels."""
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+
+from .const import DOMAIN, AlarmControlPanelState
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "disarmed": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.DISARMED),
+    "triggered": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.TRIGGERED),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for alarm control panels."""
+    return TRIGGERS

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -0,0 +1,19 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: alarm_control_panel
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+disarmed: *trigger_common
+
+triggered: *trigger_common

homeassistant/components/alexa_devices/coordinator.py

@@ -16,6 +16,7 @@ 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
@@ -43,6 +44,9 @@ 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/analytics/__init__.py

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

homeassistant/components/analytics/analytics.py

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

homeassistant/components/analytics/const.py

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

homeassistant/components/anthropic/config_flow.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from functools import partial
 import json
 import logging
+import re
 from typing import Any
 
 import anthropic
@@ -283,7 +284,11 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             vol.Optional(
                 CONF_CHAT_MODEL,
                 default=RECOMMENDED_CHAT_MODEL,
-            ): str,
+            ): SelectSelector(
+                SelectSelectorConfig(
+                    options=await self._get_model_list(), custom_value=True
+                )
+            ),
             vol.Optional(
                 CONF_MAX_TOKENS,
                 default=RECOMMENDED_MAX_TOKENS,
@@ -394,6 +399,39 @@ 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.69.0"]
+  "requirements": ["anthropic==0.73.0"]
 }

homeassistant/components/apcupsd/const.py

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

homeassistant/components/apcupsd/sensor.py

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

homeassistant/components/apcupsd/strings.json

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

homeassistant/components/assist_satellite/icons.json

@@ -14,5 +14,19 @@
     "start_conversation": {
       "service": "mdi:forum"
     }
+  },
+  "triggers": {
+    "idle": {
+      "trigger": "mdi:chat-sleep"
+    },
+    "listening": {
+      "trigger": "mdi:chat-question"
+    },
+    "processing": {
+      "trigger": "mdi:chat-processing"
+    },
+    "responding": {
+      "trigger": "mdi:chat-alert"
+    }
   }
 }

homeassistant/components/assist_satellite/strings.json

@@ -16,6 +16,13 @@
         "id": "Answer ID",
         "sentences": "Sentences"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -98,5 +105,51 @@
       "name": "Start conversation"
     }
   },
-  "title": "Assist satellite"
+  "title": "Assist satellite",
+  "triggers": {
+    "idle": {
+      "description": "Triggers when an assist satellite becomes idle.",
+      "description_configured": "[%key:component::assist_satellite::triggers::idle::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted assist satellites to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When an assist satellite becomes idle"
+    },
+    "listening": {
+      "description": "Triggers when an assist satellite starts listening.",
+      "description_configured": "[%key:component::assist_satellite::triggers::listening::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite starts listening"
+    },
+    "processing": {
+      "description": "Triggers when an assist satellite is processing.",
+      "description_configured": "[%key:component::assist_satellite::triggers::processing::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite is processing"
+    },
+    "responding": {
+      "description": "Triggers when an assist satellite is responding.",
+      "description_configured": "[%key:component::assist_satellite::triggers::responding::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite is responding"
+    }
+  }
 }

homeassistant/components/assist_satellite/trigger.py

@@ -0,0 +1,19 @@
+"""Provides triggers for assist satellites."""
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+
+from .const import DOMAIN
+from .entity import AssistSatelliteState
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "idle": make_entity_state_trigger(DOMAIN, AssistSatelliteState.IDLE),
+    "listening": make_entity_state_trigger(DOMAIN, AssistSatelliteState.LISTENING),
+    "processing": make_entity_state_trigger(DOMAIN, AssistSatelliteState.PROCESSING),
+    "responding": make_entity_state_trigger(DOMAIN, AssistSatelliteState.RESPONDING),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for assist satellites."""
+    return TRIGGERS

homeassistant/components/assist_satellite/triggers.yaml

@@ -0,0 +1,20 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: assist_satellite
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+idle: *trigger_common
+listening: *trigger_common
+processing: *trigger_common
+responding: *trigger_common

homeassistant/components/asuswrt/bridge.py

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

homeassistant/components/bsblan/climate.py

@@ -74,8 +74,11 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         super().__init__(data.fast_coordinator, data)
         self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"
 
-        self._attr_min_temp = data.static.min_temp.value
-        self._attr_max_temp = data.static.max_temp.value
+        # 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_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.0"],
+  "requirements": ["python-bsblan==3.1.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/climate/icons.json

@@ -96,5 +96,13 @@
     "turn_on": {
       "service": "mdi:power-on"
     }
+  },
+  "triggers": {
+    "started_heating": {
+      "trigger": "mdi:fire"
+    },
+    "turned_off": {
+      "trigger": "mdi:power-off"
+    }
   }
 }

homeassistant/components/climate/strings.json

@@ -187,6 +187,13 @@
         "heat_cool": "Heat/cool",
         "off": "[%key:common::state::off%]"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -285,5 +292,29 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Climate"
+  "title": "Climate",
+  "triggers": {
+    "started_heating": {
+      "description": "Triggers when a climate starts to heat.",
+      "description_configured": "[%key:component::climate::triggers::started_heating::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::triggers::turned_off::fields::behavior::description%]",
+          "name": "[%key:component::climate::triggers::turned_off::fields::behavior::name%]"
+        }
+      },
+      "name": "When a climate starts to heat"
+    },
+    "turned_off": {
+      "description": "Triggers when a climate is turned off.",
+      "description_configured": "[%key:component::climate::triggers::turned_off::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted climates to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When a climate is turned off"
+    }
+  }
 }

homeassistant/components/climate/trigger.py

@@ -0,0 +1,23 @@
+"""Provides triggers for climates."""
+
+from homeassistant.const import STATE_OFF
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import (
+    Trigger,
+    make_entity_state_attribute_trigger,
+    make_entity_state_trigger,
+)
+
+from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turned_off": make_entity_state_trigger(DOMAIN, STATE_OFF),
+    "started_heating": make_entity_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
+    ),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for climates."""
+    return TRIGGERS

homeassistant/components/climate/triggers.yaml

@@ -0,0 +1,19 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: climate
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: trigger_behavior
+          options:
+            - first
+            - last
+            - any
+
+started_heating: *trigger_common
+
+turned_off: *trigger_common

homeassistant/components/cloud/__init__.py

@@ -55,6 +55,7 @@ from .const import (
     CONF_ALIASES,
     CONF_API_SERVER,
     CONF_COGNITO_CLIENT_ID,
+    CONF_DISCOVERY_SERVICE_ACTIONS,
     CONF_ENTITY_CONFIG,
     CONF_FILTER,
     CONF_GOOGLE_ACTIONS,
@@ -139,6 +140,7 @@ 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,6 +79,7 @@ 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

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

homeassistant/components/cosori/manifest.json

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

homeassistant/components/cover/icons.json

@@ -108,5 +108,10 @@
     "toggle_cover_tilt": {
       "service": "mdi:arrow-top-right-bottom-left"
     }
+  },
+  "triggers": {
+    "garage_opened": {
+      "trigger": "mdi:garage-open"
+    }
   }
 }

homeassistant/components/cover/strings.json

@@ -82,6 +82,15 @@
       "name": "Window"
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "close_cover": {
       "description": "Closes a cover.",
@@ -136,5 +145,22 @@
       "name": "Toggle tilt"
     }
   },
-  "title": "Cover"
+  "title": "Cover",
+  "triggers": {
+    "garage_opened": {
+      "description": "Triggers when a garage door opens.",
+      "description_configured": "[%key:component::cover::triggers::garage_opened::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted garage doors to trigger on.",
+          "name": "Behavior"
+        },
+        "fully_opened": {
+          "description": "Require the garage doors to be fully opened before triggering.",
+          "name": "Fully opened"
+        }
+      },
+      "name": "When a garage door opens"
+    }
+  }
 }

homeassistant/components/cover/trigger.py

@@ -0,0 +1,108 @@
+"""Provides triggers for covers."""
+
+from typing import Final
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_OPTIONS
+from homeassistant.core import HomeAssistant, State
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity import get_device_class
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+    TriggerConfig,
+)
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+
+from . import ATTR_CURRENT_POSITION, CoverDeviceClass, CoverState
+from .const import DOMAIN
+
+ATTR_FULLY_OPENED: Final = "fully_opened"
+
+COVER_OPENED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(ATTR_FULLY_OPENED, default=False): bool,
+        },
+    }
+)
+
+
+def get_device_class_or_undefined(
+    hass: HomeAssistant, entity_id: str
+) -> str | None | UndefinedType:
+    """Get the device class of an entity or UNDEFINED if not found."""
+    try:
+        return get_device_class(hass, entity_id)
+    except HomeAssistantError:
+        return UNDEFINED
+
+
+class CoverOpenedClosedTrigger(EntityTriggerBase):
+    """Class for cover opened and closed triggers."""
+
+    _attribute: str = ATTR_CURRENT_POSITION
+    _attribute_value: int | None = None
+    _device_class: CoverDeviceClass | None
+    _domain: str = DOMAIN
+    _to_states: set[str]
+
+    def is_to_state(self, state: State) -> bool:
+        """Check if the state matches the target state."""
+        if state.state not in self._to_states:
+            return False
+        if (
+            self._attribute_value is not None
+            and (value := state.attributes.get(self._attribute)) is not None
+            and value != self._attribute_value
+        ):
+            return False
+        return True
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == self._device_class
+        }
+
+
+class CoverOpenedTrigger(CoverOpenedClosedTrigger):
+    """Class for cover opened triggers."""
+
+    _schema = COVER_OPENED_TRIGGER_SCHEMA
+    _to_states = {CoverState.OPEN, CoverState.OPENING}
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the state trigger."""
+        super().__init__(hass, config)
+        if self._options.get(ATTR_FULLY_OPENED):
+            self._attribute_value = 100
+
+
+def make_cover_opened_trigger(
+    device_class: CoverDeviceClass | None,
+) -> type[CoverOpenedTrigger]:
+    """Create an entity state attribute trigger class."""
+
+    class CustomTrigger(CoverOpenedTrigger):
+        """Trigger for entity state changes."""
+
+        _device_class = device_class
+
+    return CustomTrigger
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "garage_opened": make_cover_opened_trigger(CoverDeviceClass.GARAGE),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for covers."""
+    return TRIGGERS

homeassistant/components/cover/triggers.yaml

@@ -0,0 +1,21 @@
+garage_opened:
+  target:
+    entity:
+      domain: cover
+      device_class: garage
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: trigger_behavior
+          options:
+            - first
+            - last
+            - any
+    fully_opened:
+      required: true
+      default: false
+      selector:
+        boolean:

homeassistant/components/cync/__init__.py

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

homeassistant/components/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.45.0", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.46.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.45.0"],
+  "requirements": ["async-upnp-client==0.46.0"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",

homeassistant/components/emoncms/quality_scale.yaml

@@ -0,0 +1,84 @@
+rules:
+  # todo : add get_feed_list to the library
+  # todo : see if we can drop some extra attributes
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage:
+    status: todo
+    comment: |
+      test_reconfigure_api_error should use a mock config entry fixture
+      test_user_flow_failure should use a mock config entry fixture
+      move test_user_flow_* to the top of the file
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      No events are explicitly registered by the integration.
+  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: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage:
+    status: todo
+    comment: |
+      test the entry state in test_failure
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples:
+    status: exempt
+    comment: |
+      This integration does not provide any automation
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class:
+    status: todo
+    comment: change device_class=SensorDeviceClass.SIGNAL_STRENGTH to SOUND_PRESSURE
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: done
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/energy/validate.py

@@ -386,11 +386,260 @@ def _async_validate_auto_generated_cost_entity(
         issues.add_issue(hass, "recorder_untracked", cost_entity_id)
 
 
+def _validate_grid_source(
+    hass: HomeAssistant,
+    source: data.GridSourceType,
+    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
+    wanted_statistics_metadata: set[str],
+    source_result: ValidationIssues,
+    validate_calls: list[functools.partial[None]],
+) -> None:
+    """Validate grid energy source."""
+    flow_from: data.FlowFromGridSourceType
+    for flow_from in source["flow_from"]:
+        wanted_statistics_metadata.add(flow_from["stat_energy_from"])
+        validate_calls.append(
+            functools.partial(
+                _async_validate_usage_stat,
+                hass,
+                statistics_metadata,
+                flow_from["stat_energy_from"],
+                ENERGY_USAGE_DEVICE_CLASSES,
+                ENERGY_USAGE_UNITS,
+                ENERGY_UNIT_ERROR,
+                source_result,
+            )
+        )
+
+        if (stat_cost := flow_from.get("stat_cost")) is not None:
+            wanted_statistics_metadata.add(stat_cost)
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_cost_stat,
+                    hass,
+                    statistics_metadata,
+                    stat_cost,
+                    source_result,
+                )
+            )
+        elif (entity_energy_price := flow_from.get("entity_energy_price")) is not None:
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_price_entity,
+                    hass,
+                    entity_energy_price,
+                    source_result,
+                    ENERGY_PRICE_UNITS,
+                    ENERGY_PRICE_UNIT_ERROR,
+                )
+            )
+
+        if (
+            flow_from.get("entity_energy_price") is not None
+            or flow_from.get("number_energy_price") is not None
+        ):
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_auto_generated_cost_entity,
+                    hass,
+                    flow_from["stat_energy_from"],
+                    source_result,
+                )
+            )
+
+    flow_to: data.FlowToGridSourceType
+    for flow_to in source["flow_to"]:
+        wanted_statistics_metadata.add(flow_to["stat_energy_to"])
+        validate_calls.append(
+            functools.partial(
+                _async_validate_usage_stat,
+                hass,
+                statistics_metadata,
+                flow_to["stat_energy_to"],
+                ENERGY_USAGE_DEVICE_CLASSES,
+                ENERGY_USAGE_UNITS,
+                ENERGY_UNIT_ERROR,
+                source_result,
+            )
+        )
+
+        if (stat_compensation := flow_to.get("stat_compensation")) is not None:
+            wanted_statistics_metadata.add(stat_compensation)
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_cost_stat,
+                    hass,
+                    statistics_metadata,
+                    stat_compensation,
+                    source_result,
+                )
+            )
+        elif (entity_energy_price := flow_to.get("entity_energy_price")) is not None:
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_price_entity,
+                    hass,
+                    entity_energy_price,
+                    source_result,
+                    ENERGY_PRICE_UNITS,
+                    ENERGY_PRICE_UNIT_ERROR,
+                )
+            )
+
+        if (
+            flow_to.get("entity_energy_price") is not None
+            or flow_to.get("number_energy_price") is not None
+        ):
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_auto_generated_cost_entity,
+                    hass,
+                    flow_to["stat_energy_to"],
+                    source_result,
+                )
+            )
+
+    for power_stat in source.get("power", []):
+        wanted_statistics_metadata.add(power_stat["stat_rate"])
+        validate_calls.append(
+            functools.partial(
+                _async_validate_power_stat,
+                hass,
+                statistics_metadata,
+                power_stat["stat_rate"],
+                POWER_USAGE_DEVICE_CLASSES,
+                POWER_USAGE_UNITS,
+                POWER_UNIT_ERROR,
+                source_result,
+            )
+        )
+
+
+def _validate_gas_source(
+    hass: HomeAssistant,
+    source: data.GasSourceType,
+    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
+    wanted_statistics_metadata: set[str],
+    source_result: ValidationIssues,
+    validate_calls: list[functools.partial[None]],
+) -> None:
+    """Validate gas energy source."""
+    wanted_statistics_metadata.add(source["stat_energy_from"])
+    validate_calls.append(
+        functools.partial(
+            _async_validate_usage_stat,
+            hass,
+            statistics_metadata,
+            source["stat_energy_from"],
+            GAS_USAGE_DEVICE_CLASSES,
+            GAS_USAGE_UNITS,
+            GAS_UNIT_ERROR,
+            source_result,
+        )
+    )
+
+    if (stat_cost := source.get("stat_cost")) is not None:
+        wanted_statistics_metadata.add(stat_cost)
+        validate_calls.append(
+            functools.partial(
+                _async_validate_cost_stat,
+                hass,
+                statistics_metadata,
+                stat_cost,
+                source_result,
+            )
+        )
+    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+        validate_calls.append(
+            functools.partial(
+                _async_validate_price_entity,
+                hass,
+                entity_energy_price,
+                source_result,
+                GAS_PRICE_UNITS,
+                GAS_PRICE_UNIT_ERROR,
+            )
+        )
+
+    if (
+        source.get("entity_energy_price") is not None
+        or source.get("number_energy_price") is not None
+    ):
+        validate_calls.append(
+            functools.partial(
+                _async_validate_auto_generated_cost_entity,
+                hass,
+                source["stat_energy_from"],
+                source_result,
+            )
+        )
+
+
+def _validate_water_source(
+    hass: HomeAssistant,
+    source: data.WaterSourceType,
+    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
+    wanted_statistics_metadata: set[str],
+    source_result: ValidationIssues,
+    validate_calls: list[functools.partial[None]],
+) -> None:
+    """Validate water energy source."""
+    wanted_statistics_metadata.add(source["stat_energy_from"])
+    validate_calls.append(
+        functools.partial(
+            _async_validate_usage_stat,
+            hass,
+            statistics_metadata,
+            source["stat_energy_from"],
+            WATER_USAGE_DEVICE_CLASSES,
+            WATER_USAGE_UNITS,
+            WATER_UNIT_ERROR,
+            source_result,
+        )
+    )
+
+    if (stat_cost := source.get("stat_cost")) is not None:
+        wanted_statistics_metadata.add(stat_cost)
+        validate_calls.append(
+            functools.partial(
+                _async_validate_cost_stat,
+                hass,
+                statistics_metadata,
+                stat_cost,
+                source_result,
+            )
+        )
+    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+        validate_calls.append(
+            functools.partial(
+                _async_validate_price_entity,
+                hass,
+                entity_energy_price,
+                source_result,
+                WATER_PRICE_UNITS,
+                WATER_PRICE_UNIT_ERROR,
+            )
+        )
+
+    if (
+        source.get("entity_energy_price") is not None
+        or source.get("number_energy_price") is not None
+    ):
+        validate_calls.append(
+            functools.partial(
+                _async_validate_auto_generated_cost_entity,
+                hass,
+                source["stat_energy_from"],
+                source_result,
+            )
+        )
+
+
 async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
     """Validate the energy configuration."""
     manager: data.EnergyManager = await data.async_get_manager(hass)
     statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]] = {}
-    validate_calls = []
+    validate_calls: list[functools.partial[None]] = []
     wanted_statistics_metadata: set[str] = set()
 
     result = EnergyPreferencesValidation()
@@ -404,230 +653,35 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
         result.energy_sources.append(source_result)
 
         if source["type"] == "grid":
-            flow: data.FlowFromGridSourceType | data.FlowToGridSourceType
-            for flow in source["flow_from"]:
-                wanted_statistics_metadata.add(flow["stat_energy_from"])
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_usage_stat,
-                        hass,
-                        statistics_metadata,
-                        flow["stat_energy_from"],
-                        ENERGY_USAGE_DEVICE_CLASSES,
-                        ENERGY_USAGE_UNITS,
-                        ENERGY_UNIT_ERROR,
-                        source_result,
-                    )
-                )
-
-                if (stat_cost := flow.get("stat_cost")) is not None:
-                    wanted_statistics_metadata.add(stat_cost)
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_cost_stat,
-                            hass,
-                            statistics_metadata,
-                            stat_cost,
-                            source_result,
-                        )
-                    )
-                elif (
-                    entity_energy_price := flow.get("entity_energy_price")
-                ) is not None:
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_price_entity,
-                            hass,
-                            entity_energy_price,
-                            source_result,
-                            ENERGY_PRICE_UNITS,
-                            ENERGY_PRICE_UNIT_ERROR,
-                        )
-                    )
-
-                if (
-                    flow.get("entity_energy_price") is not None
-                    or flow.get("number_energy_price") is not None
-                ):
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_auto_generated_cost_entity,
-                            hass,
-                            flow["stat_energy_from"],
-                            source_result,
-                        )
-                    )
-
-            for flow in source["flow_to"]:
-                wanted_statistics_metadata.add(flow["stat_energy_to"])
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_usage_stat,
-                        hass,
-                        statistics_metadata,
-                        flow["stat_energy_to"],
-                        ENERGY_USAGE_DEVICE_CLASSES,
-                        ENERGY_USAGE_UNITS,
-                        ENERGY_UNIT_ERROR,
-                        source_result,
-                    )
-                )
-
-                if (stat_compensation := flow.get("stat_compensation")) is not None:
-                    wanted_statistics_metadata.add(stat_compensation)
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_cost_stat,
-                            hass,
-                            statistics_metadata,
-                            stat_compensation,
-                            source_result,
-                        )
-                    )
-                elif (
-                    entity_energy_price := flow.get("entity_energy_price")
-                ) is not None:
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_price_entity,
-                            hass,
-                            entity_energy_price,
-                            source_result,
-                            ENERGY_PRICE_UNITS,
-                            ENERGY_PRICE_UNIT_ERROR,
-                        )
-                    )
-
-                if (
-                    flow.get("entity_energy_price") is not None
-                    or flow.get("number_energy_price") is not None
-                ):
-                    validate_calls.append(
-                        functools.partial(
-                            _async_validate_auto_generated_cost_entity,
-                            hass,
-                            flow["stat_energy_to"],
-                            source_result,
-                        )
-                    )
-
-            for power_stat in source.get("power", []):
-                wanted_statistics_metadata.add(power_stat["stat_rate"])
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_power_stat,
-                        hass,
-                        statistics_metadata,
-                        power_stat["stat_rate"],
-                        POWER_USAGE_DEVICE_CLASSES,
-                        POWER_USAGE_UNITS,
-                        POWER_UNIT_ERROR,
-                        source_result,
-                    )
-                )
+            _validate_grid_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
+            )
 
         elif source["type"] == "gas":
-            wanted_statistics_metadata.add(source["stat_energy_from"])
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_usage_stat,
-                    hass,
-                    statistics_metadata,
-                    source["stat_energy_from"],
-                    GAS_USAGE_DEVICE_CLASSES,
-                    GAS_USAGE_UNITS,
-                    GAS_UNIT_ERROR,
-                    source_result,
-                )
+            _validate_gas_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
             )
 
-            if (stat_cost := source.get("stat_cost")) is not None:
-                wanted_statistics_metadata.add(stat_cost)
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_cost_stat,
-                        hass,
-                        statistics_metadata,
-                        stat_cost,
-                        source_result,
-                    )
-                )
-            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_price_entity,
-                        hass,
-                        entity_energy_price,
-                        source_result,
-                        GAS_PRICE_UNITS,
-                        GAS_PRICE_UNIT_ERROR,
-                    )
-                )
-
-            if (
-                source.get("entity_energy_price") is not None
-                or source.get("number_energy_price") is not None
-            ):
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_auto_generated_cost_entity,
-                        hass,
-                        source["stat_energy_from"],
-                        source_result,
-                    )
-                )
-
         elif source["type"] == "water":
-            wanted_statistics_metadata.add(source["stat_energy_from"])
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_usage_stat,
-                    hass,
-                    statistics_metadata,
-                    source["stat_energy_from"],
-                    WATER_USAGE_DEVICE_CLASSES,
-                    WATER_USAGE_UNITS,
-                    WATER_UNIT_ERROR,
-                    source_result,
-                )
+            _validate_water_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
             )
 
-            if (stat_cost := source.get("stat_cost")) is not None:
-                wanted_statistics_metadata.add(stat_cost)
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_cost_stat,
-                        hass,
-                        statistics_metadata,
-                        stat_cost,
-                        source_result,
-                    )
-                )
-            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_price_entity,
-                        hass,
-                        entity_energy_price,
-                        source_result,
-                        WATER_PRICE_UNITS,
-                        WATER_PRICE_UNIT_ERROR,
-                    )
-                )
-
-            if (
-                source.get("entity_energy_price") is not None
-                or source.get("number_energy_price") is not None
-            ):
-                validate_calls.append(
-                    functools.partial(
-                        _async_validate_auto_generated_cost_entity,
-                        hass,
-                        source["stat_energy_from"],
-                        source_result,
-                    )
-                )
-
         elif source["type"] == "solar":
             wanted_statistics_metadata.add(source["stat_energy_from"])
             validate_calls.append(

homeassistant/components/enphase_envoy/diagnostics.py

@@ -147,6 +147,8 @@ async def async_get_config_entry_diagnostics(
         "ctmeter_production_phases": envoy_data.ctmeter_production_phases,
         "ctmeter_consumption_phases": envoy_data.ctmeter_consumption_phases,
         "ctmeter_storage_phases": envoy_data.ctmeter_storage_phases,
+        "ctmeters": envoy_data.ctmeters,
+        "ctmeters_phases": envoy_data.ctmeters_phases,
         "dry_contact_status": envoy_data.dry_contact_status,
         "dry_contact_settings": envoy_data.dry_contact_settings,
         "inverters": envoy_data.inverters,
@@ -179,6 +181,7 @@ async def async_get_config_entry_diagnostics(
         "ct_consumption_meter": envoy.consumption_meter_type,
         "ct_production_meter": envoy.production_meter_type,
         "ct_storage_meter": envoy.storage_meter_type,
+        "ct_meters": list(envoy_data.ctmeters.keys()),
     }
 
     fixture_data: dict[str, Any] = {}

homeassistant/components/enphase_envoy/sensor.py

@@ -399,330 +399,189 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
     cttype: str | None = None
 
 
-CT_NET_CONSUMPTION_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_net_consumption",
-        translation_key="lifetime_net_consumption",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_delivered"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_net_production",
-        translation_key="lifetime_net_production",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_received"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption",
-        translation_key="net_consumption",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
-        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
-        suggested_display_precision=3,
-        value_fn=attrgetter("active_power"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="frequency",
-        translation_key="net_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="voltage",
-        translation_key="net_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_ct_current",
-        translation_key="net_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_ct_powerfactor",
-        translation_key="net_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption_ct_metering_status",
-        translation_key="net_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        options=list(CtMeterStatus),
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption_ct_status_flags",
-        translation_key="net_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-)
-
-
-CT_NET_CONSUMPTION_PHASE_SENSORS = {
-    (on_phase := PHASENAMES[phase]): [
-        replace(
-            sensor,
-            key=f"{sensor.key}_l{phase + 1}",
-            translation_key=f"{sensor.translation_key}_phase",
-            entity_registry_enabled_default=False,
-            on_phase=on_phase,
-            translation_placeholders={"phase_name": f"l{phase + 1}"},
+# All ct types unified in common setup
+CT_SENSORS = (
+    [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+            device_class=SensorDeviceClass.ENERGY,
+            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+            suggested_display_precision=3,
+            value_fn=attrgetter("energy_delivered"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "lifetime_net_consumption"),
+            # Production CT energy_delivered is not used
+            (CtType.STORAGE, "lifetime_battery_discharged"),
         )
-        for sensor in list(CT_NET_CONSUMPTION_SENSORS)
     ]
-    for phase in range(3)
-}
-
-CT_PRODUCTION_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_frequency",
-        translation_key="production_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_voltage",
-        translation_key="production_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_current",
-        translation_key="production_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_powerfactor",
-        translation_key="production_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_metering_status",
-        translation_key="production_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        options=list(CtMeterStatus),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_status_flags",
-        translation_key="production_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-)
-
-CT_PRODUCTION_PHASE_SENSORS = {
-    (on_phase := PHASENAMES[phase]): [
-        replace(
-            sensor,
-            key=f"{sensor.key}_l{phase + 1}",
-            translation_key=f"{sensor.translation_key}_phase",
-            entity_registry_enabled_default=False,
-            on_phase=on_phase,
-            translation_placeholders={"phase_name": f"l{phase + 1}"},
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+            device_class=SensorDeviceClass.ENERGY,
+            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+            suggested_display_precision=3,
+            value_fn=attrgetter("energy_received"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "lifetime_net_production"),
+            # Production CT energy_received is not used
+            (CtType.STORAGE, "lifetime_battery_charged"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfPower.WATT,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.POWER,
+            suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+            suggested_display_precision=3,
+            value_fn=attrgetter("active_power"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_consumption"),
+            # Production CT active_power is not used
+            (CtType.STORAGE, "battery_discharge"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            native_unit_of_measurement=UnitOfFrequency.HERTZ,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.FREQUENCY,
+            suggested_display_precision=1,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("frequency"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (CtType.NET_CONSUMPTION, "frequency", "net_ct_frequency"),
+            (CtType.PRODUCTION, "production_ct_frequency", ""),
+            (CtType.STORAGE, "storage_ct_frequency", ""),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.VOLTAGE,
+            suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            suggested_display_precision=1,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("voltage"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (CtType.NET_CONSUMPTION, "voltage", "net_ct_voltage"),
+            (CtType.PRODUCTION, "production_ct_voltage", ""),
+            (CtType.STORAGE, "storage_voltage", "storage_ct_voltage"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.CURRENT,
+            suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+            suggested_display_precision=3,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("current"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_ct_current"),
+            (CtType.PRODUCTION, "production_ct_current"),
+            (CtType.STORAGE, "storage_ct_current"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            device_class=SensorDeviceClass.POWER_FACTOR,
+            state_class=SensorStateClass.MEASUREMENT,
+            suggested_display_precision=2,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("power_factor"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_ct_powerfactor"),
+            (CtType.PRODUCTION, "production_ct_powerfactor"),
+            (CtType.STORAGE, "storage_ct_powerfactor"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            device_class=SensorDeviceClass.ENUM,
+            entity_category=EntityCategory.DIAGNOSTIC,
+            options=list(CtMeterStatus),
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("metering_status"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (
+                CtType.NET_CONSUMPTION,
+                "net_consumption_ct_metering_status",
+                "net_ct_metering_status",
+            ),
+            (CtType.PRODUCTION, "production_ct_metering_status", ""),
+            (CtType.STORAGE, "storage_ct_metering_status", ""),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            state_class=None,
+            entity_category=EntityCategory.DIAGNOSTIC,
+            entity_registry_enabled_default=False,
+            value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (
+                CtType.NET_CONSUMPTION,
+                "net_consumption_ct_status_flags",
+                "net_ct_status_flags",
+            ),
+            (CtType.PRODUCTION, "production_ct_status_flags", ""),
+            (CtType.STORAGE, "storage_ct_status_flags", ""),
         )
-        for sensor in list(CT_PRODUCTION_SENSORS)
     ]
-    for phase in range(3)
-}
-
-CT_STORAGE_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_battery_discharged",
-        translation_key="lifetime_battery_discharged",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_delivered"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_battery_charged",
-        translation_key="lifetime_battery_charged",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_received"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="battery_discharge",
-        translation_key="battery_discharge",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
-        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
-        suggested_display_precision=3,
-        value_fn=attrgetter("active_power"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_frequency",
-        translation_key="storage_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_voltage",
-        translation_key="storage_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_current",
-        translation_key="storage_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_powerfactor",
-        translation_key="storage_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_metering_status",
-        translation_key="storage_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        options=list(CtMeterStatus),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_status_flags",
-        translation_key="storage_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
 )
 
 
-CT_STORAGE_PHASE_SENSORS = {
+CT_PHASE_SENSORS = {
     (on_phase := PHASENAMES[phase]): [
         replace(
             sensor,
@@ -732,7 +591,7 @@ CT_STORAGE_PHASE_SENSORS = {
             on_phase=on_phase,
             translation_placeholders={"phase_name": f"l{phase + 1}"},
         )
-        for sensor in list(CT_STORAGE_SENSORS)
+        for sensor in list(CT_SENSORS)
     ]
     for phase in range(3)
 }
@@ -1060,24 +919,14 @@ async def async_setup_entry(
     if envoy_data.ctmeters:
         entities.extend(
             EnvoyCTEntity(coordinator, description)
-            for sensors in (
-                CT_NET_CONSUMPTION_SENSORS,
-                CT_PRODUCTION_SENSORS,
-                CT_STORAGE_SENSORS,
-            )
-            for description in sensors
+            for description in CT_SENSORS
             if description.cttype in envoy_data.ctmeters
         )
     # Add Current Transformer phase entities
     if ctmeters_phases := envoy_data.ctmeters_phases:
         entities.extend(
             EnvoyCTPhaseEntity(coordinator, description)
-            for sensors in (
-                CT_NET_CONSUMPTION_PHASE_SENSORS,
-                CT_PRODUCTION_PHASE_SENSORS,
-                CT_STORAGE_PHASE_SENSORS,
-            )
-            for phase, descriptions in sensors.items()
+            for phase, descriptions in CT_PHASE_SENSORS.items()
             for description in descriptions
             if (cttype := description.cttype) in ctmeters_phases
             and phase in ctmeters_phases[cttype]

homeassistant/components/fan/icons.json

@@ -47,5 +47,13 @@
     "turn_on": {
       "service": "mdi:fan"
     }
+  },
+  "triggers": {
+    "turned_off": {
+      "trigger": "mdi:fan-off"
+    },
+    "turned_on": {
+      "trigger": "mdi:fan"
+    }
   }
 }

homeassistant/components/fan/strings.json

@@ -66,6 +66,13 @@
         "forward": "Forward",
         "reverse": "Reverse"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -152,5 +159,29 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Fan"
+  "title": "Fan",
+  "triggers": {
+    "turned_off": {
+      "description": "Triggers when a fan is turned off.",
+      "description_configured": "[%key:component::fan::triggers::turned_off::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted fans to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When a fan is turned off"
+    },
+    "turned_on": {
+      "description": "Triggers when a fan is turned on.",
+      "description_configured": "[%key:component::fan::triggers::turned_on::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::fan::triggers::turned_off::fields::behavior::description%]",
+          "name": "[%key:component::fan::triggers::turned_off::fields::behavior::name%]"
+        }
+      },
+      "name": "When a fan is turned on"
+    }
+  }
 }

homeassistant/components/fan/trigger.py

@@ -0,0 +1,17 @@
+"""Provides triggers for fans."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+
+from . import DOMAIN
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turned_off": make_entity_state_trigger(DOMAIN, STATE_OFF),
+    "turned_on": make_entity_state_trigger(DOMAIN, STATE_ON),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for fans."""
+    return TRIGGERS

homeassistant/components/fan/triggers.yaml

@@ -0,0 +1,18 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: fan
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+turned_on: *trigger_common
+turned_off: *trigger_common

homeassistant/components/foscam/camera.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from urllib.parse import quote
 
 import voluptuous as vol
 
@@ -152,7 +153,9 @@ class HassFoscamCamera(FoscamEntity, Camera):
     async def stream_source(self) -> str | None:
         """Return the stream source."""
         if self._rtsp_port:
-            return f"rtsp://{self._username}:{self._password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
+            _username = quote(self._username)
+            _password = quote(self._password)
+            return f"rtsp://{_username}:{_password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
 
         return None
 

homeassistant/components/frontend/__init__.py

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

homeassistant/components/goodwe/__init__.py

@@ -1,13 +1,14 @@
 """The Goodwe inverter component."""
 
-from goodwe import InverterError, connect
-from goodwe.const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
+from goodwe import Inverter, InverterError, connect
+from goodwe.const import GOODWE_UDP_PORT
 
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, CONF_PORT
 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
 
@@ -15,28 +16,22 @@ 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=GOODWE_UDP_PORT,
+            port=port,
             family=model_family,
             retries=10,
         )
-    except InverterError as err_udp:
-        # First try with UDP failed, trying with the TCP port
+    except InverterError as err:
         try:
-            inverter = await connect(
-                host=host,
-                port=GOODWE_TCP_PORT,
-                family=model_family,
-                retries=10,
-            )
+            inverter = await async_check_port(hass, entry, host)
         except InverterError:
-            # Both ports are unavailable
-            raise ConfigEntryNotReady from err_udp
+            raise ConfigEntryNotReady from err
 
     device_info = DeviceInfo(
         configuration_url="https://www.semsportal.com",
@@ -66,6 +61,23 @@ 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:
@@ -76,3 +88,31 @@ 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 InverterError, connect
+from goodwe import Inverter, 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
+from homeassistant.const import CONF_HOST, CONF_PORT
 
 from .const import CONF_MODEL_FAMILY, DEFAULT_NAME, DOMAIN
 
@@ -26,9 +26,15 @@ _LOGGER = logging.getLogger(__name__)
 class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Goodwe config flow."""
 
-    VERSION = 1
+    MINOR_VERSION = 2
 
-    async def _handle_successful_connection(self, inverter, host):
+    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."""
         await self.async_set_unique_id(inverter.serial_number)
         self._abort_if_unique_id_configured()
 
@@ -36,6 +42,7 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
             title=DEFAULT_NAME,
             data={
                 CONF_HOST: host,
+                CONF_PORT: port,
                 CONF_MODEL_FAMILY: type(inverter).__name__,
             },
         )
@@ -48,19 +55,26 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             host = user_input[CONF_HOST]
             try:
-                inverter = await connect(host=host, port=GOODWE_UDP_PORT, retries=10)
+                inverter, port = await self.async_detect_inverter_port(host=host)
             except InverterError:
-                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)
+                errors[CONF_HOST] = "connection_error"
             else:
-                return await self._handle_successful_connection(inverter, host)
-
+                return await self.async_handle_successful_connection(
+                    inverter, host, port
+                )
         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,6 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/google_assistant_sdk",
   "integration_type": "service",
   "iot_class": "cloud_polling",
+  "quality_scale": "gold",
   "requirements": ["gassist-text==0.0.14"],
   "single_config_entry": true
 }

homeassistant/components/google_assistant_sdk/quality_scale.yaml

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

homeassistant/components/google_assistant_sdk/strings.json

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

homeassistant/components/google_sheets/services.py

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

homeassistant/components/google_sheets/services.yaml

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

homeassistant/components/google_sheets/strings.json

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

homeassistant/components/google_tasks/todo.py

@@ -53,6 +53,9 @@ 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"],
@@ -61,6 +64,7 @@ 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

@@ -0,0 +1,84 @@
+"""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

@@ -0,0 +1,198 @@
+"""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

@@ -0,0 +1,8 @@
+"""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

@@ -0,0 +1,169 @@
+"""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

@@ -0,0 +1,28 @@
+"""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

@@ -0,0 +1,12 @@
+{
+  "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/quality_scale.yaml

@@ -0,0 +1,82 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No actions.
+  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-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: No events subscribed.
+  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.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No configuration options.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # 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
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: No repairs.
+  stale-devices:
+    status: exempt
+    comment: N/A
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/google_weather/strings.json

@@ -0,0 +1,65 @@
+{
+  "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

@@ -0,0 +1,366 @@
+"""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, cast
+from typing import Any
 
 from aiohomeconnect.client import Client as HomeConnectClient
 from aiohomeconnect.model import (
@@ -247,14 +247,15 @@ 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(cast(str, event.value)),
+                                            ProgramKey(event_value),
                                         )
                                     events[event_key] = event
                             self._call_event_listener(event_message)

homeassistant/components/home_connect/entity.py

@@ -14,7 +14,6 @@ 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
@@ -62,10 +61,8 @@ 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()
-        state = STATE_UNAVAILABLE if not available else self.state
-        _LOGGER.debug("Updated %s, new state: %s", self.entity_id, state)
+        _LOGGER.debug("Updated %s", self)
 
     @property
     def bsh_key(self) -> str:
@@ -80,7 +77,7 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
         as event updates should take precedence over the coordinator
         refresh.
         """
-        return self._attr_available
+        return self.appliance.info.connected and self._attr_available
 
 
 class HomeConnectOptionEntity(HomeConnectEntity):

homeassistant/components/homeassistant_connect_zbt2/manifest.json

@@ -6,6 +6,12 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_connect_zbt2",
   "integration_type": "hardware",
+  "loggers": [
+    "bellows",
+    "universal_silabs_flasher",
+    "zigpy.serial",
+    "serial_asyncio_fast"
+  ],
   "quality_scale": "bronze",
   "usb": [
     {

homeassistant/components/homeassistant_sky_connect/manifest.json

@@ -6,6 +6,12 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_sky_connect",
   "integration_type": "hardware",
+  "loggers": [
+    "bellows",
+    "universal_silabs_flasher",
+    "zigpy.serial",
+    "serial_asyncio_fast"
+  ],
   "usb": [
     {
       "description": "*skyconnect v1.0*",

homeassistant/components/homeassistant_yellow/manifest.json

@@ -7,5 +7,11 @@
   "dependencies": ["hardware", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_yellow",
   "integration_type": "hardware",
+  "loggers": [
+    "bellows",
+    "universal_silabs_flasher",
+    "zigpy.serial",
+    "serial_asyncio_fast"
+  ],
   "single_config_entry": true
 }

homeassistant/components/husqvarna_automower/entity.py

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

homeassistant/components/husqvarna_automower/manifest.json

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

homeassistant/components/hvv_departures/binary_sensor.py

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

homeassistant/components/icloud/account.py

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

homeassistant/components/icloud/manifest.json

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

homeassistant/components/kostal_plenticore/coordinator.py

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

homeassistant/components/kostal_plenticore/diagnostics.py

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

homeassistant/components/kostal_plenticore/switch.py

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

homeassistant/components/lamarzocco/manifest.json

@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.1.2"]
+  "requirements": ["pylamarzocco==2.1.3"]
 }

homeassistant/components/lcn/__init__.py

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

homeassistant/components/lcn/binary_sensor.py

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

homeassistant/components/lcn/climate.py

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

homeassistant/components/lcn/config_flow.py

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

homeassistant/components/lcn/cover.py

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

homeassistant/components/lcn/entity.py

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

homeassistant/components/lcn/helpers.py

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