Remove location_name property from mobile_app device tracker

.github/workflows/builder.yml

@@ -108,7 +108,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
+        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -119,7 +119,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
+        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -323,7 +323,7 @@ jobs:
           exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
 
   publish_container:
-    name: Publish to ${{ matrix.registry }}
+    name: Publish meta container for ${{ matrix.registry }}
     environment: ${{ needs.init.outputs.channel }}
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]

.github/workflows/ci.yaml

@@ -281,7 +281,7 @@ jobs:
           echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
           echo "::add-matcher::.github/workflows/matchers/codespell.json"
       - name: Run prek
-        uses: j178/prek-action@6ad80277337ad479fe43bd70701c3f7f8aa74db3 # v2.0.3
+        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
         env:
           PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config,zizmor
           RUFF_OUTPUT_FORMAT: github
@@ -302,7 +302,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Run zizmor
-        uses: j178/prek-action@6ad80277337ad479fe43bd70701c3f7f8aa74db3 # v2.0.3
+        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
         with:
           extra-args: --all-files zizmor
 

.strict-typing

@@ -442,7 +442,6 @@ homeassistant.components.private_ble_device.*
 homeassistant.components.prometheus.*
 homeassistant.components.proximity.*
 homeassistant.components.prusalink.*
-homeassistant.components.ptdevices.*
 homeassistant.components.pure_energie.*
 homeassistant.components.purpleair.*
 homeassistant.components.pushbullet.*

CODEOWNERS

@@ -851,8 +851,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/input_select/ @home-assistant/core
 /homeassistant/components/input_text/ @home-assistant/core
 /tests/components/input_text/ @home-assistant/core
-/homeassistant/components/insteon/ @teharris1 @ssyrell
-/tests/components/insteon/ @teharris1 @ssyrell
+/homeassistant/components/insteon/ @teharris1
+/tests/components/insteon/ @teharris1
 /homeassistant/components/integration/ @dgomes
 /tests/components/integration/ @dgomes
 /homeassistant/components/intelliclima/ @dvdinth
@@ -1092,8 +1092,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/minecraft_server/ @elmurato @zachdeibert
 /homeassistant/components/minio/ @tkislan
 /tests/components/minio/ @tkislan
-/homeassistant/components/mitsubishi_comfort/ @nikolairahimi
-/tests/components/mitsubishi_comfort/ @nikolairahimi
 /homeassistant/components/moat/ @bdraco
 /tests/components/moat/ @bdraco
 /homeassistant/components/mobile_app/ @home-assistant/core
@@ -1380,8 +1378,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/proxmoxve/ @Corbeno @erwindouna @CoMPaTech
 /homeassistant/components/ps4/ @ktnrg45
 /tests/components/ps4/ @ktnrg45
-/homeassistant/components/ptdevices/ @ParemTech-Inc @frogman85978
-/tests/components/ptdevices/ @ParemTech-Inc @frogman85978
 /homeassistant/components/pterodactyl/ @elmurato
 /tests/components/pterodactyl/ @elmurato
 /homeassistant/components/pure_energie/ @klaasnicolaas
@@ -1495,8 +1491,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/roku/ @ctalkington
 /homeassistant/components/romy/ @xeniter
 /tests/components/romy/ @xeniter
-/homeassistant/components/roomba/ @pschmitt @cyr-ius @shenxn
-/tests/components/roomba/ @pschmitt @cyr-ius @shenxn
+/homeassistant/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
+/tests/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
 /homeassistant/components/roon/ @pavoni
 /tests/components/roon/ @pavoni
 /homeassistant/components/route_b_smart_meter/ @SeraphicRav

homeassistant/brands/sensereo.json

@@ -1,5 +0,0 @@
-{
-  "domain": "sensereo",
-  "name": "Sensereo",
-  "iot_standards": ["matter"]
-}

homeassistant/brands/zunzunbee.json

@@ -1,5 +0,0 @@
-{
-  "domain": "zunzunbee",
-  "name": "Zunzunbee",
-  "iot_standards": ["zigbee"]
-}

homeassistant/components/acer_projector/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/acer_projector",
   "iot_class": "local_polling",
   "quality_scale": "legacy",
-  "requirements": ["serialx==1.7.1"]
+  "requirements": ["serialx==1.4.1"]
 }

homeassistant/components/airnow/strings.json

@@ -17,13 +17,7 @@
           "longitude": "[%key:common::config_flow::data::longitude%]",
           "radius": "Station radius (miles; optional)"
         },
-        "data_description": {
-          "api_key": "To generate an API key, go to {api_key_url}.",
-          "latitude": "The latitude of your location.",
-          "longitude": "The longitude of your location.",
-          "radius": "The radius in miles around your location to search for reporting stations."
-        },
-        "description": "To generate an API key, go to {api_key_url}."
+        "description": "To generate API key go to {api_key_url}"
       }
     }
   },

homeassistant/components/automation/__init__.py

@@ -899,13 +899,12 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
     async def async_will_remove_from_hass(self) -> None:
         """Remove listeners when removing automation from Home Assistant."""
         await super().async_will_remove_from_hass()
+        await self._async_disable()
         if self.registry_entry and self.registry_entry.entity_id != self.entity_id:
             # Entity ID change, do not unload the script or conditions as they will
             # be reused.
-            await self._async_disable()
             return
-        await self._async_disable(stop_actions=False)
-        await self.action_script.async_unload()
+        self.action_script.async_unload()
         if self._condition is not None:
             self._condition.async_unload()
 

homeassistant/components/button/trigger.py

@@ -1,16 +1,36 @@
 """Provides triggers for buttons."""
 
-from homeassistant.core import HomeAssistant
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import StatelessEntityTriggerBase, Trigger
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+)
 
 from . import DOMAIN
 
 
-class ButtonPressedTrigger(StatelessEntityTriggerBase):
+class ButtonPressedTrigger(EntityTriggerBase):
     """Trigger for button entity presses."""
 
     _domain_specs = {DOMAIN: DomainSpec()}
+    _schema = ENTITY_STATE_TRIGGER_SCHEMA
+
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and different from the current state."""
+
+        # UNKNOWN is a valid from_state, otherwise the first time the button is pressed
+        # would not trigger
+        if from_state.state == STATE_UNAVAILABLE:
+            return False
+
+        return from_state.state != to_state.state
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the new state is not invalid."""
+        return state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
 
 
 TRIGGERS: dict[str, type[Trigger]] = {

homeassistant/components/climate/condition.py

@@ -13,8 +13,8 @@ from homeassistant.helpers.condition import (
     Condition,
     ConditionConfig,
     EntityConditionBase,
-    EntityNumericalConditionBase,
     EntityNumericalConditionWithUnitBase,
+    make_entity_numerical_condition,
     make_entity_state_condition,
 )
 from homeassistant.util.unit_conversion import TemperatureConverter
@@ -59,33 +59,12 @@ class ClimateTargetTemperatureCondition(EntityNumericalConditionWithUnitBase):
     _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
     _unit_converter = TemperatureConverter
 
-    def _should_include(self, state: State) -> bool:
-        """Skip climate entities that do not expose a target temperature."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_TEMPERATURE) is not None
-        )
-
     def _get_entity_unit(self, entity_state: State) -> str | None:
         """Get the temperature unit of a climate entity from its state."""
         # Climate entities convert temperatures to the system unit via show_temp
         return self._hass.config.units.temperature_unit
 
 
-class ClimateTargetHumidityCondition(EntityNumericalConditionBase):
-    """Condition for climate target humidity."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
-    _valid_unit = "%"
-
-    def _should_include(self, state: State) -> bool:
-        """Skip climate entities that do not expose a target humidity."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_HUMIDITY) is not None
-        )
-
-
 CONDITIONS: dict[str, type[Condition]] = {
     "is_hvac_mode": ClimateHVACModeCondition,
     "is_off": make_entity_state_condition(DOMAIN, HVACMode.OFF),
@@ -109,7 +88,10 @@ CONDITIONS: dict[str, type[Condition]] = {
     "is_heating": make_entity_state_condition(
         {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.HEATING
     ),
-    "target_humidity": ClimateTargetHumidityCondition,
+    "target_humidity": make_entity_numerical_condition(
+        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        valid_unit="%",
+    ),
     "target_temperature": ClimateTargetTemperatureCondition,
 }
 

homeassistant/components/climate/trigger.py

@@ -8,15 +8,14 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
-    EntityNumericalStateChangedTriggerBase,
     EntityNumericalStateChangedTriggerWithUnitBase,
-    EntityNumericalStateCrossedThresholdTriggerBase,
     EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
-    EntityNumericalStateTriggerBase,
     EntityNumericalStateTriggerWithUnitBase,
     EntityTargetStateTriggerBase,
     Trigger,
     TriggerConfig,
+    make_entity_numerical_state_changed_trigger,
+    make_entity_numerical_state_crossed_threshold_trigger,
     make_entity_target_state_trigger,
     make_entity_transition_trigger,
 )
@@ -56,13 +55,6 @@ class _ClimateTargetTemperatureTriggerMixin(EntityNumericalStateTriggerWithUnitB
     _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
     _unit_converter = TemperatureConverter
 
-    def _should_include(self, state: State) -> bool:
-        """Skip climate entities that do not expose a target temperature."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_TEMPERATURE) is not None
-        )
-
     def _get_entity_unit(self, state: State) -> str | None:
         """Get the temperature unit of a climate entity from its state."""
         # Climate entities convert temperatures to the system unit via show_temp
@@ -83,32 +75,6 @@ class ClimateTargetTemperatureCrossedThresholdTrigger(
     """Trigger for climate target temperature value crossing a threshold."""
 
 
-class _ClimateTargetHumidityTriggerMixin(EntityNumericalStateTriggerBase):
-    """Mixin for climate target humidity triggers."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
-    _valid_unit = "%"
-
-    def _should_include(self, state: State) -> bool:
-        """Skip climate entities that do not expose a target humidity."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_HUMIDITY) is not None
-        )
-
-
-class ClimateTargetHumidityChangedTrigger(
-    _ClimateTargetHumidityTriggerMixin, EntityNumericalStateChangedTriggerBase
-):
-    """Trigger for climate target humidity value changes."""
-
-
-class ClimateTargetHumidityCrossedThresholdTrigger(
-    _ClimateTargetHumidityTriggerMixin, EntityNumericalStateCrossedThresholdTriggerBase
-):
-    """Trigger for climate target humidity value crossing a threshold."""
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
     "hvac_mode_changed": HVACModeChangedTrigger,
     "started_cooling": make_entity_target_state_trigger(
@@ -117,8 +83,14 @@ TRIGGERS: dict[str, type[Trigger]] = {
     "started_drying": make_entity_target_state_trigger(
         {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
     ),
-    "target_humidity_changed": ClimateTargetHumidityChangedTrigger,
-    "target_humidity_crossed_threshold": ClimateTargetHumidityCrossedThresholdTrigger,
+    "target_humidity_changed": make_entity_numerical_state_changed_trigger(
+        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        valid_unit="%",
+    ),
+    "target_humidity_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
+        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        valid_unit="%",
+    ),
     "target_temperature_changed": ClimateTargetTemperatureChangedTrigger,
     "target_temperature_crossed_threshold": ClimateTargetTemperatureCrossedThresholdTrigger,
     "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),

homeassistant/components/command_line/binary_sensor.py

@@ -3,10 +3,7 @@
 import asyncio
 from datetime import datetime, timedelta
 
-from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
-    BinarySensorEntity,
-)
+from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.const import (
     CONF_COMMAND,
     CONF_NAME,
@@ -28,7 +25,6 @@ from homeassistant.util import dt as dt_util
 
 from .const import CONF_COMMAND_TIMEOUT, LOGGER, TRIGGER_ENTITY_OPTIONS
 from .sensor import CommandSensorData
-from .utils import create_platform_yaml_not_supported_issue
 
 DEFAULT_NAME = "Binary Command Sensor"
 DEFAULT_PAYLOAD_ON = "ON"
@@ -45,7 +41,6 @@ async def async_setup_platform(
 ) -> None:
     """Set up the Command line Binary Sensor."""
     if not discovery_info:
-        create_platform_yaml_not_supported_issue(hass, BINARY_SENSOR_DOMAIN)
         return
 
     binary_sensor_config = discovery_info

homeassistant/components/command_line/cover.py

@@ -4,7 +4,7 @@ import asyncio
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
-from homeassistant.components.cover import DOMAIN as COVER_DOMAIN, CoverEntity
+from homeassistant.components.cover import CoverEntity
 from homeassistant.const import (
     CONF_COMMAND_CLOSE,
     CONF_COMMAND_OPEN,
@@ -26,11 +26,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util, slugify
 
 from .const import CONF_COMMAND_TIMEOUT, LOGGER, TRIGGER_ENTITY_OPTIONS
-from .utils import (
-    async_call_shell_with_timeout,
-    async_check_output_or_log,
-    create_platform_yaml_not_supported_issue,
-)
+from .utils import async_call_shell_with_timeout, async_check_output_or_log
 
 SCAN_INTERVAL = timedelta(seconds=15)
 
@@ -43,7 +39,6 @@ async def async_setup_platform(
 ) -> None:
     """Set up cover controlled by shell commands."""
     if not discovery_info:
-        create_platform_yaml_not_supported_issue(hass, COVER_DOMAIN)
         return
 
     covers = []

homeassistant/components/command_line/notify.py

@@ -4,29 +4,25 @@ import logging
 import subprocess
 from typing import Any
 
-from homeassistant.components.notify import (
-    DOMAIN as NOTIFY_DOMAIN,
-    BaseNotificationService,
-)
+from homeassistant.components.notify import BaseNotificationService
 from homeassistant.const import CONF_COMMAND
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util.process import kill_subprocess
 
 from .const import CONF_COMMAND_TIMEOUT, LOGGER
-from .utils import create_platform_yaml_not_supported_issue, render_template_args
+from .utils import render_template_args
 
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_get_service(
+def get_service(
     hass: HomeAssistant,
     config: ConfigType,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> CommandLineNotificationService | None:
     """Get the Command Line notification service."""
     if not discovery_info:
-        create_platform_yaml_not_supported_issue(hass, NOTIFY_DOMAIN)
         return None
 
     notify_config = discovery_info

homeassistant/components/command_line/sensor.py

@@ -8,7 +8,6 @@ from typing import Any
 
 from jsonpath import jsonpath
 
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import (
     CONF_COMMAND,
     CONF_NAME,
@@ -33,11 +32,7 @@ from .const import (
     LOGGER,
     TRIGGER_ENTITY_OPTIONS,
 )
-from .utils import (
-    async_check_output_or_log,
-    create_platform_yaml_not_supported_issue,
-    render_template_args,
-)
+from .utils import async_check_output_or_log, render_template_args
 
 DEFAULT_NAME = "Command Sensor"
 
@@ -52,7 +47,6 @@ async def async_setup_platform(
 ) -> None:
     """Set up the Command Sensor."""
     if not discovery_info:
-        create_platform_yaml_not_supported_issue(hass, SENSOR_DOMAIN)
         return
 
     sensor_config = discovery_info

homeassistant/components/command_line/strings.json

@@ -1,10 +1,4 @@
 {
-  "issues": {
-    "platform_yaml_not_supported": {
-      "description": "Platform YAML setup is not supported.\nChange from configuring it using the `{platform}:` key to using the `command_line:` key directly in configuration.yaml and restart Home Assistant to resolve the issue.\nTo see the detailed documentation, select Learn more.",
-      "title": "Platform YAML is not supported in Command Line"
-    }
-  },
   "services": {
     "reload": {
       "description": "Reloads command line configuration from the YAML-configuration.",

homeassistant/components/command_line/switch.py

@@ -4,11 +4,7 @@ import asyncio
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
-from homeassistant.components.switch import (
-    DOMAIN as SWITCH_DOMAIN,
-    ENTITY_ID_FORMAT,
-    SwitchEntity,
-)
+from homeassistant.components.switch import ENTITY_ID_FORMAT, SwitchEntity
 from homeassistant.const import (
     CONF_COMMAND_OFF,
     CONF_COMMAND_ON,
@@ -29,11 +25,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util, slugify
 
 from .const import CONF_COMMAND_TIMEOUT, LOGGER, TRIGGER_ENTITY_OPTIONS
-from .utils import (
-    async_call_shell_with_timeout,
-    async_check_output_or_log,
-    create_platform_yaml_not_supported_issue,
-)
+from .utils import async_call_shell_with_timeout, async_check_output_or_log
 
 SCAN_INTERVAL = timedelta(seconds=30)
 
@@ -46,7 +38,6 @@ async def async_setup_platform(
 ) -> None:
     """Find and return switches controlled by shell commands."""
     if not discovery_info:
-        create_platform_yaml_not_supported_issue(hass, SWITCH_DOMAIN)
         return
 
     switches = []

homeassistant/components/command_line/utils.py

@@ -4,10 +4,9 @@ import asyncio
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import TemplateError
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.template import Template
 
-from .const import DOMAIN, LOGGER
+from .const import LOGGER
 
 _EXEC_FAILED_CODE = 127
 
@@ -92,19 +91,3 @@ def render_template_args(hass: HomeAssistant, command: str) -> str | None:
     LOGGER.debug("Running command: %s", command)
 
     return command
-
-
-def create_platform_yaml_not_supported_issue(
-    hass: HomeAssistant, platform_domain: str
-) -> None:
-    """Create an issue when platform yaml is used."""
-    async_create_issue(
-        hass,
-        DOMAIN,
-        f"{platform_domain}_platform_yaml_not_supported",
-        is_fixable=False,
-        severity=IssueSeverity.ERROR,
-        translation_key="platform_yaml_not_supported",
-        translation_placeholders={"platform": platform_domain},
-        learn_more_url="https://www.home-assistant.io/integrations/command_line/",
-    )

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.5.5"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.3.24"]
 }

homeassistant/components/doorbell/trigger.py

@@ -6,22 +6,39 @@ from homeassistant.components.event import (
     DoorbellEventType,
     EventDeviceClass,
 )
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import StatelessEntityTriggerBase, Trigger
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+)
 
 
-class DoorbellRangTrigger(StatelessEntityTriggerBase):
+class DoorbellRangTrigger(EntityTriggerBase):
     """Trigger for doorbell event entity when a ring event is received."""
 
     _domain_specs = {EVENT_DOMAIN: DomainSpec(device_class=EventDeviceClass.DOORBELL)}
+    _schema = ENTITY_STATE_TRIGGER_SCHEMA
 
     def is_valid_state(self, state: State) -> bool:
         """Check if the entity is available and the event type is ring."""
-        return super().is_valid_state(state) and (
-            state.attributes.get(ATTR_EVENT_TYPE) == DoorbellEventType.RING
+        return (
+            state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+            and state.attributes.get(ATTR_EVENT_TYPE) == DoorbellEventType.RING
         )
 
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and different from the current state."""
+
+        # UNKNOWN is a valid from_state, otherwise the first time the event is received
+        # would not trigger
+        if from_state.state == STATE_UNAVAILABLE:
+            return False
+
+        return from_state.state != to_state.state
+
 
 TRIGGERS: dict[str, type[Trigger]] = {
     "rang": DoorbellRangTrigger,

homeassistant/components/duckdns/__init__.py

@@ -2,6 +2,10 @@
 
 import logging
 
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_IMPORT
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
@@ -12,7 +16,18 @@ from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Required(CONF_DOMAIN): cv.string,
+                vol.Required(CONF_ACCESS_TOKEN): cv.string,
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -20,6 +35,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async_setup_services(hass)
 
+    if DOMAIN not in config:
+        return True
+
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": SOURCE_IMPORT}, data=config[DOMAIN]
+        )
+    )
+
     return True
 
 

homeassistant/components/duckdns/config_flow.py

@@ -16,6 +16,7 @@ from homeassistant.helpers.selector import (
 
 from .const import DOMAIN
 from .helpers import update_duckdns
+from .issue import deprecate_yaml_issue
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -67,6 +68,18 @@ class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
             description_placeholders={"url": "https://www.duckdns.org/"},
         )
 
+    async def async_step_import(self, import_info: dict[str, Any]) -> ConfigFlowResult:
+        """Import config from yaml."""
+
+        self._async_abort_entries_match({CONF_DOMAIN: import_info[CONF_DOMAIN]})
+        result = await self.async_step_user(import_info)
+        if errors := result.get("errors"):
+            deprecate_yaml_issue(self.hass, import_success=False)
+            return self.async_abort(reason=errors["base"])
+
+        deprecate_yaml_issue(self.hass, import_success=True)
+        return result
+
     async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/duckdns/issue.py

@@ -1,11 +1,45 @@
 """Issues for Duck DNS integration."""
 
-from homeassistant.core import HomeAssistant
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 
 from .const import DOMAIN
 
 
+@callback
+def deprecate_yaml_issue(hass: HomeAssistant, *, import_success: bool) -> None:
+    """Deprecate yaml issue."""
+    if import_success:
+        async_create_issue(
+            hass,
+            HOMEASSISTANT_DOMAIN,
+            f"deprecated_yaml_{DOMAIN}",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            breaks_in_ha_version="2026.6.0",
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "Duck DNS",
+            },
+        )
+    else:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "deprecated_yaml_import_issue_error",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml_import_issue_error",
+            translation_placeholders={
+                "url": "/config/integrations/dashboard/add?domain=duckdns"
+            },
+        )
+
+
 def action_called_without_config_entry(hass: HomeAssistant) -> None:
     """Deprecate the use of action without config entry."""
 

homeassistant/components/duckdns/strings.json

@@ -49,6 +49,10 @@
     "deprecated_call_without_config_entry": {
       "description": "Calling the `duckdns.set_txt` action without specifying a config entry is deprecated.\n\nThe `config_entry_id` field will be required in a future release.\n\nPlease update your automations and scripts to include the `config_entry_id` parameter.",
       "title": "Detected deprecated use of action without config entry"
+    },
+    "deprecated_yaml_import_issue_error": {
+      "description": "Configuring Duck DNS using YAML is being removed but there was an error when trying to import the YAML configuration.\n\nEnsure the YAML configuration is correct and restart Home Assistant to try again or remove the Duck DNS YAML configuration from your `configuration.yaml` file and continue to [set up the integration]({url}) manually.",
+      "title": "The Duck DNS YAML configuration import failed"
     }
   },
   "services": {

homeassistant/components/duco/diagnostics.py

@@ -13,9 +13,6 @@ from homeassistant.exceptions import HomeAssistantError
 from .const import DOMAIN
 from .coordinator import DucoConfigEntry
 
-# MAC addresses and serial numbers are redacted because a Duco installer or
-# manufacturer could cross-reference them against an installation registry to
-# identify the physical location of the device.
 TO_REDACT = {
     CONF_HOST,
     "mac",
@@ -34,15 +31,9 @@ async def async_get_config_entry_diagnostics(
     coordinator = entry.runtime_data
 
     board = asdict(coordinator.board_info)
-    # `time` is a Unix epoch timestamp of the last board info fetch; not useful for support triage.
     board.pop("time")
-    if board["public_api_version"] is None:
-        board.pop("public_api_version")
-    if board["software_version"] is None:
-        board.pop("software_version")
 
     try:
-        api_info_obj = await coordinator.client.async_get_api_info()
         lan_info = await coordinator.client.async_get_lan_info()
         duco_diags = await coordinator.client.async_get_diagnostics()
         write_remaining = await coordinator.client.async_get_write_req_remaining()
@@ -52,15 +43,10 @@ async def async_get_config_entry_diagnostics(
             translation_key="connection_error",
         ) from err
 
-    api_info: dict[str, Any] = {"public_api_version": api_info_obj.public_api_version}
-    if api_info_obj.reported_api_version is not None:
-        api_info["reported_api_version"] = api_info_obj.reported_api_version
-
     return async_redact_data(
         {
             "entry_data": entry.data,
             "board_info": board,
-            "api_info": api_info,
             "lan_info": asdict(lan_info),
             "nodes": {
                 str(node_id): asdict(node)

homeassistant/components/duco/manifest.json

@@ -13,7 +13,7 @@
   "iot_class": "local_polling",
   "loggers": ["duco"],
   "quality_scale": "platinum",
-  "requirements": ["python-duco-client==0.4.0"],
+  "requirements": ["python-duco-client==0.3.10"],
   "zeroconf": [
     {
       "name": "duco [[][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][]].*",

homeassistant/components/ecovacs/config_flow.py

@@ -137,6 +137,10 @@ class EcovacsConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
+
+        if not self.show_advanced_options:
+            return await self.async_step_auth()
+
         if user_input:
             self._mode = user_input[CONF_MODE]
             return await self.async_step_auth()

homeassistant/components/elkm1/manifest.json

@@ -16,5 +16,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["elkm1_lib"],
-  "requirements": ["elkm1-lib==2.2.15"]
+  "requirements": ["elkm1-lib==2.2.13"]
 }

homeassistant/components/elkm1/sensor.py

@@ -199,9 +199,7 @@ class ElkSetting(ElkSensor):
     _element: Setting
 
     def _element_changed(self, element: Element, changeset: dict[str, Any]) -> None:
-        self._attr_native_value = (
-            None if self._element.value is None else str(self._element.value)
-        )
+        self._attr_native_value = self._element.value
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:

homeassistant/components/emulated_kasa/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_push",
   "loggers": ["sense_energy"],
   "quality_scale": "internal",
-  "requirements": ["sense-energy==0.14.1"]
+  "requirements": ["sense-energy==0.14.0"]
 }

homeassistant/components/event/trigger.py

@@ -2,13 +2,13 @@
 
 import voluptuous as vol
 
-from homeassistant.const import CONF_OPTIONS
+from homeassistant.const import CONF_OPTIONS, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA,
-    StatelessEntityTriggerBase,
+    EntityTriggerBase,
     Trigger,
     TriggerConfig,
 )
@@ -28,7 +28,7 @@ EVENT_RECEIVED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
 )
 
 
-class EventReceivedTrigger(StatelessEntityTriggerBase):
+class EventReceivedTrigger(EntityTriggerBase):
     """Trigger for event entity when it receives a matching event."""
 
     _domain_specs = {DOMAIN: DomainSpec()}
@@ -39,10 +39,21 @@ class EventReceivedTrigger(StatelessEntityTriggerBase):
         super().__init__(hass, config)
         self._event_types = set(self._options[CONF_EVENT_TYPE])
 
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and different from the current state."""
+
+        # UNKNOWN is a valid from_state, otherwise the first time the event is received
+        # would not trigger
+        if from_state.state == STATE_UNAVAILABLE:
+            return False
+
+        return from_state.state != to_state.state
+
     def is_valid_state(self, state: State) -> bool:
-        """Check if the event type matches one of the configured types."""
-        return super().is_valid_state(state) and (
-            state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
+        """Check if the event type is valid and matches one of the configured types."""
+        return (
+            state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+            and state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
         )
 
 

homeassistant/components/fluss/coordinator.py

@@ -1,5 +1,7 @@
 """DataUpdateCoordinator for Fluss+ integration."""
 
+from __future__ import annotations
+
 import asyncio
 from typing import Any
 

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260429.3"]
+  "requirements": ["home-assistant-frontend==20260429.1"]
 }

homeassistant/components/gardena_bluetooth/manifest.json

@@ -15,5 +15,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==2.8.1"]
+  "requirements": ["gardena-bluetooth==2.4.0"]
 }

homeassistant/components/growatt_server/coordinator.py

@@ -596,9 +596,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         if not self.data:
             await self.async_refresh()
 
-        return self.api.sph_read_ac_charge_times(
-            self.device_id, settings_data=self.data
-        )
+        return self.api.sph_read_ac_charge_times(settings_data=self.data)
 
     async def read_ac_discharge_times(self) -> dict:
         """Read AC discharge time settings from SPH device cache."""
@@ -611,6 +609,4 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         if not self.data:
             await self.async_refresh()
 
-        return self.api.sph_read_ac_discharge_times(
-            self.device_id, settings_data=self.data
-        )
+        return self.api.sph_read_ac_discharge_times(settings_data=self.data)

homeassistant/components/growatt_server/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["growattServer"],
   "quality_scale": "silver",
-  "requirements": ["growattServer==2.1.0"]
+  "requirements": ["growattServer==1.9.0"]
 }

homeassistant/components/hassio/auth.py

@@ -12,7 +12,6 @@ import voluptuous as vol
 from homeassistant.auth.models import User
 from homeassistant.auth.providers import homeassistant as auth_ha
 from homeassistant.components.http import KEY_HASS, KEY_HASS_USER, HomeAssistantView
-from homeassistant.components.http.const import is_supervisor_unix_socket_request
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
@@ -42,18 +41,14 @@ class HassIOBaseAuth(HomeAssistantView):
 
     def _check_access(self, request: web.Request) -> None:
         """Check if this call is from Supervisor."""
-        # Requests over the Supervisor Unix socket are authenticated by the
-        # http auth middleware as the Supervisor user, so the caller-IP check
-        # below does not apply (and would crash, since `peername` is empty for
-        # Unix sockets). The user-ID check still runs to ensure only the
-        # Supervisor user can reach this endpoint.
-        if not is_supervisor_unix_socket_request(request):
-            hassio_ip = os.environ["SUPERVISOR"].split(":")[0]
-            assert request.transport
-            peername = request.transport.get_extra_info("peername")
-            if not peername or ip_address(peername[0]) != ip_address(hassio_ip):
-                _LOGGER.error("Invalid auth request from %s", request.remote)
-                raise HTTPUnauthorized
+        # Check caller IP
+        hassio_ip = os.environ["SUPERVISOR"].split(":")[0]
+        assert request.transport
+        if ip_address(request.transport.get_extra_info("peername")[0]) != ip_address(
+            hassio_ip
+        ):
+            _LOGGER.error("Invalid auth request from %s", request.remote)
+            raise HTTPUnauthorized
 
         # Check caller token
         if request[KEY_HASS_USER].id != self.user.id:

homeassistant/components/hassio/binary_sensor.py

@@ -1,9 +1,8 @@
 """Binary sensor platform for Hass.io addons."""
 
-from collections.abc import Callable
 from dataclasses import dataclass
+import itertools
 
-from aiohasupervisor.models import AddonState
 from aiohasupervisor.models.mounts import MountState
 
 from homeassistant.components.binary_sensor import (
@@ -15,46 +14,41 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import ADDONS_COORDINATOR, MAIN_COORDINATOR
+from .const import (
+    ADDONS_COORDINATOR,
+    ATTR_STARTED,
+    ATTR_STATE,
+    DATA_KEY_ADDONS,
+    DATA_KEY_MOUNTS,
+    MAIN_COORDINATOR,
+)
 from .entity import HassioAddonEntity, HassioMountEntity
 
 
-@dataclass(frozen=True, kw_only=True)
-class HassioAddonBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Hass.io add-on binary sensor entity description."""
+@dataclass(frozen=True)
+class HassioBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Hassio binary sensor entity description."""
 
-    value_fn: Callable[[HassioAddonBinarySensor], bool]
-
-
-@dataclass(frozen=True, kw_only=True)
-class HassioMountBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Hass.io mount binary sensor entity description."""
-
-    value_fn: Callable[[HassioMountBinarySensor], bool]
+    target: str | None = None
 
 
 ADDON_ENTITY_DESCRIPTIONS = (
-    HassioAddonBinarySensorEntityDescription(
+    HassioBinarySensorEntityDescription(
         device_class=BinarySensorDeviceClass.RUNNING,
         entity_registry_enabled_default=False,
-        key="state",
+        key=ATTR_STATE,
         translation_key="state",
-        value_fn=lambda entity: (
-            entity.coordinator.data.addons[entity.addon_slug].addon.state
-            == AddonState.STARTED
-        ),
+        target=ATTR_STARTED,
     ),
 )
 
 MOUNT_ENTITY_DESCRIPTIONS = (
-    HassioMountBinarySensorEntityDescription(
+    HassioBinarySensorEntityDescription(
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_registry_enabled_default=False,
-        key="state",
+        key=ATTR_STATE,
         translation_key="mount",
-        value_fn=lambda entity: (
-            entity.coordinator.data.mounts[entity.mount_name].state == MountState.ACTIVE
-        ),
+        target=MountState.ACTIVE.value,
     ),
 )
 
@@ -69,46 +63,57 @@ async def async_setup_entry(
     coordinator = hass.data[MAIN_COORDINATOR]
 
     async_add_entities(
-        [
-            *[
+        itertools.chain(
+            [
                 HassioAddonBinarySensor(
                     addon=addon,
                     coordinator=addons_coordinator,
                     entity_description=entity_description,
                 )
-                for addon in addons_coordinator.data.addons.values()
+                for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
                 for entity_description in ADDON_ENTITY_DESCRIPTIONS
             ],
-            *[
+            [
                 HassioMountBinarySensor(
                     mount=mount,
                     coordinator=coordinator,
                     entity_description=entity_description,
                 )
-                for mount in coordinator.data.mounts.values()
+                for mount in coordinator.data[DATA_KEY_MOUNTS].values()
                 for entity_description in MOUNT_ENTITY_DESCRIPTIONS
             ],
-        ]
+        )
     )
 
 
 class HassioAddonBinarySensor(HassioAddonEntity, BinarySensorEntity):
     """Binary sensor for Hass.io add-ons."""
 
-    entity_description: HassioAddonBinarySensorEntityDescription
+    entity_description: HassioBinarySensorEntityDescription
 
     @property
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
-        return self.entity_description.value_fn(self)
+        value = self.coordinator.data[DATA_KEY_ADDONS][self._addon_slug][
+            self.entity_description.key
+        ]
+        if self.entity_description.target is None:
+            return value
+        return value == self.entity_description.target
 
 
 class HassioMountBinarySensor(HassioMountEntity, BinarySensorEntity):
     """Binary sensor for Hass.io mount."""
 
-    entity_description: HassioMountBinarySensorEntityDescription
+    entity_description: HassioBinarySensorEntityDescription
 
     @property
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
-        return self.entity_description.value_fn(self)
+        value = getattr(
+            self.coordinator.data[DATA_KEY_MOUNTS][self._mount.name],
+            self.entity_description.key,
+        )
+        if self.entity_description.target is None:
+            return value
+        return value == self.entity_description.target

homeassistant/components/hassio/const.py

@@ -8,11 +8,9 @@ from homeassistant.util.hass_dict import HassKey
 
 if TYPE_CHECKING:
     from aiohasupervisor.models import (
-        AddonsStats,
         HomeAssistantInfo,
         HostInfo,
         InstalledAddon,
-        InstalledAddonComplete,
         NetworkInfo,
         OSInfo,
         RootInfo,
@@ -114,12 +112,8 @@ DATA_OS_INFO: HassKey[OSInfo] = HassKey("hassio_os_info")
 DATA_NETWORK_INFO: HassKey[NetworkInfo] = HassKey("hassio_network_info")
 DATA_SUPERVISOR_INFO: HassKey[SupervisorInfo] = HassKey("hassio_supervisor_info")
 DATA_SUPERVISOR_STATS = "hassio_supervisor_stats"
-DATA_ADDONS_INFO: HassKey[dict[str, InstalledAddonComplete | None]] = HassKey(
-    "hassio_addons_info"
-)
-DATA_ADDONS_STATS: HassKey[dict[str, AddonsStats | None]] = HassKey(
-    "hassio_addons_stats"
-)
+DATA_ADDONS_INFO = "hassio_addons_info"
+DATA_ADDONS_STATS = "hassio_addons_stats"
 DATA_ADDONS_LIST: HassKey[list[InstalledAddon]] = HassKey("hassio_addons_list")
 HASSIO_MAIN_UPDATE_INTERVAL = timedelta(minutes=5)
 HASSIO_ADDON_UPDATE_INTERVAL = timedelta(minutes=15)

homeassistant/components/hassio/coordinator.py

@@ -3,20 +3,17 @@
 import asyncio
 from collections import defaultdict
 from collections.abc import Awaitable
-from dataclasses import dataclass
+from copy import deepcopy
 import logging
 from typing import TYPE_CHECKING, Any, cast
 
 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
 from aiohasupervisor.models import (
-    AddonsStats,
     AddonState,
     CIFSMountResponse,
     HomeAssistantInfo,
-    HomeAssistantStats,
     HostInfo,
     InstalledAddon,
-    InstalledAddonComplete,
     NetworkInfo,
     NFSMountResponse,
     OSInfo,
@@ -24,11 +21,10 @@ from aiohasupervisor.models import (
     RootInfo,
     StoreInfo,
     SupervisorInfo,
-    SupervisorStats,
 )
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_MANUFACTURER
+from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.debounce import Debouncer
@@ -38,10 +34,15 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import (
     ATTR_ADDONS,
+    ATTR_AUTO_UPDATE,
     ATTR_DATA,
     ATTR_REPOSITORIES,
+    ATTR_REPOSITORY,
+    ATTR_SLUG,
     ATTR_STARTUP,
     ATTR_UPDATE_KEY,
+    ATTR_URL,
+    ATTR_VERSION,
     ATTR_WS_EVENT,
     CONTAINER_STATS,
     CORE_CONTAINER,
@@ -52,6 +53,12 @@ from .const import (
     DATA_CORE_STATS,
     DATA_HOST_INFO,
     DATA_INFO,
+    DATA_KEY_ADDONS,
+    DATA_KEY_CORE,
+    DATA_KEY_HOST,
+    DATA_KEY_MOUNTS,
+    DATA_KEY_OS,
+    DATA_KEY_SUPERVISOR,
     DATA_KEY_SUPERVISOR_ISSUES,
     DATA_NETWORK_INFO,
     DATA_OS_INFO,
@@ -79,106 +86,6 @@ if TYPE_CHECKING:
 _LOGGER = logging.getLogger(__name__)
 
 
-@dataclass
-class HassioMainData:
-    """Data class for HassioMainDataUpdateCoordinator."""
-
-    core: HomeAssistantInfo
-    supervisor: SupervisorInfo
-    host: HostInfo
-    mounts: dict[str, CIFSMountResponse | NFSMountResponse]
-    os: OSInfo | None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the data."""
-        return {
-            "core": self.core.to_dict(),
-            "supervisor": self.supervisor.to_dict(),
-            "host": self.host.to_dict(),
-            "mounts": {name: mount.to_dict() for name, mount in self.mounts.items()},
-            "os": self.os.to_dict() if self.os is not None else None,
-        }
-
-
-@dataclass
-class AddonData:
-    """Data for a single installed addon."""
-
-    addon: InstalledAddon
-    auto_update: bool
-    repository: str
-
-
-@dataclass
-class HassioAddonData:
-    """Data class for HassioAddOnDataUpdateCoordinator."""
-
-    addons: dict[str, AddonData]
-
-    def to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the data."""
-        return {
-            "addons": {
-                slug: {
-                    "addon": addon_data.addon.to_dict(),
-                    "auto_update": addon_data.auto_update,
-                    "repository": addon_data.repository,
-                }
-                for slug, addon_data in self.addons.items()
-            },
-        }
-
-
-@dataclass
-class HassioStatsData:
-    """Data class for HassioStatsDataUpdateCoordinator."""
-
-    core: HomeAssistantStats | None
-    supervisor: SupervisorStats | None
-    addons: dict[str, AddonsStats | None]
-
-    def to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the data."""
-        return {
-            "core": self.core.to_dict() if self.core is not None else None,
-            "supervisor": (
-                self.supervisor.to_dict() if self.supervisor is not None else None
-            ),
-            "addons": {
-                slug: stats.to_dict() if stats is not None else None
-                for slug, stats in self.addons.items()
-            },
-        }
-
-
-def _installed_addon_from_complete(info: InstalledAddonComplete) -> InstalledAddon:
-    """Build an InstalledAddon from an InstalledAddonComplete object.
-
-    InstalledAddonComplete contains a superset of InstalledAddon fields.
-    This helper extracts only the fields needed for InstalledAddon so fresh
-    data from an addon_info call can be stored in AddonData.addon.
-    """
-    return InstalledAddon(
-        advanced=info.advanced,
-        available=info.available,
-        build=info.build,
-        description=info.description,
-        homeassistant=info.homeassistant,
-        icon=info.icon,
-        logo=info.logo,
-        name=info.name,
-        repository=info.repository,
-        slug=info.slug,
-        stage=info.stage,
-        update_available=info.update_available,
-        url=info.url,
-        version_latest=info.version_latest,
-        version=info.version,
-        detached=info.detached,
-        state=info.state,
-    )
-
-
 @callback
 def get_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return generic information from Supervisor.
@@ -244,25 +151,7 @@ def get_addons_info(hass: HomeAssistant) -> dict[str, dict[str, Any] | None] | N
 
     Async friendly.
     """
-    addons_info: dict[str, InstalledAddonComplete | None] | None = hass.data.get(
-        DATA_ADDONS_INFO
-    )
-    if addons_info is None:
-        return None
-    # Converting these fields for compatibility as that is what was returned here.
-    # We'll leave it this way as long as these component APIs continue to return
-    # dictionaries. If/when we switch to using the aiohasupervisor models for everything
-    # internally and externally that will be dropped.
-    return {
-        slug: dict(
-            hassio_api=info.supervisor_api,
-            hassio_role=info.supervisor_role,
-            **info.to_dict(),
-        )
-        if info is not None
-        else None
-        for slug, info in addons_info.items()
-    }
+    return hass.data.get(DATA_ADDONS_INFO)
 
 
 @callback
@@ -281,11 +170,7 @@ def get_addons_stats(hass: HomeAssistant) -> dict[str, dict[str, Any] | None]:
 
     Async friendly.
     """
-    addons_stats: dict[str, AddonsStats | None] = hass.data.get(DATA_ADDONS_STATS) or {}
-    return {
-        slug: stats.to_dict() if stats is not None else None
-        for slug, stats in addons_stats.items()
-    }
+    return hass.data.get(DATA_ADDONS_STATS) or {}
 
 
 @callback
@@ -294,8 +179,7 @@ def get_core_stats(hass: HomeAssistant) -> dict[str, Any]:
 
     Async friendly.
     """
-    stats = hass.data.get(DATA_CORE_STATS)
-    return stats.to_dict() if stats is not None else {}
+    return hass.data.get(DATA_CORE_STATS) or {}
 
 
 @callback
@@ -304,8 +188,7 @@ def get_supervisor_stats(hass: HomeAssistant) -> dict[str, Any]:
 
     Async friendly.
     """
-    stats = hass.data.get(DATA_SUPERVISOR_STATS)
-    return stats.to_dict() if stats is not None else {}
+    return hass.data.get(DATA_SUPERVISOR_STATS) or {}
 
 
 @callback
@@ -339,20 +222,19 @@ def get_issues_info(hass: HomeAssistant) -> SupervisorIssues | None:
 
 @callback
 def async_register_addons_in_dev_reg(
-    entry_id: str, dev_reg: dr.DeviceRegistry, addons: list[AddonData]
+    entry_id: str, dev_reg: dr.DeviceRegistry, addons: list[dict[str, Any]]
 ) -> None:
     """Register addons in the device registry."""
-    for addon_data in addons:
-        addon = addon_data.addon
+    for addon in addons:
         params = DeviceInfo(
-            identifiers={(DOMAIN, addon.slug)},
+            identifiers={(DOMAIN, addon[ATTR_SLUG])},
             model=SupervisorEntityModel.ADDON,
-            sw_version=addon.version,
-            name=addon.name,
+            sw_version=addon[ATTR_VERSION],
+            name=addon[ATTR_NAME],
             entry_type=dr.DeviceEntryType.SERVICE,
-            configuration_url=f"homeassistant://hassio/addon/{addon.slug}",
+            configuration_url=f"homeassistant://hassio/addon/{addon[ATTR_SLUG]}",
         )
-        if manufacturer := addon_data.repository or addon.url:
+        if manufacturer := addon.get(ATTR_REPOSITORY) or addon.get(ATTR_URL):
             params[ATTR_MANUFACTURER] = manufacturer
         dev_reg.async_get_or_create(config_entry_id=entry_id, **params)
 
@@ -378,14 +260,14 @@ def async_register_mounts_in_dev_reg(
 
 @callback
 def async_register_os_in_dev_reg(
-    entry_id: str, dev_reg: dr.DeviceRegistry, os_info: OSInfo
+    entry_id: str, dev_reg: dr.DeviceRegistry, os_dict: dict[str, Any]
 ) -> None:
     """Register OS in the device registry."""
     params = DeviceInfo(
         identifiers={(DOMAIN, "OS")},
         manufacturer="Home Assistant",
         model=SupervisorEntityModel.OS,
-        sw_version=os_info.version,
+        sw_version=os_dict[ATTR_VERSION],
         name="Home Assistant Operating System",
         entry_type=dr.DeviceEntryType.SERVICE,
     )
@@ -412,14 +294,14 @@ def async_register_host_in_dev_reg(
 def async_register_core_in_dev_reg(
     entry_id: str,
     dev_reg: dr.DeviceRegistry,
-    core_info: HomeAssistantInfo,
+    core_dict: dict[str, Any],
 ) -> None:
-    """Register core in the device registry."""
+    """Register OS in the device registry."""
     params = DeviceInfo(
         identifiers={(DOMAIN, "core")},
         manufacturer="Home Assistant",
         model=SupervisorEntityModel.CORE,
-        sw_version=core_info.version,
+        sw_version=core_dict[ATTR_VERSION],
         name="Home Assistant Core",
         entry_type=dr.DeviceEntryType.SERVICE,
     )
@@ -430,14 +312,14 @@ def async_register_core_in_dev_reg(
 def async_register_supervisor_in_dev_reg(
     entry_id: str,
     dev_reg: dr.DeviceRegistry,
-    supervisor_info: SupervisorInfo,
+    supervisor_dict: dict[str, Any],
 ) -> None:
-    """Register supervisor in the device registry."""
+    """Register OS in the device registry."""
     params = DeviceInfo(
         identifiers={(DOMAIN, "supervisor")},
         manufacturer="Home Assistant",
         model=SupervisorEntityModel.SUPERVISOR,
-        sw_version=supervisor_info.version,
+        sw_version=supervisor_dict[ATTR_VERSION],
         name="Home Assistant Supervisor",
         entry_type=dr.DeviceEntryType.SERVICE,
     )
@@ -454,7 +336,7 @@ def async_remove_devices_from_dev_reg(
             dev_reg.async_remove_device(dev.id)
 
 
-class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
+class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Class to retrieve Hass.io container stats."""
 
     config_entry: ConfigEntry
@@ -476,18 +358,18 @@ class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
             lambda: defaultdict(set)
         )
 
-    async def _async_update_data(self) -> HassioStatsData:
+    async def _async_update_data(self) -> dict[str, Any]:
         """Update stats data via library."""
         try:
             await self._fetch_stats()
         except SupervisorError as err:
             raise UpdateFailed(f"Error on Supervisor API: {err}") from err
 
-        return HassioStatsData(
-            core=self.hass.data.get(DATA_CORE_STATS),
-            supervisor=self.hass.data.get(DATA_SUPERVISOR_STATS),
-            addons=self.hass.data.get(DATA_ADDONS_STATS) or {},
-        )
+        new_data: dict[str, Any] = {}
+        new_data[DATA_KEY_CORE] = get_core_stats(self.hass)
+        new_data[DATA_KEY_SUPERVISOR] = get_supervisor_stats(self.hass)
+        new_data[DATA_KEY_ADDONS] = get_addons_stats(self.hass)
+        return new_data
 
     async def _fetch_stats(self) -> None:
         """Fetch container stats for subscribed entities."""
@@ -505,7 +387,7 @@ class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
         if updates:
             api_results: list[ResponseData] = await asyncio.gather(*updates.values())
             for key, result in zip(updates, api_results, strict=True):
-                data[key] = result
+                data[key] = result.to_dict()
 
         # Fetch addon stats
         addons_list: list[InstalledAddon] = self.hass.data.get(DATA_ADDONS_LIST) or []
@@ -515,9 +397,7 @@ class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
             if addon.state in {AddonState.STARTED, AddonState.STARTUP}
         }
 
-        addons_stats: dict[str, AddonsStats | None] = data.setdefault(
-            DATA_ADDONS_STATS, {}
-        )
+        addons_stats: dict[str, Any] = data.setdefault(DATA_ADDONS_STATS, {})
 
         # Clean up cache for stopped/removed addons
         for slug in addons_stats.keys() - started_addons:
@@ -535,14 +415,14 @@ class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
         )
         addons_stats.update(addon_stats_results)
 
-    async def _update_addon_stats(self, slug: str) -> tuple[str, AddonsStats | None]:
+    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
         """Update single addon stats."""
         try:
             stats = await self.supervisor_client.addons.addon_stats(slug)
         except SupervisorError as err:
             _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
             return (slug, None)
-        return (slug, stats)
+        return (slug, stats.to_dict())
 
     @callback
     def async_enable_container_updates(
@@ -565,7 +445,7 @@ class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[HassioStatsData]):
         return _remove
 
 
-class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
+class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Class to retrieve Hass.io Add-on status."""
 
     config_entry: ConfigEntry
@@ -596,7 +476,7 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
         self.supervisor_client = get_supervisor_client(hass)
         self.jobs = jobs
 
-    async def _async_update_data(self) -> HassioAddonData:
+    async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
         is_first_update = not self.data
         client = self.supervisor_client
@@ -607,7 +487,7 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
 
             # Fetch addon info for all addons on first update, or only
             # for addons with subscribed entities on subsequent updates.
-            addon_info_results: dict[str, InstalledAddonComplete | None] = dict(
+            addon_info_results = dict(
                 await asyncio.gather(
                     *[
                         self._update_addon_info(slug)
@@ -623,35 +503,39 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
         self.hass.data[DATA_ADDONS_LIST] = installed_addons
 
         # Update addon info cache in hass.data
-        addon_info_cache = self.hass.data.setdefault(DATA_ADDONS_INFO, {})
+        addon_info_cache: dict[str, Any] = self.hass.data.setdefault(
+            DATA_ADDONS_INFO, {}
+        )
         for slug in addon_info_cache.keys() - all_addons:
             del addon_info_cache[slug]
         addon_info_cache.update(addon_info_results)
 
-        # Build repository name lookup from store data
-        store = self.hass.data.get(DATA_STORE)
-        repositories: dict[str, str] = (
-            {repo.slug: repo.name for repo in store.repositories} if store else {}
-        )
-
         # Build clean coordinator data
-        new_addons: dict[str, AddonData] = {}
-        for addon in installed_addons:
-            addon_info = addon_info_cache.get(addon.slug)
-            auto_update = addon_info.auto_update if addon_info is not None else False
-            repo_slug = addon.repository
-            repository = repositories.get(repo_slug, repo_slug)
-            new_addons[addon.slug] = AddonData(
-                addon=addon,
-                auto_update=auto_update,
-                repository=repository,
-            )
-        new_data = HassioAddonData(addons=new_addons)
+        store = self.hass.data.get(DATA_STORE)
+        if store:
+            repositories = {repo.slug: repo.name for repo in store.repositories}
+        else:
+            repositories = {}
+
+        addons_list_dicts = [addon.to_dict() for addon in installed_addons]
+        new_data: dict[str, Any] = {}
+        new_data[DATA_KEY_ADDONS] = {
+            (slug := addon[ATTR_SLUG]): {
+                **addon,
+                ATTR_AUTO_UPDATE: (addon_info_cache.get(slug) or {}).get(
+                    ATTR_AUTO_UPDATE, False
+                ),
+                ATTR_REPOSITORY: repositories.get(
+                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
+                ),
+            }
+            for addon in addons_list_dicts
+        }
 
         # If this is the initial refresh, register all addons
         if is_first_update:
             async_register_addons_in_dev_reg(
-                self.entry_id, self.dev_reg, list(new_data.addons.values())
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
             )
 
         # Remove add-ons that are no longer installed from device registry
@@ -662,16 +546,19 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
             )
             if device.model == SupervisorEntityModel.ADDON
         }
-        if stale_addons := supervisor_addon_devices - set(new_data.addons):
+        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
             async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
 
         # If there are new add-ons, we should reload the config entry so we can
-        # create new devices and entities. We can return the new data because
+        # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
-        if self.data and (set(new_data.addons) - set(self.data.addons)):
+        if self.data and (
+            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
+        ):
             self.hass.async_create_task(
                 self.hass.config_entries.async_reload(self.entry_id)
             )
+            return {}
 
         return new_data
 
@@ -682,16 +569,18 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
         except SupervisorNotFoundError:
             return None
 
-    async def _update_addon_info(
-        self, slug: str
-    ) -> tuple[str, InstalledAddonComplete | None]:
+    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
         """Return the info for an addon."""
         try:
             info = await self.supervisor_client.addons.addon_info(slug)
         except SupervisorError as err:
             _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
             return (slug, None)
-        return (slug, info)
+        # Translate to legacy hassio names for compatibility
+        info_dict = info.to_dict()
+        info_dict["hassio_api"] = info_dict.pop("supervisor_api")
+        info_dict["hassio_role"] = info_dict.pop("supervisor_role")
+        return (slug, info_dict)
 
     @callback
     def async_enable_addon_info_updates(
@@ -738,26 +627,16 @@ class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[HassioAddonData]):
         """Force refresh of addon info data for a specific addon."""
         try:
             slug, info = await self._update_addon_info(addon_slug)
+            if info is not None and DATA_KEY_ADDONS in self.data:
+                if slug in self.data[DATA_KEY_ADDONS]:
+                    data = deepcopy(self.data)
+                    data[DATA_KEY_ADDONS][slug].update(info)
+                    self.async_set_updated_data(data)
         except SupervisorError as err:
             _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
-            return
-
-        if info is not None and self.data and slug in self.data.addons:
-            updated = AddonData(
-                addon=_installed_addon_from_complete(info),
-                auto_update=info.auto_update,
-                repository=self.data.addons[slug].repository,
-            )
-            self.async_set_updated_data(
-                HassioAddonData(addons={**self.data.addons, slug: updated})
-            )
-
-            # Update addon info cache in hass.data
-            addon_info_cache = self.hass.data.setdefault(DATA_ADDONS_INFO, {})
-            addon_info_cache[slug] = info
 
 
-class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
+class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Class to retrieve Hass.io status."""
 
     config_entry: ConfigEntry
@@ -800,7 +679,7 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
         ):
             self.config_entry.async_create_task(self.hass, self.async_request_refresh())
 
-    async def _async_update_data(self) -> HassioMainData:
+    async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
         is_first_update = not self.data
         client = self.supervisor_client
@@ -843,13 +722,13 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
             raise UpdateFailed(f"Error on Supervisor API: {err}") from err
 
         # Build clean coordinator data
-        new_data = HassioMainData(
-            core=core_info,
-            supervisor=supervisor_info,
-            host=host_info,
-            mounts={mount.name: mount for mount in mounts_info.mounts},
-            os=os_info if self.is_hass_os else None,
-        )
+        new_data: dict[str, Any] = {}
+        new_data[DATA_KEY_CORE] = core_info.to_dict()
+        new_data[DATA_KEY_SUPERVISOR] = supervisor_info.to_dict()
+        new_data[DATA_KEY_HOST] = host_info.to_dict()
+        new_data[DATA_KEY_MOUNTS] = {mount.name: mount for mount in mounts_info.mounts}
+        if self.is_hass_os:
+            new_data[DATA_KEY_OS] = os_info.to_dict()
 
         # Update hass.data for legacy accessor functions
         self.hass.data[DATA_INFO] = info
@@ -863,15 +742,19 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
         # If this is the initial refresh, register all main components
         if is_first_update:
             async_register_mounts_in_dev_reg(
-                self.entry_id, self.dev_reg, list(new_data.mounts.values())
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_MOUNTS].values()
+            )
+            async_register_core_in_dev_reg(
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_CORE]
             )
-            async_register_core_in_dev_reg(self.entry_id, self.dev_reg, new_data.core)
             async_register_supervisor_in_dev_reg(
-                self.entry_id, self.dev_reg, new_data.supervisor
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_SUPERVISOR]
             )
             async_register_host_in_dev_reg(self.entry_id, self.dev_reg)
             if self.is_hass_os:
-                async_register_os_in_dev_reg(self.entry_id, self.dev_reg, os_info)
+                async_register_os_in_dev_reg(
+                    self.entry_id, self.dev_reg, new_data[DATA_KEY_OS]
+                )
 
         # Remove mounts that no longer exists from device registry
         supervisor_mount_devices = {
@@ -881,7 +764,7 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
             )
             if device.model == SupervisorEntityModel.MOUNT
         }
-        if stale_mounts := supervisor_mount_devices - set(new_data.mounts):
+        if stale_mounts := supervisor_mount_devices - set(new_data[DATA_KEY_MOUNTS]):
             async_remove_devices_from_dev_reg(
                 self.dev_reg, {f"mount_{stale_mount}" for stale_mount in stale_mounts}
             )
@@ -893,12 +776,15 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[HassioMainData]):
             self.dev_reg.async_remove_device(dev.id)
 
         # If there are new mounts, we should reload the config entry so we can
-        # create new devices and entities. We can return the new data because
+        # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
-        if self.data and (set(new_data.mounts) - set(self.data.mounts)):
+        if self.data and (
+            set(new_data[DATA_KEY_MOUNTS]) - set(self.data.get(DATA_KEY_MOUNTS, {}))
+        ):
             self.hass.async_create_task(
                 self.hass.config_entries.async_reload(self.entry_id)
             )
+            return {}
 
         return new_data
 

homeassistant/components/hassio/diagnostics.py

@@ -56,8 +56,8 @@ async def async_get_config_entry_diagnostics(
         devices.append({"device": asdict(device), "entities": entities})
 
     return {
-        "coordinator_data": coordinator.data.to_dict(),
-        "addons_coordinator_data": addons_coordinator.data.to_dict(),
-        "stats_coordinator_data": stats_coordinator.data.to_dict(),
+        "coordinator_data": coordinator.data,
+        "addons_coordinator_data": addons_coordinator.data,
+        "stats_coordinator_data": stats_coordinator.data,
         "devices": devices,
     }

homeassistant/components/hassio/entity.py

@@ -1,20 +1,27 @@
 """Base for Hass.io entities."""
 
-from collections.abc import Callable
+from typing import Any
 
-from aiohasupervisor.models import CIFSMountResponse, HostInfo, NFSMountResponse, OSInfo
-from aiohasupervisor.models.base import ContainerStats
+from aiohasupervisor.models.mounts import CIFSMountResponse, NFSMountResponse
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONTAINER_STATS, DOMAIN
+from .const import (
+    ATTR_SLUG,
+    CONTAINER_STATS,
+    DATA_KEY_ADDONS,
+    DATA_KEY_CORE,
+    DATA_KEY_HOST,
+    DATA_KEY_MOUNTS,
+    DATA_KEY_OS,
+    DATA_KEY_SUPERVISOR,
+    DOMAIN,
+)
 from .coordinator import (
-    AddonData,
     HassioAddOnDataUpdateCoordinator,
     HassioMainDataUpdateCoordinator,
-    HassioStatsData,
     HassioStatsDataUpdateCoordinator,
 )
 
@@ -30,7 +37,7 @@ class HassioStatsEntity(CoordinatorEntity[HassioStatsDataUpdateCoordinator]):
         entity_description: EntityDescription,
         *,
         container_id: str,
-        stats_fn: Callable[[HassioStatsData], ContainerStats | None],
+        data_key: str,
         device_id: str,
         unique_id_prefix: str,
     ) -> None:
@@ -38,25 +45,27 @@ class HassioStatsEntity(CoordinatorEntity[HassioStatsDataUpdateCoordinator]):
         super().__init__(coordinator)
         self.entity_description = entity_description
         self._container_id = container_id
-        self._stats_fn = stats_fn
+        self._data_key = data_key
         self._attr_unique_id = f"{unique_id_prefix}_{entity_description.key}"
         self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, device_id)})
 
-    @property
-    def _stats(self) -> ContainerStats | None:
-        """Return the stats object for this entity's container."""
-        return self._stats_fn(self.coordinator.data)
-
-    @property
-    def stats(self) -> ContainerStats:
-        """Return the stats object, asserting it is available."""
-        assert self._stats is not None
-        return self._stats
-
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
-        return super().available and self._stats is not None
+        if self._data_key == DATA_KEY_ADDONS:
+            return (
+                super().available
+                and DATA_KEY_ADDONS in self.coordinator.data
+                and self.entity_description.key
+                in (
+                    self.coordinator.data[DATA_KEY_ADDONS].get(self._container_id) or {}
+                )
+            )
+        return (
+            super().available
+            and self._data_key in self.coordinator.data
+            and self.entity_description.key in self.coordinator.data[self._data_key]
+        )
 
     async def async_added_to_hass(self) -> None:
         """Subscribe to stats updates."""
@@ -83,31 +92,24 @@ class HassioAddonEntity(CoordinatorEntity[HassioAddOnDataUpdateCoordinator]):
         self,
         coordinator: HassioAddOnDataUpdateCoordinator,
         entity_description: EntityDescription,
-        addon: AddonData,
+        addon: dict[str, Any],
     ) -> None:
         """Initialize base entity."""
         super().__init__(coordinator)
         self.entity_description = entity_description
-        self._addon_slug = addon.addon.slug
-        self._attr_unique_id = f"{addon.addon.slug}_{entity_description.key}"
-        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, addon.addon.slug)})
-
-    @property
-    def addon_slug(self) -> str:
-        """Return the add-on slug."""
-        return self._addon_slug
-
-    @property
-    def addon_data(self) -> AddonData:
-        """Return the add-on data, asserting it is available."""
-        data = self.coordinator.data
-        assert self._addon_slug in data.addons
-        return data.addons[self._addon_slug]
+        self._addon_slug = addon[ATTR_SLUG]
+        self._attr_unique_id = f"{addon[ATTR_SLUG]}_{entity_description.key}"
+        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, addon[ATTR_SLUG])})
 
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
-        return super().available and self._addon_slug in self.coordinator.data.addons
+        return (
+            super().available
+            and DATA_KEY_ADDONS in self.coordinator.data
+            and self.entity_description.key
+            in self.coordinator.data[DATA_KEY_ADDONS].get(self._addon_slug, {})
+        )
 
     async def async_added_to_hass(self) -> None:
         """Subscribe to addon info updates."""
@@ -138,13 +140,11 @@ class HassioOSEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
-        return super().available and self.coordinator.data.os is not None
-
-    @property
-    def os(self) -> OSInfo:
-        """Return the OS info object, asserting it is available."""
-        assert self.coordinator.data.os is not None
-        return self.coordinator.data.os
+        return (
+            super().available
+            and DATA_KEY_OS in self.coordinator.data
+            and self.entity_description.key in self.coordinator.data[DATA_KEY_OS]
+        )
 
 
 class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
@@ -164,10 +164,13 @@ class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
         self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, "host")})
 
     @property
-    def host(self) -> HostInfo:
-        """Return the host info, asserting it is available."""
-        assert self.coordinator.data.host is not None
-        return self.coordinator.data.host
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return (
+            super().available
+            and DATA_KEY_HOST in self.coordinator.data
+            and self.entity_description.key in self.coordinator.data[DATA_KEY_HOST]
+        )
 
 
 class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
@@ -186,6 +189,16 @@ class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator])
         self._attr_unique_id = f"home_assistant_supervisor_{entity_description.key}"
         self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, "supervisor")})
 
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return (
+            super().available
+            and DATA_KEY_SUPERVISOR in self.coordinator.data
+            and self.entity_description.key
+            in self.coordinator.data[DATA_KEY_SUPERVISOR]
+        )
+
 
 class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
     """Base Entity for Core."""
@@ -203,6 +216,15 @@ class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
         self._attr_unique_id = f"home_assistant_core_{entity_description.key}"
         self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, "core")})
 
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return (
+            super().available
+            and DATA_KEY_CORE in self.coordinator.data
+            and self.entity_description.key in self.coordinator.data[DATA_KEY_CORE]
+        )
+
 
 class HassioMountEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
     """Base Entity for Mount."""
@@ -226,12 +248,10 @@ class HassioMountEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
         )
         self._mount = mount
 
-    @property
-    def mount_name(self) -> str:
-        """Return the mount name."""
-        return self._mount.name
-
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
-        return super().available and self.mount_name in self.coordinator.data.mounts
+        return (
+            super().available
+            and self._mount.name in self.coordinator.data[DATA_KEY_MOUNTS]
+        )

homeassistant/components/hassio/sensor.py

@@ -1,10 +1,5 @@
 """Sensor platform for Hass.io addons."""
 
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from aiohasupervisor.models.base import ContainerStats
-
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -20,12 +15,19 @@ from .const import (
     ADDONS_COORDINATOR,
     ATTR_CPU_PERCENT,
     ATTR_MEMORY_PERCENT,
+    ATTR_SLUG,
+    ATTR_VERSION,
+    ATTR_VERSION_LATEST,
     CORE_CONTAINER,
+    DATA_KEY_ADDONS,
+    DATA_KEY_CORE,
+    DATA_KEY_HOST,
+    DATA_KEY_OS,
+    DATA_KEY_SUPERVISOR,
     MAIN_COORDINATOR,
     STATS_COORDINATOR,
     SUPERVISOR_CONTAINER,
 )
-from .coordinator import HassioStatsData
 from .entity import (
     HassioAddonEntity,
     HassioHostEntity,
@@ -33,125 +35,74 @@ from .entity import (
     HassioStatsEntity,
 )
 
-
-@dataclass(frozen=True, kw_only=True)
-class HassioAddonSensorEntityDescription(SensorEntityDescription):
-    """Hass.io add-on sensor entity description."""
-
-    value_fn: Callable[[HassioAddonSensor], str | None]
-
-
-@dataclass(frozen=True, kw_only=True)
-class HassioStatsSensorEntityDescription(SensorEntityDescription):
-    """Hass.io stats sensor entity description."""
-
-    value_fn: Callable[[HassioStatsSensor], float]
-
-
-@dataclass(frozen=True, kw_only=True)
-class HassioOSSensorEntityDescription(SensorEntityDescription):
-    """Hass.io OS sensor entity description."""
-
-    value_fn: Callable[[HassioOSSensor], str | None]
-
-
-@dataclass(frozen=True, kw_only=True)
-class HassioHostSensorEntityDescription(SensorEntityDescription):
-    """Hass.io host sensor entity description."""
-
-    value_fn: Callable[[HostSensor], str | float | None]
-
-
-ADDON_ENTITY_DESCRIPTIONS = (
-    HassioAddonSensorEntityDescription(
+COMMON_ENTITY_DESCRIPTIONS = (
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
-        key="version",
+        key=ATTR_VERSION,
         translation_key="version",
-        value_fn=lambda entity: entity.addon_data.addon.version,
     ),
-    HassioAddonSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
-        key="version_latest",
+        key=ATTR_VERSION_LATEST,
         translation_key="version_latest",
-        value_fn=lambda entity: entity.addon_data.addon.version_latest,
     ),
 )
 
 STATS_ENTITY_DESCRIPTIONS = (
-    HassioStatsSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key=ATTR_CPU_PERCENT,
         translation_key="cpu_percent",
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda entity: entity.stats.cpu_percent,
     ),
-    HassioStatsSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key=ATTR_MEMORY_PERCENT,
         translation_key="memory_percent",
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda entity: entity.stats.memory_percent,
     ),
 )
 
-OS_ENTITY_DESCRIPTIONS = (
-    HassioOSSensorEntityDescription(
-        entity_registry_enabled_default=False,
-        key="version",
-        translation_key="version",
-        value_fn=lambda entity: entity.os.version,
-    ),
-    HassioOSSensorEntityDescription(
-        entity_registry_enabled_default=False,
-        key="version_latest",
-        translation_key="version_latest",
-        value_fn=lambda entity: entity.os.version_latest,
-    ),
-)
+OS_ENTITY_DESCRIPTIONS = COMMON_ENTITY_DESCRIPTIONS
 
 HOST_ENTITY_DESCRIPTIONS = (
-    HassioHostSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key="agent_version",
         translation_key="agent_version",
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda entity: entity.host.agent_version,
     ),
-    HassioHostSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key="apparmor_version",
         translation_key="apparmor_version",
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda entity: entity.host.apparmor_version,
     ),
-    HassioHostSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key="disk_total",
         translation_key="disk_total",
         native_unit_of_measurement=UnitOfInformation.GIGABYTES,
         device_class=SensorDeviceClass.DATA_SIZE,
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda entity: entity.host.disk_total,
     ),
-    HassioHostSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key="disk_used",
         translation_key="disk_used",
         native_unit_of_measurement=UnitOfInformation.GIGABYTES,
         device_class=SensorDeviceClass.DATA_SIZE,
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda entity: entity.host.disk_used,
     ),
-    HassioHostSensorEntityDescription(
+    SensorEntityDescription(
         entity_registry_enabled_default=False,
         key="disk_free",
         translation_key="disk_free",
         native_unit_of_measurement=UnitOfInformation.GIGABYTES,
         device_class=SensorDeviceClass.DATA_SIZE,
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda entity: entity.host.disk_free,
     ),
 )
 
@@ -175,32 +126,21 @@ async def async_setup_entry(
             coordinator=addons_coordinator,
             entity_description=entity_description,
         )
-        for addon in addons_coordinator.data.addons.values()
-        for entity_description in ADDON_ENTITY_DESCRIPTIONS
+        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
+        for entity_description in COMMON_ENTITY_DESCRIPTIONS
     )
 
     # Add-on stats sensors (cpu_percent, memory_percent)
-    def stats_fn_factory(
-        addon_slug: str,
-    ) -> Callable[[HassioStatsData], ContainerStats | None]:
-        """Return a stats_fn for the given add-on slug."""
-
-        def stats_fn(data: HassioStatsData) -> ContainerStats | None:
-            """Return the stats for the given add-on."""
-            return data.addons.get(addon_slug)
-
-        return stats_fn
-
     entities.extend(
         HassioStatsSensor(
             coordinator=stats_coordinator,
             entity_description=entity_description,
-            container_id=addon.addon.slug,
-            stats_fn=stats_fn_factory(addon.addon.slug),
-            device_id=addon.addon.slug,
-            unique_id_prefix=addon.addon.slug,
+            container_id=addon[ATTR_SLUG],
+            data_key=DATA_KEY_ADDONS,
+            device_id=addon[ATTR_SLUG],
+            unique_id_prefix=addon[ATTR_SLUG],
         )
-        for addon in addons_coordinator.data.addons.values()
+        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
         for entity_description in STATS_ENTITY_DESCRIPTIONS
     )
 
@@ -210,7 +150,7 @@ async def async_setup_entry(
             coordinator=stats_coordinator,
             entity_description=entity_description,
             container_id=CORE_CONTAINER,
-            stats_fn=lambda data: data.core,
+            data_key=DATA_KEY_CORE,
             device_id="core",
             unique_id_prefix="home_assistant_core",
         )
@@ -223,7 +163,7 @@ async def async_setup_entry(
             coordinator=stats_coordinator,
             entity_description=entity_description,
             container_id=SUPERVISOR_CONTAINER,
-            stats_fn=lambda data: data.supervisor,
+            data_key=DATA_KEY_SUPERVISOR,
             device_id="supervisor",
             unique_id_prefix="home_assistant_supervisor",
         )
@@ -255,42 +195,40 @@ async def async_setup_entry(
 class HassioAddonSensor(HassioAddonEntity, SensorEntity):
     """Sensor to track a Hass.io add-on attribute."""
 
-    entity_description: HassioAddonSensorEntityDescription
-
     @property
-    def native_value(self) -> str | None:
+    def native_value(self) -> str:
         """Return native value of entity."""
-        return self.entity_description.value_fn(self)
+        return self.coordinator.data[DATA_KEY_ADDONS][self._addon_slug][
+            self.entity_description.key
+        ]
 
 
 class HassioStatsSensor(HassioStatsEntity, SensorEntity):
     """Sensor to track container stats."""
 
-    entity_description: HassioStatsSensorEntityDescription
-
     @property
-    def native_value(self) -> float:
+    def native_value(self) -> str:
         """Return native value of entity."""
-        return self.entity_description.value_fn(self)
+        if self._data_key == DATA_KEY_ADDONS:
+            return self.coordinator.data[DATA_KEY_ADDONS][self._container_id][
+                self.entity_description.key
+            ]
+        return self.coordinator.data[self._data_key][self.entity_description.key]
 
 
 class HassioOSSensor(HassioOSEntity, SensorEntity):
     """Sensor to track a Hass.io OS attribute."""
 
-    entity_description: HassioOSSensorEntityDescription
-
     @property
-    def native_value(self) -> str | None:
+    def native_value(self) -> str:
         """Return native value of entity."""
-        return self.entity_description.value_fn(self)
+        return self.coordinator.data[DATA_KEY_OS][self.entity_description.key]
 
 
 class HostSensor(HassioHostEntity, SensorEntity):
     """Sensor to track a host attribute."""
 
-    entity_description: HassioHostSensorEntityDescription
-
     @property
-    def native_value(self) -> str | float | None:
+    def native_value(self) -> str:
         """Return native value of entity."""
-        return self.entity_description.value_fn(self)
+        return self.coordinator.data[DATA_KEY_HOST][self.entity_description.key]

homeassistant/components/hassio/switch.py

@@ -4,15 +4,15 @@ import logging
 from typing import Any
 
 from aiohasupervisor import SupervisorError
-from aiohasupervisor.models import AddonState
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import ATTR_ICON
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import ADDONS_COORDINATOR
+from .const import ADDONS_COORDINATOR, ATTR_STARTED, ATTR_STATE, DATA_KEY_ADDONS
 from .entity import HassioAddonEntity
 from .handler import get_supervisor_client
 
@@ -20,7 +20,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 ENTITY_DESCRIPTION = SwitchEntityDescription(
-    key="state",
+    key=ATTR_STATE,
     name=None,
     icon="mdi:puzzle",
     entity_registry_enabled_default=False,
@@ -41,7 +41,7 @@ async def async_setup_entry(
             coordinator=coordinator,
             entity_description=ENTITY_DESCRIPTION,
         )
-        for addon in coordinator.data.addons.values()
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
     )
 
 
@@ -49,19 +49,19 @@ class HassioAddonSwitch(HassioAddonEntity, SwitchEntity):
     """Switch for Hass.io add-ons."""
 
     @property
-    def is_on(self) -> bool:
+    def is_on(self) -> bool | None:
         """Return true if the add-on is on."""
-        return (
-            self.coordinator.data.addons[self._addon_slug].addon.state
-            == AddonState.STARTED
-        )
+        addon_data = self.coordinator.data[DATA_KEY_ADDONS].get(self._addon_slug, {})
+        state = addon_data.get(self.entity_description.key)
+        return state == ATTR_STARTED
 
     @property
     def entity_picture(self) -> str | None:
         """Return the icon of the add-on if any."""
         if not self.available:
             return None
-        if self.coordinator.data.addons[self._addon_slug].addon.icon:
+        addon_data = self.coordinator.data[DATA_KEY_ADDONS].get(self._addon_slug, {})
+        if addon_data.get(ATTR_ICON):
             return f"/api/hassio/addons/{self._addon_slug}/icon"
         return None
 

homeassistant/components/hassio/update.py

@@ -13,12 +13,22 @@ from homeassistant.components.update import (
     UpdateEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import ATTR_ICON, ATTR_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import ADDONS_COORDINATOR, ATTR_VERSION_LATEST, MAIN_COORDINATOR
-from .coordinator import AddonData
+from .const import (
+    ADDONS_COORDINATOR,
+    ATTR_AUTO_UPDATE,
+    ATTR_VERSION,
+    ATTR_VERSION_LATEST,
+    DATA_KEY_ADDONS,
+    DATA_KEY_CORE,
+    DATA_KEY_OS,
+    DATA_KEY_SUPERVISOR,
+    MAIN_COORDINATOR,
+)
 from .entity import (
     HassioAddonEntity,
     HassioCoreEntity,
@@ -68,7 +78,7 @@ async def async_setup_entry(
             coordinator=addons_coordinator,
             entity_description=ENTITY_DESCRIPTION,
         )
-        for addon in addons_coordinator.data.addons.values()
+        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
     )
 
     async_add_entities(entities)
@@ -98,29 +108,29 @@ class SupervisorAddonUpdateEntity(HassioAddonEntity, UpdateEntity):
     _version_before_update: str | None = None
 
     @property
-    def _addon_data(self) -> AddonData:
+    def _addon_data(self) -> dict:
         """Return the add-on data."""
-        return self.coordinator.data.addons[self._addon_slug]
+        return self.coordinator.data[DATA_KEY_ADDONS][self._addon_slug]
 
     @property
     def auto_update(self) -> bool:
         """Return true if auto-update is enabled for the add-on."""
-        return self._addon_data.auto_update
+        return self._addon_data[ATTR_AUTO_UPDATE]
 
     @property
     def title(self) -> str | None:
         """Return the title of the update."""
-        return self._addon_data.addon.name
+        return self._addon_data[ATTR_NAME]
 
     @property
     def latest_version(self) -> str | None:
         """Latest version available for install."""
-        return self._addon_data.addon.version_latest
+        return self._addon_data[ATTR_VERSION_LATEST]
 
     @property
     def installed_version(self) -> str | None:
         """Version installed and in use."""
-        return self._addon_data.addon.version
+        return self._addon_data[ATTR_VERSION]
 
     @property
     def in_progress(self) -> bool | None:
@@ -134,7 +144,7 @@ class SupervisorAddonUpdateEntity(HassioAddonEntity, UpdateEntity):
         """Return the icon of the add-on if any."""
         if not self.available:
             return None
-        if self._addon_data.addon.icon:
+        if self._addon_data[ATTR_ICON]:
             return f"/api/hassio/addons/{self._addon_slug}/icon"
         return None
 
@@ -226,16 +236,14 @@ class SupervisorOSUpdateEntity(HassioOSEntity, UpdateEntity):
     _attr_title = "Home Assistant Operating System"
 
     @property
-    def latest_version(self) -> str | None:
+    def latest_version(self) -> str:
         """Return the latest version."""
-        assert self.coordinator.data.os is not None
-        return self.coordinator.data.os.version_latest
+        return self.coordinator.data[DATA_KEY_OS][ATTR_VERSION_LATEST]
 
     @property
-    def installed_version(self) -> str | None:
+    def installed_version(self) -> str:
         """Return the installed version."""
-        assert self.coordinator.data.os is not None
-        return self.coordinator.data.os.version
+        return self.coordinator.data[DATA_KEY_OS][ATTR_VERSION]
 
     @property
     def entity_picture(self) -> str | None:
@@ -285,19 +293,19 @@ class SupervisorSupervisorUpdateEntity(HassioSupervisorEntity, UpdateEntity):
         return self._attr_in_progress
 
     @property
-    def latest_version(self) -> str | None:
+    def latest_version(self) -> str:
         """Return the latest version."""
-        return self.coordinator.data.supervisor.version_latest
+        return self.coordinator.data[DATA_KEY_SUPERVISOR][ATTR_VERSION_LATEST]
 
     @property
     def installed_version(self) -> str:
         """Return the installed version."""
-        return self.coordinator.data.supervisor.version
+        return self.coordinator.data[DATA_KEY_SUPERVISOR][ATTR_VERSION]
 
     @property
     def auto_update(self) -> bool:
         """Return true if auto-update is enabled for supervisor."""
-        return self.coordinator.data.supervisor.auto_update
+        return self.coordinator.data[DATA_KEY_SUPERVISOR][ATTR_AUTO_UPDATE]
 
     @property
     def release_url(self) -> str | None:
@@ -381,14 +389,14 @@ class SupervisorCoreUpdateEntity(HassioCoreEntity, UpdateEntity):
     _attr_title = "Home Assistant Core"
 
     @property
-    def latest_version(self) -> str | None:
+    def latest_version(self) -> str:
         """Return the latest version."""
-        return self.coordinator.data.core.version_latest
+        return self.coordinator.data[DATA_KEY_CORE][ATTR_VERSION_LATEST]
 
     @property
-    def installed_version(self) -> str | None:
+    def installed_version(self) -> str:
         """Return the installed version."""
-        return self.coordinator.data.core.version
+        return self.coordinator.data[DATA_KEY_CORE][ATTR_VERSION]
 
     @property
     def entity_picture(self) -> str | None:

homeassistant/components/hive/__init__.py

@@ -44,20 +44,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: HiveConfigEntry) -> bool
     except HiveReauthRequired as err:
         raise ConfigEntryAuthFailed from err
 
-    hub_data = devices["parent"][0]
-    connections: set[tuple[str, str]] = set()
-    if mac := hub_data.get("macAddress"):
-        connections.add((dr.CONNECTION_NETWORK_MAC, dr.format_mac(mac)))
-
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
-        identifiers={(DOMAIN, hub_data["device_id"])},
-        connections=connections,
-        name=hub_data["hiveName"],
-        model=hub_data["deviceData"]["model"],
-        sw_version=hub_data["deviceData"]["version"],
-        manufacturer=hub_data["deviceData"]["manufacturer"],
+        identifiers={(DOMAIN, devices["parent"][0]["device_id"])},
+        name=devices["parent"][0]["hiveName"],
+        model=devices["parent"][0]["deviceData"]["model"],
+        sw_version=devices["parent"][0]["deviceData"]["version"],
+        manufacturer=devices["parent"][0]["deviceData"]["manufacturer"],
     )
 
     await hass.config_entries.async_forward_entry_setups(

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.96", "babel==2.15.0"]
+  "requirements": ["holidays==0.95", "babel==2.15.0"]
 }

homeassistant/components/homematicip_cloud/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.10.0"]
+  "requirements": ["homematicip==2.9.0"]
 }

homeassistant/components/humidifier/condition.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 import voluptuous as vol
 
 from homeassistant.const import ATTR_MODE, CONF_OPTIONS, PERCENTAGE, STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant, State
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
@@ -13,8 +13,8 @@ from homeassistant.helpers.condition import (
     ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL,
     Condition,
     ConditionConfig,
-    EntityNumericalConditionBase,
     EntityStateConditionBase,
+    make_entity_numerical_condition,
     make_entity_state_condition,
 )
 from homeassistant.helpers.entity import get_supported_features
@@ -46,20 +46,6 @@ def _supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> boo
         return False
 
 
-class IsTargetHumidityCondition(EntityNumericalConditionBase):
-    """Condition for humidifier target humidity."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
-    _valid_unit = PERCENTAGE
-
-    def _should_include(self, state: State) -> bool:
-        """Skip humidifier entities that do not expose a target humidity."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_HUMIDITY) is not None
-        )
-
-
 class IsModeCondition(EntityStateConditionBase):
     """Condition for humidifier mode."""
 
@@ -93,7 +79,10 @@ CONDITIONS: dict[str, type[Condition]] = {
         {DOMAIN: DomainSpec(value_source=ATTR_ACTION)}, HumidifierAction.HUMIDIFYING
     ),
     "is_mode": IsModeCondition,
-    "is_target_humidity": IsTargetHumidityCondition,
+    "is_target_humidity": make_entity_numerical_condition(
+        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
+        valid_unit=PERCENTAGE,
+    ),
 }
 
 

homeassistant/components/humidity/condition.py

@@ -14,9 +14,9 @@ from homeassistant.components.weather import (
     DOMAIN as WEATHER_DOMAIN,
 )
 from homeassistant.const import PERCENTAGE
-from homeassistant.core import HomeAssistant, State
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.condition import Condition, EntityNumericalConditionBase
+from homeassistant.helpers.condition import Condition, make_entity_numerical_condition
 
 HUMIDITY_DOMAIN_SPECS = {
     CLIMATE_DOMAIN: DomainSpec(
@@ -31,31 +31,8 @@ HUMIDITY_DOMAIN_SPECS = {
     ),
 }
 
-
-class HumidityCondition(EntityNumericalConditionBase):
-    """Condition for humidity value across multiple domains."""
-
-    _domain_specs = HUMIDITY_DOMAIN_SPECS
-    _valid_unit = PERCENTAGE
-
-    def _should_include(self, state: State) -> bool:
-        """Skip attribute-source entities that lack the humidity attribute.
-
-        Mirrors the humidity trigger: for climate / humidifier / weather
-        (attribute-based), the entity is filtered when the source attribute
-        is absent; sensor entities (state-value-based) fall through to the
-        base impl.
-        """
-        if not super()._should_include(state):
-            return False
-        domain_spec = self._domain_specs[state.domain]
-        if domain_spec.value_source is None:
-            return True
-        return state.attributes.get(domain_spec.value_source) is not None
-
-
 CONDITIONS: dict[str, type[Condition]] = {
-    "is_value": HumidityCondition,
+    "is_value": make_entity_numerical_condition(HUMIDITY_DOMAIN_SPECS, PERCENTAGE),
 }
 
 

homeassistant/components/humidity/trigger.py

@@ -13,13 +13,12 @@ from homeassistant.components.weather import (
     ATTR_WEATHER_HUMIDITY,
     DOMAIN as WEATHER_DOMAIN,
 )
-from homeassistant.core import HomeAssistant, State
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
-    EntityNumericalStateChangedTriggerBase,
-    EntityNumericalStateCrossedThresholdTriggerBase,
-    EntityNumericalStateTriggerBase,
     Trigger,
+    make_entity_numerical_state_changed_trigger,
+    make_entity_numerical_state_crossed_threshold_trigger,
 )
 
 HUMIDITY_DOMAIN_SPECS: dict[str, DomainSpec] = {
@@ -37,46 +36,13 @@ HUMIDITY_DOMAIN_SPECS: dict[str, DomainSpec] = {
     ),
 }
 
-
-class _HumidityTriggerMixin(EntityNumericalStateTriggerBase):
-    """Mixin for humidity triggers providing entity filtering."""
-
-    _domain_specs = HUMIDITY_DOMAIN_SPECS
-    _valid_unit = "%"
-
-    def _should_include(self, state: State) -> bool:
-        """Skip attribute-source entities that lack the humidity attribute.
-
-        For domains whose tracked value comes from an attribute
-        (climate / humidifier / weather), require the attribute to be
-        present; otherwise the all/count check would treat an entity that
-        cannot report a humidity as a non-match and block behavior=last.
-        Sensor entities source their value from `state.state`, so they
-        fall through to the base impl.
-        """
-        if not super()._should_include(state):
-            return False
-        domain_spec = self._domain_specs[state.domain]
-        if domain_spec.value_source is None:
-            return True
-        return state.attributes.get(domain_spec.value_source) is not None
-
-
-class HumidityChangedTrigger(
-    _HumidityTriggerMixin, EntityNumericalStateChangedTriggerBase
-):
-    """Trigger for humidity value changes across multiple domains."""
-
-
-class HumidityCrossedThresholdTrigger(
-    _HumidityTriggerMixin, EntityNumericalStateCrossedThresholdTriggerBase
-):
-    """Trigger for humidity value crossing a threshold across multiple domains."""
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "changed": HumidityChangedTrigger,
-    "crossed_threshold": HumidityCrossedThresholdTrigger,
+    "changed": make_entity_numerical_state_changed_trigger(
+        HUMIDITY_DOMAIN_SPECS, valid_unit="%"
+    ),
+    "crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
+        HUMIDITY_DOMAIN_SPECS, valid_unit="%"
+    ),
 }
 
 

homeassistant/components/husqvarna_automower/manifest.json

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

homeassistant/components/husqvarna_automower_ble/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.8.1"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.4.0"]
 }

homeassistant/components/imap/config_flow.py

@@ -76,12 +76,14 @@ CONFIG_SCHEMA = vol.Schema(
         vol.Optional(CONF_SEARCH, default="UnSeen UnDeleted"): str,
         # The default for new entries is to not include text and headers
         vol.Optional(CONF_EVENT_MESSAGE_DATA, default=[]): EVENT_MESSAGE_DATA_SELECTOR,
-        vol.Optional(
-            CONF_SSL_CIPHER_LIST, default=SSLCipherList.PYTHON_DEFAULT
-        ): CIPHER_SELECTOR,
-        vol.Optional(CONF_VERIFY_SSL, default=True): BOOLEAN_SELECTOR,
     }
 )
+CONFIG_SCHEMA_ADVANCED = {
+    vol.Optional(
+        CONF_SSL_CIPHER_LIST, default=SSLCipherList.PYTHON_DEFAULT
+    ): CIPHER_SELECTOR,
+    vol.Optional(CONF_VERIFY_SSL, default=True): BOOLEAN_SELECTOR,
+}
 
 OPTIONS_SCHEMA = vol.Schema(
     {
@@ -91,15 +93,18 @@ OPTIONS_SCHEMA = vol.Schema(
         vol.Optional(
             CONF_EVENT_MESSAGE_DATA, default=MESSAGE_DATA_OPTIONS
         ): EVENT_MESSAGE_DATA_SELECTOR,
-        vol.Optional(CONF_CUSTOM_EVENT_DATA_TEMPLATE): TEMPLATE_SELECTOR,
-        vol.Optional(CONF_MAX_MESSAGE_SIZE, default=DEFAULT_MAX_MESSAGE_SIZE): vol.All(
-            cv.positive_int,
-            vol.Range(min=DEFAULT_MAX_MESSAGE_SIZE, max=MAX_MESSAGE_SIZE_LIMIT),
-        ),
-        vol.Optional(CONF_ENABLE_PUSH, default=True): BOOLEAN_SELECTOR,
     }
 )
 
+OPTIONS_SCHEMA_ADVANCED = {
+    vol.Optional(CONF_CUSTOM_EVENT_DATA_TEMPLATE): TEMPLATE_SELECTOR,
+    vol.Optional(CONF_MAX_MESSAGE_SIZE, default=DEFAULT_MAX_MESSAGE_SIZE): vol.All(
+        cv.positive_int,
+        vol.Range(min=DEFAULT_MAX_MESSAGE_SIZE, max=MAX_MESSAGE_SIZE_LIMIT),
+    ),
+    vol.Optional(CONF_ENABLE_PUSH, default=True): BOOLEAN_SELECTOR,
+}
+
 
 async def validate_input(
     hass: HomeAssistant, user_input: dict[str, Any]
@@ -146,6 +151,8 @@ class IMAPConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle the initial step."""
 
         schema = CONFIG_SCHEMA
+        if self.show_advanced_options:
+            schema = schema.extend(CONFIG_SCHEMA_ADVANCED)
 
         if user_input is None:
             return self.async_show_form(step_id="user", data_schema=schema)
@@ -243,6 +250,8 @@ class ImapOptionsFlow(OptionsFlow):
                     return self.async_create_entry(data={})
 
         schema = OPTIONS_SCHEMA
+        if self.show_advanced_options:
+            schema = schema.extend(OPTIONS_SCHEMA_ADVANCED)
         schema = self.add_suggested_values_to_schema(schema, entry_data)
 
         return self.async_show_form(step_id="init", data_schema=schema, errors=errors)

homeassistant/components/indevolt/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/indevolt",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "quality_scale": "silver",
+  "quality_scale": "bronze",
   "requirements": ["indevolt-api==1.7.1"]
 }

homeassistant/components/infrared/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/infrared",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["infrared-protocols==2.1.0"]
+  "requirements": ["infrared-protocols==2.0.0"]
 }

homeassistant/components/insteon/manifest.json

@@ -2,7 +2,7 @@
   "domain": "insteon",
   "name": "Insteon",
   "after_dependencies": ["panel_custom"],
-  "codeowners": ["@teharris1", "@ssyrell"],
+  "codeowners": ["@teharris1"],
   "config_flow": true,
   "dependencies": ["http", "usb", "websocket_api"],
   "dhcp": [
@@ -19,7 +19,7 @@
   "loggers": ["pyinsteon", "pypubsub"],
   "requirements": [
     "pyinsteon==1.6.4",
-    "insteon-frontend-home-assistant==0.6.2"
+    "insteon-frontend-home-assistant==0.6.1"
   ],
   "single_config_entry": true,
   "usb": [

homeassistant/components/intent_script/__init__.py

@@ -77,9 +77,10 @@ async def async_reload(hass: HomeAssistant, service_call: ServiceCall) -> None:
     existing_intents = hass.data[DOMAIN]
 
     for intent_type, conf in existing_intents.items():
-        intent.async_remove(hass, intent_type)
         if isinstance(conf.get(CONF_ACTION), script.Script):
-            await conf[CONF_ACTION].async_unload()
+            await conf[CONF_ACTION].async_stop()
+            conf[CONF_ACTION].async_unload()
+        intent.async_remove(hass, intent_type)
 
     if not new_config or DOMAIN not in new_config:
         hass.data[DOMAIN] = {}

homeassistant/components/knx/manifest.json

@@ -12,7 +12,7 @@
   "quality_scale": "platinum",
   "requirements": [
     "xknx==3.15.0",
-    "xknxproject==3.9.0",
+    "xknxproject==3.8.2",
     "knx-frontend==2026.4.30.60856"
   ],
   "single_config_entry": true

homeassistant/components/litterrobot/binary_sensor.py

@@ -4,7 +4,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Generic
 
-from pylitterbot import FeederRobot, LitterRobot, LitterRobot3, LitterRobot4, Robot
+from pylitterbot import LitterRobot, LitterRobot4, Robot
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -30,11 +30,8 @@ class RobotBinarySensorEntityDescription(
     is_on_fn: Callable[[_WhiskerEntityT], bool]
 
 
-BINARY_SENSOR_MAP: dict[
-    type[Robot] | tuple[type[Robot], ...],
-    tuple[RobotBinarySensorEntityDescription, ...],
-] = {
-    LitterRobot: (
+BINARY_SENSOR_MAP: dict[type[Robot], tuple[RobotBinarySensorEntityDescription, ...]] = {
+    LitterRobot: (  # type: ignore[type-abstract]  # only used for isinstance check
         RobotBinarySensorEntityDescription[LitterRobot](
             key="sleeping",
             translation_key="sleeping",
@@ -59,14 +56,14 @@ BINARY_SENSOR_MAP: dict[
             is_on_fn=lambda robot: not robot.is_hopper_removed,
         ),
     ),
-    (FeederRobot, LitterRobot3, LitterRobot4): (
-        RobotBinarySensorEntityDescription[FeederRobot | LitterRobot3 | LitterRobot4](
+    Robot: (  # type: ignore[type-abstract]  # only used for isinstance check
+        RobotBinarySensorEntityDescription[Robot](
             key="power_status",
             translation_key="power_status",
             device_class=BinarySensorDeviceClass.PLUG,
             entity_category=EntityCategory.DIAGNOSTIC,
             entity_registry_enabled_default=False,
-            is_on_fn=lambda robot: robot.power_type == "AC",
+            is_on_fn=lambda robot: robot.power_status == "AC",
         ),
     ),
 }

homeassistant/components/litterrobot/manifest.json

@@ -16,5 +16,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylitterbot"],
   "quality_scale": "platinum",
-  "requirements": ["pylitterbot==2025.4.0"]
+  "requirements": ["pylitterbot==2025.3.2"]
 }

homeassistant/components/matter/fan.py

@@ -251,10 +251,8 @@ class MatterFan(MatterEntity, FanEntity):
             return
         self._feature_map = feature_map
         self._attr_supported_features = FanEntityFeature(0)
-        # Reset to default so a featuremap change from MultiSpeed -> non-MultiSpeed
-        # does not leave a stale speed_count / percentage_step.
-        self._attr_speed_count = 100
         if feature_map & FanControlFeature.kMultiSpeed:
+            self._attr_supported_features |= FanEntityFeature.SET_SPEED
             self._attr_speed_count = int(
                 self.get_matter_attribute_value(clusters.FanControl.Attributes.SpeedMax)
             )
@@ -304,12 +302,8 @@ class MatterFan(MatterEntity, FanEntity):
         if feature_map & FanControlFeature.kAirflowDirection:
             self._attr_supported_features |= FanEntityFeature.DIRECTION
 
-        # PercentSetting is always a mandatory attribute of the FanControl cluster,
-        # so percentage-based speed control is always available.
         self._attr_supported_features |= (
-            FanEntityFeature.SET_SPEED
-            | FanEntityFeature.TURN_OFF
-            | FanEntityFeature.TURN_ON
+            FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON
         )
 
 

homeassistant/components/media_player/condition.py

@@ -1,108 +1,11 @@
 """Provides conditions for media players."""
 
-from datetime import datetime
-from typing import Any
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
 
-from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.condition import (
-    Condition,
-    EntityConditionBase,
-    EntityNumericalConditionBase,
-    make_entity_state_condition,
-)
-
-from . import ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED
 from .const import DOMAIN, MediaPlayerState
 
-
-class _MediaPlayerMutedConditionBase(EntityConditionBase):
-    """Base class for media player is_muted/is_unmuted conditions."""
-
-    _domain_specs = {DOMAIN: DomainSpec()}
-    _target_muted: bool
-
-    def _state_valid_since(self, state: State) -> datetime:
-        """Anchor `for:` durations to `last_updated` for the muted attribute.
-
-        Needed because the domain spec does not reflect that the condition
-        reads from the muted and volume attributes.
-        """
-        return state.last_updated
-
-    def _has_volume_attributes(self, state: State) -> bool:
-        """Check if the state has volume muted or volume level attributes."""
-        return (
-            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is not None
-            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
-        )
-
-    def _should_include(self, state: State) -> bool:
-        """Skip entities without volume attributes from the all/count check."""
-        return super()._should_include(state) and self._has_volume_attributes(state)
-
-    def _is_muted(self, state: State) -> bool:
-        """Check if the media player is muted."""
-        return (
-            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is True
-            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0
-        )
-
-    def is_valid_state(self, entity_state: State) -> bool:
-        """Check if the entity state matches the targeted muted state."""
-        if not self._has_volume_attributes(entity_state):
-            return False
-        return self._is_muted(entity_state) is self._target_muted
-
-
-class MediaPlayerIsMutedCondition(_MediaPlayerMutedConditionBase):
-    """Condition that passes when the media player is muted."""
-
-    _target_muted = True
-
-
-class MediaPlayerIsUnmutedCondition(_MediaPlayerMutedConditionBase):
-    """Condition that passes when the media player is not muted."""
-
-    _target_muted = False
-
-
-class MediaPlayerIsVolumeCondition(EntityNumericalConditionBase):
-    """Condition for media player volume level with 0.0-1.0 to percentage conversion."""
-
-    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_MEDIA_VOLUME_LEVEL)}
-    _valid_unit = "%"
-
-    def _get_tracked_value(self, entity_state: State) -> Any:
-        """Get the volume value converted from 0.0-1.0 to percentage (0-100)."""
-        raw = super()._get_tracked_value(entity_state)
-        if raw is None:
-            return None
-        try:
-            return float(raw) * 100.0
-        except TypeError, ValueError:
-            return None
-
-    def _should_include(self, state: State) -> bool:
-        """Skip media players that do not expose a volume_level attribute."""
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
-        )
-
-
 CONDITIONS: dict[str, type[Condition]] = {
-    "is_muted": MediaPlayerIsMutedCondition,
-    "is_not_playing": make_entity_state_condition(
-        DOMAIN,
-        {
-            MediaPlayerState.BUFFERING,
-            MediaPlayerState.IDLE,
-            MediaPlayerState.OFF,
-            MediaPlayerState.ON,
-            MediaPlayerState.PAUSED,
-        },
-    ),
     "is_off": make_entity_state_condition(DOMAIN, MediaPlayerState.OFF),
     "is_on": make_entity_state_condition(
         DOMAIN,
@@ -114,10 +17,18 @@ CONDITIONS: dict[str, type[Condition]] = {
             MediaPlayerState.PLAYING,
         },
     ),
+    "is_not_playing": make_entity_state_condition(
+        DOMAIN,
+        {
+            MediaPlayerState.BUFFERING,
+            MediaPlayerState.IDLE,
+            MediaPlayerState.OFF,
+            MediaPlayerState.ON,
+            MediaPlayerState.PAUSED,
+        },
+    ),
     "is_paused": make_entity_state_condition(DOMAIN, MediaPlayerState.PAUSED),
     "is_playing": make_entity_state_condition(DOMAIN, MediaPlayerState.PLAYING),
-    "is_unmuted": MediaPlayerIsUnmutedCondition,
-    "is_volume": MediaPlayerIsVolumeCondition,
 }
 
 

homeassistant/components/media_player/conditions.yaml

@@ -1,51 +1,22 @@
 .condition_common: &condition_common
-  target: &condition_media_player_target
+  target:
     entity:
       domain: media_player
   fields:
-    behavior: &condition_behavior
+    behavior:
       required: true
       default: any
       selector:
         automation_behavior:
           mode: condition
-    for: &condition_for
+    for:
       required: true
       default: 00:00:00
       selector:
         duration:
 
-.volume_threshold_entity: &volume_threshold_entity
-  - domain: input_number
-    unit_of_measurement: "%"
-  - domain: number
-    unit_of_measurement: "%"
-  - domain: sensor
-    unit_of_measurement: "%"
-
-.volume_threshold_number: &volume_threshold_number
-  min: 0
-  max: 100
-  mode: box
-  unit_of_measurement: "%"
-
-is_muted: *condition_common
 is_off: *condition_common
 is_on: *condition_common
 is_not_playing: *condition_common
 is_paused: *condition_common
 is_playing: *condition_common
-is_unmuted: *condition_common
-
-is_volume:
-  target: *condition_media_player_target
-  fields:
-    behavior: *condition_behavior
-    for: *condition_for
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *volume_threshold_entity
-          mode: is
-          number: *volume_threshold_number

homeassistant/components/media_player/icons.json

@@ -1,8 +1,5 @@
 {
   "conditions": {
-    "is_muted": {
-      "condition": "mdi:volume-mute"
-    },
     "is_not_playing": {
       "condition": "mdi:stop"
     },
@@ -17,12 +14,6 @@
     },
     "is_playing": {
       "condition": "mdi:play"
-    },
-    "is_unmuted": {
-      "condition": "mdi:volume-high"
-    },
-    "is_volume": {
-      "condition": "mdi:volume-medium"
     }
   },
   "entity_component": {
@@ -132,9 +123,6 @@
     }
   },
   "triggers": {
-    "muted": {
-      "trigger": "mdi:volume-mute"
-    },
     "paused_playing": {
       "trigger": "mdi:pause"
     },
@@ -149,15 +137,6 @@
     },
     "turned_on": {
       "trigger": "mdi:power"
-    },
-    "unmuted": {
-      "trigger": "mdi:volume-high"
-    },
-    "volume_changed": {
-      "trigger": "mdi:volume-medium"
-    },
-    "volume_crossed_threshold": {
-      "trigger": "mdi:volume-medium"
     }
   }
 }

homeassistant/components/media_player/strings.json

@@ -2,24 +2,10 @@
   "common": {
     "condition_behavior_name": "Condition passes if",
     "condition_for_name": "For at least",
-    "condition_threshold_name": "Threshold",
     "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least",
-    "trigger_threshold_name": "Threshold"
+    "trigger_for_name": "For at least"
   },
   "conditions": {
-    "is_muted": {
-      "description": "Tests if one or more media players are muted.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::condition_for_name%]"
-        }
-      },
-      "name": "Media player is muted"
-    },
     "is_not_playing": {
       "description": "Tests if one or more media players are not playing.",
       "fields": {
@@ -79,33 +65,6 @@
         }
       },
       "name": "Media player is playing"
-    },
-    "is_unmuted": {
-      "description": "Tests if one or more media players are not muted.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::condition_for_name%]"
-        }
-      },
-      "name": "Media player is not muted"
-    },
-    "is_volume": {
-      "description": "Tests the volume of one or more media players.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::condition_for_name%]"
-        },
-        "threshold": {
-          "name": "[%key:component::media_player::common::condition_threshold_name%]"
-        }
-      },
-      "name": "Volume"
     }
   },
   "device_automation": {
@@ -478,18 +437,6 @@
   },
   "title": "Media player",
   "triggers": {
-    "muted": {
-      "description": "Triggers after one or more media players are muted.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::trigger_for_name%]"
-        }
-      },
-      "name": "Media player muted"
-    },
     "paused_playing": {
       "description": "Triggers after one or more media players pause playing.",
       "fields": {
@@ -549,42 +496,6 @@
         }
       },
       "name": "Media player turned on"
-    },
-    "unmuted": {
-      "description": "Triggers after one or more media players are unmuted.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::trigger_for_name%]"
-        }
-      },
-      "name": "Media player unmuted"
-    },
-    "volume_changed": {
-      "description": "Triggers after the volume of one or more media players changes.",
-      "fields": {
-        "threshold": {
-          "name": "[%key:component::media_player::common::trigger_threshold_name%]"
-        }
-      },
-      "name": "Media player volume changed"
-    },
-    "volume_crossed_threshold": {
-      "description": "Triggers after the volume of one or more media players crosses a threshold.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::media_player::common::trigger_for_name%]"
-        },
-        "threshold": {
-          "name": "[%key:component::media_player::common::trigger_threshold_name%]"
-        }
-      },
-      "name": "Media player volume crossed threshold"
     }
   }
 }

homeassistant/components/media_player/trigger.py

@@ -1,125 +1,12 @@
 """Provides triggers for media players."""
 
-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import (
-    EntityNumericalStateChangedTriggerBase,
-    EntityNumericalStateCrossedThresholdTriggerBase,
-    EntityNumericalStateTriggerBase,
-    EntityTriggerBase,
-    Trigger,
-    make_entity_transition_trigger,
-)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_transition_trigger
 
-from . import ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED, MediaPlayerState
+from . import MediaPlayerState
 from .const import DOMAIN
 
-VOLUME_DOMAIN_SPECS = {
-    DOMAIN: DomainSpec(value_source=ATTR_MEDIA_VOLUME_LEVEL),
-}
-
-
-class _MediaPlayerMutedStateTriggerBase(EntityTriggerBase):
-    """Base class for media player muted/unmuted triggers."""
-
-    _domain_specs = {DOMAIN: DomainSpec()}
-    _target_muted: bool
-
-    def _has_volume_attributes(self, state: State) -> bool:
-        """Check if the state has volume muted or volume level attributes."""
-        return (
-            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is not None
-            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
-        )
-
-    def _should_include(self, state: State) -> bool:
-        """Check if an entity should participate in all/count checks.
-
-        Entities without volume attributes cannot be muted, so they are
-        excluded from the check - otherwise an "all" check would never
-        pass when there are media players without volume support.
-        """
-        return super()._should_include(state) and self._has_volume_attributes(state)
-
-    def is_muted(self, state: State) -> bool:
-        """Check if the media player is muted."""
-        return (
-            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is True
-            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0
-        )
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the origin state is valid and the state has changed."""
-        if from_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
-            return False
-
-        if not self._has_volume_attributes(to_state):
-            return False
-
-        return self.is_muted(from_state) != self.is_muted(to_state)
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check if the new state matches the expected state."""
-        if not self._has_volume_attributes(state):
-            return False
-        return self.is_muted(state) is self._target_muted
-
-
-class MediaPlayerMutedTrigger(_MediaPlayerMutedStateTriggerBase):
-    """Class for media player muted triggers."""
-
-    _target_muted = True
-
-
-class MediaPlayerUnmutedTrigger(_MediaPlayerMutedStateTriggerBase):
-    """Class for media player unmuted triggers."""
-
-    _target_muted = False
-
-
-class VolumeTriggerMixin(EntityNumericalStateTriggerBase):
-    """Mixin for volume triggers."""
-
-    _domain_specs = VOLUME_DOMAIN_SPECS
-    _valid_unit = "%"
-
-    def _get_tracked_value(self, state: State) -> float | None:
-        """Get tracked volume as a percentage."""
-        value = super()._get_tracked_value(state)
-        if value is None:
-            return None
-        # Convert 0.0-1.0 range to percentage (0-100)
-        return value * 100.0
-
-    def _should_include(self, state: State) -> bool:
-        """Check if an entity should participate in all/count checks.
-
-        Entities without a volume level cannot have their volume tracked,
-        so they are excluded - otherwise an "all" check would never pass
-        when there are media players without volume support.
-        """
-        return (
-            super()._should_include(state)
-            and state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
-        )
-
-
-class VolumeChangedTrigger(EntityNumericalStateChangedTriggerBase, VolumeTriggerMixin):
-    """Trigger for media player volume changes."""
-
-
-class VolumeCrossedThresholdTrigger(
-    EntityNumericalStateCrossedThresholdTriggerBase, VolumeTriggerMixin
-):
-    """Trigger for media player volume crossing a threshold."""
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "muted": MediaPlayerMutedTrigger,
-    "unmuted": MediaPlayerUnmutedTrigger,
-    "volume_changed": VolumeChangedTrigger,
-    "volume_crossed_threshold": VolumeCrossedThresholdTrigger,
     "paused_playing": make_entity_transition_trigger(
         DOMAIN,
         from_states={

homeassistant/components/media_player/triggers.yaml

@@ -1,62 +1,22 @@
 .trigger_common: &trigger_common
-  target: &trigger_media_player_target
+  target:
     entity:
       domain: media_player
   fields:
-    behavior: &trigger_behavior
+    behavior:
       required: true
       default: any
       selector:
         automation_behavior:
           mode: trigger
-    for: &trigger_for
+    for:
       required: true
       default: 00:00:00
       selector:
         duration:
 
-.volume_threshold_entity: &volume_threshold_entity
-  - domain: input_number
-    unit_of_measurement: "%"
-  - domain: number
-    unit_of_measurement: "%"
-  - domain: sensor
-    unit_of_measurement: "%"
-
-.volume_threshold_number: &volume_threshold_number
-  min: 0
-  max: 100
-  mode: box
-  unit_of_measurement: "%"
-
-muted: *trigger_common
-unmuted: *trigger_common
 paused_playing: *trigger_common
 started_playing: *trigger_common
 stopped_playing: *trigger_common
 turned_off: *trigger_common
 turned_on: *trigger_common
-
-volume_changed:
-  target: *trigger_media_player_target
-  fields:
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *volume_threshold_entity
-          mode: changed
-          number: *volume_threshold_number
-
-volume_crossed_threshold:
-  target: *trigger_media_player_target
-  fields:
-    behavior: *trigger_behavior
-    for: *trigger_for
-    threshold:
-      required: true
-      selector:
-        numeric_threshold:
-          entity: *volume_threshold_entity
-          mode: crossed
-          number: *volume_threshold_number

homeassistant/components/miele/const.py

@@ -479,7 +479,6 @@ class WashingMachineProgramId(MieleEnum, missing_to_none=True):
     down_filled_items = 129
     cottons_eco = 133
     quick_power_wash = 146, 10031
-    quick_intense = 177
     eco_40_60 = 190, 10007
     bed_linen = 10047
     easy_care = 10016

homeassistant/components/mill/__init__.py

@@ -5,31 +5,30 @@ from datetime import timedelta
 from mill import Mill
 from mill_local import Mill as MillLocal
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import CLOUD, CONNECTION_TYPE, DOMAIN, LOCAL
-from .coordinator import (
-    MillConfigEntry,
-    MillDataUpdateCoordinator,
-    MillHistoricDataUpdateCoordinator,
-)
+from .coordinator import MillDataUpdateCoordinator, MillHistoricDataUpdateCoordinator
 
 PLATFORMS = [Platform.CLIMATE, Platform.NUMBER, Platform.SENSOR]
 
-__all__ = ["CLOUD", "CONNECTION_TYPE", "DOMAIN", "LOCAL"]
 
-
-async def async_setup_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up the Mill heater."""
+    hass.data.setdefault(DOMAIN, {LOCAL: {}, CLOUD: {}})
+
     if entry.data.get(CONNECTION_TYPE) == LOCAL:
         mill_data_connection = MillLocal(
             entry.data[CONF_IP_ADDRESS],
             websession=async_get_clientsession(hass),
         )
         update_interval = timedelta(seconds=15)
+        key = entry.data[CONF_IP_ADDRESS]
+        conn_type = LOCAL
     else:
         mill_data_connection = Mill(
             entry.data[CONF_USERNAME],
@@ -37,6 +36,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool
             websession=async_get_clientsession(hass),
         )
         update_interval = timedelta(seconds=30)
+        key = entry.data[CONF_USERNAME]
+        conn_type = CLOUD
 
         historic_data_coordinator = MillHistoricDataUpdateCoordinator(
             hass,
@@ -55,12 +56,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool
     )
 
     await data_coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = data_coordinator
+    # Uses legacy hass.data[DOMAIN] pattern
+    # pylint: disable-next=hass-use-runtime-data
+    hass.data[DOMAIN][conn_type][key] = data_coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/mill/climate.py

@@ -1,4 +1,5 @@
 """Support for mill wifi-enabled home heaters."""
+# pylint: disable=hass-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
 
 from typing import Any
 
@@ -13,7 +14,14 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
-from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, UnitOfTemperature
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    ATTR_TEMPERATURE,
+    CONF_IP_ADDRESS,
+    CONF_USERNAME,
+    PRECISION_TENTHS,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
@@ -25,6 +33,7 @@ from .const import (
     ATTR_COMFORT_TEMP,
     ATTR_ROOM_NAME,
     ATTR_SLEEP_TEMP,
+    CLOUD,
     CONNECTION_TYPE,
     DOMAIN,
     LOCAL,
@@ -33,7 +42,7 @@ from .const import (
     MIN_TEMP,
     SERVICE_SET_ROOM_TEMP,
 )
-from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
+from .coordinator import MillDataUpdateCoordinator
 from .entity import MillBaseEntity
 
 SET_ROOM_TEMP_SCHEMA = vol.Schema(
@@ -48,16 +57,17 @@ SET_ROOM_TEMP_SCHEMA = vol.Schema(
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: MillConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Mill climate."""
-    mill_data_coordinator = entry.runtime_data
-
     if entry.data.get(CONNECTION_TYPE) == LOCAL:
+        mill_data_coordinator = hass.data[DOMAIN][LOCAL][entry.data[CONF_IP_ADDRESS]]
         async_add_entities([LocalMillHeater(mill_data_coordinator)])
         return
 
+    mill_data_coordinator = hass.data[DOMAIN][CLOUD][entry.data[CONF_USERNAME]]
+
     entities = [
         MillHeater(mill_data_coordinator, mill_device)
         for mill_device in mill_data_coordinator.data.values()

homeassistant/components/mill/coordinator.py

@@ -57,9 +57,6 @@ class MillDataUpdateCoordinator(DataUpdateCoordinator):
         )
 
 
-type MillConfigEntry = ConfigEntry[MillDataUpdateCoordinator]
-
-
 class MillHistoricDataUpdateCoordinator(DataUpdateCoordinator):
     """Class to manage fetching Mill historic data."""
 

homeassistant/components/mill/number.py

@@ -3,23 +3,28 @@
 from mill import Heater, MillDevice
 
 from homeassistant.components.number import NumberDeviceClass, NumberEntity
-from homeassistant.const import UnitOfPower
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_USERNAME, UnitOfPower
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CLOUD, CONNECTION_TYPE
-from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
+from .const import CLOUD, CONNECTION_TYPE, DOMAIN
+from .coordinator import MillDataUpdateCoordinator
 from .entity import MillBaseEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: MillConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Mill Number."""
     if entry.data.get(CONNECTION_TYPE) == CLOUD:
-        mill_data_coordinator = entry.runtime_data
+        # Uses legacy hass.data[DOMAIN] pattern
+        # pylint: disable-next=hass-use-runtime-data
+        mill_data_coordinator: MillDataUpdateCoordinator = hass.data[DOMAIN][CLOUD][
+            entry.data[CONF_USERNAME]
+        ]
 
         async_add_entities(
             MillNumber(mill_data_coordinator, mill_device)

homeassistant/components/mill/sensor.py

@@ -1,4 +1,5 @@
 """Support for mill wifi-enabled home heaters."""
+# pylint: disable=hass-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
 
 import mill
 
@@ -8,9 +9,12 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_BILLION,
     CONCENTRATION_PARTS_PER_MILLION,
+    CONF_IP_ADDRESS,
+    CONF_USERNAME,
     PERCENTAGE,
     EntityCategory,
     UnitOfEnergy,
@@ -25,9 +29,11 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
     BATTERY,
+    CLOUD,
     CONNECTION_TYPE,
     CONSUMPTION_TODAY,
     CONSUMPTION_YEAR,
+    DOMAIN,
     ECO2,
     HUMIDITY,
     LOCAL,
@@ -35,7 +41,7 @@ from .const import (
     TEMPERATURE,
     TVOC,
 )
-from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
+from .coordinator import MillDataUpdateCoordinator
 from .entity import MillBaseEntity
 
 HEATER_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
@@ -140,13 +146,13 @@ SOCKET_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: MillConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Mill sensor."""
-    mill_data_coordinator = entry.runtime_data
-
     if entry.data.get(CONNECTION_TYPE) == LOCAL:
+        mill_data_coordinator = hass.data[DOMAIN][LOCAL][entry.data[CONF_IP_ADDRESS]]
+
         async_add_entities(
             LocalMillSensor(
                 mill_data_coordinator,
@@ -156,6 +162,8 @@ async def async_setup_entry(
         )
         return
 
+    mill_data_coordinator = hass.data[DOMAIN][CLOUD][entry.data[CONF_USERNAME]]
+
     entities = [
         MillSensor(
             mill_data_coordinator,

homeassistant/components/mitsubishi_comfort/__init__.py

@@ -1,95 +0,0 @@
-"""Mitsubishi Comfort integration for Home Assistant."""
-
-import asyncio
-import logging
-
-from mitsubishi_comfort import (
-    DeviceInfo,
-    IndoorUnit,
-    KumoStation,
-    MitsubishiCloudAccount,
-)
-from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionError
-
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DEFAULT_CONNECT_TIMEOUT, DEFAULT_RESPONSE_TIMEOUT, DOMAIN, PLATFORMS
-from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _make_device(
-    info: DeviceInfo,
-    serial: str,
-    session,
-) -> IndoorUnit | KumoStation:
-    """Create the appropriate device instance from DeviceInfo."""
-    cls = IndoorUnit if info.is_indoor_unit else KumoStation
-    return cls(
-        name=info.label,
-        address=info.address,
-        password_b64=info.password,
-        crypto_serial_hex=info.crypto_serial,
-        serial=serial,
-        connect_timeout=DEFAULT_CONNECT_TIMEOUT,
-        response_timeout=DEFAULT_RESPONSE_TIMEOUT,
-        session=session,
-    )
-
-
-async def async_setup_entry(
-    hass: HomeAssistant, entry: MitsubishiComfortConfigEntry
-) -> bool:
-    """Set up Mitsubishi Comfort from a config entry."""
-    session = async_get_clientsession(hass)
-    account = MitsubishiCloudAccount(
-        entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD], session=session
-    )
-
-    try:
-        await account.login()
-        devices = await account.discover_devices()
-    except AuthenticationError as err:
-        raise ConfigEntryError("Mitsubishi cloud authentication failed") from err
-    except DeviceConnectionError as err:
-        raise ConfigEntryNotReady("Cannot reach Mitsubishi cloud") from err
-
-    if not devices:
-        raise ConfigEntryError(
-            translation_domain=DOMAIN,
-            translation_key="no_devices",
-        )
-
-    coordinators: dict[str, MitsubishiComfortCoordinator] = {}
-    for serial, info in devices.items():
-        if not info.address or not info.password or not info.crypto_serial:
-            _LOGGER.warning("Device %s missing credentials, skipping", info.label)
-            continue
-        device = _make_device(info, serial, session)
-        coordinators[serial] = MitsubishiComfortCoordinator(
-            hass, entry, device, info.mac
-        )
-
-    await asyncio.gather(
-        *(c.async_config_entry_first_refresh() for c in coordinators.values())
-    )
-
-    entry.runtime_data = coordinators
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    return True
-
-
-async def async_unload_entry(
-    hass: HomeAssistant, entry: MitsubishiComfortConfigEntry
-) -> bool:
-    """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        await asyncio.gather(
-            *(c.device.close() for c in entry.runtime_data.values()),
-            return_exceptions=True,
-        )
-    return unload_ok

homeassistant/components/mitsubishi_comfort/climate.py

@@ -1,287 +0,0 @@
-"""Climate entity for Mitsubishi Comfort integration."""
-
-from typing import Any
-
-from mitsubishi_comfort import FanSpeed, IndoorUnit, Mode, VaneDirection
-
-from homeassistant.components.climate import (
-    ATTR_TARGET_TEMP_HIGH,
-    ATTR_TARGET_TEMP_LOW,
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACAction,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
-from .entity import MitsubishiComfortEntity
-
-_MODE_TO_HVAC: dict[str, HVACMode] = {
-    "off": HVACMode.OFF,
-    "cool": HVACMode.COOL,
-    "heat": HVACMode.HEAT,
-    "dry": HVACMode.DRY,
-    "vent": HVACMode.FAN_ONLY,
-    "auto": HVACMode.HEAT_COOL,
-    "autoCool": HVACMode.HEAT_COOL,
-    "autoHeat": HVACMode.HEAT_COOL,
-}
-
-_HVAC_TO_MODE: dict[HVACMode, Mode] = {
-    HVACMode.OFF: Mode.OFF,
-    HVACMode.COOL: Mode.COOL,
-    HVACMode.HEAT: Mode.HEAT,
-    HVACMode.DRY: Mode.DRY,
-    HVACMode.FAN_ONLY: Mode.FAN,
-    HVACMode.HEAT_COOL: Mode.AUTO,
-}
-
-_LIB_MODE_TO_HVAC: dict[Mode, HVACMode] = {v: k for k, v in _HVAC_TO_MODE.items()}
-
-_MODE_TO_ACTION: dict[str, HVACAction] = {
-    "off": HVACAction.OFF,
-    "cool": HVACAction.COOLING,
-    "heat": HVACAction.HEATING,
-    "dry": HVACAction.DRYING,
-    "vent": HVACAction.FAN,
-    "auto": HVACAction.IDLE,
-    "autoCool": HVACAction.COOLING,
-    "autoHeat": HVACAction.HEATING,
-}
-
-_FAN_SPEED_MAP: dict[str, FanSpeed] = {s.value: s for s in FanSpeed}
-_VANE_DIR_MAP: dict[str, VaneDirection] = {d.value: d for d in VaneDirection}
-
-_OPT_MODE = "mode"
-_OPT_COOL_SETPOINT = "cool_setpoint"
-_OPT_HEAT_SETPOINT = "heat_setpoint"
-_OPT_FAN_SPEED = "fan_speed"
-_OPT_VANE_DIRECTION = "vane_direction"
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MitsubishiComfortConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Mitsubishi Comfort climate entities."""
-    coordinators = entry.runtime_data
-    async_add_entities(
-        MitsubishiComfortClimate(coordinator)
-        for coordinator in coordinators.values()
-        if isinstance(coordinator.device, IndoorUnit)
-    )
-
-
-class MitsubishiComfortClimate(MitsubishiComfortEntity, ClimateEntity):
-    """Climate entity for a Mitsubishi indoor unit."""
-
-    _attr_name = None
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _enable_turn_on_off_backwards_compatibility = False
-
-    def __init__(self, coordinator: MitsubishiComfortCoordinator) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_unique_id = self._device.serial
-        self._optimistic: dict[str, Any] = {}
-
-    def _handle_coordinator_update(self) -> None:
-        """Clear optimistic state when real data arrives from device."""
-        self._optimistic.clear()
-        super()._handle_coordinator_update()
-
-    @property
-    def _effective_mode(self) -> str | None:
-        return self._optimistic.get(_OPT_MODE, self._device.status.mode)
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        mode = self._effective_mode
-        return _MODE_TO_HVAC.get(mode) if mode else None
-
-    @property
-    def hvac_action(self) -> HVACAction | None:
-        """Return the current HVAC action."""
-        mode = self._effective_mode
-        if mode and self._device.status.standby:
-            return HVACAction.IDLE
-        return _MODE_TO_ACTION.get(mode) if mode else None
-
-    @property
-    def hvac_modes(self) -> list[HVACMode]:
-        """Return the list of available HVAC modes."""
-        return [
-            _LIB_MODE_TO_HVAC[m]
-            for m in self._device.supported_modes
-            if m in _LIB_MODE_TO_HVAC
-        ]
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._device.status.room_temperature
-
-    @property
-    def current_humidity(self) -> float | None:
-        """Return the current humidity."""
-        return self._device.status.current_humidity
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the target temperature."""
-        mode = self._effective_mode
-        if mode in ("cool", "autoCool"):
-            return self._optimistic.get(
-                _OPT_COOL_SETPOINT, self._device.status.cool_setpoint
-            )
-        if mode in ("heat", "autoHeat"):
-            return self._optimistic.get(
-                _OPT_HEAT_SETPOINT, self._device.status.heat_setpoint
-            )
-        return None
-
-    @property
-    def target_temperature_high(self) -> float | None:
-        """Return the upper bound target temperature."""
-        if self._effective_mode in ("auto", "autoCool", "autoHeat"):
-            return self._optimistic.get(
-                _OPT_COOL_SETPOINT, self._device.status.cool_setpoint
-            )
-        return None
-
-    @property
-    def target_temperature_low(self) -> float | None:
-        """Return the lower bound target temperature."""
-        if self._effective_mode in ("auto", "autoCool", "autoHeat"):
-            return self._optimistic.get(
-                _OPT_HEAT_SETPOINT, self._device.status.heat_setpoint
-            )
-        return None
-
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the current fan mode."""
-        return self._optimistic.get(_OPT_FAN_SPEED, self._device.status.fan_speed)
-
-    @property
-    def fan_modes(self) -> list[str]:
-        """Return the list of available fan modes."""
-        return [s.value for s in self._device.supported_fan_speeds]
-
-    @property
-    def swing_mode(self) -> str | None:
-        """Return the current swing mode."""
-        return self._optimistic.get(
-            _OPT_VANE_DIRECTION, self._device.status.vane_direction
-        )
-
-    @property
-    def swing_modes(self) -> list[str]:
-        """Return the list of available swing modes."""
-        return [d.value for d in self._device.supported_vane_directions]
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature."""
-        if self._effective_mode in ("heat", "autoHeat"):
-            if self._device.status.min_heat_setpoint is not None:
-                return self._device.status.min_heat_setpoint
-        if self._device.status.min_cool_setpoint is not None:
-            return self._device.status.min_cool_setpoint
-        return super().min_temp
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature."""
-        if self._effective_mode in ("heat", "autoHeat"):
-            if self._device.status.max_heat_setpoint is not None:
-                return self._device.status.max_heat_setpoint
-        if self._device.status.max_cool_setpoint is not None:
-            return self._device.status.max_cool_setpoint
-        return super().max_temp
-
-    @property
-    def supported_features(self) -> ClimateEntityFeature:
-        """Return the list of supported features."""
-        features = (
-            ClimateEntityFeature.TARGET_TEMPERATURE
-            | ClimateEntityFeature.FAN_MODE
-            | ClimateEntityFeature.TURN_OFF
-        )
-        if Mode.AUTO in self._device.supported_modes:
-            features |= ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
-        if self._device.supported_vane_directions:
-            features |= ClimateEntityFeature.SWING_MODE
-        return features
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode."""
-        lib_mode = _HVAC_TO_MODE.get(hvac_mode)
-        if lib_mode is None:
-            return
-        result = await self._device.set_mode(lib_mode)
-        if result.success:
-            self._optimistic[_OPT_MODE] = result.value
-            self.async_write_ha_state()
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set the target temperature."""
-        mode = self._effective_mode
-        wrote = False
-
-        if ATTR_TARGET_TEMP_HIGH in kwargs:
-            result = await self._device.set_cool_setpoint(kwargs[ATTR_TARGET_TEMP_HIGH])
-            if result.success:
-                self._optimistic[_OPT_COOL_SETPOINT] = result.value
-                wrote = True
-
-        if ATTR_TARGET_TEMP_LOW in kwargs:
-            result = await self._device.set_heat_setpoint(kwargs[ATTR_TARGET_TEMP_LOW])
-            if result.success:
-                self._optimistic[_OPT_HEAT_SETPOINT] = result.value
-                wrote = True
-
-        temp = kwargs.get(ATTR_TEMPERATURE)
-        if temp is not None:
-            if mode in ("cool", "autoCool"):
-                result = await self._device.set_cool_setpoint(temp)
-                if result.success:
-                    self._optimistic[_OPT_COOL_SETPOINT] = result.value
-                    wrote = True
-            elif mode in ("heat", "autoHeat"):
-                result = await self._device.set_heat_setpoint(temp)
-                if result.success:
-                    self._optimistic[_OPT_HEAT_SETPOINT] = result.value
-                    wrote = True
-
-        if wrote:
-            self.async_write_ha_state()
-
-    async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set the fan mode."""
-        speed = _FAN_SPEED_MAP.get(fan_mode)
-        if speed is None:
-            return
-        result = await self._device.set_fan_speed(speed)
-        if result.success:
-            self._optimistic[_OPT_FAN_SPEED] = result.value
-            self.async_write_ha_state()
-
-    async def async_set_swing_mode(self, swing_mode: str) -> None:
-        """Set the swing mode."""
-        direction = _VANE_DIR_MAP.get(swing_mode)
-        if direction is None:
-            return
-        result = await self._device.set_vane_direction(direction)
-        if result.success:
-            self._optimistic[_OPT_VANE_DIRECTION] = result.value
-            self.async_write_ha_state()
-
-    async def async_turn_off(self) -> None:
-        """Turn the entity off."""
-        await self.async_set_hvac_mode(HVACMode.OFF)

homeassistant/components/mitsubishi_comfort/config_flow.py

@@ -1,73 +0,0 @@
-"""Config flow for Mitsubishi Comfort integration."""
-
-import logging
-from typing import Any
-
-from mitsubishi_comfort import MitsubishiCloudAccount
-from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-USER_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_USERNAME): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-
-class MitsubishiComfortConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle config flow for Mitsubishi Comfort."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the user setup step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            account = MitsubishiCloudAccount(
-                user_input[CONF_USERNAME],
-                user_input[CONF_PASSWORD],
-                session=async_get_clientsession(self.hass),
-            )
-
-            devices: dict = {}
-            try:
-                await account.login()
-                devices = await account.discover_devices()
-            except AuthenticationError:
-                errors["base"] = "invalid_auth"
-            except DeviceConnectionError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected error during setup")
-                errors["base"] = "unknown"
-
-            if not errors:
-                await self.async_set_unique_id(account.user_id)
-                self._abort_if_unique_id_configured()
-
-                if not devices:
-                    errors["base"] = "no_devices"
-                else:
-                    return self.async_create_entry(
-                        title=f"Mitsubishi Comfort ({user_input[CONF_USERNAME]})",
-                        data={
-                            CONF_USERNAME: user_input[CONF_USERNAME],
-                            CONF_PASSWORD: user_input[CONF_PASSWORD],
-                        },
-                    )
-
-        return self.async_show_form(
-            step_id="user", data_schema=USER_SCHEMA, errors=errors
-        )

homeassistant/components/mitsubishi_comfort/const.py

@@ -1,12 +0,0 @@
-"""Constants for the Mitsubishi Comfort integration."""
-
-from datetime import timedelta
-from typing import Final
-
-from homeassistant.const import Platform
-
-DOMAIN: Final = "mitsubishi_comfort"
-PLATFORMS: Final = [Platform.CLIMATE]
-DEFAULT_SCAN_INTERVAL = timedelta(seconds=60)
-DEFAULT_CONNECT_TIMEOUT: Final = 1.2
-DEFAULT_RESPONSE_TIMEOUT: Final = 8.0

homeassistant/components/mitsubishi_comfort/coordinator.py

@@ -1,56 +0,0 @@
-"""DataUpdateCoordinator for Mitsubishi Comfort devices."""
-
-import logging
-
-from mitsubishi_comfort import IndoorUnit, KumoStation
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-type MitsubishiComfortConfigEntry = ConfigEntry[dict[str, MitsubishiComfortCoordinator]]
-
-
-class MitsubishiComfortCoordinator(DataUpdateCoordinator[IndoorUnit | KumoStation]):
-    """Coordinator to poll a single Mitsubishi device."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: MitsubishiComfortConfigEntry,
-        device: IndoorUnit | KumoStation,
-        mac: str,
-    ) -> None:
-        """Initialize."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=entry,
-            name=f"mitsubishi_comfort_{device.serial}",
-            update_interval=DEFAULT_SCAN_INTERVAL,
-        )
-        self.device = device
-        self.mac = mac
-        self.data = device
-
-    async def _async_update_data(self) -> IndoorUnit | KumoStation:
-        """Poll the device and return it."""
-        try:
-            success = await self.device.update_status()
-        except Exception as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="communication_error",
-                translation_placeholders={"device_name": self.device.name},
-            ) from err
-        if not success:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_failed",
-                translation_placeholders={"device_name": self.device.name},
-            )
-        return self.device

homeassistant/components/mitsubishi_comfort/entity.py

@@ -1,34 +0,0 @@
-"""Base entity for Mitsubishi Comfort integration."""
-
-from mitsubishi_comfort import IndoorUnit, KumoStation
-
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import MitsubishiComfortCoordinator
-
-
-class MitsubishiComfortEntity(CoordinatorEntity[MitsubishiComfortCoordinator]):
-    """Base class for all Mitsubishi Comfort entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: MitsubishiComfortCoordinator) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        device = coordinator.device
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.serial)},
-            connections={(CONNECTION_NETWORK_MAC, coordinator.mac)},
-            name=device.name,
-            manufacturer="Mitsubishi",
-            serial_number=device.serial,
-            sw_version=device.status.firmware_version,
-            hw_version=device.status.hardware_version,
-        )
-
-    @property
-    def _device(self) -> IndoorUnit | KumoStation:
-        """Return the underlying device from coordinator data."""
-        return self.coordinator.data

homeassistant/components/mitsubishi_comfort/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "mitsubishi_comfort",
-  "name": "Mitsubishi Comfort",
-  "codeowners": ["@nikolairahimi"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/mitsubishi_comfort",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["mitsubishi-comfort==0.3.0"]
-}

homeassistant/components/mitsubishi_comfort/quality_scale.yaml

@@ -1,72 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: No service actions registered.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow: done
-  config-flow-test-coverage: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: No service actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  config-entry-unloading: done
-  log-when-unavailable: done
-  entity-unavailable: done
-  action-exceptions:
-    status: exempt
-    comment: No service actions registered.
-  reauthentication-flow: todo
-  parallel-updates: todo
-  test-coverage: todo
-  integration-owner: done
-  docs-installation-parameters: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: No options flow.
-
-  # Gold
-  entity-translations: todo
-  entity-device-class: todo
-  devices: done
-  entity-category:
-    status: exempt
-    comment: Single climate entity per device, no diagnostic entities yet.
-  entity-disabled-by-default:
-    status: exempt
-    comment: Single climate entity per device, enabled by default.
-  discovery: todo
-  stale-devices: todo
-  diagnostics: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  dynamic-devices: todo
-  discovery-update-info: todo
-  repair-issues: todo
-  docs-use-cases: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-data-update: done
-  docs-known-limitations: done
-  docs-examples: done
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/mitsubishi_comfort/strings.json

@@ -1,36 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "no_devices": "No devices were found on this account",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "password": "The password for your Kumo Cloud account.",
-          "username": "The email address for your Kumo Cloud account."
-        }
-      }
-    }
-  },
-  "exceptions": {
-    "communication_error": {
-      "message": "Error communicating with {device_name}"
-    },
-    "no_devices": {
-      "message": "No devices were found in your Mitsubishi Comfort account"
-    },
-    "update_failed": {
-      "message": "{device_name} returned no data"
-    }
-  }
-}

homeassistant/components/mobile_app/const.py

@@ -82,7 +82,6 @@ ATTR_SENSOR_UOM = "unit_of_measurement"
 
 SIGNAL_SENSOR_UPDATE = f"{DOMAIN}_sensor_update"
 SIGNAL_LOCATION_UPDATE = DOMAIN + "_location_update_{}"
-SIGNAL_RECORD_NOTIFICATION = f"{DOMAIN}_record_notification"
 
 ATTR_CAMERA_ENTITY_ID = "camera_entity_id"
 

homeassistant/components/mobile_app/device_tracker.py

@@ -13,10 +13,7 @@ from homeassistant.components.device_tracker import (
     ATTR_LOCATION_NAME,
     TrackerEntity,
 )
-from homeassistant.components.zone import (
-    ENTITY_ID_FORMAT as ZONE_ENTITY_ID_FORMAT,
-    HOME_ZONE,
-)
+from homeassistant.components.zone import ENTITY_ID_FORMAT as ZONE_ENTITY_ID_FORMAT
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_BATTERY_LEVEL,
@@ -24,9 +21,8 @@ from homeassistant.const import (
     ATTR_GPS_ACCURACY,
     ATTR_LATITUDE,
     ATTR_LONGITUDE,
-    STATE_HOME,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -97,6 +93,15 @@ async def async_setup_entry(
     async_add_entities([entity])
 
 
+def _zone_state(hass: HomeAssistant, data: dict[str, Any]) -> State | None:
+    """Return the state of the zone matching the location name in data, if any."""
+    if not (location_name := data.get(ATTR_LOCATION_NAME)):
+        return None
+    # If a location name is set, set the location to the center of the zone
+    # to allow the `in_zones` attribute to be populated by the base class.
+    return hass.states.get(ZONE_ENTITY_ID_FORMAT.format(location_name))
+
+
 class MobileAppEntity(TrackerEntity, RestoreEntity):
     """Represent a tracked device."""
 
@@ -129,13 +134,17 @@ class MobileAppEntity(TrackerEntity, RestoreEntity):
     @property
     def location_accuracy(self) -> float:
         """Return the gps accuracy of the device."""
+        if ATTR_GPS not in self._data:
+            return 0
         return self._data.get(ATTR_GPS_ACCURACY, 0)
 
     @property
     def latitude(self) -> float | None:
         """Return latitude value of the device."""
         if (gps := self._data.get(ATTR_GPS)) is None:
-            return None
+            if not (zone_state := _zone_state(self.hass, self._data)):
+                return None
+            return zone_state.attributes.get(ATTR_LATITUDE)
 
         return gps[0]
 
@@ -143,23 +152,12 @@ class MobileAppEntity(TrackerEntity, RestoreEntity):
     def longitude(self) -> float | None:
         """Return longitude value of the device."""
         if (gps := self._data.get(ATTR_GPS)) is None:
-            return None
+            if not (zone_state := _zone_state(self.hass, self._data)):
+                return None
+            return zone_state.attributes.get(ATTR_LONGITUDE)
 
         return gps[1]
 
-    @property
-    def location_name(self) -> str | None:
-        """Return a location name for the current location of the device."""
-        if location_name := self._data.get(ATTR_LOCATION_NAME):
-            if location_name == HOME_ZONE:
-                return STATE_HOME
-            if zone_state := self.hass.states.get(
-                ZONE_ENTITY_ID_FORMAT.format(location_name)
-            ):
-                return zone_state.name
-            return location_name
-        return None
-
     @property
     def name(self) -> str:
         """Return the name of the device."""

homeassistant/components/mobile_app/notify.py

@@ -21,13 +21,9 @@ from homeassistant.components.notify import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_DEVICE_ID
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.dispatcher import (
-    async_dispatcher_connect,
-    async_dispatcher_send,
-)
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
@@ -50,7 +46,6 @@ from .const import (
     DATA_NOTIFY,
     DATA_PUSH_CHANNEL,
     DOMAIN,
-    SIGNAL_RECORD_NOTIFICATION,
 )
 from .helpers import device_info
 from .push_notification import PushChannel
@@ -116,21 +111,6 @@ class MobileAppNotifyEntity(NotifyEntity):
                 translation_placeholders={"device_name": self._config_entry.title},
             )
 
-    @callback
-    def _async_handle_notification(self, webhook_id: str) -> None:
-        """Handle notifications triggered externally."""
-        if webhook_id == self._config_entry.data[ATTR_WEBHOOK_ID]:
-            self._async_record_notification()
-
-    async def async_added_to_hass(self) -> None:
-        """Register callback."""
-
-        self.async_on_remove(
-            async_dispatcher_connect(
-                self.hass, SIGNAL_RECORD_NOTIFICATION, self._async_handle_notification
-            )
-        )
-
 
 def push_registrations(hass: HomeAssistant) -> dict[str, str]:
     """Return a dictionary of push enabled registrations."""
@@ -215,7 +195,6 @@ class MobileAppNotificationService(BaseNotificationService):
                     data,
                     partial(self._async_send_remote_message_target, entry),
                 )
-                async_dispatcher_send(self.hass, SIGNAL_RECORD_NOTIFICATION, target)
                 continue
 
             # Test if local push only.
@@ -224,7 +203,6 @@ class MobileAppNotificationService(BaseNotificationService):
                 continue
 
             await self._async_send_remote_message_target(entry, data)
-            async_dispatcher_send(self.hass, SIGNAL_RECORD_NOTIFICATION, target)
 
         if failed_targets:
             raise HomeAssistantError(

homeassistant/components/mqtt/__init__.py

@@ -11,12 +11,7 @@ import voluptuous as vol
 from homeassistant import config as conf_util
 from homeassistant.components import websocket_api
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_DISCOVERY,
-    CONF_PLATFORM,
-    CONF_PROTOCOL,
-    SERVICE_RELOAD,
-)
+from homeassistant.const import CONF_DISCOVERY, CONF_PLATFORM, SERVICE_RELOAD
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import (
     ConfigValidationError,
@@ -32,7 +27,6 @@ from homeassistant.helpers import (
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import async_get_platforms
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.helpers.typing import ConfigType
@@ -79,14 +73,12 @@ from .const import (
     DEFAULT_DISCOVERY,
     DEFAULT_ENCODING,
     DEFAULT_PREFIX,
-    DEFAULT_PROTOCOL,
     DEFAULT_QOS,
     DEFAULT_RETAIN,
     DOMAIN,
     ENTITY_PLATFORMS,
     ENTRY_OPTION_FIELDS,
     MQTT_CONNECTION_STATE,
-    PROTOCOL_311,
     TEMPLATE_ERRORS,
     Platform,
 )
@@ -432,26 +424,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Load a config entry."""
     mqtt_data: MqttData
 
-    if (protocol := entry.data.get(CONF_PROTOCOL, PROTOCOL_311)) != DEFAULT_PROTOCOL:
-        broker: str = entry.data[CONF_BROKER]
-        async_create_issue(
-            hass,
-            DOMAIN,
-            "protocol_5_migration",
-            issue_domain=DOMAIN,
-            is_fixable=True,
-            breaks_in_ha_version="2027.1.0",
-            severity=IssueSeverity.WARNING,
-            learn_more_url="https://www.home-assistant.io/integrations/mqtt/#mqtt-protocol",
-            data={
-                "entry_id": entry.entry_id,
-                "broker": broker,
-                "protocol": protocol,
-            },
-            translation_placeholders={"broker": broker, "protocol": protocol},
-            translation_key="protocol_5_migration",
-        )
-
     async def _setup_client() -> tuple[MqttData, dict[str, Any]]:
         """Set up the MQTT client."""
         # Fetch configuration

homeassistant/components/mqtt/client.py

@@ -16,8 +16,6 @@ from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 import certifi
-import paho.mqtt.client as mqtt
-from paho.mqtt.matcher import MQTTMatcher
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -49,7 +47,6 @@ from homeassistant.setup import SetupPhases, async_pause_setup
 from homeassistant.util.collection import chunked_or_all
 from homeassistant.util.logging import catch_log_exception, log_exception
 
-from .async_client import AsyncMQTTClient
 from .const import (
     CONF_BIRTH_MESSAGE,
     CONF_BROKER,
@@ -66,6 +63,7 @@ from .const import (
     DEFAULT_ENCODING,
     DEFAULT_KEEPALIVE,
     DEFAULT_PORT,
+    DEFAULT_PROTOCOL,
     DEFAULT_QOS,
     DEFAULT_TRANSPORT,
     DEFAULT_WILL,
@@ -76,7 +74,6 @@ from .const import (
     MQTT_PROCESSED_SUBSCRIPTIONS,
     PROTOCOL_5,
     PROTOCOL_31,
-    PROTOCOL_311,
     TRANSPORT_WEBSOCKETS,
 )
 from .models import (
@@ -89,6 +86,13 @@ from .models import (
 )
 from .util import EnsureJobAfterCooldown, get_file_path, mqtt_config_entry_enabled
 
+if TYPE_CHECKING:
+    # Only import for paho-mqtt type checking here, imports are done locally
+    # because integrations should be able to optionally rely on MQTT.
+    import paho.mqtt.client as mqtt
+
+    from .async_client import AsyncMQTTClient
+
 _LOGGER = logging.getLogger(__name__)
 
 MIN_BUFFER_SIZE = 131072  # Minimum buffer size to use if preferred size fails
@@ -319,12 +323,15 @@ class MqttClientSetup:
         The setup of the MQTT client should be run in an executor job,
         because it accesses files, so it does IO.
         """
+        # We don't import on the top because some integrations
+        # should be able to optionally rely on MQTT.
+        from paho.mqtt import client as mqtt  # noqa: PLC0415
+
+        from .async_client import AsyncMQTTClient  # noqa: PLC0415
+
         config = self._config
         clean_session: bool | None = None
-        # If no protocol setting is set in the config entry data
-        # we assume the config was migrated from YAML, and the
-        # protocol version is defaulting to legacy version 3.1.1.
-        if (protocol := config.get(CONF_PROTOCOL, PROTOCOL_311)) == PROTOCOL_31:
+        if (protocol := config.get(CONF_PROTOCOL, DEFAULT_PROTOCOL)) == PROTOCOL_31:
             proto = mqtt.MQTTv31
             clean_session = True
         elif protocol == PROTOCOL_5:
@@ -413,10 +420,7 @@ class MQTT:
         self.loop = hass.loop
         self.config_entry = config_entry
         self.conf = conf
-        # If no protocol setting is set in the config entry data
-        # we assume the config was migrated from YAML, and the
-        # protocol version is defaulting to legacy version 3.1.1.
-        self.is_mqttv5 = conf.get(CONF_PROTOCOL, PROTOCOL_311) == PROTOCOL_5
+        self.is_mqttv5 = conf.get(CONF_PROTOCOL, DEFAULT_PROTOCOL) == PROTOCOL_5
 
         self._simple_subscriptions: defaultdict[str, set[Subscription]] = defaultdict(
             set
@@ -551,6 +555,7 @@ class MQTT:
         """Start the misc periodic."""
         assert self._misc_timer is None, "Misc periodic already started"
         _LOGGER.debug("%s: Starting client misc loop", self.config_entry.title)
+        import paho.mqtt.client as mqtt  # noqa: PLC0415
 
         # Inner function to avoid having to check late import
         # each time the function is called.
@@ -694,6 +699,7 @@ class MQTT:
 
     async def async_connect(self, client_available: asyncio.Future[bool]) -> None:
         """Connect to the host. Does not process messages yet."""
+        import paho.mqtt.client as mqtt  # noqa: PLC0415
 
         result: int | None = None
         self._available_future = client_available
@@ -751,6 +757,7 @@ class MQTT:
 
     async def _reconnect_loop(self) -> None:
         """Reconnect to the MQTT server."""
+        import paho.mqtt.client as mqtt  # noqa: PLC0415
 
         while True:
             if not self.connected:
@@ -1252,6 +1259,9 @@ class MQTT:
     @callback
     def _async_handle_callback_exception(self, status: mqtt.MQTTErrorCode) -> None:
         """Handle a callback exception."""
+        # We don't import on the top because some integrations
+        # should be able to optionally rely on MQTT.
+        import paho.mqtt.client as mqtt  # noqa: PLC0415
 
         _LOGGER.warning(
             "Error returned from MQTT server: %s",
@@ -1296,6 +1306,8 @@ class MQTT:
     ) -> None:
         """Wait for ACK from broker or raise on error."""
         if result_code != 0:
+            import paho.mqtt.client as mqtt  # noqa: PLC0415
+
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="mqtt_broker_error",
@@ -1342,6 +1354,8 @@ class MQTT:
 
 
 def _matcher_for_topic(subscription: str) -> Callable[[str], bool]:
+    from paho.mqtt.matcher import MQTTMatcher  # noqa: PLC0415
+
     matcher = MQTTMatcher()  # type: ignore[no-untyped-call]
     matcher[subscription] = True
 

homeassistant/components/mqtt/config_flow.py

@@ -22,7 +22,6 @@ from cryptography.hazmat.primitives.serialization import (
     load_pem_private_key,
 )
 from cryptography.x509 import load_der_x509_certificate, load_pem_x509_certificate
-import paho.mqtt.client as mqtt
 import voluptuous as vol
 import yaml
 
@@ -4074,7 +4073,6 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
             config: dict[str, Any] = {
                 CONF_BROKER: addon_discovery_config[CONF_HOST],
                 CONF_PORT: addon_discovery_config[CONF_PORT],
-                CONF_PROTOCOL: DEFAULT_PROTOCOL,
                 CONF_USERNAME: addon_discovery_config.get(CONF_USERNAME),
                 CONF_PASSWORD: addon_discovery_config.get(CONF_PASSWORD),
                 CONF_DISCOVERY: DEFAULT_DISCOVERY,
@@ -4303,7 +4301,6 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             data: dict[str, Any] = self._hassio_discovery.copy()
             data[CONF_BROKER] = data.pop(CONF_HOST)
-            data[CONF_PROTOCOL] = DEFAULT_PROTOCOL
             can_connect = await self.hass.async_add_executor_job(
                 try_connection,
                 data,
@@ -4315,7 +4312,6 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
                     data={
                         CONF_BROKER: data[CONF_BROKER],
                         CONF_PORT: data[CONF_PORT],
-                        CONF_PROTOCOL: DEFAULT_PROTOCOL,
                         CONF_USERNAME: data.get(CONF_USERNAME),
                         CONF_PASSWORD: data.get(CONF_PASSWORD),
                         CONF_DISCOVERY: DEFAULT_DISCOVERY,
@@ -5182,8 +5178,6 @@ async def async_get_broker_settings(  # noqa: C901
     ) -> bool:
         """Additional validation on broker settings for better error messages."""
 
-        if CONF_PROTOCOL not in validated_user_input:
-            validated_user_input[CONF_PROTOCOL] = DEFAULT_PROTOCOL
         # Get current certificate settings from config entry
         certificate: str | None = (
             "auto"
@@ -5372,9 +5366,12 @@ async def async_get_broker_settings(  # noqa: C901
             description={"suggested_value": current_pass},
         )
     ] = PASSWORD_SELECTOR
-    # show advanced options checkbox if no defaults
-    # of the advanced options are overridden
+    # show advanced options checkbox if requested and
+    # advanced options are enabled
+    # or when the defaults of advanced options are overridden
     if not advanced_broker_options:
+        if not flow.show_advanced_options:
+            return False
         fields[
             vol.Optional(
                 ADVANCED_OPTIONS,
@@ -5480,6 +5477,10 @@ def try_connection(
     user_input: dict[str, Any],
 ) -> bool:
     """Test if we can connect to an MQTT broker."""
+    # We don't import on the top because some integrations
+    # should be able to optionally rely on MQTT.
+    import paho.mqtt.client as mqtt  # noqa: PLC0415
+
     mqtt_client_setup = MqttClientSetup(user_input)
     mqtt_client_setup.setup()
     client = mqtt_client_setup.client

homeassistant/components/mqtt/const.py

@@ -347,14 +347,14 @@ REMOTE_CODE_TEXT = "REMOTE_CODE_TEXT"
 PROTOCOL_31 = "3.1"
 PROTOCOL_311 = "3.1.1"
 PROTOCOL_5 = "5"
-SUPPORTED_PROTOCOLS = [PROTOCOL_5, PROTOCOL_311, PROTOCOL_31]
+SUPPORTED_PROTOCOLS = [PROTOCOL_31, PROTOCOL_311, PROTOCOL_5]
 
 TRANSPORT_TCP = "tcp"
 TRANSPORT_WEBSOCKETS = "websockets"
 
 DEFAULT_PORT = 1883
 DEFAULT_KEEPALIVE = 60
-DEFAULT_PROTOCOL = PROTOCOL_5
+DEFAULT_PROTOCOL = PROTOCOL_311
 DEFAULT_TRANSPORT = TRANSPORT_TCP
 
 DEFAULT_BIRTH = {

homeassistant/components/mqtt/models.py

@@ -9,8 +9,6 @@ from enum import StrEnum
 import logging
 from typing import TYPE_CHECKING, Any, TypedDict
 
-from paho.mqtt.client import MQTTMessage
-
 from homeassistant.const import ATTR_ENTITY_ID, ATTR_NAME, Platform
 from homeassistant.core import CALLBACK_TYPE, callback
 from homeassistant.exceptions import ServiceValidationError, TemplateError
@@ -26,6 +24,8 @@ from homeassistant.helpers.typing import (
 from homeassistant.util.hass_dict import HassKey
 
 if TYPE_CHECKING:
+    from paho.mqtt.client import MQTTMessage
+
     from .client import MQTT, Subscription
     from .debug_info import TimestampedPublishMessage
     from .device_trigger import Trigger

homeassistant/components/mqtt/repairs.py

@@ -6,16 +6,10 @@ import voluptuous as vol
 
 from homeassistant import data_entry_flow
 from homeassistant.components.repairs import RepairsFlow
-from homeassistant.const import CONF_PORT, CONF_PROTOCOL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 
-from .config_flow import try_connection
-from .const import DEFAULT_PORT, DOMAIN, PROTOCOL_5
-
-URL_MQTT_BROKER_CONFIGURATION = (
-    "https://www.home-assistant.io/integrations/mqtt/#broker-configuration"
-)
+from .const import DOMAIN
 
 
 class MQTTDeviceEntryMigration(RepairsFlow):
@@ -56,55 +50,6 @@ class MQTTDeviceEntryMigration(RepairsFlow):
         )
 
 
-class MQTTProtocolV5Migration(RepairsFlow):
-    """Handler to migrate to MQTT protocol version 5."""
-
-    def __init__(self, entry_id: str, broker: str, protocol: str) -> None:
-        """Initialize the flow."""
-        self.entry_id = entry_id
-        self.broker = broker
-        self.protocol = protocol
-
-    async def async_step_init(
-        self, user_input: dict[str, str] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Handle the first step of a fix flow."""
-        return await self.async_step_confirm()
-
-    async def async_step_confirm(
-        self, user_input: dict[str, str] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Handle the confirm step of a fix flow."""
-        if user_input is not None:
-            entry = self.hass.config_entries.async_get_entry(self.entry_id)
-            if TYPE_CHECKING:
-                assert entry is not None
-            new_entry_data = entry.data.copy()
-            new_entry_data[CONF_PROTOCOL] = PROTOCOL_5
-            # Try the connection with protocol version 5
-            if await self.hass.async_add_executor_job(
-                try_connection,
-                {CONF_PORT: DEFAULT_PORT} | new_entry_data,
-            ):
-                self.hass.config_entries.async_update_entry(entry, data=new_entry_data)
-                return self.async_create_entry(data={})
-
-            return self.async_abort(
-                reason="mqtt_broker_migration_to_v5_failed",
-                description_placeholders={
-                    "broker": self.broker,
-                    "protocol": self.protocol,
-                    "url_mqtt_broker_configuration": URL_MQTT_BROKER_CONFIGURATION,
-                },
-            )
-
-        return self.async_show_form(
-            step_id="confirm",
-            data_schema=vol.Schema({}),
-            description_placeholders={"broker": self.broker, "protocol": self.protocol},
-        )
-
-
 async def async_create_fix_flow(
     hass: HomeAssistant,
     issue_id: str,
@@ -113,13 +58,13 @@ async def async_create_fix_flow(
     """Create flow."""
     if TYPE_CHECKING:
         assert data is not None
-    entry_id: str = data["entry_id"]  # type: ignore[assignment]
-    if issue_id == "protocol_5_migration":
-        broker: str = data["broker"]  # type: ignore[assignment]
-        protocol: str = data["protocol"]  # type: ignore[assignment]
-        return MQTTProtocolV5Migration(entry_id, broker, protocol)
-    subentry_id: str = data["subentry_id"]  # type: ignore[assignment]
-    name: str = data["name"]  # type: ignore[assignment]
+    entry_id = data["entry_id"]
+    subentry_id = data["subentry_id"]
+    name = data["name"]
+    if TYPE_CHECKING:
+        assert isinstance(entry_id, str)
+        assert isinstance(subentry_id, str)
+        assert isinstance(name, str)
     return MQTTDeviceEntryMigration(
         entry_id=entry_id,
         subentry_id=subentry_id,

homeassistant/components/mqtt/strings.json

@@ -1120,20 +1120,6 @@
       "description": "Home Assistant detected an invalid config for a manually configured item.\n\nPlatform domain: **{domain}**\nConfiguration file: **{config_file}**\nNear line: **{line}**\nConfiguration found:\n```yaml\n{config}\n```\nError: **{error}**.\n\nMake sure the configuration is valid and [reload](/config/developer-tools/yaml) the manually configured MQTT items or restart Home Assistant to fix this issue.",
       "title": "Invalid config found for MQTT {domain} item"
     },
-    "protocol_5_migration": {
-      "fix_flow": {
-        "abort": {
-          "mqtt_broker_migration_to_v5_failed": "Migrating the broker ({broker}) protocol version from {protocol} to 5 failed, and the migration has been aborted.\n\nYour broker may not support MQTT protocol version 5.\n\nPlease [reconfigure your MQTT broker settings]({url_mqtt_broker_configuration}) or upgrade your broker to support MQTT protocol version 5 to fix this issue."
-        },
-        "step": {
-          "confirm": {
-            "description": "Home Assistant is migrating to MQTT protocol version 5. The currently configured protocol version for broker {broker} is {protocol}. This protocol version is deprecated, and support for it will be removed.\n\nSubmitting this form will try to migrate your MQTT broker configuration to use protocol version 5 to fix this issue.",
-            "title": "MQTT protocol change required"
-          }
-        }
-      },
-      "title": "Deprecated MQTT protocol {protocol} in use"
-    },
     "subentry_migration_discovery": {
       "fix_flow": {
         "step": {

homeassistant/components/netatmo/binary_sensor.py

@@ -67,11 +67,25 @@ OPENING_CATEGORY_TO_DEVICE_CLASS: Final[dict[str | None, BinarySensorDeviceClass
 
 
 def get_opening_category(netatmo_device: NetatmoDevice) -> str:
-    """Helper function to get opening category for doortag."""
+    """Helper function to get opening category from Netatmo API raw data."""
 
-    return (
-        getattr(netatmo_device.device, "doortag_category", None)
-        or DOORTAG_CATEGORY_OTHER
+    # Iterate through each home in the raw data.
+    for home in netatmo_device.data_handler.account.raw_data["homes"]:
+        # Check if the modules list exists for the current home.
+        if "modules" in home:
+            # Iterate through each module to find a matching ID.
+            for module in home["modules"]:
+                if module["id"] == netatmo_device.device.entity_id:
+                    # We found the matching device. Get its category.
+                    if module.get("category") is not None:
+                        return cast(str, module["category"])
+                    raise ValueError(
+                        f"Device {netatmo_device.device.entity_id} found, "
+                        "but 'category' is missing in raw data."
+                    )
+
+    raise ValueError(
+        f"Device {netatmo_device.device.entity_id} not found in Netatmo raw data."
     )
 
 

homeassistant/components/netatmo/button.py

@@ -12,7 +12,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_BUTTON
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
-from .helper import device_type_to_str
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -56,7 +55,9 @@ class NetatmoCoverPreferredPositionButton(NetatmoModuleEntity, ButtonEntity):
                 },
             ]
         )
-        self._attr_unique_id = f"{self.device.entity_id}-{device_type_to_str(self.device_type)}-preferred_position"
+        self._attr_unique_id = (
+            f"{self.device.entity_id}-{self.device_type}-preferred_position"
+        )
 
     @callback
     def async_update_callback(self) -> None:

homeassistant/components/netatmo/camera.py

@@ -42,7 +42,6 @@ from .const import (
 )
 from .data_handler import EVENT, HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
-from .helper import device_type_to_str
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -103,9 +102,7 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
         Camera.__init__(self)
         super().__init__(netatmo_device)
 
-        self._attr_unique_id = (
-            f"{netatmo_device.device.entity_id}-{device_type_to_str(self.device_type)}"
-        )
+        self._attr_unique_id = f"{netatmo_device.device.entity_id}-{self.device_type}"
         self._light_state = None
 
         self._publishers.extend(

homeassistant/components/netatmo/climate.py

@@ -54,7 +54,6 @@ from .const import (
 )
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoRoom
 from .entity import NetatmoRoomEntity
-from .helper import device_type_to_str
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -220,9 +219,7 @@ class NetatmoThermostat(NetatmoRoomEntity, ClimateEntity):
         if self.device_type is NA_THERM:
             self._attr_hvac_modes.append(HVACMode.OFF)
 
-        self._attr_unique_id = (
-            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
-        )
+        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
 
     async def async_added_to_hass(self) -> None:
         """Entity created."""

homeassistant/components/netatmo/cover.py

@@ -18,7 +18,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_COVER
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
-from .helper import device_type_to_str
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -71,9 +70,7 @@ class NetatmoCover(NetatmoModuleEntity, CoverEntity):
                 },
             ]
         )
-        self._attr_unique_id = (
-            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
-        )
+        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""

homeassistant/components/netatmo/fan.py

@@ -13,7 +13,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_FAN
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
-from .helper import device_type_to_str
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -63,9 +62,7 @@ class NetatmoFan(NetatmoModuleEntity, FanEntity):
             ]
         )
 
-        self._attr_unique_id = (
-            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
-        )
+        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode of the fan."""