Just copy explicit files in the DockerFile

.github/renovate.json

@@ -1,161 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended"],
-
-  "enabledManagers": [
-    "pep621",
-    "pip_requirements",
-    "pre-commit",
-    "homeassistant-manifest"
-  ],
-
-  "pre-commit": {
-    "enabled": true
-  },
-
-  "pip_requirements": {
-    "managerFilePatterns": [
-      "/(^|/)requirements[\\w_-]*\\.txt$/",
-      "/(^|/)homeassistant/package_constraints\\.txt$/"
-    ]
-  },
-
-  "homeassistant-manifest": {
-    "managerFilePatterns": [
-      "/^homeassistant/components/[^/]+/manifest\\.json$/"
-    ]
-  },
-
-  "minimumReleaseAge": "7 days",
-  "prConcurrentLimit": 10,
-  "prHourlyLimit": 2,
-  "schedule": ["before 6am"],
-
-  "semanticCommits": "disabled",
-  "commitMessageAction": "Update",
-  "commitMessageTopic": "{{depName}}",
-  "commitMessageExtra": "to {{newVersion}}",
-
-  "automerge": false,
-
-  "vulnerabilityAlerts": {
-    "enabled": false
-  },
-
-  "packageRules": [
-    {
-      "description": "Deny all by default — allowlist below re-enables specific packages",
-      "matchPackageNames": ["*"],
-      "enabled": false
-    },
-    {
-      "description": "Core runtime dependencies (allowlisted)",
-      "matchPackageNames": [
-        "aiohttp",
-        "aiohttp-fast-zlib",
-        "aiohttp_cors",
-        "aiohttp-asyncmdnsresolver",
-        "yarl",
-        "httpx",
-        "requests",
-        "urllib3",
-        "certifi",
-        "orjson",
-        "PyYAML",
-        "Jinja2",
-        "cryptography",
-        "pyOpenSSL",
-        "PyJWT",
-        "SQLAlchemy",
-        "Pillow",
-        "attrs",
-        "uv",
-        "voluptuous",
-        "voluptuous-serialize",
-        "voluptuous-openapi",
-        "zeroconf"
-      ],
-      "enabled": true,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Test dependencies (allowlisted)",
-      "matchPackageNames": [
-        "pytest",
-        "pytest-asyncio",
-        "pytest-aiohttp",
-        "pytest-cov",
-        "pytest-freezer",
-        "pytest-github-actions-annotate-failures",
-        "pytest-socket",
-        "pytest-sugar",
-        "pytest-timeout",
-        "pytest-unordered",
-        "pytest-picked",
-        "pytest-xdist",
-        "pylint",
-        "pylint-per-file-ignores",
-        "astroid",
-        "coverage",
-        "freezegun",
-        "syrupy",
-        "respx",
-        "requests-mock",
-        "ruff",
-        "codespell",
-        "yamllint",
-        "zizmor"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "For types-* stubs, only allow patch updates. Major/minor bumps track the upstream runtime package version and must be manually coordinated with the corresponding pin.",
-      "matchPackageNames": ["/^types-/"],
-      "matchUpdateTypes": ["patch"],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Pre-commit hook repos (allowlisted, matched by owner/repo)",
-      "matchPackageNames": [
-        "astral-sh/ruff-pre-commit",
-        "codespell-project/codespell",
-        "adrienverge/yamllint",
-        "zizmorcore/zizmor-pre-commit"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Group ruff pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["astral-sh/ruff-pre-commit", "ruff"],
-      "groupName": "ruff",
-      "groupSlug": "ruff"
-    },
-    {
-      "description": "Group codespell pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["codespell-project/codespell", "codespell"],
-      "groupName": "codespell",
-      "groupSlug": "codespell"
-    },
-    {
-      "description": "Group yamllint pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["adrienverge/yamllint", "yamllint"],
-      "groupName": "yamllint",
-      "groupSlug": "yamllint"
-    },
-    {
-      "description": "Group zizmor pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["zizmorcore/zizmor-pre-commit", "zizmor"],
-      "groupName": "zizmor",
-      "groupSlug": "zizmor"
-    },
-    {
-      "description": "Group pylint with astroid (their versions are linked and must move together)",
-      "matchPackageNames": ["pylint", "astroid"],
-      "groupName": "pylint",
-      "groupSlug": "pylint"
-    }
-  ]
-}

.gitignore

@@ -142,6 +142,5 @@ pytest_buckets.txt
 
 # AI tooling
 .claude/settings.local.json
-.claude/worktrees/
 .serena/
 

.pre-commit-config.yaml

@@ -8,7 +8,7 @@ repos:
       - id: ruff-format
         files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
     hooks:
       - id: codespell
         args:
@@ -36,7 +36,7 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
     hooks:
       - id: yamllint
   - repo: https://github.com/rbubley/mirrors-prettier

Dockerfile

@@ -34,8 +34,7 @@ RUN \
 WORKDIR /usr/src
 
 ## Setup Home Assistant Core dependencies
-COPY requirements.txt homeassistant/
-COPY homeassistant/package_constraints.txt homeassistant/homeassistant/
+COPY --parents requirements.txt homeassistant/package_constraints.txt homeassistant/
 RUN \
     uv pip install \
         --no-build \
@@ -51,7 +50,7 @@ RUN \
         -r homeassistant/requirements_all.txt
 
 ## Setup Home Assistant Core
-COPY . homeassistant/
+COPY --parents CODEOWNERS LICENSE* README* homeassistant pyproject.toml homeassistant/
 RUN \
     uv pip install \
         -e ./homeassistant \

homeassistant/components/actron_air/quality_scale.yaml

@@ -57,9 +57,9 @@ rules:
   entity-category: done
   entity-device-class: todo
   entity-disabled-by-default: todo
-  entity-translations: done
+  entity-translations: todo
   exception-translations: done
-  icon-translations: done
+  icon-translations: todo
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/analytics_insights/strings.json

@@ -11,12 +11,12 @@
       "user": {
         "data": {
           "tracked_apps": "Apps",
-          "tracked_custom_integrations": "Custom integrations",
+          "tracked_custom_integrations": "Community integrations",
           "tracked_integrations": "Integrations"
         },
         "data_description": {
           "tracked_apps": "Select the apps you want to track",
-          "tracked_custom_integrations": "Select the custom integrations you want to track",
+          "tracked_custom_integrations": "Select the community integrations you want to track",
           "tracked_integrations": "Select the integrations you want to track"
         }
       }
@@ -31,7 +31,7 @@
         "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
       },
       "custom_integrations": {
-        "name": "{custom_integration_domain} (custom)",
+        "name": "{custom_integration_domain} (community)",
         "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
       },
       "total_active_installations": {

homeassistant/components/automation/__init__.py

@@ -143,7 +143,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "occupancy",
     "person",
     "power",
-    "remote",
     "schedule",
     "select",
     "siren",
@@ -151,8 +150,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "temperature",
     "text",
     "timer",
-    "todo",
-    "update",
     "vacuum",
     "valve",
     "water_heater",

homeassistant/components/doods/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_polling",
   "loggers": ["pydoods"],
   "quality_scale": "legacy",
-  "requirements": ["pydoods==1.0.2", "Pillow==12.2.0"]
+  "requirements": ["pydoods==1.0.2", "Pillow==12.1.1"]
 }

homeassistant/components/duco/const.py

@@ -5,5 +5,5 @@ from datetime import timedelta
 from homeassistant.const import Platform
 
 DOMAIN = "duco"
-PLATFORMS = [Platform.FAN, Platform.SENSOR]
+PLATFORMS = [Platform.FAN]
 SCAN_INTERVAL = timedelta(seconds=30)

homeassistant/components/duco/diagnostics.py

@@ -1,53 +0,0 @@
-"""Diagnostics support for Duco."""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import asdict
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_HOST
-from homeassistant.core import HomeAssistant
-
-from .coordinator import DucoConfigEntry
-
-TO_REDACT = {
-    CONF_HOST,
-    "mac",
-    "host_name",
-    "serial_board_box",
-    "serial_board_comm",
-    "serial_duco_box",
-    "serial_duco_comm",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: DucoConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    board = asdict(coordinator.board_info)
-    board.pop("time")
-
-    lan_info, duco_diags, write_remaining = await asyncio.gather(
-        coordinator.client.async_get_lan_info(),
-        coordinator.client.async_get_diagnostics(),
-        coordinator.client.async_get_write_req_remaining(),
-    )
-
-    return async_redact_data(
-        {
-            "entry_data": entry.data,
-            "board_info": board,
-            "lan_info": asdict(lan_info),
-            "nodes": {
-                str(node_id): asdict(node) for node_id, node in coordinator.data.items()
-            },
-            "duco_diagnostics": [asdict(d) for d in duco_diags],
-            "write_requests_remaining": write_remaining,
-        },
-        TO_REDACT,
-    )

homeassistant/components/duco/icons.json

@@ -1,15 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "iaq_co2": {
-        "default": "mdi:molecule-co2"
-      },
-      "iaq_rh": {
-        "default": "mdi:water-percent"
-      },
-      "ventilation_state": {
-        "default": "mdi:tune-variant"
-      }
-    }
-  }
-}

homeassistant/components/duco/quality_scale.yaml

@@ -45,7 +45,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: todo
     comment: >-
@@ -71,11 +71,11 @@ rules:
       Users can pair new modules (CO2 sensors, humidity sensors, zone valves)
       to their Duco box. Dynamic device support to be added in a follow-up PR.
   entity-category: todo
-  entity-device-class: done
-  entity-disabled-by-default: done
+  entity-device-class: todo
+  entity-disabled-by-default: todo
   entity-translations: done
-  exception-translations: done
-  icon-translations: done
+  exception-translations: todo
+  icon-translations: todo
   reconfiguration-flow: todo
   repair-issues: todo
   stale-devices:

homeassistant/components/duco/sensor.py

@@ -1,119 +0,0 @@
-"""Sensor platform for the Duco integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from duco.models import Node, NodeType, VentilationState
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import CONCENTRATION_PARTS_PER_MILLION, PERCENTAGE
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import DucoConfigEntry, DucoCoordinator
-from .entity import DucoEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class DucoSensorEntityDescription(SensorEntityDescription):
-    """Duco sensor entity description."""
-
-    value_fn: Callable[[Node], int | float | str | None]
-    node_types: tuple[NodeType, ...]
-
-
-SENSOR_DESCRIPTIONS: tuple[DucoSensorEntityDescription, ...] = (
-    DucoSensorEntityDescription(
-        key="ventilation_state",
-        translation_key="ventilation_state",
-        device_class=SensorDeviceClass.ENUM,
-        options=[s.lower() for s in VentilationState],
-        value_fn=lambda node: (
-            node.ventilation.state.lower() if node.ventilation else None
-        ),
-        node_types=(NodeType.BOX,),
-    ),
-    DucoSensorEntityDescription(
-        key="co2",
-        device_class=SensorDeviceClass.CO2,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
-        value_fn=lambda node: node.sensor.co2 if node.sensor else None,
-        node_types=(NodeType.UCCO2,),
-    ),
-    DucoSensorEntityDescription(
-        key="iaq_co2",
-        translation_key="iaq_co2",
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
-        value_fn=lambda node: node.sensor.iaq_co2 if node.sensor else None,
-        node_types=(NodeType.UCCO2,),
-    ),
-    DucoSensorEntityDescription(
-        key="humidity",
-        device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=PERCENTAGE,
-        value_fn=lambda node: node.sensor.rh if node.sensor else None,
-        node_types=(NodeType.BSRH,),
-    ),
-    DucoSensorEntityDescription(
-        key="iaq_rh",
-        translation_key="iaq_rh",
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
-        value_fn=lambda node: node.sensor.iaq_rh if node.sensor else None,
-        node_types=(NodeType.BSRH,),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: DucoConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Duco sensor entities."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        DucoSensorEntity(coordinator, node, description)
-        for node in coordinator.data.values()
-        for description in SENSOR_DESCRIPTIONS
-        if node.general.node_type in description.node_types
-    )
-
-
-class DucoSensorEntity(DucoEntity, SensorEntity):
-    """Sensor entity for a Duco node."""
-
-    entity_description: DucoSensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: DucoCoordinator,
-        node: Node,
-        description: DucoSensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor entity."""
-        super().__init__(coordinator, node)
-        self.entity_description = description
-        self._attr_unique_id = (
-            f"{coordinator.config_entry.unique_id}_{node.node_id}_{description.key}"
-        )
-
-    @property
-    def native_value(self) -> int | float | str | None:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self._node)

homeassistant/components/duco/strings.json

@@ -29,36 +29,6 @@
           }
         }
       }
-    },
-    "sensor": {
-      "iaq_co2": {
-        "name": "CO2 air quality index"
-      },
-      "iaq_rh": {
-        "name": "Humidity air quality index"
-      },
-      "ventilation_state": {
-        "name": "Ventilation state",
-        "state": {
-          "aut1": "Automatic boost (15 min)",
-          "aut2": "Automatic boost (30 min)",
-          "aut3": "Automatic boost (45 min)",
-          "auto": "Automatic",
-          "cnt1": "Continuous low speed",
-          "cnt2": "Continuous medium speed",
-          "cnt3": "Continuous high speed",
-          "empt": "Empty house",
-          "man1": "Manual low speed (15 min)",
-          "man1x2": "Manual low speed (30 min)",
-          "man1x3": "Manual low speed (45 min)",
-          "man2": "Manual medium speed (15 min)",
-          "man2x2": "Manual medium speed (30 min)",
-          "man2x3": "Manual medium speed (45 min)",
-          "man3": "Manual high speed (15 min)",
-          "man3x2": "Manual high speed (30 min)",
-          "man3x3": "Manual high speed (45 min)"
-        }
-      }
     }
   },
   "exceptions": {

homeassistant/components/enphase_envoy/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.4.8"],
+  "requirements": ["pyenphase==2.4.6"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/evohome/const.py

@@ -22,8 +22,9 @@ CONF_LOCATION_IDX: Final = "location_idx"
 SCAN_INTERVAL_DEFAULT: Final = timedelta(seconds=300)
 SCAN_INTERVAL_MINIMUM: Final = timedelta(seconds=60)
 
-ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 ATTR_PERIOD: Final = "period"  # number of days
+ATTR_DURATION: Final = "duration"  # number of minutes, <24h
+
 ATTR_SETPOINT: Final = "setpoint"
 
 
@@ -36,4 +37,3 @@ class EvoService(StrEnum):
     RESET_SYSTEM = "reset_system"
     SET_ZONE_OVERRIDE = "set_zone_override"
     CLEAR_ZONE_OVERRIDE = "clear_zone_override"
-    SET_DHW_OVERRIDE = "set_dhw_override"

homeassistant/components/evohome/icons.json

@@ -22,9 +22,6 @@
     "reset_system": {
       "service": "mdi:refresh"
     },
-    "set_dhw_override": {
-      "service": "mdi:water-heater"
-    },
     "set_system_mode": {
       "service": "mdi:pencil"
     },

homeassistant/components/evohome/services.py

@@ -14,8 +14,7 @@ from evohomeasync2.schemas.const import (
 import voluptuous as vol
 
 from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
-from homeassistant.components.water_heater import DOMAIN as WATER_HEATER_DOMAIN
-from homeassistant.const import ATTR_MODE, ATTR_STATE
+from homeassistant.const import ATTR_MODE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, service
@@ -50,15 +49,6 @@ SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
     ),
 }
 
-# DHW service schemas (registered as entity services)
-SET_DHW_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
-    vol.Required(ATTR_STATE): cv.boolean,
-    vol.Optional(ATTR_DURATION): vol.All(
-        cv.time_period,
-        vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
-    ),
-}
-
 
 def _register_zone_entity_services(hass: HomeAssistant) -> None:
     """Register entity-level services for zones."""
@@ -81,19 +71,6 @@ def _register_zone_entity_services(hass: HomeAssistant) -> None:
     )
 
 
-def _register_dhw_entity_services(hass: HomeAssistant) -> None:
-    """Register entity-level services for DHW zones."""
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        EvoService.SET_DHW_OVERRIDE,
-        entity_domain=WATER_HEATER_DOMAIN,
-        schema=SET_DHW_OVERRIDE_SCHEMA,
-        func="async_set_dhw_override",
-    )
-
-
 def _validate_set_system_mode_params(tcs: ControlSystem, data: dict[str, Any]) -> None:
     """Validate that a set_system_mode service call is properly formed."""
 
@@ -179,4 +156,3 @@ def setup_service_functions(
     )
 
     _register_zone_entity_services(hass)
-    _register_dhw_entity_services(hass)

homeassistant/components/evohome/services.yaml

@@ -58,19 +58,3 @@ clear_zone_override:
       domain: climate
       supported_features:
         - climate.ClimateEntityFeature.TARGET_TEMPERATURE
-
-set_dhw_override:
-  target:
-    entity:
-      integration: evohome
-      domain: water_heater
-  fields:
-    state:
-      required: true
-      selector:
-        boolean:
-    duration:
-      example: "02:15"
-      selector:
-        duration:
-          enable_second: false

homeassistant/components/evohome/strings.json

@@ -21,7 +21,7 @@
   },
   "services": {
     "clear_zone_override": {
-      "description": "Sets the zone to follow its schedule.",
+      "description": "Sets a zone to follow its schedule.",
       "name": "Clear zone override"
     },
     "refresh_system": {
@@ -29,25 +29,11 @@
       "name": "Refresh system"
     },
     "reset_system": {
-      "description": "Sets the system mode to `Auto` mode and resets all the zones to follow their schedules. Not all Evohome systems support this feature (i.e. `AutoWithReset` mode).",
+      "description": "Sets the system to `Auto` mode and resets all the zones to follow their schedules. Not all Evohome systems support this feature (i.e. `AutoWithReset` mode).",
       "name": "Reset system"
     },
-    "set_dhw_override": {
-      "description": "Overrides the DHW state, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
-      "fields": {
-        "duration": {
-          "description": "The DHW will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
-          "name": "Duration"
-        },
-        "state": {
-          "description": "The DHW state: True (on: heat the water up to the setpoint) or False (off).",
-          "name": "State"
-        }
-      },
-      "name": "Set DHW override"
-    },
     "set_system_mode": {
-      "description": "Sets the system mode, either indefinitely or until a specified end time, after which it will revert to `Auto`. Not all systems support all modes.",
+      "description": "Sets the system mode, either indefinitely, or for a specified period of time, after which it will revert to `Auto`. Not all systems support all modes.",
       "fields": {
         "duration": {
           "description": "The duration in hours; used only with `AutoWithEco` mode (up to 24 hours).",
@@ -65,7 +51,7 @@
       "name": "Set system mode"
     },
     "set_zone_override": {
-      "description": "Overrides the zone setpoint, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
+      "description": "Overrides the zone's setpoint, either indefinitely, or for a specified period of time, after which it will revert to following its schedule.",
       "fields": {
         "duration": {
           "description": "The zone will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",

homeassistant/components/evohome/water_heater.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
 import logging
 from typing import Any
 
@@ -98,28 +97,6 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
             PRECISION_TENTHS if coordinator.client_v1 else PRECISION_WHOLE
         )
 
-    async def async_set_dhw_override(
-        self, state: bool, duration: timedelta | None = None
-    ) -> None:
-        """Override the DHW zone's on/off state, either permanently or for a duration."""
-
-        if duration is None:
-            until = None  # indefinitely, aka permanent override
-        elif duration.total_seconds() == 0:
-            await self._update_schedule()
-            until = self.setpoints.get("next_sp_from")
-        else:
-            until = dt_util.now() + duration
-
-        until = dt_util.as_utc(until) if until else None
-
-        if state:
-            await self.coordinator.call_client_api(self._evo_device.set_on(until=until))
-        else:
-            await self.coordinator.call_client_api(
-                self._evo_device.set_off(until=until)
-            )
-
     @property
     def current_operation(self) -> str | None:
         """Return the current operating mode (Auto, On, or Off)."""

homeassistant/components/freshr/coordinator.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 from aiohttp import ClientError
 from pyfreshr import FreshrClient
 from pyfreshr.exceptions import ApiResponseError, LoginError
-from pyfreshr.models import DeviceReadings, DeviceSummary, DeviceType
+from pyfreshr.models import DeviceReadings, DeviceSummary
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
@@ -18,12 +18,6 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, LOGGER
 
-_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
-    DeviceType.FRESH_R: "Fresh-r",
-    DeviceType.FORWARD: "Fresh-r Forward",
-    DeviceType.MONITOR: "Fresh-r Monitor",
-}
-
 DEVICES_SCAN_INTERVAL = timedelta(hours=1)
 READINGS_SCAN_INTERVAL = timedelta(minutes=10)
 
@@ -116,12 +110,6 @@ class FreshrReadingsCoordinator(DataUpdateCoordinator[DeviceReadings]):
         )
         self._device = device
         self._client = client
-        self.device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, device.id)},
-            name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
-            serial_number=device.id,
-            manufacturer="Fresh-r",
-        )
 
     @property
     def device_id(self) -> str:

homeassistant/components/freshr/entity.py

@@ -1,18 +0,0 @@
-"""Base entity for the Fresh-r integration."""
-
-from __future__ import annotations
-
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import FreshrReadingsCoordinator
-
-
-class FreshrEntity(CoordinatorEntity[FreshrReadingsCoordinator]):
-    """Base class for Fresh-r entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: FreshrReadingsCoordinator) -> None:
-        """Initialize the Fresh-r entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info

homeassistant/components/freshr/manifest.json

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

homeassistant/components/freshr/sensor.py

@@ -21,10 +21,12 @@ from homeassistant.const import (
     UnitOfVolumeFlowRate,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from .const import DOMAIN
 from .coordinator import FreshrConfigEntry, FreshrReadingsCoordinator
-from .entity import FreshrEntity
 
 PARALLEL_UPDATES = 0
 
@@ -91,6 +93,12 @@ _TEMP = FreshrSensorEntityDescription(
     value_fn=lambda r: r.temp,
 )
 
+_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
+    DeviceType.FRESH_R: "Fresh-r",
+    DeviceType.FORWARD: "Fresh-r Forward",
+    DeviceType.MONITOR: "Fresh-r Monitor",
+}
+
 SENSOR_TYPES: dict[DeviceType, tuple[FreshrSensorEntityDescription, ...]] = {
     DeviceType.FRESH_R: (_T1, _T2, _CO2, _HUM, _FLOW, _DP),
     DeviceType.FORWARD: (_T1, _T2, _CO2, _HUM, _FLOW, _DP, _TEMP),
@@ -123,10 +131,17 @@ async def async_setup_entry(
             descriptions = SENSOR_TYPES.get(
                 device.device_type, SENSOR_TYPES[DeviceType.FRESH_R]
             )
+            device_info = DeviceInfo(
+                identifiers={(DOMAIN, device_id)},
+                name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
+                serial_number=device_id,
+                manufacturer="Fresh-r",
+            )
             entities.extend(
                 FreshrSensor(
                     config_entry.runtime_data.readings[device_id],
                     description,
+                    device_info,
                 )
                 for description in descriptions
             )
@@ -136,19 +151,22 @@ async def async_setup_entry(
     config_entry.async_on_unload(coordinator.async_add_listener(_check_devices))
 
 
-class FreshrSensor(FreshrEntity, SensorEntity):
+class FreshrSensor(CoordinatorEntity[FreshrReadingsCoordinator], SensorEntity):
     """Representation of a Fresh-r sensor."""
 
+    _attr_has_entity_name = True
     entity_description: FreshrSensorEntityDescription
 
     def __init__(
         self,
         coordinator: FreshrReadingsCoordinator,
         description: FreshrSensorEntityDescription,
+        device_info: DeviceInfo,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
         self.entity_description = description
+        self._attr_device_info = device_info
         self._attr_unique_id = f"{coordinator.device_id}_{description.key}"
 
     @property

homeassistant/components/gardena_bluetooth/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 
 from bleak.backends.device import BLEDevice
@@ -12,8 +13,7 @@ from gardena_bluetooth.exceptions import (
     CharacteristicNotFound,
     CommunicationFailure,
 )
-from gardena_bluetooth.parse import CharacteristicTime, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.parse import CharacteristicTime
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -29,6 +29,7 @@ from .coordinator import (
     GardenaBluetoothConfigEntry,
     GardenaBluetoothCoordinator,
 )
+from .util import async_get_product_type
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -75,10 +76,11 @@ async def async_setup_entry(
 
     address = entry.data[CONF_ADDRESS]
 
-    mfg_data = await async_get_manufacturer_data({address})
-    product_type = mfg_data[address].product_type
-    if product_type == ProductType.UNKNOWN:
-        raise ConfigEntryNotReady("Unable to find product type")
+    try:
+        async with asyncio.timeout(TIMEOUT):
+            product_type = await async_get_product_type(hass, address)
+    except TimeoutError as exception:
+        raise ConfigEntryNotReady("Unable to find product type") from exception
 
     client = Client(get_connection(hass, address), product_type)
     try:

homeassistant/components/gardena_bluetooth/config_flow.py

@@ -9,7 +9,6 @@ from gardena_bluetooth.client import Client
 from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
 from gardena_bluetooth.parse import ManufacturerData, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
 import voluptuous as vol
 
 from homeassistant.components.bluetooth import (
@@ -25,27 +24,41 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-_SUPPORTED_PRODUCT_TYPES = {
-    ProductType.PUMP,
-    ProductType.VALVE,
-    ProductType.WATER_COMPUTER,
-    ProductType.AUTOMATS,
-    ProductType.PRESSURE_TANKS,
-    ProductType.AQUA_CONTOURS,
-}
-
 
 def _is_supported(discovery_info: BluetoothServiceInfo):
     """Check if device is supported."""
     if ScanService not in discovery_info.service_uuids:
         return False
 
-    if discovery_info.manufacturer_data.get(ManufacturerData.company) is None:
+    if not (data := discovery_info.manufacturer_data.get(ManufacturerData.company)):
         _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
         return False
+
+    manufacturer_data = ManufacturerData.decode(data)
+    product_type = ProductType.from_manufacturer_data(manufacturer_data)
+
+    if product_type not in (
+        ProductType.PUMP,
+        ProductType.VALVE,
+        ProductType.WATER_COMPUTER,
+        ProductType.AUTOMATS,
+        ProductType.PRESSURE_TANKS,
+        ProductType.AQUA_CONTOURS,
+    ):
+        _LOGGER.debug("Unsupported device: %s", manufacturer_data)
+        return False
+
     return True
 
 
+def _get_name(discovery_info: BluetoothServiceInfo):
+    data = discovery_info.manufacturer_data[ManufacturerData.company]
+    manufacturer_data = ManufacturerData.decode(data)
+    product_type = ProductType.from_manufacturer_data(manufacturer_data)
+
+    return PRODUCT_NAMES.get(product_type, "Gardena Device")
+
+
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Gardena Bluetooth."""
 
@@ -77,13 +90,11 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the bluetooth discovery step."""
         _LOGGER.debug("Discovered device: %s", discovery_info)
-        data = await async_get_manufacturer_data({discovery_info.address})
-        product_type = data[discovery_info.address].product_type
-        if product_type not in _SUPPORTED_PRODUCT_TYPES:
+        if not _is_supported(discovery_info):
             return self.async_abort(reason="no_devices_found")
 
         self.address = discovery_info.address
-        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
+        self.devices = {discovery_info.address: _get_name(discovery_info)}
         await self.async_set_unique_id(self.address)
         self._abort_if_unique_id_configured()
         return await self.async_step_confirm()
@@ -120,21 +131,12 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             return await self.async_step_confirm()
 
         current_addresses = self._async_current_ids(include_ignore=False)
-        candidates = set()
         for discovery_info in async_discovered_service_info(self.hass):
             address = discovery_info.address
             if address in current_addresses or not _is_supported(discovery_info):
                 continue
-            candidates.add(address)
 
-        data = await async_get_manufacturer_data(candidates)
-        for address, mfg_data in data.items():
-            if mfg_data.product_type not in _SUPPORTED_PRODUCT_TYPES:
-                continue
-            self.devices[address] = PRODUCT_NAMES[mfg_data.product_type]
-
-        # Keep selection sorted by address to ensure stable tests
-        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
+            self.devices[address] = _get_name(discovery_info)
 
         if not self.devices:
             return self.async_abort(reason="no_devices_found")

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.4.0"]
+  "requirements": ["gardena-bluetooth==2.3.0"]
 }

homeassistant/components/gardena_bluetooth/util.py

@@ -0,0 +1,51 @@
+"""Utility functions for Gardena Bluetooth integration."""
+
+import asyncio
+from collections.abc import AsyncIterator
+
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+
+from homeassistant.components import bluetooth
+
+
+async def _async_service_info(
+    hass, address
+) -> AsyncIterator[bluetooth.BluetoothServiceInfoBleak]:
+    queue = asyncio.Queue[bluetooth.BluetoothServiceInfoBleak]()
+
+    def _callback(
+        service_info: bluetooth.BluetoothServiceInfoBleak,
+        change: bluetooth.BluetoothChange,
+    ) -> None:
+        if change != bluetooth.BluetoothChange.ADVERTISEMENT:
+            return
+
+        queue.put_nowait(service_info)
+
+    service_info = bluetooth.async_last_service_info(hass, address, True)
+    if service_info:
+        yield service_info
+
+    cancel = bluetooth.async_register_callback(
+        hass,
+        _callback,
+        {bluetooth.match.ADDRESS: address},
+        bluetooth.BluetoothScanningMode.ACTIVE,
+    )
+    try:
+        while True:
+            yield await queue.get()
+    finally:
+        cancel()
+
+
+async def async_get_product_type(hass, address: str) -> ProductType:
+    """Wait for enough packets of manufacturer data to get the product type."""
+    data = ManufacturerData()
+
+    async for service_info in _async_service_info(hass, address):
+        data.update(service_info.manufacturer_data.get(ManufacturerData.company, b""))
+        product_type = ProductType.from_manufacturer_data(data)
+        if product_type is not ProductType.UNKNOWN:
+            return product_type
+    raise AssertionError("Iterator should have been infinite")

homeassistant/components/generic/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/generic",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["av==16.0.1", "Pillow==12.2.0"]
+  "requirements": ["av==16.0.1", "Pillow==12.1.1"]
 }

homeassistant/components/go2rtc/__init__.py

@@ -175,7 +175,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             await server.start()
         except Exception:  # noqa: BLE001
             _LOGGER.warning("Could not start go2rtc server", exc_info=True)
-            await session.close()
             return False
 
         async def on_stop(event: Event) -> None:

homeassistant/components/hassio/__init__.py

@@ -91,14 +91,10 @@ from .const import (
     DATA_STORE,
     DATA_SUPERVISOR_INFO,
     DOMAIN,
-    HASSIO_MAIN_UPDATE_INTERVAL,
-    MAIN_COORDINATOR,
-    STATS_COORDINATOR,
+    HASSIO_UPDATE_INTERVAL,
 )
 from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
+    HassioDataUpdateCoordinator,
     get_addons_info,
     get_addons_list,
     get_addons_stats,
@@ -388,6 +384,12 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             ]
             hass.data[DATA_SUPERVISOR_INFO]["addons"] = hass.data[DATA_ADDONS_LIST]
 
+        async_call_later(
+            hass,
+            HASSIO_UPDATE_INTERVAL,
+            HassJob(update_info_data, cancel_on_shutdown=True),
+        )
+
     # Fetch data
     update_info_task = hass.async_create_task(update_info_data(), eager_start=True)
 
@@ -434,7 +436,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             # os info not yet fetched from supervisor, retry later
             async_call_later(
                 hass,
-                HASSIO_MAIN_UPDATE_INTERVAL,
+                HASSIO_UPDATE_INTERVAL,
                 async_setup_hardware_integration_job,
             )
             return
@@ -460,20 +462,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
     dev_reg = dr.async_get(hass)
-
-    coordinator = HassioMainDataUpdateCoordinator(hass, entry, dev_reg)
+    coordinator = HassioDataUpdateCoordinator(hass, entry, dev_reg)
     await coordinator.async_config_entry_first_refresh()
-    hass.data[MAIN_COORDINATOR] = coordinator
-
-    addon_coordinator = HassioAddOnDataUpdateCoordinator(
-        hass, entry, dev_reg, coordinator.jobs
-    )
-    await addon_coordinator.async_config_entry_first_refresh()
-    hass.data[ADDONS_COORDINATOR] = addon_coordinator
-
-    stats_coordinator = HassioStatsDataUpdateCoordinator(hass, entry)
-    await stats_coordinator.async_config_entry_first_refresh()
-    hass.data[STATS_COORDINATOR] = stats_coordinator
+    hass.data[ADDONS_COORDINATOR] = coordinator
 
     def deprecated_setup_issue() -> None:
         os_info = get_os_info(hass)
@@ -540,12 +531,10 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
     # Unload coordinator
-    coordinator: HassioMainDataUpdateCoordinator = hass.data[MAIN_COORDINATOR]
+    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
     coordinator.unload()
 
-    # Pop coordinators
-    hass.data.pop(MAIN_COORDINATOR, None)
+    # Pop coordinator
     hass.data.pop(ADDONS_COORDINATOR, None)
-    hass.data.pop(STATS_COORDINATOR, None)
 
     return unload_ok

homeassistant/components/hassio/binary_sensor.py

@@ -22,7 +22,6 @@ from .const import (
     ATTR_STATE,
     DATA_KEY_ADDONS,
     DATA_KEY_MOUNTS,
-    MAIN_COORDINATOR,
 )
 from .entity import HassioAddonEntity, HassioMountEntity
 
@@ -61,18 +60,17 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Binary sensor set up for Hass.io config entry."""
-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    coordinator = hass.data[MAIN_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]
 
     async_add_entities(
         itertools.chain(
             [
                 HassioAddonBinarySensor(
                     addon=addon,
-                    coordinator=addons_coordinator,
+                    coordinator=coordinator,
                     entity_description=entity_description,
                 )
-                for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
+                for addon in coordinator.data[DATA_KEY_ADDONS].values()
                 for entity_description in ADDON_ENTITY_DESCRIPTIONS
             ],
             [

homeassistant/components/hassio/const.py

@@ -77,9 +77,7 @@ EVENT_JOB = "job"
 UPDATE_KEY_SUPERVISOR = "supervisor"
 STARTUP_COMPLETE = "complete"
 
-MAIN_COORDINATOR = "hassio_main_coordinator"
 ADDONS_COORDINATOR = "hassio_addons_coordinator"
-STATS_COORDINATOR = "hassio_stats_coordinator"
 
 
 DATA_COMPONENT: HassKey[HassIO] = HassKey(DOMAIN)
@@ -96,9 +94,7 @@ DATA_SUPERVISOR_STATS = "hassio_supervisor_stats"
 DATA_ADDONS_INFO = "hassio_addons_info"
 DATA_ADDONS_STATS = "hassio_addons_stats"
 DATA_ADDONS_LIST = "hassio_addons_list"
-HASSIO_MAIN_UPDATE_INTERVAL = timedelta(minutes=5)
-HASSIO_ADDON_UPDATE_INTERVAL = timedelta(minutes=15)
-HASSIO_STATS_UPDATE_INTERVAL = timedelta(seconds=60)
+HASSIO_UPDATE_INTERVAL = timedelta(minutes=5)
 
 ATTR_AUTO_UPDATE = "auto_update"
 ATTR_VERSION = "version"

homeassistant/components/hassio/coordinator.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from collections.abc import Awaitable
 from copy import deepcopy
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
 from aiohasupervisor.models import (
@@ -15,9 +15,9 @@ from aiohasupervisor.models import (
     CIFSMountResponse,
     InstalledAddon,
     NFSMountResponse,
-    ResponseData,
     StoreInfo,
 )
+from aiohasupervisor.models.base import ResponseData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
@@ -35,11 +35,13 @@ from .const import (
     ATTR_SLUG,
     ATTR_URL,
     ATTR_VERSION,
+    CONTAINER_INFO,
     CONTAINER_STATS,
     CORE_CONTAINER,
     DATA_ADDONS_INFO,
     DATA_ADDONS_LIST,
     DATA_ADDONS_STATS,
+    DATA_COMPONENT,
     DATA_CORE_INFO,
     DATA_CORE_STATS,
     DATA_HOST_INFO,
@@ -57,9 +59,7 @@ from .const import (
     DATA_SUPERVISOR_INFO,
     DATA_SUPERVISOR_STATS,
     DOMAIN,
-    HASSIO_ADDON_UPDATE_INTERVAL,
-    HASSIO_MAIN_UPDATE_INTERVAL,
-    HASSIO_STATS_UPDATE_INTERVAL,
+    HASSIO_UPDATE_INTERVAL,
     REQUEST_REFRESH_DELAY,
     SUPERVISOR_CONTAINER,
     SupervisorEntityModel,
@@ -318,314 +318,7 @@ def async_remove_devices_from_dev_reg(
             dev_reg.async_remove_device(dev.id)
 
 
-class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Class to retrieve Hass.io container stats."""
-
-    config_entry: ConfigEntry
-
-    def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None:
-        """Initialize coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=HASSIO_STATS_UPDATE_INTERVAL,
-            request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
-            ),
-        )
-        self.supervisor_client = get_supervisor_client(hass)
-        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
-            lambda: defaultdict(set)
-        )
-
-    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
-
-        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."""
-        container_updates = self._container_updates
-        data = self.hass.data
-        client = self.supervisor_client
-
-        # Fetch core and supervisor stats
-        updates: dict[str, Awaitable] = {}
-        if container_updates.get(CORE_CONTAINER, {}).get(CONTAINER_STATS):
-            updates[DATA_CORE_STATS] = client.homeassistant.stats()
-        if container_updates.get(SUPERVISOR_CONTAINER, {}).get(CONTAINER_STATS):
-            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
-
-        if updates:
-            api_results: list[ResponseData] = await asyncio.gather(*updates.values())
-            for key, result in zip(updates, api_results, strict=True):
-                data[key] = result.to_dict()
-
-        # Fetch addon stats
-        addons_list = get_addons_list(self.hass) or []
-        started_addons = {
-            addon[ATTR_SLUG]
-            for addon in addons_list
-            if addon.get("state") in {AddonState.STARTED, AddonState.STARTUP}
-        }
-
-        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:
-            del addons_stats[slug]
-
-        # Fetch stats for addons with subscribed entities
-        addon_stats_results = dict(
-            await asyncio.gather(
-                *[
-                    self._update_addon_stats(slug)
-                    for slug in started_addons
-                    if container_updates.get(slug, {}).get(CONTAINER_STATS)
-                ]
-            )
-        )
-        addons_stats.update(addon_stats_results)
-
-    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.to_dict())
-
-    @callback
-    def async_enable_container_updates(
-        self, slug: str, entity_id: str, types: set[str]
-    ) -> CALLBACK_TYPE:
-        """Enable stats updates for a container."""
-        enabled_updates = self._container_updates[slug]
-        for key in types:
-            enabled_updates[key].add(entity_id)
-
-        @callback
-        def _remove() -> None:
-            for key in types:
-                enabled_updates[key].discard(entity_id)
-                if not enabled_updates[key]:
-                    del enabled_updates[key]
-            if not enabled_updates:
-                self._container_updates.pop(slug, None)
-
-        return _remove
-
-
-class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Class to retrieve Hass.io Add-on status."""
-
-    config_entry: ConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        dev_reg: dr.DeviceRegistry,
-        jobs: SupervisorJobs,
-    ) -> None:
-        """Initialize coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=HASSIO_ADDON_UPDATE_INTERVAL,
-            # We don't want an immediate refresh since we want to avoid
-            # hammering the Supervisor API on startup
-            request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
-            ),
-        )
-        self.entry_id = config_entry.entry_id
-        self.dev_reg = dev_reg
-        self._addon_info_subscriptions: defaultdict[str, set[str]] = defaultdict(set)
-        self.supervisor_client = get_supervisor_client(hass)
-        self.jobs = jobs
-
-    async def _async_update_data(self) -> dict[str, Any]:
-        """Update data via library."""
-        is_first_update = not self.data
-        client = self.supervisor_client
-
-        try:
-            installed_addons: list[InstalledAddon] = await client.addons.list()
-            all_addons = {addon.slug for addon in installed_addons}
-
-            # Fetch addon info for all addons on first update, or only
-            # for addons with subscribed entities on subsequent updates.
-            addon_info_results = dict(
-                await asyncio.gather(
-                    *[
-                        self._update_addon_info(slug)
-                        for slug in all_addons
-                        if is_first_update or self._addon_info_subscriptions.get(slug)
-                    ]
-                )
-            )
-        except SupervisorError as err:
-            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
-
-        # Update hass.data for legacy accessor functions
-        data = self.hass.data
-        addons_list_dicts = [addon.to_dict() for addon in installed_addons]
-        data[DATA_ADDONS_LIST] = addons_list_dicts
-
-        # Update addon info cache in hass.data
-        addon_info_cache: dict[str, Any] = 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)
-
-        # Deprecated 2026.4.0: Folding addons.list results into supervisor_info
-        # for compatibility. Written to hass.data only, not coordinator data.
-        if DATA_SUPERVISOR_INFO in data:
-            data[DATA_SUPERVISOR_INFO]["addons"] = addons_list_dicts
-
-        # Build clean coordinator data
-        store_data = get_store(self.hass)
-        if store_data:
-            repositories = {
-                repo.slug: repo.name
-                for repo in StoreInfo.from_dict(store_data).repositories
-            }
-        else:
-            repositories = {}
-
-        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, new_data[DATA_KEY_ADDONS].values()
-            )
-
-        # Remove add-ons that are no longer installed from device registry
-        supervisor_addon_devices = {
-            list(device.identifiers)[0][1]
-            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
-                self.entry_id
-            )
-            if device.model == SupervisorEntityModel.ADDON
-        }
-        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 an empty dict because
-        # coordinator will be recreated.
-        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
-
-    async def get_changelog(self, addon_slug: str) -> str | None:
-        """Get the changelog for an add-on."""
-        try:
-            return await self.supervisor_client.store.addon_changelog(addon_slug)
-        except SupervisorNotFoundError:
-            return 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)
-        # 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(
-        self, slug: str, entity_id: str
-    ) -> CALLBACK_TYPE:
-        """Enable info updates for an add-on."""
-        self._addon_info_subscriptions[slug].add(entity_id)
-
-        @callback
-        def _remove() -> None:
-            self._addon_info_subscriptions[slug].discard(entity_id)
-            if not self._addon_info_subscriptions[slug]:
-                del self._addon_info_subscriptions[slug]
-
-        return _remove
-
-    async def _async_refresh(
-        self,
-        log_failures: bool = True,
-        raise_on_auth_failed: bool = False,
-        scheduled: bool = False,
-        raise_on_entry_error: bool = False,
-    ) -> None:
-        """Refresh data."""
-        if not scheduled and not raise_on_auth_failed:
-            # Force reloading add-on updates for non-scheduled
-            # updates.
-            #
-            # If `raise_on_auth_failed` is set, it means this is
-            # the first refresh and we do not want to delay
-            # startup or cause a timeout so we only refresh the
-            # updates if this is not a scheduled refresh and
-            # we are not doing the first refresh.
-            try:
-                await self.supervisor_client.store.reload()
-            except SupervisorError as err:
-                _LOGGER.warning("Error on Supervisor API: %s", err)
-
-        await super()._async_refresh(
-            log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
-        )
-
-    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
-        """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)
-
-
-class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+class HassioDataUpdateCoordinator(DataUpdateCoordinator):
     """Class to retrieve Hass.io status."""
 
     config_entry: ConfigEntry
@@ -639,77 +332,82 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             _LOGGER,
             config_entry=config_entry,
             name=DOMAIN,
-            update_interval=HASSIO_MAIN_UPDATE_INTERVAL,
+            update_interval=HASSIO_UPDATE_INTERVAL,
             # We don't want an immediate refresh since we want to avoid
-            # hammering the Supervisor API on startup
+            # fetching the container stats right away and avoid hammering
+            # the Supervisor API on startup
             request_refresh_debouncer=Debouncer(
                 hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
             ),
         )
+        self.hassio = hass.data[DATA_COMPONENT]
+        self.data = {}
         self.entry_id = config_entry.entry_id
         self.dev_reg = dev_reg
         self.is_hass_os = (get_info(self.hass) or {}).get("hassos") is not None
+        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
+            lambda: defaultdict(set)
+        )
         self.supervisor_client = get_supervisor_client(hass)
         self.jobs = SupervisorJobs(hass)
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
         is_first_update = not self.data
-        client = self.supervisor_client
 
         try:
-            (
-                info,
-                core_info,
-                supervisor_info,
-                os_info,
-                host_info,
-                store_info,
-                network_info,
-            ) = await asyncio.gather(
-                client.info(),
-                client.homeassistant.info(),
-                client.supervisor.info(),
-                client.os.info(),
-                client.host.info(),
-                client.store.info(),
-                client.network.info(),
-            )
-            mounts_info = await client.mounts.info()
-            await self.jobs.refresh_data(is_first_update)
+            await self.force_data_refresh(is_first_update)
         except SupervisorError as err:
             raise UpdateFailed(f"Error on Supervisor API: {err}") from err
 
-        # Build clean coordinator data
         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}
+        supervisor_info = get_supervisor_info(self.hass) or {}
+        addons_info = get_addons_info(self.hass) or {}
+        addons_stats = get_addons_stats(self.hass)
+        store_data = get_store(self.hass)
+        mounts_info = await self.supervisor_client.mounts.info()
+        addons_list = get_addons_list(self.hass) or []
+
+        if store_data:
+            repositories = {
+                repo.slug: repo.name
+                for repo in StoreInfo.from_dict(store_data).repositories
+            }
+        else:
+            repositories = {}
+
+        new_data[DATA_KEY_ADDONS] = {
+            (slug := addon[ATTR_SLUG]): {
+                **addon,
+                **(addons_stats.get(slug) or {}),
+                ATTR_AUTO_UPDATE: (addons_info.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
+        }
         if self.is_hass_os:
-            new_data[DATA_KEY_OS] = os_info.to_dict()
+            new_data[DATA_KEY_OS] = get_os_info(self.hass)
 
-        # Update hass.data for legacy accessor functions
-        data = self.hass.data
-        data[DATA_INFO] = info.to_dict()
-        data[DATA_CORE_INFO] = new_data[DATA_KEY_CORE]
-        data[DATA_OS_INFO] = new_data.get(DATA_KEY_OS, os_info.to_dict())
-        data[DATA_HOST_INFO] = new_data[DATA_KEY_HOST]
-        data[DATA_STORE] = store_info.to_dict()
-        data[DATA_NETWORK_INFO] = network_info.to_dict()
-        # Separate dict for hass.data supervisor info since we add deprecated
-        # compat keys that should not be in coordinator data
-        supervisor_info_dict = supervisor_info.to_dict()
-        # Deprecated 2026.4.0: Folding repositories and addons into
-        # supervisor_info for compatibility. Written to hass.data only, not
-        # coordinator data. Preserve the addons key from the addon coordinator.
-        supervisor_info_dict["repositories"] = data[DATA_STORE][ATTR_REPOSITORIES]
-        if (prev := data.get(DATA_SUPERVISOR_INFO)) and "addons" in prev:
-            supervisor_info_dict["addons"] = prev["addons"]
-        data[DATA_SUPERVISOR_INFO] = supervisor_info_dict
+        new_data[DATA_KEY_CORE] = {
+            **(get_core_info(self.hass) or {}),
+            **get_core_stats(self.hass),
+        }
+        new_data[DATA_KEY_SUPERVISOR] = {
+            **supervisor_info,
+            **get_supervisor_stats(self.hass),
+        }
+        new_data[DATA_KEY_HOST] = get_host_info(self.hass) or {}
+        new_data[DATA_KEY_MOUNTS] = {mount.name: mount for mount in mounts_info.mounts}
 
-        # If this is the initial refresh, register all main components
+        # If this is the initial refresh, register all addons and return the dict
         if is_first_update:
+            async_register_addons_in_dev_reg(
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
+            )
             async_register_mounts_in_dev_reg(
                 self.entry_id, self.dev_reg, new_data[DATA_KEY_MOUNTS].values()
             )
@@ -725,6 +423,17 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                     self.entry_id, self.dev_reg, new_data[DATA_KEY_OS]
                 )
 
+        # Remove add-ons that are no longer installed from device registry
+        supervisor_addon_devices = {
+            list(device.identifiers)[0][1]
+            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
+                self.entry_id
+            )
+            if device.model == SupervisorEntityModel.ADDON
+        }
+        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
+            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
+
         # Remove mounts that no longer exists from device registry
         supervisor_mount_devices = {
             device.name
@@ -744,11 +453,12 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             # Remove the OS device if it exists and the installation is not hassos
             self.dev_reg.async_remove_device(dev.id)
 
-        # If there are new mounts, we should reload the config entry so we can
+        # If there are new add-ons or mounts, we should reload the config entry so we can
         # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
         if self.data and (
-            set(new_data[DATA_KEY_MOUNTS]) - set(self.data.get(DATA_KEY_MOUNTS, {}))
+            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
+            or set(new_data[DATA_KEY_MOUNTS]) - set(self.data[DATA_KEY_MOUNTS])
         ):
             self.hass.async_create_task(
                 self.hass.config_entries.async_reload(self.entry_id)
@@ -757,6 +467,146 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         return new_data
 
+    async def get_changelog(self, addon_slug: str) -> str | None:
+        """Get the changelog for an add-on."""
+        try:
+            return await self.supervisor_client.store.addon_changelog(addon_slug)
+        except SupervisorNotFoundError:
+            return None
+
+    async def force_data_refresh(self, first_update: bool) -> None:
+        """Force update of the addon info."""
+        container_updates = self._container_updates
+
+        data = self.hass.data
+        client = self.supervisor_client
+
+        updates: dict[str, Awaitable[ResponseData]] = {
+            DATA_INFO: client.info(),
+            DATA_CORE_INFO: client.homeassistant.info(),
+            DATA_SUPERVISOR_INFO: client.supervisor.info(),
+            DATA_OS_INFO: client.os.info(),
+            DATA_STORE: client.store.info(),
+        }
+        if CONTAINER_STATS in container_updates[CORE_CONTAINER]:
+            updates[DATA_CORE_STATS] = client.homeassistant.stats()
+        if CONTAINER_STATS in container_updates[SUPERVISOR_CONTAINER]:
+            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
+
+        # Pull off addons.list results for further processing before caching
+        addons_list, *results = await asyncio.gather(
+            client.addons.list(), *updates.values()
+        )
+        for key, result in zip(updates, cast(list[ResponseData], results), strict=True):
+            data[key] = result.to_dict()
+
+        installed_addons = cast(list[InstalledAddon], addons_list)
+        data[DATA_ADDONS_LIST] = [addon.to_dict() for addon in installed_addons]
+
+        # Deprecated 2026.4.0: Folding repositories and addons.list results into supervisor_info for compatibility
+        # Can drop this after removal period
+        data[DATA_SUPERVISOR_INFO].update(
+            {
+                "repositories": data[DATA_STORE][ATTR_REPOSITORIES],
+                "addons": [addon.to_dict() for addon in installed_addons],
+            }
+        )
+
+        all_addons = {addon.slug for addon in installed_addons}
+        started_addons = {
+            addon.slug
+            for addon in installed_addons
+            if addon.state in {AddonState.STARTED, AddonState.STARTUP}
+        }
+
+        #
+        # Update addon info if its the first update or
+        # there is at least one entity that needs the data.
+        #
+        # When entities are added they call async_enable_container_updates
+        # to enable updates for the endpoints they need via
+        # async_added_to_hass. This ensures that we only update
+        # the data for the endpoints that are needed to avoid unnecessary
+        # API calls since otherwise we would fetch stats for all containers
+        # and throw them away.
+        #
+        for data_key, update_func, enabled_key, wanted_addons, needs_first_update in (
+            (
+                DATA_ADDONS_STATS,
+                self._update_addon_stats,
+                CONTAINER_STATS,
+                started_addons,
+                False,
+            ),
+            (
+                DATA_ADDONS_INFO,
+                self._update_addon_info,
+                CONTAINER_INFO,
+                all_addons,
+                True,
+            ),
+        ):
+            container_data: dict[str, Any] = data.setdefault(data_key, {})
+
+            # Clean up cache
+            for slug in container_data.keys() - wanted_addons:
+                del container_data[slug]
+
+            # Update cache from API
+            container_data.update(
+                dict(
+                    await asyncio.gather(
+                        *[
+                            update_func(slug)
+                            for slug in wanted_addons
+                            if (first_update and needs_first_update)
+                            or enabled_key in container_updates[slug]
+                        ]
+                    )
+                )
+            )
+
+        # Refresh jobs data
+        await self.jobs.refresh_data(first_update)
+
+    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.to_dict())
+
+    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)
+        # 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_container_updates(
+        self, slug: str, entity_id: str, types: set[str]
+    ) -> CALLBACK_TYPE:
+        """Enable updates for an add-on."""
+        enabled_updates = self._container_updates[slug]
+        for key in types:
+            enabled_updates[key].add(entity_id)
+
+        @callback
+        def _remove() -> None:
+            for key in types:
+                enabled_updates[key].remove(entity_id)
+
+        return _remove
+
     async def _async_refresh(
         self,
         log_failures: bool = True,
@@ -766,16 +616,14 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     ) -> None:
         """Refresh data."""
         if not scheduled and not raise_on_auth_failed:
-            # Force reloading updates of main components for
-            # non-scheduled updates.
-            #
+            # Force refreshing updates for non-scheduled updates
             # If `raise_on_auth_failed` is set, it means this is
             # the first refresh and we do not want to delay
             # startup or cause a timeout so we only refresh the
             # updates if this is not a scheduled refresh and
             # we are not doing the first refresh.
             try:
-                await self.supervisor_client.reload_updates()
+                await self.supervisor_client.refresh_updates()
             except SupervisorError as err:
                 _LOGGER.warning("Error on Supervisor API: %s", err)
 
@@ -783,6 +631,18 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
         )
 
+    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
+        """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)
+
     @callback
     def unload(self) -> None:
         """Clean up when config entry unloaded."""

homeassistant/components/hassio/diagnostics.py

@@ -11,12 +11,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
-from .const import ADDONS_COORDINATOR, MAIN_COORDINATOR, STATS_COORDINATOR
-from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
-)
+from .const import ADDONS_COORDINATOR
+from .coordinator import HassioDataUpdateCoordinator
 
 
 async def async_get_config_entry_diagnostics(
@@ -24,9 +20,7 @@ async def async_get_config_entry_diagnostics(
     config_entry: ConfigEntry,
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
-    coordinator: HassioMainDataUpdateCoordinator = hass.data[MAIN_COORDINATOR]
-    addons_coordinator: HassioAddOnDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
-    stats_coordinator: HassioStatsDataUpdateCoordinator = hass.data[STATS_COORDINATOR]
+    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
     device_registry = dr.async_get(hass)
     entity_registry = er.async_get(hass)
 
@@ -59,7 +53,5 @@ async def async_get_config_entry_diagnostics(
 
     return {
         "coordinator_data": coordinator.data,
-        "addons_coordinator_data": addons_coordinator.data,
-        "stats_coordinator_data": stats_coordinator.data,
         "devices": devices,
     }

homeassistant/components/hassio/entity.py

@@ -13,6 +13,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from .const import (
     ATTR_SLUG,
     CONTAINER_STATS,
+    CORE_CONTAINER,
     DATA_KEY_ADDONS,
     DATA_KEY_CORE,
     DATA_KEY_HOST,
@@ -20,79 +21,20 @@ from .const import (
     DATA_KEY_OS,
     DATA_KEY_SUPERVISOR,
     DOMAIN,
+    KEY_TO_UPDATE_TYPES,
+    SUPERVISOR_CONTAINER,
 )
-from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
-)
+from .coordinator import HassioDataUpdateCoordinator
 
 
-class HassioStatsEntity(CoordinatorEntity[HassioStatsDataUpdateCoordinator]):
-    """Base entity for container stats (CPU, memory)."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: HassioStatsDataUpdateCoordinator,
-        entity_description: EntityDescription,
-        *,
-        container_id: str,
-        data_key: str,
-        device_id: str,
-        unique_id_prefix: str,
-    ) -> None:
-        """Initialize base entity."""
-        super().__init__(coordinator)
-        self.entity_description = entity_description
-        self._container_id = container_id
-        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 available(self) -> bool:
-        """Return True if entity is available."""
-        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."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self.coordinator.async_enable_container_updates(
-                self._container_id, self.entity_id, {CONTAINER_STATS}
-            )
-        )
-        # Stats are only fetched for containers with subscribed entities.
-        # The first coordinator refresh (before entities exist) has no
-        # subscribers, so no stats are fetched. Schedule a debounced
-        # refresh so that all stats entities registering during platform
-        # setup are batched into a single API call.
-        await self.coordinator.async_request_refresh()
-
-
-class HassioAddonEntity(CoordinatorEntity[HassioAddOnDataUpdateCoordinator]):
+class HassioAddonEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base entity for a Hass.io add-on."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioAddOnDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
         addon: dict[str, Any],
     ) -> None:
@@ -114,23 +56,26 @@ class HassioAddonEntity(CoordinatorEntity[HassioAddOnDataUpdateCoordinator]):
         )
 
     async def async_added_to_hass(self) -> None:
-        """Subscribe to addon info updates."""
+        """Subscribe to updates."""
         await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
         self.async_on_remove(
-            self.coordinator.async_enable_addon_info_updates(
-                self._addon_slug, self.entity_id
+            self.coordinator.async_enable_container_updates(
+                self._addon_slug, self.entity_id, update_types
             )
         )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()
 
 
-class HassioOSEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioOSEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base Entity for Hass.io OS."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
     ) -> None:
         """Initialize base entity."""
@@ -149,14 +94,14 @@ class HassioOSEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
         )
 
 
-class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioHostEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base Entity for Hass.io host."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
     ) -> None:
         """Initialize base entity."""
@@ -175,14 +120,14 @@ class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
         )
 
 
-class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioSupervisorEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base Entity for Supervisor."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
     ) -> None:
         """Initialize base entity."""
@@ -201,15 +146,27 @@ class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator])
             in self.coordinator.data[DATA_KEY_SUPERVISOR]
         )
 
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to updates."""
+        await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
+        self.async_on_remove(
+            self.coordinator.async_enable_container_updates(
+                SUPERVISOR_CONTAINER, self.entity_id, update_types
+            )
+        )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()
 
-class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+
+class HassioCoreEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base Entity for Core."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
     ) -> None:
         """Initialize base entity."""
@@ -227,15 +184,27 @@ class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
             and self.entity_description.key in self.coordinator.data[DATA_KEY_CORE]
         )
 
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to updates."""
+        await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
+        self.async_on_remove(
+            self.coordinator.async_enable_container_updates(
+                CORE_CONTAINER, self.entity_id, update_types
+            )
+        )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()
 
-class HassioMountEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+
+class HassioMountEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
     """Base Entity for Mount."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
         entity_description: EntityDescription,
         mount: CIFSMountResponse | NFSMountResponse,
     ) -> None:

homeassistant/components/hassio/issues.py

@@ -28,6 +28,7 @@ from homeassistant.helpers.issue_registry import (
 )
 
 from .const import (
+    ADDONS_COORDINATOR,
     ATTR_DATA,
     ATTR_HEALTHY,
     ATTR_SLUG,
@@ -53,7 +54,6 @@ from .const import (
     ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_MOUNT_MOUNT_FAILED,
-    MAIN_COORDINATOR,
     PLACEHOLDER_KEY_ADDON,
     PLACEHOLDER_KEY_ADDON_URL,
     PLACEHOLDER_KEY_FREE_SPACE,
@@ -62,7 +62,7 @@ from .const import (
     STARTUP_COMPLETE,
     UPDATE_KEY_SUPERVISOR,
 )
-from .coordinator import HassioMainDataUpdateCoordinator, get_addons_list, get_host_info
+from .coordinator import HassioDataUpdateCoordinator, get_addons_list, get_host_info
 from .handler import get_supervisor_client
 
 ISSUE_KEY_UNHEALTHY = "unhealthy"
@@ -417,8 +417,8 @@ class SupervisorIssues:
 
     def _async_coordinator_refresh(self) -> None:
         """Refresh coordinator to update latest data in entities."""
-        coordinator: HassioMainDataUpdateCoordinator | None
-        if coordinator := self._hass.data.get(MAIN_COORDINATOR):
+        coordinator: HassioDataUpdateCoordinator | None
+        if coordinator := self._hass.data.get(ADDONS_COORDINATOR):
             coordinator.config_entry.async_create_task(
                 self._hass, coordinator.async_refresh()
             )

homeassistant/components/hassio/sensor.py

@@ -17,24 +17,20 @@ 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 .entity import (
     HassioAddonEntity,
+    HassioCoreEntity,
     HassioHostEntity,
     HassioOSEntity,
-    HassioStatsEntity,
+    HassioSupervisorEntity,
 )
 
 COMMON_ENTITY_DESCRIPTIONS = (
@@ -67,7 +63,10 @@ STATS_ENTITY_DESCRIPTIONS = (
     ),
 )
 
+ADDON_ENTITY_DESCRIPTIONS = COMMON_ENTITY_DESCRIPTIONS + STATS_ENTITY_DESCRIPTIONS
+CORE_ENTITY_DESCRIPTIONS = STATS_ENTITY_DESCRIPTIONS
 OS_ENTITY_DESCRIPTIONS = COMMON_ENTITY_DESCRIPTIONS
+SUPERVISOR_ENTITY_DESCRIPTIONS = STATS_ENTITY_DESCRIPTIONS
 
 HOST_ENTITY_DESCRIPTIONS = (
     SensorEntityDescription(
@@ -115,64 +114,36 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Sensor set up for Hass.io config entry."""
-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    coordinator = hass.data[MAIN_COORDINATOR]
-    stats_coordinator = hass.data[STATS_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]
 
-    entities: list[SensorEntity] = []
-
-    # Add-on non-stats sensors (version, version_latest)
-    entities.extend(
+    entities: list[
+        HassioOSSensor | HassioAddonSensor | CoreSensor | SupervisorSensor | HostSensor
+    ] = [
         HassioAddonSensor(
             addon=addon,
-            coordinator=addons_coordinator,
+            coordinator=coordinator,
             entity_description=entity_description,
         )
-        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
-        for entity_description in COMMON_ENTITY_DESCRIPTIONS
-    )
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
+        for entity_description in ADDON_ENTITY_DESCRIPTIONS
+    ]
 
-    # Add-on stats sensors (cpu_percent, memory_percent)
     entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
+        CoreSensor(
+            coordinator=coordinator,
             entity_description=entity_description,
-            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[DATA_KEY_ADDONS].values()
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
+        for entity_description in CORE_ENTITY_DESCRIPTIONS
     )
 
-    # Core stats sensors
     entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
+        SupervisorSensor(
+            coordinator=coordinator,
             entity_description=entity_description,
-            container_id=CORE_CONTAINER,
-            data_key=DATA_KEY_CORE,
-            device_id="core",
-            unique_id_prefix="home_assistant_core",
         )
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
+        for entity_description in SUPERVISOR_ENTITY_DESCRIPTIONS
     )
 
-    # Supervisor stats sensors
-    entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
-            entity_description=entity_description,
-            container_id=SUPERVISOR_CONTAINER,
-            data_key=DATA_KEY_SUPERVISOR,
-            device_id="supervisor",
-            unique_id_prefix="home_assistant_supervisor",
-        )
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
-    )
-
-    # Host sensors
     entities.extend(
         HostSensor(
             coordinator=coordinator,
@@ -181,7 +152,6 @@ async def async_setup_entry(
         for entity_description in HOST_ENTITY_DESCRIPTIONS
     )
 
-    # OS sensors
     if coordinator.is_hass_os:
         entities.extend(
             HassioOSSensor(
@@ -205,21 +175,8 @@ class HassioAddonSensor(HassioAddonEntity, SensorEntity):
         ]
 
 
-class HassioStatsSensor(HassioStatsEntity, SensorEntity):
-    """Sensor to track container stats."""
-
-    @property
-    def native_value(self) -> str:
-        """Return native value of entity."""
-        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."""
+    """Sensor to track a Hass.io add-on attribute."""
 
     @property
     def native_value(self) -> str:
@@ -227,6 +184,24 @@ class HassioOSSensor(HassioOSEntity, SensorEntity):
         return self.coordinator.data[DATA_KEY_OS][self.entity_description.key]
 
 
+class CoreSensor(HassioCoreEntity, SensorEntity):
+    """Sensor to track a core attribute."""
+
+    @property
+    def native_value(self) -> str:
+        """Return native value of entity."""
+        return self.coordinator.data[DATA_KEY_CORE][self.entity_description.key]
+
+
+class SupervisorSensor(HassioSupervisorEntity, SensorEntity):
+    """Sensor to track a supervisor attribute."""
+
+    @property
+    def native_value(self) -> str:
+        """Return native value of entity."""
+        return self.coordinator.data[DATA_KEY_SUPERVISOR][self.entity_description.key]
+
+
 class HostSensor(HassioHostEntity, SensorEntity):
     """Sensor to track a host attribute."""
 

homeassistant/components/hassio/services.py

@@ -32,6 +32,7 @@ from homeassistant.helpers import (
 from homeassistant.util.dt import now
 
 from .const import (
+    ADDONS_COORDINATOR,
     ATTR_ADDON,
     ATTR_ADDONS,
     ATTR_APP,
@@ -45,10 +46,9 @@ from .const import (
     ATTR_PASSWORD,
     ATTR_SLUG,
     DOMAIN,
-    MAIN_COORDINATOR,
     SupervisorEntityModel,
 )
-from .coordinator import HassioMainDataUpdateCoordinator, get_addons_info
+from .coordinator import HassioDataUpdateCoordinator, get_addons_info
 
 SERVICE_ADDON_START = "addon_start"
 SERVICE_ADDON_STOP = "addon_stop"
@@ -406,7 +406,7 @@ def async_register_network_storage_services(
 
     async def async_mount_reload(service: ServiceCall) -> None:
         """Handle service calls for Hass.io."""
-        coordinator: HassioMainDataUpdateCoordinator | None = None
+        coordinator: HassioDataUpdateCoordinator | None = None
 
         if (device := dev_reg.async_get(service.data[ATTR_DEVICE_ID])) is None:
             raise ServiceValidationError(
@@ -417,7 +417,7 @@ def async_register_network_storage_services(
         if (
             device.name is None
             or device.model != SupervisorEntityModel.MOUNT
-            or (coordinator := hass.data.get(MAIN_COORDINATOR)) is None
+            or (coordinator := hass.data.get(ADDONS_COORDINATOR)) is None
             or coordinator.entry_id not in device.config_entries
         ):
             raise ServiceValidationError(

homeassistant/components/hassio/update.py

@@ -29,7 +29,6 @@ from .const import (
     DATA_KEY_CORE,
     DATA_KEY_OS,
     DATA_KEY_SUPERVISOR,
-    MAIN_COORDINATOR,
 )
 from .entity import (
     HassioAddonEntity,
@@ -52,9 +51,9 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Supervisor update based on a config entry."""
-    coordinator = hass.data[MAIN_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]
 
-    entities: list[UpdateEntity] = [
+    entities = [
         SupervisorSupervisorUpdateEntity(
             coordinator=coordinator,
             entity_description=ENTITY_DESCRIPTION,
@@ -65,6 +64,15 @@ async def async_setup_entry(
         ),
     ]
 
+    entities.extend(
+        SupervisorAddonUpdateEntity(
+            addon=addon,
+            coordinator=coordinator,
+            entity_description=ENTITY_DESCRIPTION,
+        )
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
+    )
+
     if coordinator.is_hass_os:
         entities.append(
             SupervisorOSUpdateEntity(
@@ -73,16 +81,6 @@ async def async_setup_entry(
             )
         )
 
-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    entities.extend(
-        SupervisorAddonUpdateEntity(
-            addon=addon,
-            coordinator=addons_coordinator,
-            entity_description=ENTITY_DESCRIPTION,
-        )
-        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
-    )
-
     async_add_entities(entities)
 
 

homeassistant/components/homeassistant_hardware/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
   "requirements": [
-    "serialx==1.2.2",
+    "serialx==1.1.1",
     "universal-silabs-flasher==1.0.3",
     "ha-silabs-firmware-client==0.3.0"
   ]

homeassistant/components/homekit/util.py

@@ -625,13 +625,10 @@ def _get_test_socket() -> socket.socket:
 @callback
 def async_port_is_available(port: int) -> bool:
     """Check to see if a port is available."""
-    test_socket = _get_test_socket()
     try:
-        test_socket.bind(("", port))
+        _get_test_socket().bind(("", port))
     except OSError:
         return False
-    finally:
-        test_socket.close()
     return True
 
 

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.4.0"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.3.0"]
 }

homeassistant/components/iaqualink/binary_sensor.py

@@ -42,6 +42,7 @@ class HassAqualinkBinarySensor(
     ) -> None:
         """Initialize AquaLink binary sensor."""
         super().__init__(coordinator, dev)
+        self._attr_name = dev.label
         if dev.label == "Freeze Protection":
             self._attr_device_class = BinarySensorDeviceClass.COLD
 

homeassistant/components/iaqualink/climate.py

@@ -57,6 +57,7 @@ class HassAqualinkThermostat(AqualinkEntity[AqualinkThermostat], ClimateEntity):
     ) -> None:
         """Initialize AquaLink thermostat."""
         super().__init__(coordinator, dev)
+        self._attr_name = dev.label.split(" ")[0]
         self._attr_temperature_unit = (
             UnitOfTemperature.FAHRENHEIT
             if dev.unit == "F"

homeassistant/components/iaqualink/entity.py

@@ -22,9 +22,6 @@ class AqualinkEntity[AqualinkDeviceT: AqualinkDevice](
     entity update flow.
     """
 
-    _attr_has_entity_name = True
-    _attr_name = None
-
     def __init__(
         self, coordinator: AqualinkDataUpdateCoordinator, dev: AqualinkDeviceT
     ) -> None:

homeassistant/components/iaqualink/light.py

@@ -46,6 +46,7 @@ class HassAqualinkLight(AqualinkEntity[AqualinkLight], LightEntity):
     ) -> None:
         """Initialize AquaLink light."""
         super().__init__(coordinator, dev)
+        self._attr_name = dev.label
         if dev.supports_effect:
             self._attr_effect_list = list(dev.supported_effects)
             self._attr_supported_features = LightEntityFeature.EFFECT

homeassistant/components/iaqualink/sensor.py

@@ -38,6 +38,7 @@ class HassAqualinkSensor(AqualinkEntity[AqualinkSensor], SensorEntity):
     ) -> None:
         """Initialize AquaLink sensor."""
         super().__init__(coordinator, dev)
+        self._attr_name = dev.label
         if not dev.name.endswith("_temp"):
             return
         self._attr_device_class = SensorDeviceClass.TEMPERATURE

homeassistant/components/iaqualink/switch.py

@@ -40,7 +40,7 @@ class HassAqualinkSwitch(AqualinkEntity[AqualinkSwitch], SwitchEntity):
     ) -> None:
         """Initialize AquaLink switch."""
         super().__init__(coordinator, dev)
-        name = dev.label
+        name = self._attr_name = dev.label
         if name == "Cleaner":
             self._attr_icon = "mdi:robot-vacuum"
         elif name == "Waterfall" or name.endswith("Dscnt"):

homeassistant/components/image_upload/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/image_upload",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["Pillow==12.2.0"]
+  "requirements": ["Pillow==12.1.1"]
 }

homeassistant/components/lutron/__init__.py

@@ -92,15 +92,83 @@ async def async_setup_entry(
     for area in lutron_client.areas:
         _LOGGER.debug("Working on area %s", area.name)
         for output in area.outputs:
-            _setup_output(
-                hass, entry_data, output, area.name, entity_registry, device_registry
+            platform = None
+            _LOGGER.debug("Working on output %s", output.type)
+            if output.type == "SYSTEM_SHADE":
+                entry_data.covers.append((area.name, output))
+                platform = Platform.COVER
+            elif output.type == "CEILING_FAN_TYPE":
+                entry_data.fans.append((area.name, output))
+                platform = Platform.FAN
+            elif output.is_dimmable:
+                entry_data.lights.append((area.name, output))
+                platform = Platform.LIGHT
+            else:
+                entry_data.switches.append((area.name, output))
+                platform = Platform.SWITCH
+
+            _async_check_entity_unique_id(
+                hass,
+                entity_registry,
+                platform,
+                output.uuid,
+                output.legacy_uuid,
+                entry_data.client.guid,
+            )
+            _async_check_device_identifiers(
+                hass,
+                device_registry,
+                output.uuid,
+                output.legacy_uuid,
+                entry_data.client.guid,
             )
 
         for keypad in area.keypads:
-            _setup_keypad(
-                hass, entry_data, keypad, area.name, entity_registry, device_registry
+            _async_check_keypad_identifiers(
+                hass,
+                device_registry,
+                keypad.id,
+                keypad.uuid,
+                keypad.legacy_uuid,
+                entry_data.client.guid,
             )
+            for button in keypad.buttons:
+                # If the button has a function assigned to it, add it as a scene
+                if button.name != "Unknown Button" and button.button_type in (
+                    "SingleAction",
+                    "Toggle",
+                    "SingleSceneRaiseLower",
+                    "MasterRaiseLower",
+                    "AdvancedToggle",
+                ):
+                    # Associate an LED with a button if there is one
+                    led = next(
+                        (led for led in keypad.leds if led.number == button.number),
+                        None,
+                    )
+                    entry_data.scenes.append((area.name, keypad, button, led))
 
+                    platform = Platform.SCENE
+                    _async_check_entity_unique_id(
+                        hass,
+                        entity_registry,
+                        platform,
+                        button.uuid,
+                        button.legacy_uuid,
+                        entry_data.client.guid,
+                    )
+                    if led is not None:
+                        platform = Platform.SWITCH
+                        _async_check_entity_unique_id(
+                            hass,
+                            entity_registry,
+                            platform,
+                            led.uuid,
+                            led.legacy_uuid,
+                            entry_data.client.guid,
+                        )
+                if button.button_type:
+                    entry_data.buttons.append((area.name, keypad, button))
         if area.occupancy_group is not None:
             entry_data.binary_sensors.append((area.name, area.occupancy_group))
             platform = Platform.BINARY_SENSOR
@@ -134,99 +202,6 @@ async def async_setup_entry(
     return True
 
 
-def _setup_output(
-    hass: HomeAssistant,
-    entry_data: LutronData,
-    output: Output,
-    area_name: str,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Set up a Lutron output."""
-    _LOGGER.debug("Working on output %s", output.type)
-    if output.type == "SYSTEM_SHADE":
-        entry_data.covers.append((area_name, output))
-        platform = Platform.COVER
-    elif output.type == "CEILING_FAN_TYPE":
-        entry_data.fans.append((area_name, output))
-        platform = Platform.FAN
-    elif output.is_dimmable:
-        entry_data.lights.append((area_name, output))
-        platform = Platform.LIGHT
-    else:
-        entry_data.switches.append((area_name, output))
-        platform = Platform.SWITCH
-
-    _async_check_entity_unique_id(
-        hass,
-        entity_registry,
-        platform,
-        output.uuid,
-        output.legacy_uuid,
-        entry_data.client.guid,
-    )
-    _async_check_device_identifiers(
-        hass,
-        device_registry,
-        output.uuid,
-        output.legacy_uuid,
-        entry_data.client.guid,
-    )
-
-
-def _setup_keypad(
-    hass: HomeAssistant,
-    entry_data: LutronData,
-    keypad: Keypad,
-    area_name: str,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Set up a Lutron keypad."""
-
-    _async_check_keypad_identifiers(
-        hass,
-        device_registry,
-        keypad.id,
-        keypad.uuid,
-        keypad.legacy_uuid,
-        entry_data.client.guid,
-    )
-    leds_by_number = {led.number: led for led in keypad.leds}
-    for button in keypad.buttons:
-        # If the button has a function assigned to it, add it as a scene
-        if button.name != "Unknown Button" and button.button_type in (
-            "SingleAction",
-            "Toggle",
-            "SingleSceneRaiseLower",
-            "MasterRaiseLower",
-            "AdvancedToggle",
-        ):
-            # Associate an LED with a button if there is one
-            led = leds_by_number.get(button.number)
-            entry_data.scenes.append((area_name, keypad, button, led))
-
-            _async_check_entity_unique_id(
-                hass,
-                entity_registry,
-                Platform.SCENE,
-                button.uuid,
-                button.legacy_uuid,
-                entry_data.client.guid,
-            )
-            if led is not None:
-                _async_check_entity_unique_id(
-                    hass,
-                    entity_registry,
-                    Platform.SWITCH,
-                    led.uuid,
-                    led.legacy_uuid,
-                    entry_data.client.guid,
-                )
-        if button.button_type:
-            entry_data.buttons.append((area_name, keypad, button))
-
-
 def _async_check_entity_unique_id(
     hass: HomeAssistant,
     entity_registry: er.EntityRegistry,

homeassistant/components/matrix/__init__.py

@@ -127,12 +127,6 @@ CONFIG_SCHEMA = vol.Schema(
 )
 
 
-def _read_image_size(image_path: str) -> tuple[int, int]:
-    """Open image to determine image size."""
-    with Image.open(image_path) as image:
-        return image.size
-
-
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Matrix bot component."""
     config = config[DOMAIN]
@@ -510,9 +504,8 @@ class MatrixBot:
             return
 
         # Get required image metadata.
-        (width, height) = await self.hass.async_add_executor_job(
-            _read_image_size, image_path
-        )
+        image = await self.hass.async_add_executor_job(Image.open, image_path)
+        (width, height) = image.size
         mime_type = mimetypes.guess_type(image_path)[0]
         file_stat = await aiofiles.os.stat(image_path)
 

homeassistant/components/matrix/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "cloud_push",
   "loggers": ["matrix_client"],
   "quality_scale": "legacy",
-  "requirements": ["matrix-nio==0.25.2", "Pillow==12.2.0", "aiofiles==24.1.0"]
+  "requirements": ["matrix-nio==0.25.2", "Pillow==12.1.1", "aiofiles==24.1.0"]
 }

homeassistant/components/mcp_server/http.py

@@ -24,8 +24,6 @@ See https://modelcontextprotocol.io/docs/concepts/transports
 """
 
 import asyncio
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from http import HTTPStatus
 import logging
@@ -104,29 +102,17 @@ class Streams:
     write_stream: MemoryObjectSendStream[SessionMessage]
     write_stream_reader: MemoryObjectReceiveStream[SessionMessage]
 
-    async def aclose(self) -> None:
-        """Close open memory streams."""
-        await self.read_stream.aclose()
-        await self.read_stream_writer.aclose()
-        await self.write_stream.aclose()
-        await self.write_stream_reader.aclose()
 
-
-@asynccontextmanager
-async def create_streams() -> AsyncGenerator[Streams]:
+def create_streams() -> Streams:
     """Create a new pair of streams for MCP server communication."""
     read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
     write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-    streams = Streams(
+    return Streams(
         read_stream=read_stream,
         read_stream_writer=read_stream_writer,
         write_stream=write_stream,
         write_stream_reader=write_stream_reader,
     )
-    try:
-        yield streams
-    finally:
-        await streams.aclose()
 
 
 async def create_mcp_server(
@@ -169,9 +155,9 @@ class ModelContextProtocolSSEView(HomeAssistantView):
         session_manager = entry.runtime_data
 
         server, options = await create_mcp_server(hass, self.context(request), entry)
+        streams = create_streams()
 
         async with (
-            create_streams() as streams,
             sse_response(request) as response,
             session_manager.create(Session(streams.read_stream_writer)) as session_id,
         ):
@@ -275,24 +261,21 @@ class ModelContextProtocolStreamableView(HomeAssistantView):
         # request is sent to the MCP server and we wait for a single response
         # then shut down the server.
         server, options = await create_mcp_server(hass, self.context(request), entry)
+        streams = create_streams()
 
-        async with create_streams() as streams:
-
-            async def run_server() -> None:
-                await server.run(
-                    streams.read_stream, streams.write_stream, options, stateless=True
-                )
-
-            async with asyncio.timeout(TIMEOUT), anyio.create_task_group() as tg:
-                tg.start_soon(run_server)
-
-                await streams.read_stream_writer.send(SessionMessage(message))
-                session_message = await anext(streams.write_stream_reader)
-                tg.cancel_scope.cancel()
-
-            _LOGGER.debug("Sending response: %s", session_message)
-            return web.json_response(
-                data=session_message.message.model_dump(
-                    by_alias=True, exclude_none=True
-                ),
+        async def run_server() -> None:
+            await server.run(
+                streams.read_stream, streams.write_stream, options, stateless=True
             )
+
+        async with asyncio.timeout(TIMEOUT), anyio.create_task_group() as tg:
+            tg.start_soon(run_server)
+
+            await streams.read_stream_writer.send(SessionMessage(message))
+            session_message = await anext(streams.write_stream_reader)
+            tg.cancel_scope.cancel()
+
+        _LOGGER.debug("Sending response: %s", session_message)
+        return web.json_response(
+            data=session_message.message.model_dump(by_alias=True, exclude_none=True),
+        )

homeassistant/components/melcloud/__init__.py

@@ -19,12 +19,7 @@ from homeassistant.helpers.update_coordinator import UpdateFailed
 
 from .coordinator import MelCloudConfigEntry, MelCloudDeviceUpdateCoordinator
 
-PLATFORMS = [
-    Platform.BINARY_SENSOR,
-    Platform.CLIMATE,
-    Platform.SENSOR,
-    Platform.WATER_HEATER,
-]
+PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: MelCloudConfigEntry) -> bool:

homeassistant/components/melcloud/binary_sensor.py

@@ -1,175 +0,0 @@
-"""Support for MelCloud device binary sensors."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-import dataclasses
-from typing import Any
-
-from pymelcloud import DEVICE_TYPE_ATW
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-    BinarySensorEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import MelCloudConfigEntry, MelCloudDeviceUpdateCoordinator
-from .entity import MelCloudEntity
-
-
-@dataclasses.dataclass(frozen=True, kw_only=True)
-class MelcloudBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Describes Melcloud binary sensor entity."""
-
-    value_fn: Callable[[Any], bool | None]
-    enabled: Callable[[Any], bool]
-
-
-ATW_BINARY_SENSORS: tuple[MelcloudBinarySensorEntityDescription, ...] = (
-    MelcloudBinarySensorEntityDescription(
-        key="boiler_status",
-        translation_key="boiler_status",
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.boiler_status,
-        enabled=lambda data: data.device.boiler_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="booster_heater1_status",
-        translation_key="booster_heater_status",
-        translation_placeholders={"number": "1"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.booster_heater1_status,
-        enabled=lambda data: data.device.booster_heater1_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="booster_heater2_status",
-        translation_key="booster_heater_status",
-        translation_placeholders={"number": "2"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda data: data.device.booster_heater2_status,
-        enabled=lambda data: data.device.booster_heater2_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="booster_heater2plus_status",
-        translation_key="booster_heater_status",
-        translation_placeholders={"number": "2+"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda data: data.device.booster_heater2plus_status,
-        enabled=lambda data: data.device.booster_heater2plus_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="immersion_heater_status",
-        translation_key="immersion_heater_status",
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.immersion_heater_status,
-        enabled=lambda data: data.device.immersion_heater_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="water_pump1_status",
-        translation_key="water_pump_status",
-        translation_placeholders={"number": "1"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.water_pump1_status,
-        enabled=lambda data: data.device.water_pump1_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="water_pump2_status",
-        translation_key="water_pump_status",
-        translation_placeholders={"number": "2"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.water_pump2_status,
-        enabled=lambda data: data.device.water_pump2_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="water_pump3_status",
-        translation_key="water_pump_status",
-        translation_placeholders={"number": "3"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda data: data.device.water_pump3_status,
-        enabled=lambda data: data.device.water_pump3_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="water_pump4_status",
-        translation_key="water_pump_status",
-        translation_placeholders={"number": "4"},
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda data: data.device.water_pump4_status,
-        enabled=lambda data: data.device.water_pump4_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="valve_3way_status",
-        translation_key="valve_3way_status",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.device.valve_3way_status,
-        enabled=lambda data: data.device.valve_3way_status is not None,
-    ),
-    MelcloudBinarySensorEntityDescription(
-        key="valve_2way_status",
-        translation_key="valve_2way_status",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda data: data.device.valve_2way_status,
-        enabled=lambda data: data.device.valve_2way_status is not None,
-    ),
-)
-
-
-async def async_setup_entry(
-    _hass: HomeAssistant,
-    entry: MelCloudConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up MELCloud device binary sensors based on config_entry."""
-    coordinator = entry.runtime_data
-
-    if DEVICE_TYPE_ATW not in coordinator:
-        return
-
-    entities: list[MelDeviceBinarySensor] = [
-        MelDeviceBinarySensor(coord, description)
-        for description in ATW_BINARY_SENSORS
-        for coord in coordinator[DEVICE_TYPE_ATW]
-        if description.enabled(coord)
-    ]
-    async_add_entities(entities)
-
-
-class MelDeviceBinarySensor(MelCloudEntity, BinarySensorEntity):
-    """Representation of a Binary Sensor."""
-
-    entity_description: MelcloudBinarySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MelCloudDeviceUpdateCoordinator,
-        description: MelcloudBinarySensorEntityDescription,
-    ) -> None:
-        """Initialize the binary sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = (
-            f"{coordinator.device.serial}-{coordinator.device.mac}-{description.key}"
-        )
-        self._attr_device_info = coordinator.device_info
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return the state of the binary sensor."""
-        return self.entity_description.value_fn(self.coordinator)

homeassistant/components/melcloud/icons.json

@@ -1,25 +1,5 @@
 {
   "entity": {
-    "binary_sensor": {
-      "boiler_status": {
-        "default": "mdi:water-boiler-off",
-        "state": {
-          "on": "mdi:water-boiler"
-        }
-      },
-      "valve_2way_status": {
-        "default": "mdi:valve-closed",
-        "state": {
-          "on": "mdi:valve-open"
-        }
-      },
-      "valve_3way_status": {
-        "default": "mdi:valve-closed",
-        "state": {
-          "on": "mdi:valve-open"
-        }
-      }
-    },
     "sensor": {
       "energy_consumed": {
         "default": "mdi:factory"

homeassistant/components/melcloud/strings.json

@@ -42,26 +42,6 @@
     }
   },
   "entity": {
-    "binary_sensor": {
-      "boiler_status": {
-        "name": "Boiler"
-      },
-      "booster_heater_status": {
-        "name": "Booster heater {number}"
-      },
-      "immersion_heater_status": {
-        "name": "Immersion heater"
-      },
-      "valve_2way_status": {
-        "name": "2-way valve"
-      },
-      "valve_3way_status": {
-        "name": "3-way valve"
-      },
-      "water_pump_status": {
-        "name": "Water pump {number}"
-      }
-    },
     "sensor": {
       "condensing_temperature": {
         "name": "Condensing temperature"

homeassistant/components/meteo_france/weather.py

@@ -11,7 +11,6 @@ from homeassistant.components.weather import (
     ATTR_FORECAST_NATIVE_PRECIPITATION,
     ATTR_FORECAST_NATIVE_TEMP,
     ATTR_FORECAST_NATIVE_TEMP_LOW,
-    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED,
     ATTR_FORECAST_NATIVE_WIND_SPEED,
     ATTR_FORECAST_TIME,
     ATTR_FORECAST_WIND_BEARING,
@@ -185,9 +184,6 @@ class MeteoFranceWeather(
                         ATTR_FORECAST_NATIVE_TEMP: forecast["T"]["value"],
                         ATTR_FORECAST_NATIVE_PRECIPITATION: forecast["rain"].get("1h"),
                         ATTR_FORECAST_NATIVE_WIND_SPEED: forecast["wind"]["speed"],
-                        ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: forecast["wind"].get(
-                            "gust"
-                        ),
                         ATTR_FORECAST_WIND_BEARING: forecast["wind"]["direction"]
                         if forecast["wind"]["direction"] != -1
                         else None,

homeassistant/components/motionmount/sensor.py

@@ -54,7 +54,7 @@ class MotionMountErrorStatusSensor(MotionMountEntity, SensorEntity):
     def __init__(
         self, mm: motionmount.MotionMount, config_entry: MotionMountConfigEntry
     ) -> None:
-        """Initialize sensor entity."""
+        """Initialize sensor entiry."""
         super().__init__(mm, config_entry)
         self._attr_unique_id = f"{self._base_unique_id}-error-status"
 

homeassistant/components/octoprint/config_flow.py

@@ -154,8 +154,6 @@ class OctoPrintConfigFlow(ConfigFlow, domain=DOMAIN):
         except ApiError as err:
             _LOGGER.error("Failed to connect to printer")
             raise CannotConnect from err
-        finally:
-            await self._sessions.pop().close()
 
         await self.async_set_unique_id(discovery.upnp_uuid, raise_on_progress=False)
         self._abort_if_unique_id_configured()
@@ -264,12 +262,9 @@ class OctoPrintConfigFlow(ConfigFlow, domain=DOMAIN):
             assert self._user_input is not None
         octoprint = self._get_octoprint_client(self._user_input)
 
-        try:
-            self._user_input[CONF_API_KEY] = await octoprint.request_app_key(
-                "Home Assistant", self._user_input[CONF_USERNAME], 300
-            )
-        finally:
-            await self._sessions.pop().close()
+        self._user_input[CONF_API_KEY] = await octoprint.request_app_key(
+            "Home Assistant", self._user_input[CONF_USERNAME], 300
+        )
 
     def _get_octoprint_client(self, user_input: dict[str, Any]) -> OctoprintClient:
         """Build an octoprint client from the user_input."""
@@ -292,6 +287,11 @@ class OctoPrintConfigFlow(ConfigFlow, domain=DOMAIN):
             path=user_input[CONF_PATH],
         )
 
+    def async_remove(self) -> None:
+        """Detach the session."""
+        for session in self._sessions:
+            session.detach()
+
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/plaato/__init__.py

@@ -23,6 +23,7 @@ import voluptuous as vol
 
 from homeassistant.components import webhook
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_SCAN_INTERVAL,
     CONF_TOKEN,
@@ -38,15 +39,21 @@ from .const import (
     CONF_DEVICE_NAME,
     CONF_DEVICE_TYPE,
     CONF_USE_WEBHOOK,
+    COORDINATOR,
     DEFAULT_SCAN_INTERVAL,
+    DEVICE,
+    DEVICE_ID,
+    DEVICE_NAME,
+    DEVICE_TYPE,
     DOMAIN,
     PLATFORMS,
+    SENSOR_DATA,
+    UNDO_UPDATE_LISTENER,
 )
-from .coordinator import PlaatoConfigEntry, PlaatoCoordinator, PlaatoData
+from .coordinator import PlaatoCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
-
 DEPENDENCIES = ["webhook"]
 
 SENSOR_UPDATE = f"{DOMAIN}_sensor_update"
@@ -75,15 +82,15 @@ WEBHOOK_SCHEMA = vol.Schema(
 )
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: PlaatoConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Configure based on config entry."""
+    hass.data.setdefault(DOMAIN, {})
+
     if entry.data[CONF_USE_WEBHOOK]:
         async_setup_webhook(hass, entry)
     else:
         await async_setup_coordinator(hass, entry)
 
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
-
     await hass.config_entries.async_forward_entry_setups(
         entry, [platform for platform in PLATFORMS if entry.options.get(platform, True)]
     )
@@ -92,26 +99,19 @@ async def async_setup_entry(hass: HomeAssistant, entry: PlaatoConfigEntry) -> bo
 
 
 @callback
-def async_setup_webhook(hass: HomeAssistant, entry: PlaatoConfigEntry) -> None:
+def async_setup_webhook(hass: HomeAssistant, entry: ConfigEntry):
     """Init webhook based on config entry."""
     webhook_id = entry.data[CONF_WEBHOOK_ID]
     device_name = entry.data[CONF_DEVICE_NAME]
 
-    entry.runtime_data = PlaatoData(
-        coordinator=None,
-        device_name=entry.data[CONF_DEVICE_NAME],
-        device_type=entry.data[CONF_DEVICE_TYPE],
-        device_id=None,
-    )
+    _set_entry_data(entry, hass)
 
     webhook.async_register(
         hass, DOMAIN, f"{DOMAIN}.{device_name}", webhook_id, handle_webhook
     )
 
 
-async def async_setup_coordinator(
-    hass: HomeAssistant, entry: PlaatoConfigEntry
-) -> None:
+async def async_setup_coordinator(hass: HomeAssistant, entry: ConfigEntry):
     """Init auth token based on config entry."""
     auth_token = entry.data[CONF_TOKEN]
     device_type = entry.data[CONF_DEVICE_TYPE]
@@ -126,44 +126,62 @@ async def async_setup_coordinator(
     )
     await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = PlaatoData(
-        coordinator=coordinator,
-        device_name=entry.data[CONF_DEVICE_NAME],
-        device_type=entry.data[CONF_DEVICE_TYPE],
-        device_id=auth_token,
-    )
+    _set_entry_data(entry, hass, coordinator, auth_token)
 
     for platform in PLATFORMS:
         if entry.options.get(platform, True):
             coordinator.platforms.append(platform)
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: PlaatoConfigEntry) -> bool:
+def _set_entry_data(entry, hass, coordinator=None, device_id=None):
+    device = {
+        DEVICE_NAME: entry.data[CONF_DEVICE_NAME],
+        DEVICE_TYPE: entry.data[CONF_DEVICE_TYPE],
+        DEVICE_ID: device_id,
+    }
+
+    hass.data[DOMAIN][entry.entry_id] = {
+        COORDINATOR: coordinator,
+        DEVICE: device,
+        SENSOR_DATA: None,
+        UNDO_UPDATE_LISTENER: entry.add_update_listener(_async_update_listener),
+    }
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    if entry.data[CONF_USE_WEBHOOK]:
+    use_webhook = entry.data[CONF_USE_WEBHOOK]
+    hass.data[DOMAIN][entry.entry_id][UNDO_UPDATE_LISTENER]()
+
+    if use_webhook:
         return await async_unload_webhook(hass, entry)
 
     return await async_unload_coordinator(hass, entry)
 
 
-async def async_unload_webhook(hass: HomeAssistant, entry: PlaatoConfigEntry) -> bool:
+async def async_unload_webhook(hass: HomeAssistant, entry: ConfigEntry):
     """Unload webhook based entry."""
     if entry.data[CONF_WEBHOOK_ID] is not None:
         webhook.async_unregister(hass, entry.data[CONF_WEBHOOK_ID])
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    return await async_unload_platforms(hass, entry, PLATFORMS)
 
 
-async def async_unload_coordinator(
-    hass: HomeAssistant, entry: PlaatoConfigEntry
-) -> bool:
+async def async_unload_coordinator(hass: HomeAssistant, entry: ConfigEntry):
     """Unload auth token based entry."""
-    coordinator = entry.runtime_data.coordinator
-    return await hass.config_entries.async_unload_platforms(
-        entry, coordinator.platforms if coordinator else PLATFORMS
-    )
+    coordinator = hass.data[DOMAIN][entry.entry_id][COORDINATOR]
+    return await async_unload_platforms(hass, entry, coordinator.platforms)
 
 
-async def _async_update_listener(hass: HomeAssistant, entry: PlaatoConfigEntry) -> None:
+async def async_unload_platforms(hass: HomeAssistant, entry: ConfigEntry, platforms):
+    """Unload platforms."""
+    unloaded = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unloaded:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unloaded
+
+
+async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(entry.entry_id)
 

homeassistant/components/plaato/binary_sensor.py

@@ -8,17 +8,17 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CONF_USE_WEBHOOK
-from .coordinator import PlaatoConfigEntry, PlaatoCoordinator, PlaatoData
+from .const import CONF_USE_WEBHOOK, COORDINATOR, DOMAIN
 from .entity import PlaatoEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: PlaatoConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Plaato from a config entry."""
@@ -26,12 +26,10 @@ async def async_setup_entry(
     if config_entry.data[CONF_USE_WEBHOOK]:
         return
 
-    entry_data = config_entry.runtime_data
-    coordinator = entry_data.coordinator
-    assert coordinator is not None
+    coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
     async_add_entities(
         PlaatoBinarySensor(
-            entry_data,
+            hass.data[DOMAIN][config_entry.entry_id],
             sensor_type,
             coordinator,
         )
@@ -42,12 +40,7 @@ async def async_setup_entry(
 class PlaatoBinarySensor(PlaatoEntity, BinarySensorEntity):
     """Representation of a Binary Sensor."""
 
-    def __init__(
-        self,
-        data: PlaatoData,
-        sensor_type: str,
-        coordinator: PlaatoCoordinator | None = None,
-    ) -> None:
+    def __init__(self, data, sensor_type, coordinator=None) -> None:
         """Initialize plaato binary sensor."""
         super().__init__(data, sensor_type, coordinator)
         if sensor_type is PlaatoKeg.Pins.LEAK_DETECTION:

homeassistant/components/plaato/const.py

@@ -19,7 +19,13 @@ PLACEHOLDER_DEVICE_TYPE = "device_type"
 PLACEHOLDER_DEVICE_NAME = "device_name"
 DOCS_URL = "https://www.home-assistant.io/integrations/plaato/"
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
-
+SENSOR_DATA = "sensor_data"
+COORDINATOR = "coordinator"
+DEVICE = "device"
+DEVICE_NAME = "device_name"
+DEVICE_TYPE = "device_type"
+DEVICE_ID = "device_id"
+UNDO_UPDATE_LISTENER = "undo_update_listener"
 DEFAULT_SCAN_INTERVAL = 5
 MIN_UPDATE_INTERVAL = timedelta(minutes=1)
 

homeassistant/components/plaato/coordinator.py

@@ -1,10 +1,8 @@
 """Coordinator for Plaato devices."""
 
-from dataclasses import dataclass, field
 from datetime import timedelta
 import logging
 
-from pyplaato.models.device import PlaatoDevice
 from pyplaato.plaato import Plaato, PlaatoDeviceType
 
 from homeassistant.config_entries import ConfigEntry
@@ -18,29 +16,15 @@ from .const import DOMAIN
 _LOGGER = logging.getLogger(__name__)
 
 
-@dataclass
-class PlaatoData:
-    """Runtime data for the Plaato integration."""
-
-    coordinator: PlaatoCoordinator | None
-    device_name: str
-    device_type: str
-    device_id: str | None
-    sensor_data: PlaatoDevice | None = field(default=None)
-
-
-type PlaatoConfigEntry = ConfigEntry[PlaatoData]
-
-
-class PlaatoCoordinator(DataUpdateCoordinator[PlaatoDevice]):
+class PlaatoCoordinator(DataUpdateCoordinator):
     """Class to manage fetching data from the API."""
 
-    config_entry: PlaatoConfigEntry
+    config_entry: ConfigEntry
 
     def __init__(
         self,
         hass: HomeAssistant,
-        config_entry: PlaatoConfigEntry,
+        config_entry: ConfigEntry,
         auth_token: str,
         device_type: PlaatoDeviceType,
         update_interval: timedelta,
@@ -58,7 +42,7 @@ class PlaatoCoordinator(DataUpdateCoordinator[PlaatoDevice]):
             update_interval=update_interval,
         )
 
-    async def _async_update_data(self) -> PlaatoDevice:
+    async def _async_update_data(self):
         """Update data via library."""
         return await self.api.get_data(
             session=aiohttp_client.async_get_clientsession(self.hass),

homeassistant/components/plaato/entity.py

@@ -1,6 +1,6 @@
 """PlaatoEntity class."""
 
-from typing import Any, cast
+from typing import Any
 
 from pyplaato.models.device import PlaatoDevice
 
@@ -8,8 +8,16 @@ from homeassistant.helpers import entity
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 
-from .const import DOMAIN, EXTRA_STATE_ATTRIBUTES, SENSOR_SIGNAL
-from .coordinator import PlaatoCoordinator, PlaatoData
+from .const import (
+    DEVICE,
+    DEVICE_ID,
+    DEVICE_NAME,
+    DEVICE_TYPE,
+    DOMAIN,
+    EXTRA_STATE_ATTRIBUTES,
+    SENSOR_DATA,
+    SENSOR_SIGNAL,
+)
 
 
 class PlaatoEntity(entity.Entity):
@@ -17,20 +25,14 @@ class PlaatoEntity(entity.Entity):
 
     _attr_should_poll = False
 
-    def __init__(
-        self,
-        data: PlaatoData,
-        sensor_type: str,
-        coordinator: PlaatoCoordinator | None = None,
-    ) -> None:
+    def __init__(self, data, sensor_type, coordinator=None):
         """Initialize the sensor."""
         self._coordinator = coordinator
         self._entry_data = data
         self._sensor_type = sensor_type
-        assert self._entry_data.device_id is not None
-        self._device_id = cast(str, data.device_id)
-        self._device_type = data.device_type
-        self._device_name = data.device_name
+        self._device_id = data[DEVICE][DEVICE_ID]
+        self._device_type = data[DEVICE][DEVICE_TYPE]
+        self._device_name = data[DEVICE][DEVICE_NAME]
         self._attr_unique_id = f"{self._device_id}_{self._sensor_type}"
         self._attr_name = f"{DOMAIN} {self._device_type} {self._device_name} {self._sensor_name}".title()
         sw_version = None
@@ -56,7 +58,7 @@ class PlaatoEntity(entity.Entity):
     def _sensor_data(self) -> PlaatoDevice:
         if self._coordinator:
             return self._coordinator.data
-        return self._entry_data.sensor_data
+        return self._entry_data[SENSOR_DATA]
 
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:

homeassistant/components/plaato/sensor.py

@@ -6,6 +6,7 @@ from pyplaato.models.device import PlaatoDevice
 from pyplaato.plaato import PlaatoKeg
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import (
     async_dispatcher_connect,
@@ -18,8 +19,15 @@ from homeassistant.helpers.entity_platform import (
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import ATTR_TEMP, SENSOR_UPDATE
-from .const import CONF_USE_WEBHOOK, SENSOR_SIGNAL
-from .coordinator import PlaatoConfigEntry, PlaatoCoordinator, PlaatoData
+from .const import (
+    CONF_USE_WEBHOOK,
+    COORDINATOR,
+    DEVICE,
+    DEVICE_ID,
+    DOMAIN,
+    SENSOR_DATA,
+    SENSOR_SIGNAL,
+)
 from .entity import PlaatoEntity
 
 
@@ -34,19 +42,19 @@ async def async_setup_platform(
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: PlaatoConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Plaato from a config entry."""
-    entry_data = entry.runtime_data
+    entry_data = hass.data[DOMAIN][entry.entry_id]
 
     @callback
     def _async_update_from_webhook(device_id, sensor_data: PlaatoDevice):
         """Update/Create the sensors."""
-        entry_data.sensor_data = sensor_data
+        entry_data[SENSOR_DATA] = sensor_data
 
-        if device_id != entry_data.device_id:
-            entry_data.device_id = device_id
+        if device_id != entry_data[DEVICE][DEVICE_ID]:
+            entry_data[DEVICE][DEVICE_ID] = device_id
             async_add_entities(
                 [
                     PlaatoSensor(entry_data, sensor_type)
@@ -60,8 +68,7 @@ async def async_setup_entry(
     if entry.data[CONF_USE_WEBHOOK]:
         async_dispatcher_connect(hass, SENSOR_UPDATE, _async_update_from_webhook)
     else:
-        coordinator = entry_data.coordinator
-        assert coordinator is not None
+        coordinator = entry_data[COORDINATOR]
         async_add_entities(
             PlaatoSensor(entry_data, sensor_type, coordinator)
             for sensor_type in coordinator.data.sensors
@@ -71,23 +78,18 @@ async def async_setup_entry(
 class PlaatoSensor(PlaatoEntity, SensorEntity):
     """Representation of a Plaato Sensor."""
 
-    def __init__(
-        self,
-        data: PlaatoData,
-        sensor_type: str,
-        coordinator: PlaatoCoordinator | None = None,
-    ) -> None:
+    def __init__(self, data, sensor_type, coordinator=None) -> None:
         """Initialize plaato sensor."""
         super().__init__(data, sensor_type, coordinator)
         if sensor_type is PlaatoKeg.Pins.TEMPERATURE or sensor_type == ATTR_TEMP:
             self._attr_device_class = SensorDeviceClass.TEMPERATURE
 
     @property
-    def native_value(self) -> str | int | float | None:
+    def native_value(self):
         """Return the state of the sensor."""
         return self._sensor_data.sensors.get(self._sensor_type)
 
     @property
-    def native_unit_of_measurement(self) -> str | None:
+    def native_unit_of_measurement(self):
         """Return the unit of measurement."""
         return self._sensor_data.get_unit_of_measurement(self._sensor_type)

homeassistant/components/proxy/manifest.json

@@ -4,5 +4,5 @@
   "codeowners": [],
   "documentation": "https://www.home-assistant.io/integrations/proxy",
   "quality_scale": "legacy",
-  "requirements": ["Pillow==12.2.0"]
+  "requirements": ["Pillow==12.1.1"]
 }

homeassistant/components/pvoutput/coordinator.py

@@ -2,14 +2,7 @@
 
 from __future__ import annotations
 
-from pvo import (
-    PVOutput,
-    PVOutputAuthenticationError,
-    PVOutputConnectionError,
-    PVOutputError,
-    PVOutputNoDataError,
-    Status,
-)
+from pvo import PVOutput, PVOutputAuthenticationError, PVOutputNoDataError, Status
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY
@@ -44,20 +37,7 @@ class PVOutputDataUpdateCoordinator(DataUpdateCoordinator[Status]):
         """Fetch system status from PVOutput."""
         try:
             return await self.pvoutput.status()
+        except PVOutputNoDataError as err:
+            raise UpdateFailed("PVOutput has no data available") from err
         except PVOutputAuthenticationError as err:
             raise ConfigEntryAuthFailed from err
-        except PVOutputNoDataError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="no_data_available",
-            ) from err
-        except PVOutputConnectionError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="communication_error",
-            ) from err
-        except PVOutputError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="unknown_error",
-            ) from err

homeassistant/components/pvoutput/strings.json

@@ -42,16 +42,5 @@
         "name": "Power generation"
       }
     }
-  },
-  "exceptions": {
-    "communication_error": {
-      "message": "An error occurred while communicating with the PVOutput service."
-    },
-    "no_data_available": {
-      "message": "The PVOutput service has no data available for this system."
-    },
-    "unknown_error": {
-      "message": "An unknown error occurred while communicating with the PVOutput service."
-    }
   }
 }

homeassistant/components/qrcode/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "calculated",
   "loggers": ["pyzbar"],
   "quality_scale": "legacy",
-  "requirements": ["Pillow==12.2.0", "pyzbar==0.1.7"]
+  "requirements": ["Pillow==12.1.1", "pyzbar==0.1.7"]
 }

homeassistant/components/recorder/db_schema.py

@@ -192,7 +192,7 @@ ID_TYPE = BigInteger().with_variant(sqlite.INTEGER, "sqlite")
 # For MariaDB and MySQL we can use an unsigned integer type since it will fit 2**32
 # for sqlite and postgresql we use a bigint
 UINT_32_TYPE = BigInteger().with_variant(
-    mysql.INTEGER(unsigned=True),
+    mysql.INTEGER(unsigned=True),  # type: ignore[no-untyped-call]
     "mysql",
     "mariadb",
 )
@@ -206,12 +206,12 @@ JSONB_VARIANT_CAST = Text().with_variant(
 )
 DATETIME_TYPE = (
     DateTime(timezone=True)
-    .with_variant(mysql.DATETIME(timezone=True, fsp=6), "mysql", "mariadb")
+    .with_variant(mysql.DATETIME(timezone=True, fsp=6), "mysql", "mariadb")  # type: ignore[no-untyped-call]
     .with_variant(FAST_PYSQLITE_DATETIME(), "sqlite")  # type: ignore[no-untyped-call]
 )
 DOUBLE_TYPE = (
     Float()
-    .with_variant(mysql.DOUBLE(asdecimal=False), "mysql", "mariadb")
+    .with_variant(mysql.DOUBLE(asdecimal=False), "mysql", "mariadb")  # type: ignore[no-untyped-call]
     .with_variant(oracle.DOUBLE_PRECISION(), "oracle")
     .with_variant(postgresql.DOUBLE_PRECISION(), "postgresql")
 )

homeassistant/components/recorder/manifest.json

@@ -7,7 +7,7 @@
   "iot_class": "local_push",
   "quality_scale": "internal",
   "requirements": [
-    "SQLAlchemy==2.0.49",
+    "SQLAlchemy==2.0.41",
     "fnv-hash-fast==2.0.0",
     "psutil-home-assistant==0.0.1"
   ]

homeassistant/components/recorder/util.py

@@ -447,10 +447,10 @@ def setup_connection_for_dialect(
     slow_dependent_subquery = False
     if dialect_name == SupportedDialect.SQLITE:
         if first_connection:
-            old_isolation = dbapi_connection.isolation_level
-            dbapi_connection.isolation_level = None
+            old_isolation = dbapi_connection.isolation_level  # type: ignore[attr-defined]
+            dbapi_connection.isolation_level = None  # type: ignore[attr-defined]
             execute_on_connection(dbapi_connection, "PRAGMA journal_mode=WAL")
-            dbapi_connection.isolation_level = old_isolation
+            dbapi_connection.isolation_level = old_isolation  # type: ignore[attr-defined]
             # WAL mode only needs to be setup once
             # instead of every time we open the sqlite connection
             # as its persistent and isn't free to call every time.

homeassistant/components/remote/condition.py

@@ -1,17 +0,0 @@
-"""Provides conditions for remotes."""
-
-from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.condition import Condition, make_entity_state_condition
-
-from . import DOMAIN
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "is_off": make_entity_state_condition(DOMAIN, STATE_OFF),
-    "is_on": make_entity_state_condition(DOMAIN, STATE_ON),
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the remote conditions."""
-    return CONDITIONS

homeassistant/components/remote/conditions.yaml

@@ -1,17 +0,0 @@
-.condition_common: &condition_common
-  target:
-    entity:
-      domain: remote
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          translation_key: condition_behavior
-          options:
-            - all
-            - any
-
-is_off: *condition_common
-is_on: *condition_common

homeassistant/components/remote/icons.json

@@ -1,12 +1,4 @@
 {
-  "conditions": {
-    "is_off": {
-      "condition": "mdi:remote-off"
-    },
-    "is_on": {
-      "condition": "mdi:remote"
-    }
-  },
   "entity_component": {
     "_": {
       "default": "mdi:remote",

homeassistant/components/remote/strings.json

@@ -1,28 +1,7 @@
 {
   "common": {
-    "condition_behavior_name": "Condition passes if",
     "trigger_behavior_name": "Trigger when"
   },
-  "conditions": {
-    "is_off": {
-      "description": "Tests if one or more remotes are off.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::remote::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Remote is off"
-    },
-    "is_on": {
-      "description": "Tests if one or more remotes are on.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::remote::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Remote is on"
-    }
-  },
   "device_automation": {
     "action_type": {
       "toggle": "[%key:common::device_automation::action_type::toggle%]",
@@ -52,12 +31,6 @@
     }
   },
   "selector": {
-    "condition_behavior": {
-      "options": {
-        "all": "All",
-        "any": "Any"
-      }
-    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/rituals_perfume_genie/binary_sensor.py

@@ -21,8 +21,6 @@ from .const import DOMAIN
 from .coordinator import RitualsDataUpdateCoordinator
 from .entity import DiffuserEntity
 
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class RitualsBinarySensorEntityDescription(BinarySensorEntityDescription):

homeassistant/components/rituals_perfume_genie/number.py

@@ -17,8 +17,6 @@ from .const import DOMAIN
 from .coordinator import RitualsDataUpdateCoordinator
 from .entity import DiffuserEntity
 
-PARALLEL_UPDATES = 1
-
 
 @dataclass(frozen=True, kw_only=True)
 class RitualsNumberEntityDescription(NumberEntityDescription):

homeassistant/components/rituals_perfume_genie/select.py

@@ -17,8 +17,6 @@ from .const import DOMAIN
 from .coordinator import RitualsDataUpdateCoordinator
 from .entity import DiffuserEntity
 
-PARALLEL_UPDATES = 1
-
 
 @dataclass(frozen=True, kw_only=True)
 class RitualsSelectEntityDescription(SelectEntityDescription):

homeassistant/components/rituals_perfume_genie/sensor.py

@@ -21,8 +21,6 @@ from .const import DOMAIN
 from .coordinator import RitualsDataUpdateCoordinator
 from .entity import DiffuserEntity
 
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class RitualsSensorEntityDescription(SensorEntityDescription):

homeassistant/components/rituals_perfume_genie/switch.py

@@ -17,8 +17,6 @@ from .const import DOMAIN
 from .coordinator import RitualsDataUpdateCoordinator
 from .entity import DiffuserEntity
 
-PARALLEL_UPDATES = 1
-
 
 @dataclass(frozen=True, kw_only=True)
 class RitualsSwitchEntityDescription(SwitchEntityDescription):

homeassistant/components/ruckus_unleashed/__init__.py

@@ -49,14 +49,10 @@ async def async_setup_entry(
 
     await coordinator.async_config_entry_first_refresh()
 
-    try:
-        system_info = await ruckus.api.get_system_info()
-        aps = await ruckus.api.get_aps()
-    except (ConnectionError, SchemaError) as err:
-        await ruckus.close()
-        raise ConfigEntryNotReady from err
+    system_info = await ruckus.api.get_system_info()
 
     registry = dr.async_get(hass)
+    aps = await ruckus.api.get_aps()
     for access_point in aps:
         _LOGGER.debug("AP [%s] %s", access_point[API_AP_MAC], entry.entry_id)
         registry.async_get_or_create(

homeassistant/components/ruckus_unleashed/config_flow.py

@@ -86,10 +86,12 @@ class RuckusConfigFlow(ConfigFlow, domain=DOMAIN):
                     return self.async_create_entry(
                         title=info[KEY_SYS_TITLE], data=user_input
                     )
-                self._abort_if_unique_id_mismatch(reason="invalid_host")
-                return self.async_update_reload_and_abort(
-                    self._get_reauth_entry(), data=user_input
-                )
+                reauth_entry = self._get_reauth_entry()
+                if info[KEY_SYS_SERIAL] == reauth_entry.unique_id:
+                    return self.async_update_reload_and_abort(
+                        reauth_entry, data=user_input
+                    )
+                errors["base"] = "invalid_host"
 
         data_schema = DATA_SCHEMA
         if self.source == SOURCE_REAUTH:

homeassistant/components/ruckus_unleashed/strings.json

@@ -2,12 +2,12 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "invalid_host": "[%key:common::config_flow::error::invalid_host%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_host": "[%key:common::config_flow::error::invalid_host%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {

homeassistant/components/russound_rio/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["aiorussound"],
   "quality_scale": "silver",
-  "requirements": ["aiorussound==5.0.1"],
+  "requirements": ["aiorussound==5.0.0"],
   "zeroconf": ["_rio._tcp.local."]
 }

homeassistant/components/scrape/__init__.py

@@ -4,40 +4,27 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Coroutine
-from copy import deepcopy
 from datetime import timedelta
-import logging
-from types import MappingProxyType
 from typing import Any
 
 import voluptuous as vol
 
 from homeassistant.components.rest import RESOURCE_SCHEMA, create_rest_data_from_config
-from homeassistant.components.sensor import CONF_STATE_CLASS, DOMAIN as SENSOR_DOMAIN
-from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_ATTRIBUTE,
-    CONF_AUTHENTICATION,
-    CONF_DEVICE_CLASS,
-    CONF_HEADERS,
-    CONF_NAME,
-    CONF_PASSWORD,
     CONF_SCAN_INTERVAL,
-    CONF_TIMEOUT,
-    CONF_UNIQUE_ID,
-    CONF_UNIT_OF_MEASUREMENT,
-    CONF_USERNAME,
     CONF_VALUE_TEMPLATE,
-    CONF_VERIFY_SSL,
     Platform,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import (
     config_validation as cv,
-    device_registry as dr,
     discovery,
     entity_registry as er,
 )
+from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.trigger_template_entity import (
     CONF_AVAILABILITY,
     TEMPLATE_SENSOR_BASE_SCHEMA,
@@ -45,22 +32,11 @@ from homeassistant.helpers.trigger_template_entity import (
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    CONF_ADVANCED,
-    CONF_AUTH,
-    CONF_ENCODING,
-    CONF_INDEX,
-    CONF_SELECT,
-    DEFAULT_SCAN_INTERVAL,
-    DOMAIN,
-    PLATFORMS,
-)
+from .const import CONF_INDEX, CONF_SELECT, DEFAULT_SCAN_INTERVAL, DOMAIN, PLATFORMS
 from .coordinator import ScrapeCoordinator
 
 type ScrapeConfigEntry = ConfigEntry[ScrapeCoordinator]
 
-_LOGGER = logging.getLogger(__name__)
-
 SENSOR_SCHEMA = vol.Schema(
     {
         **TEMPLATE_SENSOR_BASE_SCHEMA.schema,
@@ -127,13 +103,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
     """Set up Scrape from a config entry."""
 
-    config: dict[str, Any] = dict(entry.options)
-    # Config flow uses sections but the COMBINED SCHEMA does not
-    # so we need to flatten the config here
-    config.update(config.pop(CONF_ADVANCED, {}))
-    config.update(config.pop(CONF_AUTH, {}))
-
-    rest_config: dict[str, Any] = COMBINED_SCHEMA(dict(config))
+    rest_config: dict[str, Any] = COMBINED_SCHEMA(dict(entry.options))
     rest = create_rest_data_from_config(hass, rest_config)
 
     coordinator = ScrapeCoordinator(
@@ -147,159 +117,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bo
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(update_listener))
 
     return True
 
 
-async def async_migrate_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
-    """Migrate old entry."""
-
-    if entry.version > 2:
-        # Don't migrate from future version
-        return False
-
-    if entry.version == 1:
-        old_to_new_sensor_id = {}
-        for sensor_config in entry.options[SENSOR_DOMAIN]:
-            # Create a new sub config entry per sensor
-            title = sensor_config[CONF_NAME]
-            old_unique_id = sensor_config[CONF_UNIQUE_ID]
-            subentry_config = {
-                CONF_INDEX: sensor_config[CONF_INDEX],
-                CONF_SELECT: sensor_config[CONF_SELECT],
-                CONF_ADVANCED: {},
-            }
-
-            for sensor_advanced_key in (
-                CONF_ATTRIBUTE,
-                CONF_VALUE_TEMPLATE,
-                CONF_AVAILABILITY,
-                CONF_DEVICE_CLASS,
-                CONF_STATE_CLASS,
-                CONF_UNIT_OF_MEASUREMENT,
-            ):
-                if sensor_advanced_key not in sensor_config:
-                    continue
-                subentry_config[CONF_ADVANCED][sensor_advanced_key] = sensor_config[
-                    sensor_advanced_key
-                ]
-
-            new_sub_entry = ConfigSubentry(
-                data=MappingProxyType(subentry_config),
-                subentry_type="entity",
-                title=title,
-                unique_id=None,
-            )
-            _LOGGER.debug(
-                "Migrating sensor %s with unique id %s to sub config entry id %s, old data %s, new data %s",
-                title,
-                old_unique_id,
-                new_sub_entry.subentry_id,
-                sensor_config,
-                subentry_config,
-            )
-            old_to_new_sensor_id[old_unique_id] = new_sub_entry.subentry_id
-            hass.config_entries.async_add_subentry(entry, new_sub_entry)
-
-        # Use the new sub config entry id as the unique id for the sensor entity
-        entity_reg = er.async_get(hass)
-        entities = er.async_entries_for_config_entry(entity_reg, entry.entry_id)
-        for entity in entities:
-            if (old_unique_id := entity.unique_id) in old_to_new_sensor_id:
-                new_unique_id = old_to_new_sensor_id[old_unique_id]
-                _LOGGER.debug(
-                    "Migrating entity %s with unique id %s to new unique id %s",
-                    entity.entity_id,
-                    entity.unique_id,
-                    new_unique_id,
-                )
-                entity_reg.async_update_entity(
-                    entity.entity_id,
-                    config_entry_id=entry.entry_id,
-                    config_subentry_id=new_unique_id,
-                    new_unique_id=new_unique_id,
-                )
-
-        # Use the new sub config entry id as the identifier for the sensor device
-        device_reg = dr.async_get(hass)
-        devices = dr.async_entries_for_config_entry(device_reg, entry.entry_id)
-        for device in devices:
-            for domain, identifier in device.identifiers:
-                if domain != DOMAIN or identifier not in old_to_new_sensor_id:
-                    continue
-
-                subentry_id = old_to_new_sensor_id[identifier]
-                new_identifiers = deepcopy(device.identifiers)
-                new_identifiers.remove((domain, identifier))
-                new_identifiers.add((domain, old_to_new_sensor_id[identifier]))
-                _LOGGER.debug(
-                    "Migrating device %s with identifiers %s to new identifiers %s",
-                    device.id,
-                    device.identifiers,
-                    new_identifiers,
-                )
-                device_reg.async_update_device(
-                    device.id,
-                    add_config_entry_id=entry.entry_id,
-                    add_config_subentry_id=subentry_id,
-                    new_identifiers=new_identifiers,
-                )
-
-                # Removing None from the list of subentries if existing
-                # as the device should only belong to the subentry
-                # and not the main config entry
-                device_reg.async_update_device(
-                    device.id,
-                    remove_config_entry_id=entry.entry_id,
-                    remove_config_subentry_id=None,
-                )
-
-        # Update the resource config
-        new_config_entry_data = dict(entry.options)
-        new_config_entry_data[CONF_AUTH] = {}
-        new_config_entry_data[CONF_ADVANCED] = {}
-        new_config_entry_data.pop(SENSOR_DOMAIN, None)
-        for resource_advanced_key in (
-            CONF_HEADERS,
-            CONF_VERIFY_SSL,
-            CONF_TIMEOUT,
-            CONF_ENCODING,
-        ):
-            if resource_advanced_key in new_config_entry_data:
-                new_config_entry_data[CONF_ADVANCED][resource_advanced_key] = (
-                    new_config_entry_data.pop(resource_advanced_key)
-                )
-        for resource_auth_key in (CONF_AUTHENTICATION, CONF_USERNAME, CONF_PASSWORD):
-            if resource_auth_key in new_config_entry_data:
-                new_config_entry_data[CONF_AUTH][resource_auth_key] = (
-                    new_config_entry_data.pop(resource_auth_key)
-                )
-
-        _LOGGER.debug(
-            "Migrating config entry %s from version 1 to version 2 with data %s",
-            entry.entry_id,
-            new_config_entry_data,
-        )
-        hass.config_entries.async_update_entry(
-            entry, version=2, options=new_config_entry_data
-        )
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload Scrape config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def update_listener(hass: HomeAssistant, entry: ScrapeConfigEntry) -> None:
-    """Handle config entry update."""
-    hass.config_entries.async_schedule_reload(entry.entry_id)
-
-
 async def async_remove_config_entry_device(
-    hass: HomeAssistant, entry: ConfigEntry, device: dr.DeviceEntry
+    hass: HomeAssistant, entry: ConfigEntry, device: DeviceEntry
 ) -> bool:
     """Remove Scrape config entry from a device."""
     entity_registry = er.async_get(hass)

homeassistant/components/scrape/config_flow.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
-from copy import deepcopy
-import logging
-from typing import Any
+from collections.abc import Mapping
+from typing import Any, cast
+import uuid
 
 import voluptuous as vol
 
-from homeassistant import data_entry_flow
 from homeassistant.components.rest import create_rest_data_from_config
 from homeassistant.components.rest.data import (  # pylint: disable=hass-component-root-import
     DEFAULT_TIMEOUT,
@@ -19,17 +18,10 @@ from homeassistant.components.rest.schema import (  # pylint: disable=hass-compo
 )
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS,
+    DOMAIN as SENSOR_DOMAIN,
     SensorDeviceClass,
     SensorStateClass,
 )
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    ConfigSubentryFlow,
-    OptionsFlow,
-    SubentryFlowResult,
-)
 from homeassistant.const import (
     CONF_ATTRIBUTE,
     CONF_AUTHENTICATION,
@@ -41,6 +33,7 @@ from homeassistant.const import (
     CONF_PAYLOAD,
     CONF_RESOURCE,
     CONF_TIMEOUT,
+    CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
     CONF_USERNAME,
     CONF_VALUE_TEMPLATE,
@@ -49,7 +42,15 @@ from homeassistant.const import (
     HTTP_DIGEST_AUTHENTICATION,
     UnitOfTemperature,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import async_get_hass
+from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers.schema_config_entry_flow import (
+    SchemaCommonFlowHandler,
+    SchemaConfigFlowHandler,
+    SchemaFlowError,
+    SchemaFlowFormStep,
+    SchemaFlowMenuStep,
+)
 from homeassistant.helpers.selector import (
     BooleanSelector,
     NumberSelector,
@@ -68,8 +69,6 @@ from homeassistant.helpers.trigger_template_entity import CONF_AVAILABILITY
 
 from . import COMBINED_SCHEMA
 from .const import (
-    CONF_ADVANCED,
-    CONF_AUTH,
     CONF_ENCODING,
     CONF_INDEX,
     CONF_SELECT,
@@ -79,212 +78,243 @@ from .const import (
     DOMAIN,
 )
 
-_LOGGER = logging.getLogger(__name__)
+RESOURCE_SETUP = {
+    vol.Required(CONF_RESOURCE): TextSelector(
+        TextSelectorConfig(type=TextSelectorType.URL)
+    ),
+    vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): SelectSelector(
+        SelectSelectorConfig(options=METHODS, mode=SelectSelectorMode.DROPDOWN)
+    ),
+    vol.Optional(CONF_PAYLOAD): ObjectSelector(),
+    vol.Optional(CONF_AUTHENTICATION): SelectSelector(
+        SelectSelectorConfig(
+            options=[HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION],
+            mode=SelectSelectorMode.DROPDOWN,
+        )
+    ),
+    vol.Optional(CONF_USERNAME): TextSelector(),
+    vol.Optional(CONF_PASSWORD): TextSelector(
+        TextSelectorConfig(type=TextSelectorType.PASSWORD)
+    ),
+    vol.Optional(CONF_HEADERS): ObjectSelector(),
+    vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): BooleanSelector(),
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): NumberSelector(
+        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
+    ),
+    vol.Optional(CONF_ENCODING, default=DEFAULT_ENCODING): TextSelector(),
+}
 
-RESOURCE_SETUP = vol.Schema(
-    {
-        vol.Required(CONF_RESOURCE): TextSelector(
-            TextSelectorConfig(type=TextSelectorType.URL)
-        ),
-        vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): SelectSelector(
-            SelectSelectorConfig(options=METHODS, mode=SelectSelectorMode.DROPDOWN)
-        ),
-        vol.Optional(CONF_PAYLOAD): ObjectSelector(),
-        vol.Required(CONF_AUTH): data_entry_flow.section(
-            vol.Schema(
-                {
-                    vol.Optional(CONF_AUTHENTICATION): SelectSelector(
-                        SelectSelectorConfig(
-                            options=[
-                                HTTP_BASIC_AUTHENTICATION,
-                                HTTP_DIGEST_AUTHENTICATION,
-                            ],
-                            mode=SelectSelectorMode.DROPDOWN,
-                        )
-                    ),
-                    vol.Optional(CONF_USERNAME): TextSelector(
-                        TextSelectorConfig(
-                            type=TextSelectorType.TEXT, autocomplete="username"
-                        )
-                    ),
-                    vol.Optional(CONF_PASSWORD): TextSelector(
-                        TextSelectorConfig(
-                            type=TextSelectorType.PASSWORD,
-                            autocomplete="current-password",
-                        )
-                    ),
-                }
-            ),
-            data_entry_flow.SectionConfig(collapsed=True),
-        ),
-        vol.Required(CONF_ADVANCED): data_entry_flow.section(
-            vol.Schema(
-                {
-                    vol.Optional(CONF_HEADERS): ObjectSelector(),
-                    vol.Optional(
-                        CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL
-                    ): BooleanSelector(),
-                    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): NumberSelector(
-                        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
-                    ),
-                    vol.Optional(
-                        CONF_ENCODING, default=DEFAULT_ENCODING
-                    ): TextSelector(),
-                }
-            ),
-            data_entry_flow.SectionConfig(collapsed=True),
-        ),
-    }
-)
-
-SENSOR_SETUP = vol.Schema(
-    {
-        vol.Optional(CONF_NAME, default=DEFAULT_NAME): TextSelector(),
-        vol.Required(CONF_SELECT): TextSelector(),
-        vol.Optional(CONF_INDEX, default=0): vol.All(
-            NumberSelector(
-                NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
-            ),
-            vol.Coerce(int),
-        ),
-        vol.Required(CONF_ADVANCED): data_entry_flow.section(
-            vol.Schema(
-                {
-                    vol.Optional(CONF_ATTRIBUTE): TextSelector(),
-                    vol.Optional(CONF_VALUE_TEMPLATE): TemplateSelector(),
-                    vol.Optional(CONF_AVAILABILITY): TemplateSelector(),
-                    vol.Optional(CONF_DEVICE_CLASS): SelectSelector(
-                        SelectSelectorConfig(
-                            options=[
-                                cls.value
-                                for cls in SensorDeviceClass
-                                if cls != SensorDeviceClass.ENUM
-                            ],
-                            mode=SelectSelectorMode.DROPDOWN,
-                            translation_key="device_class",
-                            sort=True,
-                        )
-                    ),
-                    vol.Optional(CONF_STATE_CLASS): SelectSelector(
-                        SelectSelectorConfig(
-                            options=[cls.value for cls in SensorStateClass],
-                            mode=SelectSelectorMode.DROPDOWN,
-                            translation_key="state_class",
-                            sort=True,
-                        )
-                    ),
-                    vol.Optional(CONF_UNIT_OF_MEASUREMENT): SelectSelector(
-                        SelectSelectorConfig(
-                            options=[cls.value for cls in UnitOfTemperature],
-                            custom_value=True,
-                            mode=SelectSelectorMode.DROPDOWN,
-                            translation_key="unit_of_measurement",
-                            sort=True,
-                        )
-                    ),
-                }
-            ),
-            data_entry_flow.SectionConfig(collapsed=True),
-        ),
-    }
-)
+SENSOR_SETUP = {
+    vol.Required(CONF_SELECT): TextSelector(),
+    vol.Optional(CONF_INDEX, default=0): NumberSelector(
+        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
+    ),
+    vol.Optional(CONF_ATTRIBUTE): TextSelector(),
+    vol.Optional(CONF_VALUE_TEMPLATE): TemplateSelector(),
+    vol.Optional(CONF_AVAILABILITY): TemplateSelector(),
+    vol.Optional(CONF_DEVICE_CLASS): SelectSelector(
+        SelectSelectorConfig(
+            options=[
+                cls.value for cls in SensorDeviceClass if cls != SensorDeviceClass.ENUM
+            ],
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="device_class",
+            sort=True,
+        )
+    ),
+    vol.Optional(CONF_STATE_CLASS): SelectSelector(
+        SelectSelectorConfig(
+            options=[cls.value for cls in SensorStateClass],
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="state_class",
+            sort=True,
+        )
+    ),
+    vol.Optional(CONF_UNIT_OF_MEASUREMENT): SelectSelector(
+        SelectSelectorConfig(
+            options=[cls.value for cls in UnitOfTemperature],
+            custom_value=True,
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="unit_of_measurement",
+            sort=True,
+        )
+    ),
+}
 
 
 async def validate_rest_setup(
-    hass: HomeAssistant, user_input: dict[str, Any]
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
 ) -> dict[str, Any]:
     """Validate rest setup."""
-    config = deepcopy(user_input)
-    config.update(config.pop(CONF_ADVANCED, {}))
-    config.update(config.pop(CONF_AUTH, {}))
-    rest_config: dict[str, Any] = COMBINED_SCHEMA(config)
+    hass = async_get_hass()
+    rest_config: dict[str, Any] = COMBINED_SCHEMA(user_input)
     try:
         rest = create_rest_data_from_config(hass, rest_config)
         await rest.async_update()
-    except Exception:
-        _LOGGER.exception("Error when getting resource %s", config[CONF_RESOURCE])
-        return {"base": "resource_error"}
+    except Exception as err:
+        raise SchemaFlowError("resource_error") from err
     if rest.data is None:
-        return {"base": "no_data"}
+        raise SchemaFlowError("resource_error")
+    return user_input
+
+
+async def validate_sensor_setup(
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate sensor input."""
+    user_input[CONF_INDEX] = int(user_input[CONF_INDEX])
+    user_input[CONF_UNIQUE_ID] = str(uuid.uuid1())
+
+    # Standard behavior is to merge the result with the options.
+    # In this case, we want to add a sub-item so we update the options directly.
+    sensors: list[dict[str, Any]] = handler.options.setdefault(SENSOR_DOMAIN, [])
+    sensors.append(user_input)
     return {}
 
 
-class ScrapeConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Scrape configuration flow."""
-
-    VERSION = 2
-
-    @staticmethod
-    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> ScrapeOptionFlow:
-        """Get the options flow for this handler."""
-        return ScrapeOptionFlow()
-
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type[ConfigSubentryFlow]]:
-        """Return subentries supported by this handler."""
-        return {"entity": ScrapeSubentryFlowHandler}
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """User flow to create the main config entry."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            errors = await validate_rest_setup(self.hass, user_input)
-            title = user_input[CONF_RESOURCE]
-            if not errors:
-                return self.async_create_entry(data={}, options=user_input, title=title)
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                RESOURCE_SETUP, user_input or {}
-            ),
-            errors=errors,
-        )
+async def validate_select_sensor(
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Store sensor index in flow state."""
+    handler.flow_state["_idx"] = int(user_input[CONF_INDEX])
+    return {}
 
 
-class ScrapeOptionFlow(OptionsFlow):
-    """Scrape Options flow."""
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Manage Scrape options."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            errors = await validate_rest_setup(self.hass, user_input)
-            if not errors:
-                return self.async_create_entry(data=user_input)
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=self.add_suggested_values_to_schema(
-                RESOURCE_SETUP,
-                user_input or self.config_entry.options,
-            ),
-            errors=errors,
-        )
+async def get_select_sensor_schema(handler: SchemaCommonFlowHandler) -> vol.Schema:
+    """Return schema for selecting a sensor."""
+    return vol.Schema(
+        {
+            vol.Required(CONF_INDEX): vol.In(
+                {
+                    str(index): config[CONF_NAME]
+                    for index, config in enumerate(handler.options[SENSOR_DOMAIN])
+                },
+            )
+        }
+    )
 
 
-class ScrapeSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle subentry flow."""
+async def get_edit_sensor_suggested_values(
+    handler: SchemaCommonFlowHandler,
+) -> dict[str, Any]:
+    """Return suggested values for sensor editing."""
+    idx: int = handler.flow_state["_idx"]
+    return dict(handler.options[SENSOR_DOMAIN][idx])
 
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """User flow to create a sensor subentry."""
-        if user_input is not None:
-            title = user_input.pop("name")
-            return self.async_create_entry(data=user_input, title=title)
 
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                SENSOR_SETUP, user_input or {}
-            ),
-        )
+async def validate_sensor_edit(
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Update edited sensor."""
+    user_input[CONF_INDEX] = int(user_input[CONF_INDEX])
+
+    # Standard behavior is to merge the result with the options.
+    # In this case, we want to add a sub-item so we update the options directly,
+    # including popping omitted optional schema items.
+    idx: int = handler.flow_state["_idx"]
+    handler.options[SENSOR_DOMAIN][idx].update(user_input)
+    for key in DATA_SCHEMA_EDIT_SENSOR.schema:
+        if isinstance(key, vol.Optional) and key not in user_input:
+            # Key not present, delete keys old value (if present) too
+            handler.options[SENSOR_DOMAIN][idx].pop(key, None)
+    return {}
+
+
+async def get_remove_sensor_schema(handler: SchemaCommonFlowHandler) -> vol.Schema:
+    """Return schema for sensor removal."""
+    return vol.Schema(
+        {
+            vol.Required(CONF_INDEX): cv.multi_select(
+                {
+                    str(index): config[CONF_NAME]
+                    for index, config in enumerate(handler.options[SENSOR_DOMAIN])
+                },
+            )
+        }
+    )
+
+
+async def validate_remove_sensor(
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate remove sensor."""
+    removed_indexes: set[str] = set(user_input[CONF_INDEX])
+
+    # Standard behavior is to merge the result with the options.
+    # In this case, we want to remove sub-items so we update the options directly.
+    entity_registry = er.async_get(handler.parent_handler.hass)
+    sensors: list[dict[str, Any]] = []
+    sensor: dict[str, Any]
+    for index, sensor in enumerate(handler.options[SENSOR_DOMAIN]):
+        if str(index) not in removed_indexes:
+            sensors.append(sensor)
+        elif entity_id := entity_registry.async_get_entity_id(
+            SENSOR_DOMAIN, DOMAIN, sensor[CONF_UNIQUE_ID]
+        ):
+            entity_registry.async_remove(entity_id)
+    handler.options[SENSOR_DOMAIN] = sensors
+    return {}
+
+
+DATA_SCHEMA_RESOURCE = vol.Schema(RESOURCE_SETUP)
+DATA_SCHEMA_EDIT_SENSOR = vol.Schema(SENSOR_SETUP)
+DATA_SCHEMA_SENSOR = vol.Schema(
+    {
+        vol.Optional(CONF_NAME, default=DEFAULT_NAME): TextSelector(),
+        **SENSOR_SETUP,
+    }
+)
+
+CONFIG_FLOW = {
+    "user": SchemaFlowFormStep(
+        schema=DATA_SCHEMA_RESOURCE,
+        next_step="sensor",
+        validate_user_input=validate_rest_setup,
+    ),
+    "sensor": SchemaFlowFormStep(
+        schema=DATA_SCHEMA_SENSOR,
+        validate_user_input=validate_sensor_setup,
+    ),
+}
+OPTIONS_FLOW = {
+    "init": SchemaFlowMenuStep(
+        ["resource", "add_sensor", "select_edit_sensor", "remove_sensor"]
+    ),
+    "resource": SchemaFlowFormStep(
+        DATA_SCHEMA_RESOURCE,
+        validate_user_input=validate_rest_setup,
+    ),
+    "add_sensor": SchemaFlowFormStep(
+        DATA_SCHEMA_SENSOR,
+        suggested_values=None,
+        validate_user_input=validate_sensor_setup,
+    ),
+    "select_edit_sensor": SchemaFlowFormStep(
+        get_select_sensor_schema,
+        suggested_values=None,
+        validate_user_input=validate_select_sensor,
+        next_step="edit_sensor",
+    ),
+    "edit_sensor": SchemaFlowFormStep(
+        DATA_SCHEMA_EDIT_SENSOR,
+        suggested_values=get_edit_sensor_suggested_values,
+        validate_user_input=validate_sensor_edit,
+    ),
+    "remove_sensor": SchemaFlowFormStep(
+        get_remove_sensor_schema,
+        suggested_values=None,
+        validate_user_input=validate_remove_sensor,
+    ),
+}
+
+
+class ScrapeConfigFlowHandler(SchemaConfigFlowHandler, domain=DOMAIN):
+    """Handle a config flow for Scrape."""
+
+    config_flow = CONFIG_FLOW
+    options_flow = OPTIONS_FLOW
+    options_flow_reloads = True
+
+    def async_config_entry_title(self, options: Mapping[str, Any]) -> str:
+        """Return config entry title."""
+        return cast(str, options[CONF_RESOURCE])

homeassistant/components/scrape/const.py

@@ -14,8 +14,6 @@ DEFAULT_SCAN_INTERVAL = timedelta(minutes=10)
 
 PLATFORMS = [Platform.SENSOR]
 
-CONF_ADVANCED = "advanced"
-CONF_AUTH = "auth"
 CONF_ENCODING = "encoding"
 CONF_SELECT = "select"
 CONF_INDEX = "index"

homeassistant/components/scrape/icons.json

@@ -1,21 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "sections": {
-          "advanced": "mdi:cog",
-          "auth": "mdi:lock"
-        }
-      }
-    }
-  },
-  "options": {
-    "step": {
-      "init": {
-        "sections": {
-          "advanced": "mdi:cog"
-        }
-      }
-    }
-  }
-}

homeassistant/components/scrape/sensor.py

@@ -46,10 +46,9 @@ TRIGGER_ENTITY_OPTIONS = (
     CONF_AVAILABILITY,
     CONF_DEVICE_CLASS,
     CONF_ICON,
-    CONF_NAME,
     CONF_PICTURE,
-    CONF_STATE_CLASS,
     CONF_UNIQUE_ID,
+    CONF_STATE_CLASS,
     CONF_UNIT_OF_MEASUREMENT,
 )
 
@@ -71,7 +70,7 @@ async def async_setup_platform(
 
     entities: list[ScrapeSensor] = []
     for sensor_config in sensors_config:
-        trigger_entity_config = {}
+        trigger_entity_config = {CONF_NAME: sensor_config[CONF_NAME]}
         for key in TRIGGER_ENTITY_OPTIONS:
             if key not in sensor_config:
                 continue
@@ -99,24 +98,23 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Scrape sensor entry."""
-    coordinator = entry.runtime_data
-    for subentry in entry.subentries.values():
-        sensor = dict(subentry.data)
-        sensor.update(sensor.pop("advanced", {}))
-        sensor[CONF_UNIQUE_ID] = subentry.subentry_id
-        sensor[CONF_NAME] = subentry.title
+    entities: list = []
 
+    coordinator = entry.runtime_data
+    config = dict(entry.options)
+    for sensor in config["sensor"]:
         sensor_config: ConfigType = vol.Schema(
             TEMPLATE_SENSOR_BASE_SCHEMA.schema, extra=vol.ALLOW_EXTRA
         )(sensor)
 
+        name: str = sensor_config[CONF_NAME]
         value_string: str | None = sensor_config.get(CONF_VALUE_TEMPLATE)
 
         value_template: ValueTemplate | None = (
             ValueTemplate(value_string, hass) if value_string is not None else None
         )
 
-        trigger_entity_config: dict[str, str | Template | None] = {}
+        trigger_entity_config: dict[str, str | Template | None] = {CONF_NAME: name}
         for key in TRIGGER_ENTITY_OPTIONS:
             if key not in sensor_config:
                 continue
@@ -125,22 +123,21 @@ async def async_setup_entry(
                 continue
             trigger_entity_config[key] = sensor_config[key]
 
-        async_add_entities(
-            [
-                ScrapeSensor(
-                    hass,
-                    coordinator,
-                    trigger_entity_config,
-                    sensor_config[CONF_SELECT],
-                    sensor_config.get(CONF_ATTRIBUTE),
-                    sensor_config[CONF_INDEX],
-                    value_template,
-                    False,
-                )
-            ],
-            config_subentry_id=subentry.subentry_id,
+        entities.append(
+            ScrapeSensor(
+                hass,
+                coordinator,
+                trigger_entity_config,
+                sensor_config[CONF_SELECT],
+                sensor_config.get(CONF_ATTRIBUTE),
+                sensor_config[CONF_INDEX],
+                value_template,
+                False,
+            )
         )
 
+    async_add_entities(entities)
+
 
 class ScrapeSensor(CoordinatorEntity[ScrapeCoordinator], ManualTriggerSensorEntity):
     """Representation of a web scrape sensor."""

homeassistant/components/scrape/strings.json

@@ -4,140 +4,134 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
     "error": {
-      "no_data": "REST data is empty. Verify your configuration",
-      "resource_error": "Could not update REST data. Verify your configuration"
+      "resource_error": "Could not update rest data. Verify your configuration"
     },
     "step": {
-      "user": {
+      "sensor": {
         "data": {
-          "method": "Method",
-          "payload": "Payload",
-          "resource": "Resource"
+          "attribute": "Attribute",
+          "availability": "Availability template",
+          "device_class": "Device class",
+          "index": "Index",
+          "name": "[%key:common::config_flow::data::name%]",
+          "select": "Select",
+          "state_class": "State class",
+          "unit_of_measurement": "Unit of measurement",
+          "value_template": "Value template"
         },
         "data_description": {
-          "payload": "Payload to use when method is POST.",
-          "resource": "The URL to the website that contains the value."
-        },
-        "sections": {
-          "advanced": {
-            "data": {
-              "encoding": "Character encoding",
-              "headers": "Headers",
-              "timeout": "Timeout",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "encoding": "Character encoding to use. Defaults to UTF-8.",
-              "headers": "Headers to use for the web request.",
-              "timeout": "Timeout for connection to website.",
-              "verify_ssl": "Enables/disables verification of SSL/TLS certificate, for example if it is self-signed."
-            },
-            "description": "Provide additional advanced settings for the resource.",
-            "name": "Advanced settings"
-          },
-          "auth": {
-            "data": {
-              "authentication": "Select authentication method",
-              "password": "[%key:common::config_flow::data::password%]",
-              "username": "[%key:common::config_flow::data::username%]"
-            },
-            "data_description": {
-              "authentication": "Type of the HTTP authentication. Either basic or digest."
-            },
-            "description": "Provide authentication details to access the resource.",
-            "name": "Authentication settings"
-          }
+          "attribute": "Get value of an attribute on the selected tag.",
+          "availability": "Defines a template to get the availability of the sensor.",
+          "device_class": "The type/class of the sensor to set the icon in the frontend.",
+          "index": "Defines which of the elements returned by the CSS selector to use.",
+          "select": "Defines what tag to search for. Check Beautifulsoup CSS selectors for details.",
+          "state_class": "The state_class of the sensor.",
+          "unit_of_measurement": "Choose unit of measurement or create your own.",
+          "value_template": "Defines a template to get the state of the sensor."
         }
-      }
-    }
-  },
-  "config_subentries": {
-    "entity": {
-      "entry_type": "Sensor",
-      "initiate_flow": {
-        "user": "Add sensor"
       },
-      "step": {
-        "user": {
-          "data": {
-            "index": "Index",
-            "select": "Select"
-          },
-          "data_description": {
-            "index": "Defines which of the elements returned by the CSS selector to use.",
-            "select": "Defines what tag to search for. Check Beautifulsoup CSS selectors for details."
-          },
-          "sections": {
-            "advanced": {
-              "data": {
-                "attribute": "Attribute",
-                "availability": "Availability template",
-                "device_class": "Device class",
-                "state_class": "State class",
-                "unit_of_measurement": "Unit of measurement",
-                "value_template": "Value template"
-              },
-              "data_description": {
-                "attribute": "Get value of an attribute on the selected tag.",
-                "availability": "Defines a template to get the availability of the sensor.",
-                "device_class": "The type/class of the sensor to set the icon in the frontend.",
-                "state_class": "The state_class of the sensor.",
-                "unit_of_measurement": "Choose unit of measurement or create your own.",
-                "value_template": "Defines a template to get the state of the sensor."
-              },
-              "description": "Provide additional advanced settings for the sensor.",
-              "name": "Advanced settings"
-            }
-          }
+      "user": {
+        "data": {
+          "authentication": "Select authentication method",
+          "encoding": "Character encoding",
+          "headers": "Headers",
+          "method": "Method",
+          "password": "[%key:common::config_flow::data::password%]",
+          "payload": "Payload",
+          "resource": "Resource",
+          "timeout": "Timeout",
+          "username": "[%key:common::config_flow::data::username%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "data_description": {
+          "authentication": "Type of the HTTP authentication. Either basic or digest.",
+          "encoding": "Character encoding to use. Defaults to UTF-8.",
+          "headers": "Headers to use for the web request.",
+          "payload": "Payload to use when method is POST.",
+          "resource": "The URL to the website that contains the value.",
+          "timeout": "Timeout for connection to website.",
+          "verify_ssl": "Enables/disables verification of SSL/TLS certificate, for example if it is self-signed."
         }
       }
     }
   },
   "options": {
-    "error": {
-      "no_data": "[%key:component::scrape::config::error::no_data%]",
-      "resource_error": "[%key:component::scrape::config::error::resource_error%]"
-    },
     "step": {
-      "init": {
+      "add_sensor": {
         "data": {
-          "method": "[%key:component::scrape::config::step::user::data::method%]",
-          "payload": "[%key:component::scrape::config::step::user::data::payload%]",
-          "resource": "[%key:component::scrape::config::step::user::data::resource%]"
+          "attribute": "[%key:component::scrape::config::step::sensor::data::attribute%]",
+          "availability": "[%key:component::scrape::config::step::sensor::data::availability%]",
+          "device_class": "[%key:component::scrape::config::step::sensor::data::device_class%]",
+          "index": "[%key:component::scrape::config::step::sensor::data::index%]",
+          "name": "[%key:common::config_flow::data::name%]",
+          "select": "[%key:component::scrape::config::step::sensor::data::select%]",
+          "state_class": "[%key:component::scrape::config::step::sensor::data::state_class%]",
+          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data::unit_of_measurement%]",
+          "value_template": "[%key:component::scrape::config::step::sensor::data::value_template%]"
         },
         "data_description": {
-          "payload": "[%key:component::scrape::config::step::user::data_description::payload%]",
-          "resource": "[%key:component::scrape::config::step::user::data_description::resource%]"
+          "attribute": "[%key:component::scrape::config::step::sensor::data_description::attribute%]",
+          "availability": "[%key:component::scrape::config::step::sensor::data_description::availability%]",
+          "device_class": "[%key:component::scrape::config::step::sensor::data_description::device_class%]",
+          "index": "[%key:component::scrape::config::step::sensor::data_description::index%]",
+          "select": "[%key:component::scrape::config::step::sensor::data_description::select%]",
+          "state_class": "[%key:component::scrape::config::step::sensor::data_description::state_class%]",
+          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data_description::unit_of_measurement%]",
+          "value_template": "[%key:component::scrape::config::step::sensor::data_description::value_template%]"
+        }
+      },
+      "edit_sensor": {
+        "data": {
+          "attribute": "[%key:component::scrape::config::step::sensor::data::attribute%]",
+          "availability": "[%key:component::scrape::config::step::sensor::data::availability%]",
+          "device_class": "[%key:component::scrape::config::step::sensor::data::device_class%]",
+          "index": "[%key:component::scrape::config::step::sensor::data::index%]",
+          "name": "[%key:common::config_flow::data::name%]",
+          "select": "[%key:component::scrape::config::step::sensor::data::select%]",
+          "state_class": "[%key:component::scrape::config::step::sensor::data::state_class%]",
+          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data::unit_of_measurement%]",
+          "value_template": "[%key:component::scrape::config::step::sensor::data::value_template%]"
         },
-        "sections": {
-          "advanced": {
-            "data": {
-              "encoding": "[%key:component::scrape::config::step::user::sections::advanced::data::encoding%]",
-              "headers": "[%key:component::scrape::config::step::user::sections::advanced::data::headers%]",
-              "timeout": "[%key:component::scrape::config::step::user::sections::advanced::data::timeout%]",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "encoding": "[%key:component::scrape::config::step::user::sections::advanced::data_description::encoding%]",
-              "headers": "[%key:component::scrape::config::step::user::sections::advanced::data_description::headers%]",
-              "timeout": "[%key:component::scrape::config::step::user::sections::advanced::data_description::timeout%]",
-              "verify_ssl": "[%key:component::scrape::config::step::user::sections::advanced::data_description::verify_ssl%]"
-            },
-            "description": "[%key:component::scrape::config::step::user::sections::advanced::description%]",
-            "name": "[%key:component::scrape::config::step::user::sections::advanced::name%]"
-          },
-          "auth": {
-            "data": {
-              "authentication": "[%key:component::scrape::config::step::user::sections::auth::data::authentication%]",
-              "password": "[%key:common::config_flow::data::password%]",
-              "username": "[%key:common::config_flow::data::username%]"
-            },
-            "data_description": {
-              "authentication": "[%key:component::scrape::config::step::user::sections::auth::data_description::authentication%]"
-            },
-            "description": "[%key:component::scrape::config::step::user::sections::auth::description%]",
-            "name": "[%key:component::scrape::config::step::user::sections::auth::name%]"
-          }
+        "data_description": {
+          "attribute": "[%key:component::scrape::config::step::sensor::data_description::attribute%]",
+          "availability": "[%key:component::scrape::config::step::sensor::data_description::availability%]",
+          "device_class": "[%key:component::scrape::config::step::sensor::data_description::device_class%]",
+          "index": "[%key:component::scrape::config::step::sensor::data_description::index%]",
+          "select": "[%key:component::scrape::config::step::sensor::data_description::select%]",
+          "state_class": "[%key:component::scrape::config::step::sensor::data_description::state_class%]",
+          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data_description::unit_of_measurement%]",
+          "value_template": "[%key:component::scrape::config::step::sensor::data_description::value_template%]"
+        }
+      },
+      "init": {
+        "menu_options": {
+          "add_sensor": "Add sensor",
+          "remove_sensor": "Remove sensor",
+          "resource": "Configure resource",
+          "select_edit_sensor": "Configure sensor"
+        }
+      },
+      "resource": {
+        "data": {
+          "authentication": "[%key:component::scrape::config::step::user::data::authentication%]",
+          "encoding": "[%key:component::scrape::config::step::user::data::encoding%]",
+          "headers": "[%key:component::scrape::config::step::user::data::headers%]",
+          "method": "[%key:component::scrape::config::step::user::data::method%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "payload": "[%key:component::scrape::config::step::user::data::payload%]",
+          "resource": "[%key:component::scrape::config::step::user::data::resource%]",
+          "timeout": "[%key:component::scrape::config::step::user::data::timeout%]",
+          "username": "[%key:common::config_flow::data::username%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "data_description": {
+          "authentication": "[%key:component::scrape::config::step::user::data_description::authentication%]",
+          "encoding": "[%key:component::scrape::config::step::user::data_description::encoding%]",
+          "headers": "[%key:component::scrape::config::step::user::data_description::headers%]",
+          "payload": "[%key:component::scrape::config::step::user::data_description::payload%]",
+          "resource": "[%key:component::scrape::config::step::user::data_description::resource%]",
+          "timeout": "[%key:component::scrape::config::step::user::data_description::timeout%]",
+          "verify_ssl": "[%key:component::scrape::config::step::user::data_description::verify_ssl%]"
         }
       }
     }

homeassistant/components/seven_segments/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/seven_segments",
   "iot_class": "local_polling",
   "quality_scale": "legacy",
-  "requirements": ["Pillow==12.2.0"]
+  "requirements": ["Pillow==12.1.1"]
 }

homeassistant/components/shelly/config_flow.py

@@ -807,7 +807,7 @@ class ShellyConfigFlow(ConfigFlow, domain=DOMAIN):
         )
         ssid_options = [network["ssid"] for network in sorted_networks]
 
-        # Preselect SSID if returning from failed provisioning attempt
+        # Pre-select SSID if returning from failed provisioning attempt
         suggested_values: dict[str, Any] = {}
         if self.selected_ssid:
             suggested_values[CONF_SSID] = self.selected_ssid
@@ -1086,7 +1086,7 @@ class ShellyConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle failed provisioning - allow retry."""
         if user_input is not None:
-            # User wants to retry - keep selected_ssid so it's preselected
+            # User wants to retry - keep selected_ssid so it's pre-selected
             self.wifi_networks = []
             return await self.async_step_wifi_scan()
 

homeassistant/components/sighthound/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["simplehound"],
   "quality_scale": "legacy",
-  "requirements": ["Pillow==12.2.0", "simplehound==0.3"]
+  "requirements": ["Pillow==12.1.1", "simplehound==0.3"]
 }

homeassistant/components/sql/manifest.json

@@ -6,5 +6,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/sql",
   "iot_class": "local_polling",
-  "requirements": ["SQLAlchemy==2.0.49", "sqlparse==0.5.5"]
+  "requirements": ["SQLAlchemy==2.0.41", "sqlparse==0.5.5"]
 }

homeassistant/components/sunricher_dali/diagnostics.py

@@ -1,98 +0,0 @@
-"""Diagnostics support for Sunricher DALI."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from homeassistant.components.diagnostics import REDACTED, async_redact_data
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant
-
-from .const import CONF_SERIAL_NUMBER
-from .types import DaliCenterConfigEntry
-
-if TYPE_CHECKING:
-    from PySrDaliGateway import Device, Scene
-    from PySrDaliGateway.types import SceneDeviceType
-
-TO_REDACT = {
-    CONF_HOST,
-    CONF_USERNAME,
-    CONF_PASSWORD,
-    CONF_SERIAL_NUMBER,
-    "dev_sn",
-}
-
-ALLOWED_ENTRY_KEYS: tuple[str, ...] = (
-    CONF_HOST,
-    CONF_PORT,
-    CONF_NAME,
-    CONF_USERNAME,
-    CONF_PASSWORD,
-    CONF_SERIAL_NUMBER,
-)
-
-
-def _serialize_entry_data(entry: DaliCenterConfigEntry) -> dict[str, Any]:
-    """Return entry data filtered by the whitelist."""
-    return {key: entry.data[key] for key in ALLOWED_ENTRY_KEYS if key in entry.data}
-
-
-def _serialize_device(device: Device) -> dict[str, Any]:
-    """Return a whitelisted dict view of a Device."""
-    return {
-        "dev_id": device.dev_id,
-        "unique_id": device.unique_id,
-        "name": device.name,
-        "dev_type": device.dev_type,
-        "channel": device.channel,
-        "address": device.address,
-        "status": device.status,
-        "dev_sn": device.dev_sn,
-        "area_name": getattr(device, "area_name", None),
-        "area_id": getattr(device, "area_id", None),
-        "model": device.model,
-    }
-
-
-def _serialize_scene(scene: Scene) -> dict[str, Any]:
-    """Return a whitelisted dict view of a Scene."""
-    members: list[SceneDeviceType] = scene.devices
-    return {
-        "scene_id": scene.scene_id,
-        "name": scene.name,
-        "channel": scene.channel,
-        "area_id": getattr(scene, "area_id", None),
-        "unique_id": scene.unique_id,
-        "device_unique_ids": [member["unique_id"] for member in members],
-    }
-
-
-def _strip_gw_sn(data: Any, gw_sn: str) -> Any:
-    """Recursively replace gw_sn in string values and list items."""
-    if isinstance(data, dict):
-        return {key: _strip_gw_sn(value, gw_sn) for key, value in data.items()}
-    if isinstance(data, list):
-        return [_strip_gw_sn(item, gw_sn) for item in data]
-    if isinstance(data, str):
-        return data.replace(gw_sn, REDACTED)
-    return data
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: DaliCenterConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    data = entry.runtime_data
-    payload = {
-        "entry_data": _serialize_entry_data(entry),
-        "devices": [_serialize_device(device) for device in data.devices],
-        "scenes": [_serialize_scene(scene) for scene in data.scenes],
-    }
-    return _strip_gw_sn(async_redact_data(payload, TO_REDACT), data.gateway.gw_sn)

homeassistant/components/sunricher_dali/quality_scale.yaml

@@ -46,7 +46,7 @@ rules:
   test-coverage: done
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info: done
   discovery:
     status: exempt