Bump powerfox to v2.1.1 (#164004)

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

.github/workflows/builder.yml

@@ -272,7 +272,7 @@ jobs:
     name: Build ${{ matrix.machine }} machine core image
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.runs-on }}
     permissions:
       contents: read # To check out the repository
       packages: write # To push to GHCR
@@ -294,6 +294,21 @@ jobs:
           - raspberrypi5-64
           - yellow
           - green
+        include:
+          # Default: aarch64 on native ARM runner
+          - arch: aarch64
+            runs-on: ubuntu-24.04-arm
+          # Overrides for amd64 machines
+          - machine: generic-x86-64
+            arch: amd64
+            runs-on: ubuntu-24.04
+          - machine: qemux86-64
+            arch: amd64
+            runs-on: ubuntu-24.04
+          # TODO: remove, intel-nuc is a legacy name for x86-64, renamed in 2021
+          - machine: intel-nuc
+            arch: amd64
+            runs-on: ubuntu-24.04
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -321,8 +336,9 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build base image
-        uses: home-assistant/builder@21bc64d76dad7a5184c67826aab41c6b6f89023a # 2025.11.0
+        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
         with:
+          image: ${{ matrix.arch }}
           args: |
             $BUILD_ARGS \
             --target /data/machine \

CODEOWNERS

@@ -555,8 +555,6 @@ build.json @home-assistant/supervisor
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
 /tests/components/fritzbox/ @mib1185 @flabbamann
-/homeassistant/components/fritzbox_callmonitor/ @cdce8p
-/tests/components/fritzbox_callmonitor/ @cdce8p
 /homeassistant/components/fronius/ @farmio
 /tests/components/fronius/ @farmio
 /homeassistant/components/frontend/ @home-assistant/frontend
@@ -1968,6 +1966,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/zone/ @home-assistant/core
 /tests/components/zone/ @home-assistant/core
 /homeassistant/components/zoneminder/ @rohankapoorcom @nabbi
+/tests/components/zoneminder/ @rohankapoorcom @nabbi
 /homeassistant/components/zwave_js/ @home-assistant/z-wave
 /tests/components/zwave_js/ @home-assistant/z-wave
 /homeassistant/components/zwave_me/ @lawfulchaos @Z-Wave-Me @PoltoS

homeassistant/components/airos/__init__.py

@@ -4,7 +4,16 @@ from __future__ import annotations
 
 import logging
 
+from airos.airos6 import AirOS6
 from airos.airos8 import AirOS8
+from airos.exceptions import (
+    AirOSConnectionAuthenticationError,
+    AirOSConnectionSetupError,
+    AirOSDataMissingError,
+    AirOSDeviceConnectionError,
+    AirOSKeyDataMissingError,
+)
+from airos.helpers import DetectDeviceData, async_get_firmware_data
 
 from homeassistant.const import (
     CONF_HOST,
@@ -15,6 +24,11 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryError,
+    ConfigEntryNotReady,
+)
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -39,15 +53,40 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
         hass, verify_ssl=entry.data[SECTION_ADVANCED_SETTINGS][CONF_VERIFY_SSL]
     )
 
-    airos_device = AirOS8(
-        host=entry.data[CONF_HOST],
-        username=entry.data[CONF_USERNAME],
-        password=entry.data[CONF_PASSWORD],
-        session=session,
-        use_ssl=entry.data[SECTION_ADVANCED_SETTINGS][CONF_SSL],
+    conn_data = {
+        CONF_HOST: entry.data[CONF_HOST],
+        CONF_USERNAME: entry.data[CONF_USERNAME],
+        CONF_PASSWORD: entry.data[CONF_PASSWORD],
+        "use_ssl": entry.data[SECTION_ADVANCED_SETTINGS][CONF_SSL],
+        "session": session,
+    }
+
+    # Determine firmware version before creating the device instance
+    try:
+        device_data: DetectDeviceData = await async_get_firmware_data(**conn_data)
+    except (
+        AirOSConnectionSetupError,
+        AirOSDeviceConnectionError,
+        TimeoutError,
+    ) as err:
+        raise ConfigEntryNotReady from err
+    except (
+        AirOSConnectionAuthenticationError,
+        AirOSDataMissingError,
+    ) as err:
+        raise ConfigEntryAuthFailed from err
+    except AirOSKeyDataMissingError as err:
+        raise ConfigEntryError("key_data_missing") from err
+    except Exception as err:
+        raise ConfigEntryError("unknown") from err
+
+    airos_class: type[AirOS8 | AirOS6] = (
+        AirOS8 if device_data["fw_major"] == 8 else AirOS6
     )
 
-    coordinator = AirOSDataUpdateCoordinator(hass, entry, airos_device)
+    airos_device = airos_class(**conn_data)
+
+    coordinator = AirOSDataUpdateCoordinator(hass, entry, device_data, airos_device)
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator

homeassistant/components/airos/binary_sensor.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-import logging
+from typing import Generic, TypeVar
+
+from airos.data import AirOSDataBaseClass
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -18,25 +20,24 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import AirOS8Data, AirOSConfigEntry, AirOSDataUpdateCoordinator
 from .entity import AirOSEntity
 
-_LOGGER = logging.getLogger(__name__)
-
 PARALLEL_UPDATES = 0
 
+AirOSDataModel = TypeVar("AirOSDataModel", bound=AirOSDataBaseClass)
+
 
 @dataclass(frozen=True, kw_only=True)
-class AirOSBinarySensorEntityDescription(BinarySensorEntityDescription):
+class AirOSBinarySensorEntityDescription(
+    BinarySensorEntityDescription,
+    Generic[AirOSDataModel],
+):
     """Describe an AirOS binary sensor."""
 
-    value_fn: Callable[[AirOS8Data], bool]
+    value_fn: Callable[[AirOSDataModel], bool]
 
 
-BINARY_SENSORS: tuple[AirOSBinarySensorEntityDescription, ...] = (
-    AirOSBinarySensorEntityDescription(
-        key="portfw",
-        translation_key="port_forwarding",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.portfw,
-    ),
+AirOS8BinarySensorEntityDescription = AirOSBinarySensorEntityDescription[AirOS8Data]
+
+COMMON_BINARY_SENSORS: tuple[AirOSBinarySensorEntityDescription, ...] = (
     AirOSBinarySensorEntityDescription(
         key="dhcp_client",
         translation_key="dhcp_client",
@@ -52,14 +53,6 @@ BINARY_SENSORS: tuple[AirOSBinarySensorEntityDescription, ...] = (
         value_fn=lambda data: data.services.dhcpd,
         entity_registry_enabled_default=False,
     ),
-    AirOSBinarySensorEntityDescription(
-        key="dhcp6_server",
-        translation_key="dhcp6_server",
-        device_class=BinarySensorDeviceClass.RUNNING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: data.services.dhcp6d_stateful,
-        entity_registry_enabled_default=False,
-    ),
     AirOSBinarySensorEntityDescription(
         key="pppoe",
         translation_key="pppoe",
@@ -70,6 +63,23 @@ BINARY_SENSORS: tuple[AirOSBinarySensorEntityDescription, ...] = (
     ),
 )
 
+AIROS8_BINARY_SENSORS: tuple[AirOS8BinarySensorEntityDescription, ...] = (
+    AirOS8BinarySensorEntityDescription(
+        key="portfw",
+        translation_key="port_forwarding",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda data: data.portfw,
+    ),
+    AirOS8BinarySensorEntityDescription(
+        key="dhcp6_server",
+        translation_key="dhcp6_server",
+        device_class=BinarySensorDeviceClass.RUNNING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda data: data.services.dhcp6d_stateful,
+        entity_registry_enabled_default=False,
+    ),
+)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -79,10 +89,20 @@ async def async_setup_entry(
     """Set up the AirOS binary sensors from a config entry."""
     coordinator = config_entry.runtime_data
 
-    async_add_entities(
-        AirOSBinarySensor(coordinator, description) for description in BINARY_SENSORS
+    entities: list[BinarySensorEntity] = []
+    entities.extend(
+        AirOSBinarySensor(coordinator, description)
+        for description in COMMON_BINARY_SENSORS
     )
 
+    if coordinator.device_data["fw_major"] == 8:
+        entities.extend(
+            AirOSBinarySensor(coordinator, description)
+            for description in AIROS8_BINARY_SENSORS
+        )
+
+    async_add_entities(entities)
+
 
 class AirOSBinarySensor(AirOSEntity, BinarySensorEntity):
     """Representation of a binary sensor."""

homeassistant/components/airos/button.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import logging
-
 from airos.exceptions import AirOSException
 
 from homeassistant.components.button import (
@@ -18,8 +16,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import DOMAIN, AirOSConfigEntry, AirOSDataUpdateCoordinator
 from .entity import AirOSEntity
 
-_LOGGER = logging.getLogger(__name__)
-
 PARALLEL_UPDATES = 0
 
 REBOOT_BUTTON = ButtonEntityDescription(

homeassistant/components/airos/config_flow.py

@@ -7,6 +7,8 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
+from airos.airos6 import AirOS6
+from airos.airos8 import AirOS8
 from airos.discovery import airos_discover_devices
 from airos.exceptions import (
     AirOSConnectionAuthenticationError,
@@ -17,6 +19,7 @@ from airos.exceptions import (
     AirOSKeyDataMissingError,
     AirOSListenerError,
 )
+from airos.helpers import DetectDeviceData, async_get_firmware_data
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -34,11 +37,13 @@ from homeassistant.const import (
 )
 from homeassistant.data_entry_flow import section
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.selector import (
     TextSelector,
     TextSelectorConfig,
     TextSelectorType,
 )
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
 from .const import (
     DEFAULT_SSL,
@@ -51,10 +56,11 @@ from .const import (
     MAC_ADDRESS,
     SECTION_ADVANCED_SETTINGS,
 )
-from .coordinator import AirOS8
 
 _LOGGER = logging.getLogger(__name__)
 
+AirOSDeviceDetect = AirOS8 | AirOS6
+
 # Discovery duration in seconds, airOS announces every 20 seconds
 DISCOVER_INTERVAL: int = 30
 
@@ -90,7 +96,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     def __init__(self) -> None:
         """Initialize the config flow."""
         super().__init__()
-        self.airos_device: AirOS8
+        self.airos_device: AirOSDeviceDetect
         self.errors: dict[str, str] = {}
         self.discovered_devices: dict[str, dict[str, Any]] = {}
         self.discovery_abort_reason: str | None = None
@@ -133,16 +139,14 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             verify_ssl=config_data[SECTION_ADVANCED_SETTINGS][CONF_VERIFY_SSL],
         )
 
-        airos_device = AirOS8(
-            host=config_data[CONF_HOST],
-            username=config_data[CONF_USERNAME],
-            password=config_data[CONF_PASSWORD],
-            session=session,
-            use_ssl=config_data[SECTION_ADVANCED_SETTINGS][CONF_SSL],
-        )
         try:
-            await airos_device.login()
-            airos_data = await airos_device.status()
+            device_data: DetectDeviceData = await async_get_firmware_data(
+                host=config_data[CONF_HOST],
+                username=config_data[CONF_USERNAME],
+                password=config_data[CONF_PASSWORD],
+                session=session,
+                use_ssl=config_data[SECTION_ADVANCED_SETTINGS][CONF_SSL],
+            )
 
         except (
             AirOSConnectionSetupError,
@@ -157,14 +161,14 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.exception("Unexpected exception during credential validation")
             self.errors["base"] = "unknown"
         else:
-            await self.async_set_unique_id(airos_data.derived.mac)
+            await self.async_set_unique_id(device_data["mac"])
 
             if self.source in [SOURCE_REAUTH, SOURCE_RECONFIGURE]:
                 self._abort_if_unique_id_mismatch()
             else:
                 self._abort_if_unique_id_configured()
 
-            return {"title": airos_data.host.hostname, "data": config_data}
+            return {"title": device_data["hostname"], "data": config_data}
 
         return None
 
@@ -392,6 +396,18 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
         except asyncio.CancelledError:
             pass
 
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Automatically handle a DHCP discovered IP change."""
+        ip_address = discovery_info.ip
+        # python-airos defaults to upper for derived mac_address
+        normalized_mac = format_mac(discovery_info.macaddress).upper()
+        await self.async_set_unique_id(normalized_mac)
+
+        self._abort_if_unique_id_configured(updates={CONF_HOST: ip_address})
+        return self.async_abort(reason="unreachable")
+
     async def async_step_discovery_no_devices(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/airos/coordinator.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 
+from airos.airos6 import AirOS6, AirOS6Data
 from airos.airos8 import AirOS8, AirOS8Data
 from airos.exceptions import (
     AirOSConnectionAuthenticationError,
@@ -11,6 +12,7 @@ from airos.exceptions import (
     AirOSDataMissingError,
     AirOSDeviceConnectionError,
 )
+from airos.helpers import DetectDeviceData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -21,19 +23,28 @@ from .const import DOMAIN, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
+AirOSDeviceDetect = AirOS8 | AirOS6
+AirOSDataDetect = AirOS8Data | AirOS6Data
+
 type AirOSConfigEntry = ConfigEntry[AirOSDataUpdateCoordinator]
 
 
-class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOS8Data]):
+class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
     """Class to manage fetching AirOS data from single endpoint."""
 
+    airos_device: AirOSDeviceDetect
     config_entry: AirOSConfigEntry
 
     def __init__(
-        self, hass: HomeAssistant, config_entry: AirOSConfigEntry, airos_device: AirOS8
+        self,
+        hass: HomeAssistant,
+        config_entry: AirOSConfigEntry,
+        device_data: DetectDeviceData,
+        airos_device: AirOSDeviceDetect,
     ) -> None:
         """Initialize the coordinator."""
         self.airos_device = airos_device
+        self.device_data = device_data
         super().__init__(
             hass,
             _LOGGER,
@@ -42,7 +53,7 @@ class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOS8Data]):
             update_interval=SCAN_INTERVAL,
         )
 
-    async def _async_update_data(self) -> AirOS8Data:
+    async def _async_update_data(self) -> AirOSDataDetect:
         """Fetch data from AirOS."""
         try:
             await self.airos_device.login()
@@ -62,7 +73,7 @@ class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOS8Data]):
                 translation_domain=DOMAIN,
                 translation_key="cannot_connect",
             ) from err
-        except (AirOSDataMissingError,) as err:
+        except AirOSDataMissingError as err:
             _LOGGER.error("Expected data not returned by airOS device: %s", err)
             raise UpdateFailed(
                 translation_domain=DOMAIN,

homeassistant/components/airos/manifest.json

@@ -3,9 +3,10 @@
   "name": "Ubiquiti airOS",
   "codeowners": ["@CoMPaTech"],
   "config_flow": true,
+  "dhcp": [{ "registered_devices": true }],
   "documentation": "https://www.home-assistant.io/integrations/airos",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["airos==0.6.4"]
 }

homeassistant/components/airos/quality_scale.yaml

@@ -42,16 +42,20 @@ rules:
   # Gold
   devices: done
   diagnostics: done
-  discovery-update-info: todo
-  discovery: todo
+  discovery-update-info: done
+  discovery:
+    status: exempt
+    comment: No way to detect device on the network
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: todo
+  dynamic-devices:
+    status: exempt
+    comment: single airOS device per config entry; peer/remote endpoints are not modeled as child devices/entities at this time
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
@@ -61,8 +65,10 @@ rules:
     status: exempt
     comment: no (custom) icons used or envisioned
   reconfiguration-flow: done
-  repair-issues: todo
-  stale-devices: todo
+  repair-issues: done
+  stale-devices:
+    status: exempt
+    comment: single airOS device per config entry; peer/remote endpoints are not modeled as child devices/entities at this time
 
   # Platinum
   async-dependency: done

homeassistant/components/airos/sensor.py

@@ -5,8 +5,14 @@ from __future__ import annotations
 from collections.abc import Callable
 from dataclasses import dataclass
 import logging
+from typing import Generic, TypeVar
 
-from airos.data import DerivedWirelessMode, DerivedWirelessRole, NetRole
+from airos.data import (
+    AirOSDataBaseClass,
+    DerivedWirelessMode,
+    DerivedWirelessRole,
+    NetRole,
+)
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -37,15 +43,19 @@ WIRELESS_ROLE_OPTIONS = [mode.value for mode in DerivedWirelessRole]
 
 PARALLEL_UPDATES = 0
 
+AirOSDataModel = TypeVar("AirOSDataModel", bound=AirOSDataBaseClass)
+
 
 @dataclass(frozen=True, kw_only=True)
-class AirOSSensorEntityDescription(SensorEntityDescription):
+class AirOSSensorEntityDescription(SensorEntityDescription, Generic[AirOSDataModel]):
     """Describe an AirOS sensor."""
 
-    value_fn: Callable[[AirOS8Data], StateType]
+    value_fn: Callable[[AirOSDataModel], StateType]
 
 
-SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
+AirOS8SensorEntityDescription = AirOSSensorEntityDescription[AirOS8Data]
+
+COMMON_SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
     AirOSSensorEntityDescription(
         key="host_cpuload",
         translation_key="host_cpuload",
@@ -75,54 +85,6 @@ SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
         translation_key="wireless_essid",
         value_fn=lambda data: data.wireless.essid,
     ),
-    AirOSSensorEntityDescription(
-        key="wireless_antenna_gain",
-        translation_key="wireless_antenna_gain",
-        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
-        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.wireless.antenna_gain,
-    ),
-    AirOSSensorEntityDescription(
-        key="wireless_throughput_tx",
-        translation_key="wireless_throughput_tx",
-        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
-        device_class=SensorDeviceClass.DATA_RATE,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
-        value_fn=lambda data: data.wireless.throughput.tx,
-    ),
-    AirOSSensorEntityDescription(
-        key="wireless_throughput_rx",
-        translation_key="wireless_throughput_rx",
-        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
-        device_class=SensorDeviceClass.DATA_RATE,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
-        value_fn=lambda data: data.wireless.throughput.rx,
-    ),
-    AirOSSensorEntityDescription(
-        key="wireless_polling_dl_capacity",
-        translation_key="wireless_polling_dl_capacity",
-        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
-        device_class=SensorDeviceClass.DATA_RATE,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
-        value_fn=lambda data: data.wireless.polling.dl_capacity,
-    ),
-    AirOSSensorEntityDescription(
-        key="wireless_polling_ul_capacity",
-        translation_key="wireless_polling_ul_capacity",
-        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
-        device_class=SensorDeviceClass.DATA_RATE,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
-        value_fn=lambda data: data.wireless.polling.ul_capacity,
-    ),
     AirOSSensorEntityDescription(
         key="host_uptime",
         translation_key="host_uptime",
@@ -158,6 +120,57 @@ SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
         options=WIRELESS_ROLE_OPTIONS,
         entity_registry_enabled_default=False,
     ),
+    AirOSSensorEntityDescription(
+        key="wireless_antenna_gain",
+        translation_key="wireless_antenna_gain",
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.antenna_gain,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_polling_dl_capacity",
+        translation_key="wireless_polling_dl_capacity",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
+        value_fn=lambda data: data.wireless.polling.dl_capacity,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_polling_ul_capacity",
+        translation_key="wireless_polling_ul_capacity",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
+        value_fn=lambda data: data.wireless.polling.ul_capacity,
+    ),
+)
+
+AIROS8_SENSORS: tuple[AirOS8SensorEntityDescription, ...] = (
+    AirOS8SensorEntityDescription(
+        key="wireless_throughput_tx",
+        translation_key="wireless_throughput_tx",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
+        value_fn=lambda data: data.wireless.throughput.tx,
+    ),
+    AirOS8SensorEntityDescription(
+        key="wireless_throughput_rx",
+        translation_key="wireless_throughput_rx",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        suggested_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
+        value_fn=lambda data: data.wireless.throughput.rx,
+    ),
 )
 
 
@@ -169,7 +182,14 @@ async def async_setup_entry(
     """Set up the AirOS sensors from a config entry."""
     coordinator = config_entry.runtime_data
 
-    async_add_entities(AirOSSensor(coordinator, description) for description in SENSORS)
+    async_add_entities(
+        AirOSSensor(coordinator, description) for description in COMMON_SENSORS
+    )
+
+    if coordinator.device_data["fw_major"] == 8:
+        async_add_entities(
+            AirOSSensor(coordinator, description) for description in AIROS8_SENSORS
+        )
 
 
 class AirOSSensor(AirOSEntity, SensorEntity):

homeassistant/components/aladdin_connect/__init__.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import aiohttp
 from genie_partner_sdk.client import AladdinConnectClient
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import (
     aiohttp_client,
     config_entry_oauth2_flow,
@@ -31,11 +33,27 @@ async def async_setup_entry(
 
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
 
+    try:
+        await session.async_ensure_token_valid()
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed(err) from err
+        raise ConfigEntryNotReady from err
+    except aiohttp.ClientError as err:
+        raise ConfigEntryNotReady from err
+
     client = AladdinConnectClient(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    doors = await client.get_doors()
+    try:
+        doors = await client.get_doors()
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed(err) from err
+        raise ConfigEntryNotReady from err
+    except aiohttp.ClientError as err:
+        raise ConfigEntryNotReady from err
 
     entry.runtime_data = {
         door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)

homeassistant/components/aladdin_connect/api.py

@@ -11,6 +11,18 @@ API_URL = "https://twdvzuefzh.execute-api.us-east-2.amazonaws.com/v1"
 API_KEY = "k6QaiQmcTm2zfaNns5L1Z8duBtJmhDOW8JawlCC3"
 
 
+class AsyncConfigFlowAuth(Auth):
+    """Provide Aladdin Connect Genie authentication for config flow validation."""
+
+    def __init__(self, websession: ClientSession, access_token: str) -> None:
+        """Initialize Aladdin Connect Genie auth."""
+        super().__init__(websession, API_URL, access_token, API_KEY)
+
+    async def async_get_access_token(self) -> str:
+        """Return the access token."""
+        return self.access_token
+
+
 class AsyncConfigEntryAuth(Auth):
     """Provide Aladdin Connect Genie authentication tied to an OAuth2 based config entry."""
 

homeassistant/components/aladdin_connect/config_flow.py

@@ -4,12 +4,14 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
+from genie_partner_sdk.client import AladdinConnectClient
 import jwt
 import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
-from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
 
+from .api import AsyncConfigFlowAuth
 from .const import CONFIG_FLOW_MINOR_VERSION, CONFIG_FLOW_VERSION, DOMAIN
 
 
@@ -52,11 +54,25 @@ class OAuth2FlowHandler(
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an oauth config entry or update existing entry for reauth."""
-        # Extract the user ID from the JWT token's 'sub' field
-        token = jwt.decode(
-            data["token"]["access_token"], options={"verify_signature": False}
+        try:
+            token = jwt.decode(
+                data["token"]["access_token"], options={"verify_signature": False}
+            )
+            user_id = token["sub"]
+        except jwt.DecodeError, KeyError:
+            return self.async_abort(reason="oauth_error")
+
+        client = AladdinConnectClient(
+            AsyncConfigFlowAuth(
+                aiohttp_client.async_get_clientsession(self.hass),
+                data["token"]["access_token"],
+            )
         )
-        user_id = token["sub"]
+        try:
+            await client.get_doors()
+        except Exception:  # noqa: BLE001
+            return self.async_abort(reason="cannot_connect")
+
         await self.async_set_unique_id(user_id)
 
         if self.source == SOURCE_REAUTH:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -7,39 +7,31 @@ rules:
   brands: done
   common-modules: done
   config-flow: done
-  config-flow-test-coverage: todo
+  config-flow-test-coverage: done
   dependency-transparency: done
   docs-actions:
     status: exempt
     comment: Integration does not register any service actions.
   docs-high-level-description: done
-  docs-installation-instructions:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-removal-instructions:
-    status: todo
-    comment: Documentation needs to be created.
+  docs-installation-instructions: done
+  docs-removal-instructions: done
   entity-event-setup:
     status: exempt
     comment: Integration does not subscribe to external events.
   entity-unique-id: done
   has-entity-name: done
   runtime-data: done
-  test-before-configure:
-    status: todo
-    comment: Config flow does not currently test connection during setup.
-  test-before-setup: todo
+  test-before-configure: done
+  test-before-setup: done
   unique-config-entry: done
 
   # Silver
   action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-installation-parameters:
-    status: todo
-    comment: Documentation needs to be created.
+    status: exempt
+    comment: Integration does not have an options flow.
+  docs-installation-parameters: done
   entity-unavailable: todo
   integration-owner: done
   log-when-unavailable: todo
@@ -52,29 +44,17 @@ rules:
   # Gold
   devices: done
   diagnostics: todo
-  discovery: todo
-  discovery-update-info: todo
-  docs-data-update:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-examples:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-known-limitations:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-supported-devices:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-supported-functions:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-troubleshooting:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-use-cases:
-    status: todo
-    comment: Documentation needs to be created.
+  discovery: done
+  discovery-update-info:
+    status: exempt
+    comment: Integration connects via the cloud and not locally.
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
@@ -86,7 +66,7 @@ rules:
   repair-issues: todo
   stale-devices:
     status: todo
-    comment: Stale devices can be done dynamically
+    comment: We can automatically remove removed devices
 
   # Platinum
   async-dependency: todo

homeassistant/components/aladdin_connect/strings.json

@@ -4,6 +4,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "cloud_not_enabled": "Please make sure you run Home Assistant with `{default_config}` enabled in your configuration.yaml.",
       "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",

homeassistant/components/anthropic/config_flow.py

@@ -112,19 +112,12 @@ async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionD
         # Resolve alias from versioned model name:
         model_alias = (
             model_info.id[:-9]
-            if model_info.id
-            not in (
-                "claude-3-haiku-20240307",
-                "claude-3-5-haiku-20241022",
-                "claude-3-opus-20240229",
-            )
+            if model_info.id != "claude-3-haiku-20240307"
             and model_info.id[-2:-1] != "-"
             else model_info.id
         )
         if short_form.search(model_alias):
             model_alias += "-0"
-        if model_alias.endswith(("haiku", "opus", "sonnet")):
-            model_alias += "-latest"
         model_options.append(
             SelectOptionDict(
                 label=model_info.display_name,

homeassistant/components/anthropic/const.py

@@ -37,8 +37,6 @@ DEFAULT = {
 MIN_THINKING_BUDGET = 1024
 
 NON_THINKING_MODELS = [
-    "claude-3-5",  # Both sonnet and haiku
-    "claude-3-opus",
     "claude-3-haiku",
 ]
 
@@ -51,7 +49,7 @@ NON_ADAPTIVE_THINKING_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3",
+    "claude-3-haiku",
 ]
 
 UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
@@ -60,19 +58,13 @@ UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3",
+    "claude-3-haiku",
 ]
 
 WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
-    "claude-3-opus",
-    "claude-3-5-sonnet-20240620",
-    "claude-3-5-sonnet-20241022",
 ]
 
 DEPRECATED_MODELS = [
-    "claude-3-5-haiku",
-    "claude-3-7-sonnet",
-    "claude-3-5-sonnet",
-    "claude-3-opus",
+    "claude-3",
 ]

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,6 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.78.0"]
+  "quality_scale": "bronze",
+  "requirements": ["anthropic==0.83.0"]
 }

homeassistant/components/anthropic/repairs.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 import voluptuous as vol
 
@@ -19,7 +19,7 @@ from homeassistant.helpers.selector import (
 )
 
 from .config_flow import get_model_list
-from .const import CONF_CHAT_MODEL, DEFAULT, DEPRECATED_MODELS, DOMAIN
+from .const import CONF_CHAT_MODEL, DEPRECATED_MODELS, DOMAIN
 
 if TYPE_CHECKING:
     from . import AnthropicConfigEntry
@@ -67,13 +67,23 @@ class ModelDeprecatedRepairFlow(RepairsFlow):
             self._model_list_cache[entry.entry_id] = model_list
 
         if "opus" in model:
-            suggested_model = "claude-opus-4-5"
-        elif "haiku" in model:
-            suggested_model = "claude-haiku-4-5"
+            family = "claude-opus"
         elif "sonnet" in model:
-            suggested_model = "claude-sonnet-4-5"
+            family = "claude-sonnet"
         else:
-            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
+            family = "claude-haiku"
+
+        suggested_model = next(
+            (
+                model_option["value"]
+                for model_option in sorted(
+                    (m for m in model_list if family in m["value"]),
+                    key=lambda x: x["value"],
+                    reverse=True,
+                )
+            ),
+            vol.UNDEFINED,
+        )
 
         schema = vol.Schema(
             {

homeassistant/components/backup/util.py

@@ -16,6 +16,7 @@ from typing import IO, Any, cast
 
 import aiohttp
 from securetar import (
+    InvalidPasswordError,
     SecureTarArchive,
     SecureTarError,
     SecureTarFile,
@@ -165,7 +166,7 @@ def validate_password(path: Path, password: str | None) -> bool:
             ):
                 # If we can read the tar file, the password is correct
                 return True
-        except tarfile.ReadError, SecureTarReadError:
+        except tarfile.ReadError, InvalidPasswordError, SecureTarReadError:
             LOGGER.debug("Invalid password")
             return False
         except Exception:  # noqa: BLE001
@@ -192,13 +193,14 @@ def validate_password_stream(
         for obj in input_archive.tar:
             if not obj.name.endswith((".tar", ".tgz", ".tar.gz")):
                 continue
-            with input_archive.extract_tar(obj) as decrypted:
-                if decrypted.plaintext_size is None:
-                    raise UnsupportedSecureTarVersion
-                try:
+            try:
+                with input_archive.extract_tar(obj) as decrypted:
+                    if decrypted.plaintext_size is None:
+                        raise UnsupportedSecureTarVersion
                     decrypted.read(1)  # Read a single byte to trigger the decryption
-                except SecureTarReadError as err:
-                    raise IncorrectPassword from err
+            except (InvalidPasswordError, SecureTarReadError) as err:
+                raise IncorrectPassword from err
+            else:
                 return
     raise BackupEmpty
 

homeassistant/components/bsblan/__init__.py

@@ -1,4 +1,4 @@
-"""The BSB-Lan integration."""
+"""The BSB-LAN integration."""
 
 import asyncio
 import dataclasses
@@ -36,7 +36,7 @@ from .const import CONF_PASSKEY, DOMAIN
 from .coordinator import BSBLanFastCoordinator, BSBLanSlowCoordinator
 from .services import async_setup_services
 
-PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
+PLATFORMS = [Platform.BUTTON, Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
@@ -56,13 +56,13 @@ class BSBLanData:
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the BSB-Lan integration."""
+    """Set up the BSB-LAN integration."""
     async_setup_services(hass)
     return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bool:
-    """Set up BSB-Lan from a config entry."""
+    """Set up BSB-LAN from a config entry."""
 
     # create config using BSBLANConfig
     config = BSBLANConfig(

homeassistant/components/bsblan/button.py

@@ -0,0 +1,59 @@
+"""Button platform for BSB-Lan integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BSBLanConfigEntry, BSBLanData
+from .coordinator import BSBLanFastCoordinator
+from .entity import BSBLanEntity
+from .helpers import async_sync_device_time
+
+PARALLEL_UPDATES = 1
+
+BUTTON_DESCRIPTIONS: tuple[ButtonEntityDescription, ...] = (
+    ButtonEntityDescription(
+        key="sync_time",
+        translation_key="sync_time",
+        entity_category=EntityCategory.CONFIG,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: BSBLanConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up BSB-Lan button entities from a config entry."""
+    data = entry.runtime_data
+
+    async_add_entities(
+        BSBLanButtonEntity(data.fast_coordinator, data, description)
+        for description in BUTTON_DESCRIPTIONS
+    )
+
+
+class BSBLanButtonEntity(BSBLanEntity, ButtonEntity):
+    """Defines a BSB-Lan button entity."""
+
+    entity_description: ButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: BSBLanFastCoordinator,
+        data: BSBLanData,
+        description: ButtonEntityDescription,
+    ) -> None:
+        """Initialize BSB-Lan button entity."""
+        super().__init__(coordinator, data)
+        self.entity_description = description
+        self._attr_unique_id = f"{data.device.MAC}-{description.key}"
+        self._data = data
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        await async_sync_device_time(self._data.client, self._data.device.name)

homeassistant/components/bsblan/climate.py

@@ -39,15 +39,15 @@ PRESET_MODES = [
     PRESET_NONE,
 ]
 
-# Mapping from Home Assistant HVACMode to BSB-Lan integer values
-# BSB-Lan uses: 0=off, 1=auto, 2=eco/reduced, 3=heat/comfort
+# Mapping from Home Assistant HVACMode to BSB-LAN integer values
+# BSB-LAN uses: 0=off, 1=auto, 2=eco/reduced, 3=heat/comfort
 HA_TO_BSBLAN_HVAC_MODE: Final[dict[HVACMode, int]] = {
     HVACMode.OFF: 0,
     HVACMode.AUTO: 1,
     HVACMode.HEAT: 3,
 }
 
-# Mapping from BSB-Lan integer values to Home Assistant HVACMode
+# Mapping from BSB-LAN integer values to Home Assistant HVACMode
 BSBLAN_TO_HA_HVAC_MODE: Final[dict[int, HVACMode]] = {
     0: HVACMode.OFF,
     1: HVACMode.AUTO,
@@ -69,7 +69,6 @@ async def async_setup_entry(
 class BSBLANClimate(BSBLanEntity, ClimateEntity):
     """Defines a BSBLAN climate device."""
 
-    _attr_has_entity_name = True
     _attr_name = None
     # Determine preset modes
     _attr_supported_features = (
@@ -138,7 +137,7 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        # BSB-Lan mode 2 is eco/reduced mode
+        # BSB-LAN mode 2 is eco/reduced mode
         if self._hvac_mode_value == 2:
             return PRESET_ECO
         return PRESET_NONE
@@ -163,7 +162,7 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         if ATTR_HVAC_MODE in kwargs:
             data[ATTR_HVAC_MODE] = HA_TO_BSBLAN_HVAC_MODE[kwargs[ATTR_HVAC_MODE]]
         if ATTR_PRESET_MODE in kwargs:
-            # eco preset uses BSB-Lan mode 2, none preset uses mode 1 (auto)
+            # eco preset uses BSB-LAN mode 2, none preset uses mode 1 (auto)
             if kwargs[ATTR_PRESET_MODE] == PRESET_ECO:
                 data[ATTR_HVAC_MODE] = 2
             elif kwargs[ATTR_PRESET_MODE] == PRESET_NONE:

homeassistant/components/bsblan/config_flow.py

@@ -1,4 +1,4 @@
-"""Config flow for BSB-Lan integration."""
+"""Config flow for BSB-LAN integration."""
 
 from __future__ import annotations
 

homeassistant/components/bsblan/const.py

@@ -1,4 +1,4 @@
-"""Constants for the BSB-Lan integration."""
+"""Constants for the BSB-LAN integration."""
 
 from __future__ import annotations
 

homeassistant/components/bsblan/coordinator.py

@@ -1,4 +1,4 @@
-"""DataUpdateCoordinator for the BSB-Lan integration."""
+"""DataUpdateCoordinator for the BSB-LAN integration."""
 
 from __future__ import annotations
 
@@ -29,8 +29,13 @@ if TYPE_CHECKING:
 
 # Filter lists for optimized API calls - only fetch parameters we actually use
 # This significantly reduces response time (~0.2s per parameter saved)
-STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
-SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
+STATE_INCLUDE = [
+    "current_temperature",
+    "target_temperature",
+    "hvac_mode",
+    "hvac_action",
+]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature", "total_energy"]
 DHW_STATE_INCLUDE = [
     "operating_mode",
     "nominal_setpoint",
@@ -57,7 +62,7 @@ class BSBLanSlowData:
 
 
 class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
-    """Base BSB-Lan coordinator."""
+    """Base BSB-LAN coordinator."""
 
     config_entry: BSBLanConfigEntry
 
@@ -69,7 +74,7 @@ class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
         name: str,
         update_interval: timedelta,
     ) -> None:
-        """Initialize the BSB-Lan coordinator."""
+        """Initialize the BSB-LAN coordinator."""
         super().__init__(
             hass,
             logger=LOGGER,
@@ -81,7 +86,7 @@ class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
 
 
 class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
-    """The BSB-Lan fast update coordinator for frequently changing data."""
+    """The BSB-LAN fast update coordinator for frequently changing data."""
 
     def __init__(
         self,
@@ -89,7 +94,7 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
         config_entry: BSBLanConfigEntry,
         client: BSBLAN,
     ) -> None:
-        """Initialize the BSB-Lan fast coordinator."""
+        """Initialize the BSB-LAN fast coordinator."""
         super().__init__(
             hass,
             config_entry,
@@ -99,7 +104,7 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
         )
 
     async def _async_update_data(self) -> BSBLanFastData:
-        """Fetch fast-changing data from the BSB-Lan device."""
+        """Fetch fast-changing data from the BSB-LAN device."""
         try:
             # Client is already initialized in async_setup_entry
             # Use include filtering to only fetch parameters we actually use
@@ -110,12 +115,15 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
 
         except BSBLANAuthError as err:
             raise ConfigEntryAuthFailed(
-                "Authentication failed for BSB-Lan device"
+                translation_domain=DOMAIN,
+                translation_key="coordinator_auth_error",
             ) from err
         except BSBLANConnectionError as err:
             host = self.config_entry.data[CONF_HOST]
             raise UpdateFailed(
-                f"Error while establishing connection with BSB-Lan device at {host}"
+                translation_domain=DOMAIN,
+                translation_key="coordinator_connection_error",
+                translation_placeholders={"host": host},
             ) from err
 
         return BSBLanFastData(
@@ -126,7 +134,7 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
 
 
 class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
-    """The BSB-Lan slow update coordinator for infrequently changing data."""
+    """The BSB-LAN slow update coordinator for infrequently changing data."""
 
     def __init__(
         self,
@@ -134,7 +142,7 @@ class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
         config_entry: BSBLanConfigEntry,
         client: BSBLAN,
     ) -> None:
-        """Initialize the BSB-Lan slow coordinator."""
+        """Initialize the BSB-LAN slow coordinator."""
         super().__init__(
             hass,
             config_entry,
@@ -144,7 +152,7 @@ class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
         )
 
     async def _async_update_data(self) -> BSBLanSlowData:
-        """Fetch slow-changing data from the BSB-Lan device."""
+        """Fetch slow-changing data from the BSB-LAN device."""
         try:
             # Client is already initialized in async_setup_entry
             # Use include filtering to only fetch parameters we actually use

homeassistant/components/bsblan/entity.py

@@ -32,6 +32,15 @@ class BSBLanEntityBase[_T: BSBLanCoordinator](CoordinatorEntity[_T]):
             model=(
                 data.info.device_identification.value
                 if data.info.device_identification
+                and data.info.device_identification.value
+                else None
+            ),
+            model_id=(
+                f"{data.info.controller_family.value}_{data.info.controller_variant.value}"
+                if data.info.controller_family
+                and data.info.controller_variant
+                and data.info.controller_family.value
+                and data.info.controller_variant.value
                 else None
             ),
             sw_version=data.device.version,

homeassistant/components/bsblan/helpers.py

@@ -0,0 +1,42 @@
+"""Helper functions for BSB-Lan integration."""
+
+from __future__ import annotations
+
+from bsblan import BSBLAN, BSBLANError
+
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.util import dt as dt_util
+
+from .const import DOMAIN
+
+
+async def async_sync_device_time(client: BSBLAN, device_name: str) -> None:
+    """Synchronize BSB-LAN device time with Home Assistant.
+
+    Only updates if device time differs from Home Assistant time.
+
+    Args:
+        client: The BSB-LAN client instance.
+        device_name: The name of the device (used in error messages).
+
+    Raises:
+        HomeAssistantError: If the time sync operation fails.
+
+    """
+    try:
+        device_time = await client.time()
+        current_time = dt_util.now()
+        current_time_str = current_time.strftime("%d.%m.%Y %H:%M:%S")
+
+        # Only sync if device time differs from HA time
+        if device_time.time.value != current_time_str:
+            await client.set_time(current_time_str)
+    except BSBLANError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="sync_time_failed",
+            translation_placeholders={
+                "device_name": device_name,
+                "error": str(err),
+            },
+        ) from err

homeassistant/components/bsblan/icons.json

@@ -1,4 +1,11 @@
 {
+  "entity": {
+    "button": {
+      "sync_time": {
+        "default": "mdi:timer-sync-outline"
+      }
+    }
+  },
   "services": {
     "set_hot_water_schedule": {
       "service": "mdi:calendar-clock"

homeassistant/components/bsblan/manifest.json

@@ -1,12 +1,13 @@
 {
   "domain": "bsblan",
-  "name": "BSB-Lan",
+  "name": "BSB-LAN",
   "codeowners": ["@liudger"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/bsblan",
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
+  "quality_scale": "silver",
   "requirements": ["python-bsblan==5.0.1"],
   "zeroconf": [
     {

homeassistant/components/bsblan/quality_scale.yaml

@@ -0,0 +1,74 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions: done
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities of this integration does not explicitly subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info: done
+  discovery: done
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: |
+      This integration has a fixed single device.
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: |
+      This integration provides a limited number of entities, all of which are useful to users.
+  entity-translations: done
+  exception-translations: done
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: |
+      This integration doesn't have any cases where raising an issue is needed.
+  stale-devices:
+    status: exempt
+    comment: |
+      This integration has a fixed single device.
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/bsblan/sensor.py

@@ -1,4 +1,4 @@
-"""Support for BSB-Lan sensors."""
+"""Support for BSB-LAN sensors."""
 
 from __future__ import annotations
 
@@ -11,7 +11,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import UnitOfEnergy, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -25,7 +25,7 @@ PARALLEL_UPDATES = 1
 
 @dataclass(frozen=True, kw_only=True)
 class BSBLanSensorEntityDescription(SensorEntityDescription):
-    """Describes BSB-Lan sensor entity."""
+    """Describes BSB-LAN sensor entity."""
 
     value_fn: Callable[[BSBLanFastData], StateType]
     exists_fn: Callable[[BSBLanFastData], bool] = lambda data: True
@@ -58,6 +58,19 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         ),
         exists_fn=lambda data: data.sensor.outside_temperature is not None,
     ),
+    BSBLanSensorEntityDescription(
+        key="total_energy",
+        translation_key="total_energy",
+        device_class=SensorDeviceClass.ENERGY,
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        value_fn=lambda data: (
+            data.sensor.total_energy.value
+            if data.sensor.total_energy is not None
+            else None
+        ),
+        exists_fn=lambda data: data.sensor.total_energy is not None,
+    ),
 )
 
 
@@ -66,7 +79,7 @@ async def async_setup_entry(
     entry: BSBLanConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up BSB-Lan sensor based on a config entry."""
+    """Set up BSB-LAN sensor based on a config entry."""
     data = entry.runtime_data
 
     # Only create sensors for available data points
@@ -81,7 +94,7 @@ async def async_setup_entry(
 
 
 class BSBLanSensor(BSBLanEntity, SensorEntity):
-    """Defines a BSB-Lan sensor."""
+    """Defines a BSB-LAN sensor."""
 
     entity_description: BSBLanSensorEntityDescription
 
@@ -90,7 +103,7 @@ class BSBLanSensor(BSBLanEntity, SensorEntity):
         data: BSBLanData,
         description: BSBLanSensorEntityDescription,
     ) -> None:
-        """Initialize BSB-Lan sensor."""
+        """Initialize BSB-LAN sensor."""
         super().__init__(data.fast_coordinator, data)
         self.entity_description = description
         self._attr_unique_id = f"{data.device.MAC}-{description.key}"

homeassistant/components/bsblan/services.py

@@ -1,4 +1,4 @@
-"""Support for BSB-Lan services."""
+"""Support for BSB-LAN services."""
 
 from __future__ import annotations
 
@@ -13,9 +13,9 @@ from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv, device_registry as dr
-from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN
+from .helpers import async_sync_device_time
 
 if TYPE_CHECKING:
     from . import BSBLanConfigEntry
@@ -192,7 +192,7 @@ async def set_hot_water_schedule(service_call: ServiceCall) -> None:
     )
 
     try:
-        # Call the BSB-Lan API to set the schedule
+        # Call the BSB-LAN API to set the schedule
         await client.set_hot_water_schedule(dhw_schedule)
     except BSBLANError as err:
         raise HomeAssistantError(
@@ -245,25 +245,7 @@ async def async_sync_time(service_call: ServiceCall) -> None:
         )
 
     client = entry.runtime_data.client
-
-    try:
-        # Get current device time
-        device_time = await client.time()
-        current_time = dt_util.now()
-        current_time_str = current_time.strftime("%d.%m.%Y %H:%M:%S")
-
-        # Only sync if device time differs from HA time
-        if device_time.time.value != current_time_str:
-            await client.set_time(current_time_str)
-    except BSBLANError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="sync_time_failed",
-            translation_placeholders={
-                "device_name": device_entry.name or device_id,
-                "error": str(err),
-            },
-        ) from err
+    await async_sync_device_time(client, device_entry.name or device_id)
 
 
 SYNC_TIME_SCHEMA = vol.Schema(
@@ -275,7 +257,7 @@ SYNC_TIME_SCHEMA = vol.Schema(
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
-    """Register the BSB-Lan services."""
+    """Register the BSB-LAN services."""
     hass.services.async_register(
         DOMAIN,
         SERVICE_SET_HOT_WATER_SCHEDULE,

homeassistant/components/bsblan/strings.json

@@ -22,8 +22,8 @@
           "password": "[%key:component::bsblan::config::step::user::data_description::password%]",
           "username": "[%key:component::bsblan::config::step::user::data_description::username%]"
         },
-        "description": "A BSB-Lan device was discovered at {host}. Please provide credentials if required.",
-        "title": "BSB-Lan device discovered"
+        "description": "A BSB-LAN device was discovered at {host}. Please provide credentials if required.",
+        "title": "BSB-LAN device discovered"
       },
       "reauth_confirm": {
         "data": {
@@ -36,7 +36,7 @@
           "password": "[%key:component::bsblan::config::step::user::data_description::password%]",
           "username": "[%key:component::bsblan::config::step::user::data_description::username%]"
         },
-        "description": "The BSB-Lan integration needs to re-authenticate with {name}",
+        "description": "The BSB-LAN integration needs to re-authenticate with {name}",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
       "user": {
@@ -48,24 +48,32 @@
           "username": "[%key:common::config_flow::data::username%]"
         },
         "data_description": {
-          "host": "The hostname or IP address of your BSB-Lan device.",
-          "passkey": "The passkey for your BSB-Lan device.",
-          "password": "The password for your BSB-Lan device.",
-          "port": "The port number of your BSB-Lan device.",
-          "username": "The username for your BSB-Lan device."
+          "host": "The hostname or IP address of your BSB-LAN device.",
+          "passkey": "The passkey for your BSB-LAN device.",
+          "password": "The password for your BSB-LAN device.",
+          "port": "The port number of your BSB-LAN device.",
+          "username": "The username for your BSB-LAN device."
         },
-        "description": "Set up your BSB-Lan device to integrate with Home Assistant.",
-        "title": "Connect to the BSB-Lan device"
+        "description": "Set up your BSB-LAN device to integrate with Home Assistant.",
+        "title": "Connect to the BSB-LAN device"
       }
     }
   },
   "entity": {
+    "button": {
+      "sync_time": {
+        "name": "Sync time"
+      }
+    },
     "sensor": {
       "current_temperature": {
         "name": "Current temperature"
       },
       "outside_temperature": {
         "name": "Outside temperature"
+      },
+      "total_energy": {
+        "name": "Total energy"
       }
     }
   },
@@ -73,6 +81,12 @@
     "config_entry_not_loaded": {
       "message": "The device `{device_name}` is not currently loaded or available"
     },
+    "coordinator_auth_error": {
+      "message": "Authentication failed for BSB-LAN device"
+    },
+    "coordinator_connection_error": {
+      "message": "Error while establishing connection with BSB-LAN device at {host}"
+    },
     "end_time_before_start_time": {
       "message": "End time ({end_time}) must be after start time ({start_time})"
     },
@@ -83,14 +97,11 @@
       "message": "No configuration entry found for device: {device_id}"
     },
     "set_data_error": {
-      "message": "An error occurred while sending the data to the BSB-Lan device"
+      "message": "An error occurred while sending the data to the BSB-LAN device"
     },
     "set_operation_mode_error": {
       "message": "An error occurred while setting the operation mode"
     },
-    "set_preset_mode_error": {
-      "message": "Can't set preset mode to {preset_mode} when HVAC mode is not set to auto"
-    },
     "set_schedule_failed": {
       "message": "Failed to set hot water schedule: {error}"
     },
@@ -101,7 +112,7 @@
       "message": "Authentication failed while retrieving static device data"
     },
     "setup_connection_error": {
-      "message": "Failed to retrieve static device data from BSB-Lan device at {host}"
+      "message": "Failed to retrieve static device data from BSB-LAN device at {host}"
     },
     "setup_general_error": {
       "message": "An unknown error occurred while retrieving static device data"
@@ -150,7 +161,7 @@
       "name": "Set hot water schedule"
     },
     "sync_time": {
-      "description": "Synchronize Home Assistant time to the BSB-Lan device. Only updates if device time differs from Home Assistant time.",
+      "description": "Synchronize Home Assistant time to the BSB-LAN device. Only updates if device time differs from Home Assistant time.",
       "fields": {
         "device_id": {
           "description": "The BSB-LAN device to sync time for.",

homeassistant/components/bsblan/water_heater.py

@@ -63,6 +63,7 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
     """Defines a BSBLAN water heater entity."""
 
     _attr_name = None
+    _attr_operation_list = list(HA_TO_BSBLAN_OPERATION_MODE.keys())
     _attr_supported_features = (
         WaterHeaterEntityFeature.TARGET_TEMPERATURE
         | WaterHeaterEntityFeature.OPERATION_MODE
@@ -73,7 +74,6 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
         """Initialize BSBLAN water heater."""
         super().__init__(data.fast_coordinator, data.slow_coordinator, data)
         self._attr_unique_id = format_mac(data.device.MAC)
-        self._attr_operation_list = list(HA_TO_BSBLAN_OPERATION_MODE.keys())
 
         # Set temperature unit
         self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit

homeassistant/components/compit/__init__.py

@@ -10,9 +10,11 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
 
 PLATFORMS = [
+    Platform.BINARY_SENSOR,
     Platform.CLIMATE,
     Platform.NUMBER,
     Platform.SELECT,
+    Platform.SENSOR,
     Platform.WATER_HEATER,
 ]
 

homeassistant/components/compit/binary_sensor.py

@@ -0,0 +1,189 @@
+"""Binary sensor platform for Compit integration."""
+
+from dataclasses import dataclass
+
+from compit_inext_api.consts import CompitParameter
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, MANUFACTURER_NAME
+from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
+
+PARALLEL_UPDATES = 0
+NO_SENSOR = "no_sensor"
+ON_STATES = ["on", "yes", "charging", "alert", "exceeded"]
+
+DESCRIPTIONS: dict[CompitParameter, BinarySensorEntityDescription] = {
+    CompitParameter.AIRING: BinarySensorEntityDescription(
+        key=CompitParameter.AIRING.value,
+        translation_key="airing",
+        device_class=BinarySensorDeviceClass.WINDOW,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.BATTERY_CHARGE_STATUS: BinarySensorEntityDescription(
+        key=CompitParameter.BATTERY_CHARGE_STATUS.value,
+        device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.CO2_ALERT: BinarySensorEntityDescription(
+        key=CompitParameter.CO2_ALERT.value,
+        translation_key="co2_alert",
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.CO2_LEVEL: BinarySensorEntityDescription(
+        key=CompitParameter.CO2_LEVEL.value,
+        translation_key="co2_level",
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.DUST_ALERT: BinarySensorEntityDescription(
+        key=CompitParameter.DUST_ALERT.value,
+        translation_key="dust_alert",
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.PUMP_STATUS: BinarySensorEntityDescription(
+        key=CompitParameter.PUMP_STATUS.value,
+        translation_key="pump_status",
+        device_class=BinarySensorDeviceClass.RUNNING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    CompitParameter.TEMPERATURE_ALERT: BinarySensorEntityDescription(
+        key=CompitParameter.TEMPERATURE_ALERT.value,
+        translation_key="temperature_alert",
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+}
+
+
+@dataclass(frozen=True, kw_only=True)
+class CompitDeviceDescription:
+    """Class to describe a Compit device."""
+
+    name: str
+    parameters: dict[CompitParameter, BinarySensorEntityDescription]
+
+
+DEVICE_DEFINITIONS: dict[int, CompitDeviceDescription] = {
+    12: CompitDeviceDescription(
+        name="Nano Color",
+        parameters={
+            CompitParameter.CO2_LEVEL: DESCRIPTIONS[CompitParameter.CO2_LEVEL],
+        },
+    ),
+    78: CompitDeviceDescription(
+        name="SPM - Nano Color 2",
+        parameters={
+            CompitParameter.DUST_ALERT: DESCRIPTIONS[CompitParameter.DUST_ALERT],
+            CompitParameter.TEMPERATURE_ALERT: DESCRIPTIONS[
+                CompitParameter.TEMPERATURE_ALERT
+            ],
+            CompitParameter.CO2_ALERT: DESCRIPTIONS[CompitParameter.CO2_ALERT],
+        },
+    ),
+    223: CompitDeviceDescription(
+        name="Nano Color 2",
+        parameters={
+            CompitParameter.AIRING: DESCRIPTIONS[CompitParameter.AIRING],
+            CompitParameter.CO2_LEVEL: DESCRIPTIONS[CompitParameter.CO2_LEVEL],
+        },
+    ),
+    225: CompitDeviceDescription(
+        name="SPM - Nano Color",
+        parameters={
+            CompitParameter.CO2_LEVEL: DESCRIPTIONS[CompitParameter.CO2_LEVEL],
+        },
+    ),
+    226: CompitDeviceDescription(
+        name="AF-1",
+        parameters={
+            CompitParameter.BATTERY_CHARGE_STATUS: DESCRIPTIONS[
+                CompitParameter.BATTERY_CHARGE_STATUS
+            ],
+            CompitParameter.PUMP_STATUS: DESCRIPTIONS[CompitParameter.PUMP_STATUS],
+        },
+    ),
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CompitConfigEntry,
+    async_add_devices: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Compit binary sensor entities from a config entry."""
+
+    coordinator = entry.runtime_data
+    async_add_devices(
+        CompitBinarySensor(
+            coordinator,
+            device_id,
+            device_definition.name,
+            code,
+            entity_description,
+        )
+        for device_id, device in coordinator.connector.all_devices.items()
+        if (device_definition := DEVICE_DEFINITIONS.get(device.definition.code))
+        for code, entity_description in device_definition.parameters.items()
+        if coordinator.connector.get_current_value(device_id, code) != NO_SENSOR
+    )
+
+
+class CompitBinarySensor(
+    CoordinatorEntity[CompitDataUpdateCoordinator], BinarySensorEntity
+):
+    """Representation of a Compit binary sensor entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: CompitDataUpdateCoordinator,
+        device_id: int,
+        device_name: str,
+        parameter_code: CompitParameter,
+        entity_description: BinarySensorEntityDescription,
+    ) -> None:
+        """Initialize the binary sensor entity."""
+        super().__init__(coordinator)
+        self.device_id = device_id
+        self.entity_description = entity_description
+        self._attr_unique_id = f"{device_id}_{entity_description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, str(device_id))},
+            name=device_name,
+            manufacturer=MANUFACTURER_NAME,
+            model=device_name,
+        )
+        self.parameter_code = parameter_code
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return (
+            super().available
+            and self.coordinator.connector.get_device(self.device_id) is not None
+        )
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return the state of the binary sensor."""
+        value = self.coordinator.connector.get_current_value(
+            self.device_id, self.parameter_code
+        )
+
+        if value is None:
+            return None
+
+        return value in ON_STATES

homeassistant/components/compit/icons.json

@@ -1,5 +1,25 @@
 {
   "entity": {
+    "binary_sensor": {
+      "airing": {
+        "default": "mdi:window-open-variant"
+      },
+      "co2_alert": {
+        "default": "mdi:alert"
+      },
+      "co2_level": {
+        "default": "mdi:molecule-co2"
+      },
+      "dust_alert": {
+        "default": "mdi:alert"
+      },
+      "pump_status": {
+        "default": "mdi:pump"
+      },
+      "temperature_alert": {
+        "default": "mdi:alert"
+      }
+    },
     "number": {
       "boiler_target_temperature": {
         "default": "mdi:water-boiler"
@@ -138,6 +158,119 @@
           "winter": "mdi:snowflake"
         }
       }
+    },
+    "sensor": {
+      "alarm_code": {
+        "default": "mdi:alert-circle",
+        "state": {
+          "no_alarm": "mdi:check-circle"
+        }
+      },
+      "battery_level": {
+        "default": "mdi:battery"
+      },
+      "boiler_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "calculated_heating_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "calculated_target_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "charging_power": {
+        "default": "mdi:flash"
+      },
+      "circuit_target_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "co2_percent": {
+        "default": "mdi:molecule-co2"
+      },
+      "collector_power": {
+        "default": "mdi:solar-power"
+      },
+      "collector_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "dhw_measured_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "energy_consumption": {
+        "default": "mdi:lightning-bolt"
+      },
+      "energy_smart_grid_yesterday": {
+        "default": "mdi:lightning-bolt"
+      },
+      "energy_today": {
+        "default": "mdi:lightning-bolt"
+      },
+      "energy_total": {
+        "default": "mdi:lightning-bolt"
+      },
+      "energy_yesterday": {
+        "default": "mdi:lightning-bolt"
+      },
+      "fuel_level": {
+        "default": "mdi:gauge"
+      },
+      "humidity": {
+        "default": "mdi:water-percent"
+      },
+      "mixer_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "outdoor_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "pk1_function": {
+        "default": "mdi:cog",
+        "state": {
+          "cooling": "mdi:snowflake-thermometer",
+          "off": "mdi:cog-off",
+          "summer": "mdi:weather-sunny",
+          "winter": "mdi:snowflake"
+        }
+      },
+      "pm10_level": {
+        "default": "mdi:air-filter",
+        "state": {
+          "exceeded": "mdi:alert",
+          "no_sensor": "mdi:cancel",
+          "normal": "mdi:air-filter",
+          "warning": "mdi:alert-circle-outline"
+        }
+      },
+      "pm25_level": {
+        "default": "mdi:air-filter",
+        "state": {
+          "exceeded": "mdi:alert",
+          "no_sensor": "mdi:cancel",
+          "normal": "mdi:air-filter",
+          "warning": "mdi:alert-circle-outline"
+        }
+      },
+      "return_circuit_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "tank_temperature_t2": {
+        "default": "mdi:thermometer"
+      },
+      "tank_temperature_t3": {
+        "default": "mdi:thermometer"
+      },
+      "tank_temperature_t4": {
+        "default": "mdi:thermometer"
+      },
+      "target_heating_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "ventilation_alarm": {
+        "default": "mdi:alert",
+        "state": {
+          "no_alarm": "mdi:check-circle"
+        }
+      }
     }
   }
 }

homeassistant/components/compit/strings.json

@@ -33,6 +33,26 @@
     }
   },
   "entity": {
+    "binary_sensor": {
+      "airing": {
+        "name": "Airing"
+      },
+      "co2_alert": {
+        "name": "CO2 alert"
+      },
+      "co2_level": {
+        "name": "CO2 level"
+      },
+      "dust_alert": {
+        "name": "Dust alert"
+      },
+      "pump_status": {
+        "name": "Pump status"
+      },
+      "temperature_alert": {
+        "name": "Temperature alert"
+      }
+    },
     "number": {
       "boiler_target_temperature": {
         "name": "Boiler target temperature"
@@ -183,6 +203,219 @@
           "winter": "Winter"
         }
       }
+    },
+    "sensor": {
+      "actual_buffer_temp": {
+        "name": "Actual buffer temperature"
+      },
+      "actual_dhw_temp": {
+        "name": "Actual DHW temperature"
+      },
+      "actual_hc_temperature_zone": {
+        "name": "Actual heating circuit {zone} temperature"
+      },
+      "actual_upper_source_temp": {
+        "name": "Actual upper source temperature"
+      },
+      "alarm_code": {
+        "name": "Alarm code",
+        "state": {
+          "battery_fault": "Battery fault",
+          "damaged_outdoor_temp": "Damaged outdoor temperature sensor",
+          "damaged_return_temp": "Damaged return temperature sensor",
+          "discharged_battery": "Discharged battery",
+          "internal_af": "Internal fault",
+          "low_battery_level": "Low battery level",
+          "no_alarm": "No alarm",
+          "no_battery": "No battery",
+          "no_power": "No power",
+          "no_pump": "No pump",
+          "pump_fault": "Pump fault"
+        }
+      },
+      "battery_level": {
+        "name": "Battery level"
+      },
+      "boiler_temperature": {
+        "name": "Boiler temperature"
+      },
+      "buffer_return_temperature": {
+        "name": "Buffer return temperature"
+      },
+      "buffer_set_temperature": {
+        "name": "Buffer set temperature"
+      },
+      "calculated_buffer_temp": {
+        "name": "Calculated buffer temperature"
+      },
+      "calculated_dhw_temp": {
+        "name": "Calculated DHW temperature"
+      },
+      "calculated_heating_temperature": {
+        "name": "Calculated heating temperature"
+      },
+      "calculated_target_temperature": {
+        "name": "Calculated target temperature"
+      },
+      "calculated_upper_source_temp": {
+        "name": "Calculated upper source temperature"
+      },
+      "charging_power": {
+        "name": "Charging power"
+      },
+      "circuit_target_temperature": {
+        "name": "Circuit target temperature"
+      },
+      "co2_percent": {
+        "name": "CO2 percent"
+      },
+      "collector_power": {
+        "name": "Collector power"
+      },
+      "collector_temperature": {
+        "name": "Collector temperature"
+      },
+      "dhw_measured_temperature": {
+        "name": "DHW measured temperature"
+      },
+      "dhw_temperature": {
+        "name": "DHW temperature"
+      },
+      "energy_consumption": {
+        "name": "Energy consumption"
+      },
+      "energy_smart_grid_yesterday": {
+        "name": "Energy smart grid yesterday"
+      },
+      "energy_today": {
+        "name": "Energy today"
+      },
+      "energy_total": {
+        "name": "Energy total"
+      },
+      "energy_yesterday": {
+        "name": "Energy yesterday"
+      },
+      "fuel_level": {
+        "name": "Fuel level"
+      },
+      "heating_target_temperature_zone": {
+        "name": "Heating circuit {zone} target temperature"
+      },
+      "lower_source_temperature": {
+        "name": "Lower source temperature"
+      },
+      "mixer_temperature": {
+        "name": "Mixer temperature"
+      },
+      "mixer_temperature_zone": {
+        "name": "Mixer {zone} temperature"
+      },
+      "outdoor_temperature": {
+        "name": "Outdoor temperature"
+      },
+      "pk1_function": {
+        "name": "PK1 function",
+        "state": {
+          "cooling": "Cooling",
+          "holiday": "Holiday",
+          "nano_nr_1": "Nano 1",
+          "nano_nr_2": "Nano 2",
+          "nano_nr_3": "Nano 3",
+          "nano_nr_4": "Nano 4",
+          "nano_nr_5": "Nano 5",
+          "off": "Off",
+          "on": "On",
+          "summer": "Summer",
+          "winter": "Winter"
+        }
+      },
+      "pm10_level": {
+        "name": "PM10 level",
+        "state": {
+          "exceeded": "Exceeded",
+          "no_sensor": "No sensor",
+          "normal": "Normal",
+          "warning": "Warning"
+        }
+      },
+      "pm1_level": {
+        "name": "PM1 level"
+      },
+      "pm25_level": {
+        "name": "PM2.5 level",
+        "state": {
+          "exceeded": "Exceeded",
+          "no_sensor": "No sensor",
+          "normal": "Normal",
+          "warning": "Warning"
+        }
+      },
+      "pm4_level": {
+        "name": "PM4 level"
+      },
+      "preset_mode": {
+        "name": "Preset mode"
+      },
+      "protection_temperature": {
+        "name": "Protection temperature"
+      },
+      "pump_status": {
+        "name": "Pump status",
+        "state": {
+          "off": "Off",
+          "on": "On"
+        }
+      },
+      "return_circuit_temperature": {
+        "name": "Return circuit temperature"
+      },
+      "set_target_temperature": {
+        "name": "Set target temperature"
+      },
+      "tank_temperature_t2": {
+        "name": "Tank T2 bottom temperature"
+      },
+      "tank_temperature_t3": {
+        "name": "Tank T3 top temperature"
+      },
+      "tank_temperature_t4": {
+        "name": "Tank T4 temperature"
+      },
+      "target_heating_temperature": {
+        "name": "Target heating temperature"
+      },
+      "target_temperature": {
+        "name": "Target temperature"
+      },
+      "temperature_alert": {
+        "name": "Temperature alert",
+        "state": {
+          "alert": "Alert",
+          "no_alert": "No alert"
+        }
+      },
+      "upper_source_temperature": {
+        "name": "Upper source temperature"
+      },
+      "ventilation_alarm": {
+        "name": "Ventilation alarm",
+        "state": {
+          "ahu_alarm": "AHU alarm",
+          "bot_alarm": "BOT alarm",
+          "damaged_exhaust_sensor": "Damaged exhaust sensor",
+          "damaged_preheater_sensor": "Damaged preheater sensor",
+          "damaged_supply_and_exhaust_sensors": "Damaged supply and exhaust sensors",
+          "damaged_supply_sensor": "Damaged supply sensor",
+          "no_alarm": "No alarm"
+        }
+      },
+      "ventilation_gear": {
+        "name": "Ventilation gear"
+      },
+      "weather_curve": {
+        "name": "Weather curve"
+      }
     }
   }
 }

homeassistant/components/ecobee/__init__.py

@@ -2,10 +2,17 @@
 
 from datetime import timedelta
 
-from pyecobee import ECOBEE_API_KEY, ECOBEE_REFRESH_TOKEN, Ecobee, ExpiredTokenError
+from pyecobee import (
+    ECOBEE_API_KEY,
+    ECOBEE_PASSWORD,
+    ECOBEE_REFRESH_TOKEN,
+    ECOBEE_USERNAME,
+    Ecobee,
+    ExpiredTokenError,
+)
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY
+from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.util import Throttle
 
@@ -18,10 +25,19 @@ type EcobeeConfigEntry = ConfigEntry[EcobeeData]
 
 async def async_setup_entry(hass: HomeAssistant, entry: EcobeeConfigEntry) -> bool:
     """Set up ecobee via a config entry."""
-    api_key = entry.data[CONF_API_KEY]
+    api_key = entry.data.get(CONF_API_KEY)
+    username = entry.data.get(CONF_USERNAME)
+    password = entry.data.get(CONF_PASSWORD)
     refresh_token = entry.data[CONF_REFRESH_TOKEN]
 
-    runtime_data = EcobeeData(hass, entry, api_key=api_key, refresh_token=refresh_token)
+    runtime_data = EcobeeData(
+        hass,
+        entry,
+        api_key=api_key,
+        username=username,
+        password=password,
+        refresh_token=refresh_token,
+    )
 
     if not await runtime_data.refresh():
         return False
@@ -46,14 +62,32 @@ class EcobeeData:
     """
 
     def __init__(
-        self, hass: HomeAssistant, entry: ConfigEntry, api_key: str, refresh_token: str
+        self,
+        hass: HomeAssistant,
+        entry: ConfigEntry,
+        api_key: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        refresh_token: str | None = None,
     ) -> None:
         """Initialize the Ecobee data object."""
         self._hass = hass
         self.entry = entry
-        self.ecobee = Ecobee(
-            config={ECOBEE_API_KEY: api_key, ECOBEE_REFRESH_TOKEN: refresh_token}
-        )
+
+        if api_key:
+            self.ecobee = Ecobee(
+                config={ECOBEE_API_KEY: api_key, ECOBEE_REFRESH_TOKEN: refresh_token}
+            )
+        elif username and password:
+            self.ecobee = Ecobee(
+                config={
+                    ECOBEE_USERNAME: username,
+                    ECOBEE_PASSWORD: password,
+                    ECOBEE_REFRESH_TOKEN: refresh_token,
+                }
+            )
+        else:
+            raise ValueError("No ecobee credentials provided")
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     async def update(self):
@@ -69,12 +103,23 @@ class EcobeeData:
         """Refresh ecobee tokens and update config entry."""
         _LOGGER.debug("Refreshing ecobee tokens and updating config entry")
         if await self._hass.async_add_executor_job(self.ecobee.refresh_tokens):
-            self._hass.config_entries.async_update_entry(
-                self.entry,
-                data={
+            data = {}
+            if self.ecobee.config.get(ECOBEE_API_KEY):
+                data = {
                     CONF_API_KEY: self.ecobee.config[ECOBEE_API_KEY],
                     CONF_REFRESH_TOKEN: self.ecobee.config[ECOBEE_REFRESH_TOKEN],
-                },
+                }
+            elif self.ecobee.config.get(ECOBEE_USERNAME) and self.ecobee.config.get(
+                ECOBEE_PASSWORD
+            ):
+                data = {
+                    CONF_USERNAME: self.ecobee.config[ECOBEE_USERNAME],
+                    CONF_PASSWORD: self.ecobee.config[ECOBEE_PASSWORD],
+                    CONF_REFRESH_TOKEN: self.ecobee.config[ECOBEE_REFRESH_TOKEN],
+                }
+            self._hass.config_entries.async_update_entry(
+                self.entry,
+                data=data,
             )
             return True
         _LOGGER.error("Error refreshing ecobee tokens")

homeassistant/components/ecobee/config_flow.py

@@ -2,15 +2,21 @@
 
 from typing import Any
 
-from pyecobee import ECOBEE_API_KEY, Ecobee
+from pyecobee import ECOBEE_API_KEY, ECOBEE_PASSWORD, ECOBEE_USERNAME, Ecobee
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY
+from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
 
 from .const import CONF_REFRESH_TOKEN, DOMAIN
 
-_USER_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
+_USER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_API_KEY): str,
+        vol.Optional(CONF_USERNAME): str,
+        vol.Optional(CONF_PASSWORD): str,
+    }
+)
 
 
 class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
@@ -27,13 +33,34 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
         errors = {}
 
         if user_input is not None:
-            # Use the user-supplied API key to attempt to obtain a PIN from ecobee.
-            self._ecobee = Ecobee(config={ECOBEE_API_KEY: user_input[CONF_API_KEY]})
+            api_key = user_input.get(CONF_API_KEY)
+            username = user_input.get(CONF_USERNAME)
+            password = user_input.get(CONF_PASSWORD)
 
-            if await self.hass.async_add_executor_job(self._ecobee.request_pin):
-                # We have a PIN; move to the next step of the flow.
-                return await self.async_step_authorize()
-            errors["base"] = "pin_request_failed"
+            if api_key and not (username or password):
+                # Use the user-supplied API key to attempt to obtain a PIN from ecobee.
+                self._ecobee = Ecobee(config={ECOBEE_API_KEY: api_key})
+                if await self.hass.async_add_executor_job(self._ecobee.request_pin):
+                    # We have a PIN; move to the next step of the flow.
+                    return await self.async_step_authorize()
+                errors["base"] = "pin_request_failed"
+            elif username and password and not api_key:
+                self._ecobee = Ecobee(
+                    config={
+                        ECOBEE_USERNAME: username,
+                        ECOBEE_PASSWORD: password,
+                    }
+                )
+                if await self.hass.async_add_executor_job(self._ecobee.refresh_tokens):
+                    config = {
+                        CONF_USERNAME: username,
+                        CONF_PASSWORD: password,
+                        CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
+                    }
+                    return self.async_create_entry(title=DOMAIN, data=config)
+                errors["base"] = "login_failed"
+            else:
+                errors["base"] = "invalid_auth"
 
         return self.async_show_form(
             step_id="user",

homeassistant/components/ecobee/strings.json

@@ -4,6 +4,8 @@
       "single_instance_allowed": "[%key:common::config_flow::abort::single_instance_allowed%]"
     },
     "error": {
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "login_failed": "Error authenticating with ecobee; please verify your credentials are correct.",
       "pin_request_failed": "Error requesting PIN from ecobee; please verify API key is correct.",
       "token_request_failed": "Error requesting tokens from ecobee; please try again."
     },

homeassistant/components/econet/__init__.py

@@ -28,6 +28,7 @@ _LOGGER = logging.getLogger(__name__)
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
+    Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
     Platform.WATER_HEATER,

homeassistant/components/econet/climate.py

@@ -5,7 +5,7 @@ from typing import Any
 from pyeconet.equipment import EquipmentType
 from pyeconet.equipment.thermostat import (
     Thermostat,
-    ThermostatFanMode,
+    ThermostatFanSpeed,
     ThermostatOperationMode,
 )
 
@@ -16,6 +16,7 @@ from homeassistant.components.climate import (
     FAN_HIGH,
     FAN_LOW,
     FAN_MEDIUM,
+    FAN_TOP,
     ClimateEntity,
     ClimateEntityFeature,
     HVACMode,
@@ -41,13 +42,16 @@ HA_STATE_TO_ECONET = {
     if key != ThermostatOperationMode.EMERGENCY_HEAT
 }
 
-ECONET_FAN_STATE_TO_HA = {
-    ThermostatFanMode.AUTO: FAN_AUTO,
-    ThermostatFanMode.LOW: FAN_LOW,
-    ThermostatFanMode.MEDIUM: FAN_MEDIUM,
-    ThermostatFanMode.HIGH: FAN_HIGH,
+ECONET_FAN_SPEED_TO_HA = {
+    ThermostatFanSpeed.AUTO: FAN_AUTO,
+    ThermostatFanSpeed.LOW: FAN_LOW,
+    ThermostatFanSpeed.MEDIUM: FAN_MEDIUM,
+    ThermostatFanSpeed.HIGH: FAN_HIGH,
+    ThermostatFanSpeed.MAX: FAN_TOP,
+}
+HA_FAN_STATE_TO_ECONET_FAN_SPEED = {
+    value: key for key, value in ECONET_FAN_SPEED_TO_HA.items()
 }
-HA_FAN_STATE_TO_ECONET = {value: key for key, value in ECONET_FAN_STATE_TO_HA.items()}
 
 SUPPORT_FLAGS_THERMOSTAT = (
     ClimateEntityFeature.TARGET_TEMPERATURE
@@ -103,7 +107,7 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
         return self._econet.set_point
 
     @property
-    def current_humidity(self) -> int:
+    def current_humidity(self) -> int | None:
         """Return the current humidity."""
         return self._econet.humidity
 
@@ -149,7 +153,7 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
 
     @property
     def hvac_mode(self) -> HVACMode:
-        """Return hvac operation ie. heat, cool, mode.
+        """Return hvac operation i.e. heat, cool, mode.
 
         Needs to be one of HVAC_MODE_*.
         """
@@ -174,35 +178,35 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
     @property
     def fan_mode(self) -> str:
         """Return the current fan mode."""
-        econet_fan_mode = self._econet.fan_mode
+        econet_fan_speed = self._econet.fan_speed
 
         # Remove this after we figure out how to handle med lo and med hi
-        if econet_fan_mode in [ThermostatFanMode.MEDHI, ThermostatFanMode.MEDLO]:
-            econet_fan_mode = ThermostatFanMode.MEDIUM
+        if econet_fan_speed in [ThermostatFanSpeed.MEDHI, ThermostatFanSpeed.MEDLO]:
+            econet_fan_speed = ThermostatFanSpeed.MEDIUM
 
-        _current_fan_mode = FAN_AUTO
-        if econet_fan_mode is not None:
-            _current_fan_mode = ECONET_FAN_STATE_TO_HA[econet_fan_mode]
-        return _current_fan_mode
+        _current_fan_speed = FAN_AUTO
+        if econet_fan_speed is not None:
+            _current_fan_speed = ECONET_FAN_SPEED_TO_HA[econet_fan_speed]
+        return _current_fan_speed
 
     @property
     def fan_modes(self) -> list[str]:
         """Return the fan modes."""
+        # Remove the MEDLO MEDHI once we figure out how to handle it
         return [
-            ECONET_FAN_STATE_TO_HA[mode]
-            for mode in self._econet.fan_modes
-            # Remove the MEDLO MEDHI once we figure out how to handle it
+            ECONET_FAN_SPEED_TO_HA[mode]
+            for mode in self._econet.fan_speeds
             if mode
             not in [
-                ThermostatFanMode.UNKNOWN,
-                ThermostatFanMode.MEDLO,
-                ThermostatFanMode.MEDHI,
+                ThermostatFanSpeed.UNKNOWN,
+                ThermostatFanSpeed.MEDLO,
+                ThermostatFanSpeed.MEDHI,
             ]
         ]
 
     def set_fan_mode(self, fan_mode: str) -> None:
         """Set the fan mode."""
-        self._econet.set_fan_mode(HA_FAN_STATE_TO_ECONET[fan_mode])
+        self._econet.set_fan_speed(HA_FAN_STATE_TO_ECONET_FAN_SPEED[fan_mode])
 
     @property
     def min_temp(self) -> float:

homeassistant/components/econet/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["paho_mqtt", "pyeconet"],
-  "requirements": ["pyeconet==0.1.28"]
+  "requirements": ["pyeconet==0.2.1"]
 }

homeassistant/components/econet/select.py

@@ -0,0 +1,53 @@
+"""Support for Rheem EcoNet thermostats with variable fan speeds and fan modes."""
+
+from __future__ import annotations
+
+from pyeconet.equipment import EquipmentType
+from pyeconet.equipment.thermostat import Thermostat, ThermostatFanMode
+
+from homeassistant.components.select import SelectEntity
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import EconetConfigEntry
+from .entity import EcoNetEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: EconetConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the econet thermostat select entity."""
+    equipment = entry.runtime_data
+    async_add_entities(
+        EconetFanModeSelect(thermostat)
+        for thermostat in equipment[EquipmentType.THERMOSTAT]
+        if thermostat.supports_fan_mode
+    )
+
+
+class EconetFanModeSelect(EcoNetEntity[Thermostat], SelectEntity):
+    """Select entity."""
+
+    def __init__(self, thermostat: Thermostat) -> None:
+        """Initialize EcoNet platform."""
+        super().__init__(thermostat)
+        self._attr_name = f"{thermostat.device_name} fan mode"
+        self._attr_unique_id = (
+            f"{thermostat.device_id}_{thermostat.device_name}_fan_mode"
+        )
+
+    @property
+    def options(self) -> list[str]:
+        """Return available select options."""
+        return [e.value for e in self._econet.fan_modes]
+
+    @property
+    def current_option(self) -> str:
+        """Return current select option."""
+        return self._econet.fan_mode.value
+
+    def select_option(self, option: str) -> None:
+        """Set the selected option."""
+        self._econet.set_fan_mode(ThermostatFanMode.by_string(option))

homeassistant/components/econet/switch.py

@@ -23,19 +23,20 @@ async def async_setup_entry(
     entry: EconetConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the ecobee thermostat switch entity."""
+    """Set up the econet thermostat switch entity."""
     equipment = entry.runtime_data
     async_add_entities(
         EcoNetSwitchAuxHeatOnly(thermostat)
         for thermostat in equipment[EquipmentType.THERMOSTAT]
+        if ThermostatOperationMode.EMERGENCY_HEAT in thermostat.modes
     )
 
 
 class EcoNetSwitchAuxHeatOnly(EcoNetEntity[Thermostat], SwitchEntity):
-    """Representation of a aux_heat_only EcoNet switch."""
+    """Representation of an aux_heat_only EcoNet switch."""
 
     def __init__(self, thermostat: Thermostat) -> None:
-        """Initialize EcoNet ventilator platform."""
+        """Initialize EcoNet platform."""
         super().__init__(thermostat)
         self._attr_name = f"{thermostat.device_name} emergency heat"
         self._attr_unique_id = (

homeassistant/components/ecovacs/vacuum.py

@@ -8,17 +8,24 @@ from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import Capabilities, DeviceType
 from deebot_client.device import Device
-from deebot_client.events import FanSpeedEvent, RoomsEvent, StateEvent
-from deebot_client.models import CleanAction, CleanMode, Room, State
+from deebot_client.events import (
+    CachedMapInfoEvent,
+    FanSpeedEvent,
+    RoomsEvent,
+    StateEvent,
+)
+from deebot_client.events.map import Map
+from deebot_client.models import CleanAction, CleanMode, State
 import sucks
 
 from homeassistant.components.vacuum import (
+    Segment,
     StateVacuumEntity,
     StateVacuumEntityDescription,
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
@@ -29,6 +36,7 @@ from .entity import EcovacsEntity, EcovacsLegacyEntity
 from .util import get_name_key
 
 _LOGGER = logging.getLogger(__name__)
+_SEGMENTS_SEPARATOR = "_"
 
 ATTR_ERROR = "error"
 
@@ -218,7 +226,8 @@ class EcovacsVacuum(
         """Initialize the vacuum."""
         super().__init__(device, device.capabilities)
 
-        self._rooms: list[Room] = []
+        self._room_event: RoomsEvent | None = None
+        self._maps: dict[str, Map] = {}
 
         if fan_speed := self._capability.fan_speed:
             self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
@@ -226,14 +235,13 @@ class EcovacsVacuum(
                 get_name_key(level) for level in fan_speed.types
             ]
 
+        if self._capability.map and self._capability.clean.action.area:
+            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
+
     async def async_added_to_hass(self) -> None:
         """Set up the event listeners now that hass is ready."""
         await super().async_added_to_hass()
 
-        async def on_rooms(event: RoomsEvent) -> None:
-            self._rooms = event.rooms
-            self.async_write_ha_state()
-
         async def on_status(event: StateEvent) -> None:
             self._attr_activity = _STATE_TO_VACUUM_STATE[event.state]
             self.async_write_ha_state()
@@ -249,8 +257,20 @@ class EcovacsVacuum(
             self._subscribe(self._capability.fan_speed.event, on_fan_speed)
 
         if map_caps := self._capability.map:
+
+            async def on_rooms(event: RoomsEvent) -> None:
+                self._room_event = event
+                self._check_segments_changed()
+                self.async_write_ha_state()
+
             self._subscribe(map_caps.rooms.event, on_rooms)
 
+            async def on_map_info(event: CachedMapInfoEvent) -> None:
+                self._maps = {map_obj.id: map_obj for map_obj in event.maps}
+                self._check_segments_changed()
+
+            self._subscribe(map_caps.cached_info.event, on_map_info)
+
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes.
@@ -259,7 +279,10 @@ class EcovacsVacuum(
         is lowercase snake_case.
         """
         rooms: dict[str, Any] = {}
-        for room in self._rooms:
+        if self._room_event is None:
+            return rooms
+
+        for room in self._room_event.rooms:
             # convert room name to snake_case to meet the convention
             room_name = slugify(room.name)
             room_values = rooms.get(room_name)
@@ -374,3 +397,116 @@ class EcovacsVacuum(
             )
 
         return await self._device.execute_command(position_commands[0])
+
+    @callback
+    def _check_segments_changed(self) -> None:
+        """Check if segments have changed and create repair issue."""
+        last_seen = self.last_seen_segments
+        if last_seen is None:
+            return
+
+        last_seen_ids = {seg.id for seg in last_seen}
+        current_ids = {seg.id for seg in self._get_segments()}
+
+        if current_ids != last_seen_ids:
+            self.async_create_segments_issue()
+
+    def _get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        last_seen = self.last_seen_segments or []
+        if self._room_event is None or not self._maps:
+            # If we don't have the necessary information to determine segments, return the last
+            # seen segments to avoid temporarily losing all segments until we get the necessary
+            # information, which could cause unnecessary issues to be created
+            return last_seen
+
+        map_id = self._room_event.map_id
+        if (map_obj := self._maps.get(map_id)) is None:
+            _LOGGER.warning("Map ID %s not found in available maps", map_id)
+            return []
+
+        id_prefix = f"{map_id}{_SEGMENTS_SEPARATOR}"
+        other_map_ids = {
+            map_obj.id
+            for map_obj in self._maps.values()
+            if map_obj.id != self._room_event.map_id
+        }
+        # Include segments from the current map and any segments from other maps that were
+        # previously seen, as we want to continue showing segments from other maps for
+        # mapping purposes
+        segments = [
+            seg for seg in last_seen if _split_composite_id(seg.id)[0] in other_map_ids
+        ]
+        segments.extend(
+            Segment(
+                id=f"{id_prefix}{room.id}",
+                name=room.name,
+                group=map_obj.name,
+            )
+            for room in self._room_event.rooms
+        )
+        return segments
+
+    async def async_get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        return self._get_segments()
+
+    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
+        """Perform an area clean.
+
+        Only cleans segments from the currently selected map.
+        """
+        if not self._maps:
+            _LOGGER.warning("No map information available, cannot clean segments")
+            return
+
+        valid_room_ids: list[int | float] = []
+        for composite_id in segment_ids:
+            map_id, segment_id = _split_composite_id(composite_id)
+            if (map_obj := self._maps.get(map_id)) is None:
+                _LOGGER.warning("Map ID %s not found in available maps", map_id)
+                continue
+
+            if not map_obj.using:
+                room_name = next(
+                    (
+                        segment.name
+                        for segment in self.last_seen_segments or []
+                        if segment.id == composite_id
+                    ),
+                    "",
+                )
+                _LOGGER.warning(
+                    'Map "%s" is not currently selected, skipping segment "%s" (%s)',
+                    map_obj.name,
+                    room_name,
+                    segment_id,
+                )
+                continue
+
+            valid_room_ids.append(int(segment_id))
+
+        if not valid_room_ids:
+            _LOGGER.warning(
+                "No valid segments to clean after validation, skipping clean segments command"
+            )
+            return
+
+        if TYPE_CHECKING:
+            # Supported feature is only added if clean.action.area is not None
+            assert self._capability.clean.action.area is not None
+
+        await self._device.execute_command(
+            self._capability.clean.action.area(
+                CleanMode.SPOT_AREA,
+                valid_room_ids,
+                1,
+            )
+        )
+
+
+@callback
+def _split_composite_id(composite_id: str) -> tuple[str, str]:
+    """Split a composite ID into its components."""
+    map_id, _, segment_id = composite_id.partition(_SEGMENTS_SEPARATOR)
+    return map_id, segment_id

homeassistant/components/enocean/config_flow.py

@@ -4,17 +4,23 @@ from typing import Any
 
 import voluptuous as vol
 
+from homeassistant.components import usb
+from homeassistant.components.usb import (
+    human_readable_device_name,
+    usb_unique_id_from_service_info,
+)
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_DEVICE
+from homeassistant.const import ATTR_MANUFACTURER, CONF_DEVICE, CONF_NAME
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import (
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
 )
+from homeassistant.helpers.service_info.usb import UsbServiceInfo
 
 from . import dongle
-from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER
+from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER, MANUFACTURER
 
 MANUAL_SCHEMA = vol.Schema(
     {
@@ -31,8 +37,48 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the EnOcean config flow."""
-        self.dongle_path = None
-        self.discovery_info = None
+        self.data: dict[str, Any] = {}
+
+    async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
+        """Handle usb discovery."""
+        unique_id = usb_unique_id_from_service_info(discovery_info)
+
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured(
+            updates={CONF_DEVICE: discovery_info.device}
+        )
+
+        discovery_info.device = await self.hass.async_add_executor_job(
+            usb.get_serial_by_id, discovery_info.device
+        )
+
+        self.data[CONF_DEVICE] = discovery_info.device
+        self.context["title_placeholders"] = {
+            CONF_NAME: human_readable_device_name(
+                discovery_info.device,
+                discovery_info.serial_number,
+                discovery_info.manufacturer,
+                discovery_info.description,
+                discovery_info.vid,
+                discovery_info.pid,
+            )
+        }
+        return await self.async_step_usb_confirm()
+
+    async def async_step_usb_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle USB Discovery confirmation."""
+        if user_input is not None:
+            return await self.async_step_manual({CONF_DEVICE: self.data[CONF_DEVICE]})
+        self._set_confirm_only()
+        return self.async_show_form(
+            step_id="usb_confirm",
+            description_placeholders={
+                ATTR_MANUFACTURER: MANUFACTURER,
+                CONF_DEVICE: self.data.get(CONF_DEVICE, ""),
+            },
+        )
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Import a yaml configuration."""
@@ -104,4 +150,4 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def create_enocean_entry(self, user_input):
         """Create an entry for the provided configuration."""
-        return self.async_create_entry(title="EnOcean", data=user_input)
+        return self.async_create_entry(title=MANUFACTURER, data=user_input)

homeassistant/components/enocean/const.py

@@ -6,6 +6,8 @@ from homeassistant.const import Platform
 
 DOMAIN = "enocean"
 
+MANUFACTURER = "EnOcean"
+
 ERROR_INVALID_DONGLE_PATH = "invalid_dongle_path"
 
 SIGNAL_RECEIVE_MESSAGE = "enocean.receive_message"

homeassistant/components/enocean/manifest.json

@@ -3,10 +3,19 @@
   "name": "EnOcean",
   "codeowners": [],
   "config_flow": true,
+  "dependencies": ["usb"],
   "documentation": "https://www.home-assistant.io/integrations/enocean",
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["enocean"],
   "requirements": ["enocean==0.50"],
-  "single_config_entry": true
+  "single_config_entry": true,
+  "usb": [
+    {
+      "description": "*usb 300*",
+      "manufacturer": "*enocean*",
+      "pid": "6001",
+      "vid": "0403"
+    }
+  ]
 }

homeassistant/components/enocean/strings.json

@@ -25,6 +25,9 @@
           "device": "[%key:component::enocean::config::step::detect::data_description::device%]"
         },
         "description": "Enter the path to your EnOcean USB dongle."
+      },
+      "usb_confirm": {
+        "description": "{manufacturer} USB dongle detected at {device}. Do you want to set up this device?"
       }
     }
   },

homeassistant/components/esphome/entry_data.py

@@ -300,16 +300,23 @@ class RuntimeEntryData:
                 needed_platforms.add(Platform.BINARY_SENSOR)
                 needed_platforms.add(Platform.SELECT)
 
-        needed_platforms.update(INFO_TYPE_TO_PLATFORM[type(info)] for info in infos)
-        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
-
         # Make a dict of the EntityInfo by type and send
         # them to the listeners for each specific EntityInfo type
+        info_types_to_platform = INFO_TYPE_TO_PLATFORM
         infos_by_type: defaultdict[type[EntityInfo], list[EntityInfo]] = defaultdict(
             list
         )
         for info in infos:
-            infos_by_type[type(info)].append(info)
+            info_type = type(info)
+            if platform := info_types_to_platform.get(info_type):
+                needed_platforms.add(platform)
+                infos_by_type[info_type].append(info)
+            else:
+                _LOGGER.warning(
+                    "Entity type %s is not supported in this version of Home Assistant",
+                    info_type,
+                )
+        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
 
         for type_, callbacks in self.entity_info_callbacks.items():
             # If all entities for a type are removed, we

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==44.0.0",
+    "aioesphomeapi==44.1.0",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.6.0"
   ],

homeassistant/components/fritz/coordinator.py

@@ -12,11 +12,7 @@ import re
 from typing import Any, TypedDict, cast
 
 from fritzconnection import FritzConnection
-from fritzconnection.core.exceptions import (
-    FritzActionError,
-    FritzConnectionException,
-    FritzSecurityError,
-)
+from fritzconnection.core.exceptions import FritzActionError
 from fritzconnection.lib.fritzcall import FritzCall
 from fritzconnection.lib.fritzhosts import FritzHosts
 from fritzconnection.lib.fritzstatus import FritzStatus
@@ -47,6 +43,7 @@ from .const import (
     DEFAULT_SSL,
     DEFAULT_USERNAME,
     DOMAIN,
+    FRITZ_AUTH_EXCEPTIONS,
     FRITZ_EXCEPTIONS,
     SCAN_INTERVAL,
     MeshRoles,
@@ -425,12 +422,18 @@ class FritzBoxTools(DataUpdateCoordinator[UpdateCoordinatorDataType]):
         hosts_info: list[HostInfo] = []
         try:
             try:
-                hosts_attributes = await self.hass.async_add_executor_job(
-                    self.fritz_hosts.get_hosts_attributes
+                hosts_attributes = cast(
+                    list[HostAttributes],
+                    await self.hass.async_add_executor_job(
+                        self.fritz_hosts.get_hosts_attributes
+                    ),
                 )
             except FritzActionError:
-                hosts_info = await self.hass.async_add_executor_job(
-                    self.fritz_hosts.get_hosts_info
+                hosts_info = cast(
+                    list[HostInfo],
+                    await self.hass.async_add_executor_job(
+                        self.fritz_hosts.get_hosts_info
+                    ),
                 )
         except Exception as ex:
             if not self.hass.is_stopping:
@@ -586,7 +589,7 @@ class FritzBoxTools(DataUpdateCoordinator[UpdateCoordinatorDataType]):
                 topology := await self.hass.async_add_executor_job(
                     self.fritz_hosts.get_mesh_topology
                 )
-            ):
+            ) or not isinstance(topology, dict):
                 raise Exception("Mesh supported but empty topology reported")  # noqa: TRY002
         except FritzActionError:
             self.mesh_role = MeshRoles.SLAVE
@@ -742,7 +745,7 @@ class AvmWrapper(FritzBoxTools):
                     **kwargs,
                 )
             )
-        except FritzSecurityError:
+        except FRITZ_AUTH_EXCEPTIONS:
             _LOGGER.exception(
                 "Authorization Error: Please check the provided credentials and"
                 " verify that you can log into the web interface"
@@ -755,12 +758,6 @@ class AvmWrapper(FritzBoxTools):
                 action_name,
             )
             return {}
-        except FritzConnectionException:
-            _LOGGER.exception(
-                "Connection Error: Please check the device is properly configured"
-                " for remote login"
-            )
-            return {}
         return result
 
     async def async_get_upnp_configuration(self) -> dict[str, Any]:

homeassistant/components/fritzbox_callmonitor/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "fritzbox_callmonitor",
   "name": "FRITZ!Box Call Monitor",
-  "codeowners": ["@cdce8p"],
+  "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/fritzbox_callmonitor",
   "integration_type": "device",

homeassistant/components/google_assistant/trait.py

@@ -1752,15 +1752,15 @@ class FanSpeedTrait(_Trait):
         """Initialize a trait for a state."""
         super().__init__(hass, state, config)
         if state.domain == fan.DOMAIN:
-            speed_count = min(
-                FAN_SPEED_MAX_SPEED_COUNT,
-                round(
-                    100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
-                ),
+            speed_count = round(
+                100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
             )
-            self._ordered_speed = [
-                f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
-            ]
+            if speed_count <= FAN_SPEED_MAX_SPEED_COUNT:
+                self._ordered_speed = [
+                    f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
+                ]
+            else:
+                self._ordered_speed = []
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -1786,7 +1786,11 @@ class FanSpeedTrait(_Trait):
             result.update(
                 {
                     "reversible": reversible,
-                    "supportsFanSpeedPercent": True,
+                    # supportsFanSpeedPercent is mutually exclusive with
+                    # availableFanSpeeds, where supportsFanSpeedPercent takes
+                    # precedence. Report it only when step speeds are not
+                    # supported so Google renders a percent slider (1-100%).
+                    "supportsFanSpeedPercent": not self._ordered_speed,
                 }
             )
 
@@ -1832,10 +1836,12 @@ class FanSpeedTrait(_Trait):
 
         if domain == fan.DOMAIN:
             percent = attrs.get(fan.ATTR_PERCENTAGE) or 0
-            response["currentFanSpeedPercent"] = percent
-            response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
-                self._ordered_speed, percent
-            )
+            if self._ordered_speed:
+                response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
+                    self._ordered_speed, percent
+                )
+            else:
+                response["currentFanSpeedPercent"] = percent
 
         return response
 
@@ -1855,7 +1861,7 @@ class FanSpeedTrait(_Trait):
             )
 
         if domain == fan.DOMAIN:
-            if fan_speed := params.get("fanSpeed"):
+            if self._ordered_speed and (fan_speed := params.get("fanSpeed")):
                 fan_speed_percent = ordered_list_item_to_percentage(
                     self._ordered_speed, fan_speed
                 )

homeassistant/components/hassio/ingress.py

@@ -181,8 +181,7 @@ class HassIOIngress(HomeAssistantView):
             skip_auto_headers={hdrs.CONTENT_TYPE},
         ) as result:
             headers = _response_header(result)
-            content_length_int = 0
-            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
+
             # Avoid parsing content_type in simple cases for better performance
             if maybe_content_type := result.headers.get(hdrs.CONTENT_TYPE):
                 content_type: str = (maybe_content_type.partition(";"))[0].strip()
@@ -190,17 +189,30 @@ class HassIOIngress(HomeAssistantView):
                 # default value according to RFC 2616
                 content_type = "application/octet-stream"
 
+            # Empty body responses (304, 204, HEAD, etc.) should not be streamed,
+            # otherwise aiohttp < 3.9.0 may generate an invalid "0\r\n\r\n" chunk
+            # This also avoids setting content_type for empty responses.
+            if must_be_empty_body(request.method, result.status):
+                # If upstream contains content-type, preserve it (e.g. for HEAD requests)
+                # Note: This still is omitting content-length. We can't simply forward
+                # the upstream length since the proxy might change the body length
+                # (e.g. due to compression).
+                if maybe_content_type:
+                    headers[hdrs.CONTENT_TYPE] = content_type
+                return web.Response(
+                    headers=headers,
+                    status=result.status,
+                )
+
             # Simple request
-            if (empty_body := must_be_empty_body(result.method, result.status)) or (
+            content_length_int = 0
+            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
+            if (
                 content_length is not UNDEFINED
                 and (content_length_int := int(content_length))
                 <= MAX_SIMPLE_RESPONSE_SIZE
             ):
-                # Return Response
-                if empty_body:
-                    body = None
-                else:
-                    body = await result.read()
+                body = await result.read()
                 simple_response = web.Response(
                     headers=headers,
                     status=result.status,

homeassistant/components/hikvision/manifest.json

@@ -7,6 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyhik"],
-  "quality_scale": "legacy",
   "requirements": ["pyHik==0.4.2"]
 }

homeassistant/components/hikvision/quality_scale.yaml

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

homeassistant/components/homee/config_flow.py

@@ -11,7 +11,12 @@ from pyHomee import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_USER,
+    ConfigEntryState,
+    ConfigFlow,
+    ConfigFlowResult,
+)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
@@ -113,7 +118,22 @@ class HomeeConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery_info.ip_address.version == 6:
             return self.async_abort(reason="ipv6_address")
 
-        await self.async_set_unique_id(self._name)
+        # If an already configured homee reports with a second IP, abort.
+        existing_entry = await self.async_set_unique_id(self._name)
+        if (
+            existing_entry
+            and existing_entry.state == ConfigEntryState.LOADED
+            and existing_entry.runtime_data.connected
+            and existing_entry.data[CONF_HOST] != self._host
+        ):
+            _LOGGER.debug(
+                "Aborting config flow for discovered homee with IP %s "
+                "since it is already configured at IP %s",
+                self._host,
+                existing_entry.data[CONF_HOST],
+            )
+            return self.async_abort(reason="2nd_ip_address")
+
         self._abort_if_unique_id_configured(updates={CONF_HOST: self._host})
 
         # Cause an auth-error to see if homee is reachable.

homeassistant/components/homee/event.py

@@ -20,6 +20,7 @@ PARALLEL_UPDATES = 0
 
 REMOTE_PROFILES = [
     NodeProfile.REMOTE,
+    NodeProfile.ONE_BUTTON_REMOTE,
     NodeProfile.TWO_BUTTON_REMOTE,
     NodeProfile.THREE_BUTTON_REMOTE,
     NodeProfile.FOUR_BUTTON_REMOTE,

homeassistant/components/homee/strings.json

@@ -1,6 +1,7 @@
 {
   "config": {
     "abort": {
+      "2nd_ip_address": "Your homee is already connected using another IP address",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",

homeassistant/components/homematicip_cloud/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import Any
 
 import voluptuous as vol
@@ -70,6 +71,11 @@ class HomematicipCloudFlowHandler(ConfigFlow, domain=DOMAIN):
             authtoken = await self.auth.async_register()
             if authtoken:
                 _LOGGER.debug("Write config entry for HomematicIP Cloud")
+                if self.source == "reauth":
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(),
+                        data_updates={HMIPC_AUTHTOKEN: authtoken},
+                    )
                 return self.async_create_entry(
                     title=self.auth.config[HMIPC_HAPID],
                     data={
@@ -78,11 +84,50 @@ class HomematicipCloudFlowHandler(ConfigFlow, domain=DOMAIN):
                         HMIPC_NAME: self.auth.config.get(HMIPC_NAME),
                     },
                 )
-            return self.async_abort(reason="connection_aborted")
-        errors["base"] = "press_the_button"
+            if self.source == "reauth":
+                errors["base"] = "connection_aborted"
+            else:
+                return self.async_abort(reason="connection_aborted")
+        else:
+            errors["base"] = "press_the_button"
 
         return self.async_show_form(step_id="link", errors=errors)
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication when the auth token becomes invalid."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauth confirmation and start link process."""
+        errors = {}
+        reauth_entry = self._get_reauth_entry()
+
+        if user_input is not None:
+            config = {
+                HMIPC_HAPID: reauth_entry.data[HMIPC_HAPID],
+                HMIPC_PIN: user_input.get(HMIPC_PIN),
+                HMIPC_NAME: reauth_entry.data.get(HMIPC_NAME),
+            }
+            self.auth = HomematicipAuth(self.hass, config)
+            connected = await self.auth.async_setup()
+            if connected:
+                return await self.async_step_link()
+            errors["base"] = "invalid_sgtin_or_pin"
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(HMIPC_PIN): str,
+                }
+            ),
+            errors=errors,
+        )
+
     async def async_step_import(self, import_data: dict[str, str]) -> ConfigFlowResult:
         """Import a new access point as a config entry."""
         hapid = import_data[HMIPC_HAPID].replace("-", "").upper()

homeassistant/components/homematicip_cloud/diagnostics.py

@@ -0,0 +1,27 @@
+"""Diagnostics support for HomematicIP Cloud."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from homematicip.base.helpers import handle_config
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.core import HomeAssistant
+
+from .hap import HomematicIPConfigEntry
+
+TO_REDACT_CONFIG = {"city", "latitude", "longitude", "refreshToken"}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, config_entry: HomematicIPConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    hap = config_entry.runtime_data
+    json_state = await hap.home.download_configuration_async()
+    anonymized = handle_config(json_state, anonymize=True)
+    config = json.loads(anonymized)
+
+    return async_redact_data(config, TO_REDACT_CONFIG)

homeassistant/components/homematicip_cloud/hap.py

@@ -12,7 +12,10 @@ from homematicip.auth import Auth
 from homematicip.base.enums import EventType
 from homematicip.connection.connection_context import ConnectionContextBuilder
 from homematicip.connection.rest_connection import RestConnection
-from homematicip.exceptions.connection_exceptions import HmipConnectionError
+from homematicip.exceptions.connection_exceptions import (
+    HmipAuthenticationError,
+    HmipConnectionError,
+)
 
 import homeassistant
 from homeassistant.config_entries import ConfigEntry
@@ -192,6 +195,12 @@ class HomematicipHAP:
             try:
                 await self.get_state()
                 break
+            except HmipAuthenticationError:
+                _LOGGER.error(
+                    "Authentication error from HomematicIP Cloud, triggering reauth"
+                )
+                self.config_entry.async_start_reauth(self.hass)
+                break
             except HmipConnectionError as err:
                 _LOGGER.warning(
                     "Get_state failed, retrying in %s seconds: %s", delay, err

homeassistant/components/homematicip_cloud/light.py

@@ -55,7 +55,7 @@ async def async_setup_entry(
     entities: list[HomematicipGenericEntity] = []
 
     entities.extend(
-        HomematicipLightHS(hap, d, ch.index)
+        HomematicipColorLight(hap, d, ch.index)
         for d in hap.home.devices
         for ch in d.functionalChannels
         if ch.functionalChannelType == FunctionalChannelType.UNIVERSAL_LIGHT_CHANNEL
@@ -136,16 +136,32 @@ class HomematicipLight(HomematicipGenericEntity, LightEntity):
         await self._device.turn_off_async()
 
 
-class HomematicipLightHS(HomematicipGenericEntity, LightEntity):
-    """Representation of the HomematicIP light with HS color mode."""
-
-    _attr_color_mode = ColorMode.HS
-    _attr_supported_color_modes = {ColorMode.HS}
+class HomematicipColorLight(HomematicipGenericEntity, LightEntity):
+    """Representation of the HomematicIP color light."""
 
     def __init__(self, hap: HomematicipHAP, device: Device, channel_index: int) -> None:
         """Initialize the light entity."""
         super().__init__(hap, device, channel=channel_index, is_multi_channel=True)
 
+    def _supports_color(self) -> bool:
+        """Return true if device supports hue/saturation color control."""
+        channel = self.get_channel_or_raise()
+        return channel.hue is not None and channel.saturationLevel is not None
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the color mode of the light."""
+        if self._supports_color():
+            return ColorMode.HS
+        return ColorMode.BRIGHTNESS
+
+    @property
+    def supported_color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        if self._supports_color():
+            return {ColorMode.HS}
+        return {ColorMode.BRIGHTNESS}
+
     @property
     def is_on(self) -> bool:
         """Return true if light is on."""
@@ -172,18 +188,26 @@ class HomematicipLightHS(HomematicipGenericEntity, LightEntity):
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the light on."""
         channel = self.get_channel_or_raise()
-        hs_color = kwargs.get(ATTR_HS_COLOR, (0.0, 0.0))
-        hue = hs_color[0] % 360.0
-        saturation = hs_color[1] / 100.0
         dim_level = round(kwargs.get(ATTR_BRIGHTNESS, 255) / 255.0, 2)
 
-        if ATTR_HS_COLOR not in kwargs:
-            hue = channel.hue
-            saturation = channel.saturationLevel
-
         if ATTR_BRIGHTNESS not in kwargs:
             # If no brightness is set, use the current brightness
             dim_level = channel.dimLevel or 1.0
+
+        # Use dim-only method for monochrome mode (hue/saturation not supported)
+        if not self._supports_color():
+            await channel.set_dim_level_async(dim_level=dim_level)
+            return
+
+        # Full color mode with hue/saturation
+        if ATTR_HS_COLOR in kwargs:
+            hs_color = kwargs[ATTR_HS_COLOR]
+            hue = hs_color[0] % 360.0
+            saturation = hs_color[1] / 100.0
+        else:
+            hue = channel.hue
+            saturation = channel.saturationLevel
+
         await channel.set_hue_saturation_dim_level_async(
             hue=hue, saturation_level=saturation, dim_level=dim_level
         )

homeassistant/components/homematicip_cloud/strings.json

@@ -3,9 +3,11 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "connection_aborted": "[%key:common::config_flow::error::cannot_connect%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "error": {
+      "connection_aborted": "Registration failed, please try again.",
       "invalid_sgtin_or_pin": "Invalid SGTIN or PIN code, please try again.",
       "press_the_button": "Please press the blue button.",
       "register_failed": "Failed to register, please try again.",
@@ -24,6 +26,13 @@
       "link": {
         "description": "Press the blue button on the access point and the **Submit** button to register Homematic IP with Home Assistant.\n\n![Location of button on bridge](/static/images/config_flows/config_homematicip_cloud.png)",
         "title": "Link access point"
+      },
+      "reauth_confirm": {
+        "data": {
+          "pin": "[%key:common::config_flow::data::pin%]"
+        },
+        "description": "The authentication token for your HomematicIP access point is no longer valid. Press **Submit** and then press the blue button on your access point to re-register.",
+        "title": "Re-authenticate HomematicIP access point"
       }
     }
   },

homeassistant/components/hue_ble/config_flow.py

@@ -6,6 +6,7 @@ from enum import Enum
 import logging
 from typing import Any
 
+from bleak.backends.scanner import AdvertisementData
 from HueBLE import ConnectionError, HueBleError, HueBleLight, PairingError
 import voluptuous as vol
 
@@ -26,6 +27,17 @@ from .light import get_available_color_modes
 _LOGGER = logging.getLogger(__name__)
 
 
+SERVICE_UUID = SERVICE_DATA_UUID = "0000fe0f-0000-1000-8000-00805f9b34fb"
+
+
+def device_filter(advertisement_data: AdvertisementData) -> bool:
+    """Return True if the device is supported."""
+    return (
+        SERVICE_UUID in advertisement_data.service_uuids
+        and SERVICE_DATA_UUID in advertisement_data.service_data
+    )
+
+
 async def validate_input(hass: HomeAssistant, address: str) -> Error | None:
     """Return error if cannot connect and validate."""
 
@@ -70,28 +82,66 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
+        self._discovered_devices: dict[str, bluetooth.BluetoothServiceInfoBleak] = {}
         self._discovery_info: bluetooth.BluetoothServiceInfoBleak | None = None
 
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the user step to pick discovered device."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            unique_id = dr.format_mac(user_input[CONF_MAC])
+            # Don't raise on progress because there may be discovery flows
+            await self.async_set_unique_id(unique_id, raise_on_progress=False)
+            # Guard against the user selecting a device which has been configured by
+            # another flow.
+            self._abort_if_unique_id_configured()
+            self._discovery_info = self._discovered_devices[user_input[CONF_MAC]]
+            return await self.async_step_confirm()
+
+        current_addresses = self._async_current_ids(include_ignore=False)
+        for discovery in bluetooth.async_discovered_service_info(self.hass):
+            if (
+                discovery.address in current_addresses
+                or discovery.address in self._discovered_devices
+                or not device_filter(discovery.advertisement)
+            ):
+                continue
+            self._discovered_devices[discovery.address] = discovery
+
+        if not self._discovered_devices:
+            return self.async_abort(reason="no_devices_found")
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(CONF_MAC): vol.In(
+                    {
+                        service_info.address: (
+                            f"{service_info.name} ({service_info.address})"
+                        )
+                        for service_info in self._discovered_devices.values()
+                    }
+                ),
+            }
+        )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=data_schema,
+            errors=errors,
+        )
+
     async def async_step_bluetooth(
         self, discovery_info: bluetooth.BluetoothServiceInfoBleak
     ) -> ConfigFlowResult:
         """Handle a flow initialized by the home assistant scanner."""
 
         _LOGGER.debug(
-            "HA found light %s. Will show in UI but not auto connect",
+            "HA found light %s. Use user flow to show in UI and connect",
             discovery_info.name,
         )
-
-        unique_id = dr.format_mac(discovery_info.address)
-        await self.async_set_unique_id(unique_id)
-        self._abort_if_unique_id_configured()
-
-        name = f"{discovery_info.name} ({discovery_info.address})"
-        self.context.update({"title_placeholders": {CONF_NAME: name}})
-
-        self._discovery_info = discovery_info
-
-        return await self.async_step_confirm()
+        return self.async_abort(reason="discovery_unsupported")
 
     async def async_step_confirm(
         self, user_input: dict[str, Any] | None = None
@@ -103,7 +153,10 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
         if user_input is not None:
             unique_id = dr.format_mac(self._discovery_info.address)
-            await self.async_set_unique_id(unique_id)
+            # Don't raise on progress because there may be discovery flows
+            await self.async_set_unique_id(unique_id, raise_on_progress=False)
+            # Guard against the user selecting a device which has been configured by
+            # another flow.
             self._abort_if_unique_id_configured()
             error = await validate_input(self.hass, unique_id)
             if error:

homeassistant/components/hue_ble/strings.json

@@ -2,7 +2,8 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "not_implemented": "This integration can only be set up via discovery."
+      "discovery_unsupported": "Discovery flow is not supported by the Hue BLE integration.",
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -14,7 +15,16 @@
     },
     "step": {
       "confirm": {
-        "description": "Do you want to set up {name} ({mac})?. Make sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
+        "description": "Do you want to set up {name} ({mac})?\nMake sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
+      },
+      "user": {
+        "data": {
+          "mac": "[%key:common::config_flow::data::device%]"
+        },
+        "data_description": {
+          "mac": "Select the Hue device you want to set up"
+        },
+        "description": "[%key:component::bluetooth::config::step::user::description%]"
       }
     }
   }

homeassistant/components/husqvarna_automower/services.yaml

@@ -10,6 +10,7 @@ override_schedule:
       selector:
         duration:
           enable_day: true
+          enable_second: false
     override_mode:
       required: true
       example: "mow"
@@ -32,6 +33,7 @@ override_schedule_work_area:
       selector:
         duration:
           enable_day: true
+          enable_second: false
     work_area_id:
       required: true
       example: "123"

homeassistant/components/husqvarna_automower/strings.json

@@ -511,7 +511,7 @@
       "description": "Lets the mower either mow or park for a given duration, overriding all schedules.",
       "fields": {
         "duration": {
-          "description": "Minimum: 1 minute, maximum: 42 days, seconds will be ignored.",
+          "description": "Minimum: 1 minute, maximum: 42 days.",
           "name": "Duration"
         },
         "override_mode": {

homeassistant/components/imgw_pib/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["imgw_pib==2.0.1"]
+  "requirements": ["imgw_pib==2.0.2"]
 }

homeassistant/components/imgw_pib/strings.json

@@ -24,6 +24,7 @@
       "hydrological_alert": {
         "name": "Hydrological alert",
         "state": {
+          "exceeding_the_alarm_level": "Exceeding the alarm level",
           "exceeding_the_warning_level": "Exceeding the warning level",
           "hydrological_drought": "Hydrological drought",
           "no_alert": "No alert",

homeassistant/components/indevolt/__init__.py

@@ -7,7 +7,12 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import IndevoltConfigEntry, IndevoltCoordinator
 
-PLATFORMS: list[Platform] = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
+PLATFORMS: list[Platform] = [
+    Platform.NUMBER,
+    Platform.SELECT,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: IndevoltConfigEntry) -> bool:

homeassistant/components/indevolt/select.py

@@ -0,0 +1,111 @@
+"""Select platform for Indevolt integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Final
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import IndevoltConfigEntry
+from .coordinator import IndevoltCoordinator
+from .entity import IndevoltEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class IndevoltSelectEntityDescription(SelectEntityDescription):
+    """Custom entity description class for Indevolt select entities."""
+
+    read_key: str
+    write_key: str
+    value_to_option: dict[int, str]
+    unavailable_values: list[int] = field(default_factory=list)
+    generation: list[int] = field(default_factory=lambda: [1, 2])
+
+
+SELECTS: Final = (
+    IndevoltSelectEntityDescription(
+        key="energy_mode",
+        translation_key="energy_mode",
+        read_key="7101",
+        write_key="47005",
+        value_to_option={
+            1: "self_consumed_prioritized",
+            4: "real_time_control",
+            5: "charge_discharge_schedule",
+        },
+        unavailable_values=[0],
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: IndevoltConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the select platform for Indevolt."""
+    coordinator = entry.runtime_data
+    device_gen = coordinator.generation
+
+    # Select initialization
+    async_add_entities(
+        IndevoltSelectEntity(coordinator=coordinator, description=description)
+        for description in SELECTS
+        if device_gen in description.generation
+    )
+
+
+class IndevoltSelectEntity(IndevoltEntity, SelectEntity):
+    """Represents a select entity for Indevolt devices."""
+
+    entity_description: IndevoltSelectEntityDescription
+
+    def __init__(
+        self,
+        coordinator: IndevoltCoordinator,
+        description: IndevoltSelectEntityDescription,
+    ) -> None:
+        """Initialize the Indevolt select entity."""
+        super().__init__(coordinator)
+
+        self.entity_description = description
+        self._attr_unique_id = f"{self.serial_number}_{description.key}"
+        self._attr_options = list(description.value_to_option.values())
+        self._option_to_value = {v: k for k, v in description.value_to_option.items()}
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the currently selected option."""
+        raw_value = self.coordinator.data.get(self.entity_description.read_key)
+        if raw_value is None:
+            return None
+
+        return self.entity_description.value_to_option.get(raw_value)
+
+    @property
+    def available(self) -> bool:
+        """Return False when the device is in a mode that cannot be selected."""
+        if not super().available:
+            return False
+
+        raw_value = self.coordinator.data.get(self.entity_description.read_key)
+        return raw_value not in self.entity_description.unavailable_values
+
+    async def async_select_option(self, option: str) -> None:
+        """Select a new option."""
+        value = self._option_to_value[option]
+        success = await self.coordinator.async_push_data(
+            self.entity_description.write_key, value
+        )
+
+        if success:
+            await self.coordinator.async_request_refresh()
+
+        else:
+            raise HomeAssistantError(f"Failed to set option {option} for {self.name}")

homeassistant/components/indevolt/strings.json

@@ -37,6 +37,16 @@
         "name": "Max AC output power"
       }
     },
+    "select": {
+      "energy_mode": {
+        "name": "[%key:component::indevolt::entity::sensor::energy_mode::name%]",
+        "state": {
+          "charge_discharge_schedule": "[%key:component::indevolt::entity::sensor::energy_mode::state::charge_discharge_schedule%]",
+          "real_time_control": "[%key:component::indevolt::entity::sensor::energy_mode::state::real_time_control%]",
+          "self_consumed_prioritized": "[%key:component::indevolt::entity::sensor::energy_mode::state::self_consumed_prioritized%]"
+        }
+      }
+    },
     "sensor": {
       "ac_input_power": {
         "name": "AC input power"

homeassistant/components/liebherr/__init__.py

@@ -1,8 +1,10 @@
-"""The liebherr integration."""
+"""The Liebherr integration."""
 
 from __future__ import annotations
 
 import asyncio
+from datetime import datetime
+import logging
 
 from pyliebherrhomeapi import LiebherrClient
 from pyliebherrhomeapi.exceptions import (
@@ -14,10 +16,20 @@ from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.event import async_track_time_interval
 
-from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+from .const import DEVICE_SCAN_INTERVAL, DOMAIN
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator, LiebherrData
 
-PLATFORMS: list[Platform] = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS: list[Platform] = [
+    Platform.NUMBER,
+    Platform.SELECT,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:
@@ -37,7 +49,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) ->
         raise ConfigEntryNotReady(f"Failed to connect to Liebherr API: {err}") from err
 
     # Create a coordinator for each device (may be empty if no devices)
-    coordinators: dict[str, LiebherrCoordinator] = {}
+    data = LiebherrData(client=client)
     for device in devices:
         coordinator = LiebherrCoordinator(
             hass=hass,
@@ -45,20 +57,61 @@ async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) ->
             client=client,
             device_id=device.device_id,
         )
-        coordinators[device.device_id] = coordinator
+        data.coordinators[device.device_id] = coordinator
 
     await asyncio.gather(
         *(
             coordinator.async_config_entry_first_refresh()
-            for coordinator in coordinators.values()
+            for coordinator in data.coordinators.values()
         )
     )
 
-    # Store coordinators in runtime data
-    entry.runtime_data = coordinators
+    # Store runtime data
+    entry.runtime_data = data
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
+    # Schedule periodic scan for new devices
+    async def _async_scan_for_new_devices(_now: datetime) -> None:
+        """Scan for new devices added to the account."""
+        try:
+            devices = await client.get_devices()
+        except LiebherrAuthenticationError, LiebherrConnectionError:
+            _LOGGER.debug("Failed to scan for new devices")
+            return
+        except Exception:
+            _LOGGER.exception("Unexpected error scanning for new devices")
+            return
+
+        new_coordinators: list[LiebherrCoordinator] = []
+        for device in devices:
+            if device.device_id not in data.coordinators:
+                coordinator = LiebherrCoordinator(
+                    hass=hass,
+                    config_entry=entry,
+                    client=client,
+                    device_id=device.device_id,
+                )
+                await coordinator.async_refresh()
+                if not coordinator.last_update_success:
+                    _LOGGER.debug("Failed to set up new device %s", device.device_id)
+                    continue
+                data.coordinators[device.device_id] = coordinator
+                new_coordinators.append(coordinator)
+
+        if new_coordinators:
+            async_dispatcher_send(
+                hass,
+                f"{DOMAIN}_new_device_{entry.entry_id}",
+                new_coordinators,
+            )
+
+    entry.async_on_unload(
+        async_track_time_interval(
+            hass, _async_scan_for_new_devices, DEVICE_SCAN_INTERVAL
+        )
+    )
+
     return True
 
 

homeassistant/components/liebherr/const.py

@@ -6,4 +6,6 @@ from typing import Final
 DOMAIN: Final = "liebherr"
 MANUFACTURER: Final = "Liebherr"
 
+SCAN_INTERVAL: Final = timedelta(seconds=60)
+DEVICE_SCAN_INTERVAL: Final = timedelta(minutes=5)
 REFRESH_DELAY: Final = timedelta(seconds=5)

homeassistant/components/liebherr/coordinator.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
+from dataclasses import dataclass, field
 import logging
 
 from pyliebherrhomeapi import (
@@ -18,13 +18,20 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import DOMAIN
-
-type LiebherrConfigEntry = ConfigEntry[dict[str, LiebherrCoordinator]]
+from .const import DOMAIN, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
-SCAN_INTERVAL = timedelta(seconds=60)
+
+@dataclass
+class LiebherrData:
+    """Runtime data for the Liebherr integration."""
+
+    client: LiebherrClient
+    coordinators: dict[str, LiebherrCoordinator] = field(default_factory=dict)
+
+
+type LiebherrConfigEntry = ConfigEntry[LiebherrData]
 
 
 class LiebherrCoordinator(DataUpdateCoordinator[DeviceState]):

homeassistant/components/liebherr/diagnostics.py

@@ -29,6 +29,6 @@ async def async_get_config_entry_diagnostics(
                 },
                 "data": asdict(coordinator.data),
             }
-            for device_id, coordinator in entry.runtime_data.items()
+            for device_id, coordinator in entry.runtime_data.coordinators.items()
         },
     }

homeassistant/components/liebherr/icons.json

@@ -1,5 +1,55 @@
 {
   "entity": {
+    "select": {
+      "bio_fresh_plus": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_bottom_zone": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_middle_zone": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_top_zone": {
+        "default": "mdi:leaf"
+      },
+      "hydro_breeze": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_bottom_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_middle_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_top_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "ice_maker": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_bottom_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_middle_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_top_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      }
+    },
     "switch": {
       "night_mode": {
         "default": "mdi:sleep",

homeassistant/components/liebherr/number.py

@@ -16,9 +16,11 @@ from homeassistant.components.number import (
     NumberEntityDescription,
 )
 from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from .const import DOMAIN
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 from .entity import LiebherrZoneEntity
 
@@ -53,22 +55,41 @@ NUMBER_TYPES: tuple[LiebherrNumberEntityDescription, ...] = (
 )
 
 
+def _create_number_entities(
+    coordinators: list[LiebherrCoordinator],
+) -> list[LiebherrNumber]:
+    """Create number entities for the given coordinators."""
+    return [
+        LiebherrNumber(
+            coordinator=coordinator,
+            zone_id=temp_control.zone_id,
+            description=description,
+        )
+        for coordinator in coordinators
+        for temp_control in coordinator.data.get_temperature_controls().values()
+        for description in NUMBER_TYPES
+    ]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: LiebherrConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Liebherr number entities."""
-    coordinators = entry.runtime_data
     async_add_entities(
-        LiebherrNumber(
-            coordinator=coordinator,
-            zone_id=temp_control.zone_id,
-            description=description,
+        _create_number_entities(list(entry.runtime_data.coordinators.values()))
+    )
+
+    @callback
+    def _async_new_device(coordinators: list[LiebherrCoordinator]) -> None:
+        """Add number entities for new devices."""
+        async_add_entities(_create_number_entities(coordinators))
+
+    entry.async_on_unload(
+        async_dispatcher_connect(
+            hass, f"{DOMAIN}_new_device_{entry.entry_id}", _async_new_device
         )
-        for coordinator in coordinators.values()
-        for temp_control in coordinator.data.get_temperature_controls().values()
-        for description in NUMBER_TYPES
     )
 
 

homeassistant/components/liebherr/quality_scale.yaml

@@ -53,7 +53,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default:

homeassistant/components/liebherr/select.py

@@ -0,0 +1,238 @@
+"""Select platform for Liebherr integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING, Any
+
+from pyliebherrhomeapi import (
+    BioFreshPlusControl,
+    BioFreshPlusMode,
+    HydroBreezeControl,
+    HydroBreezeMode,
+    IceMakerControl,
+    IceMakerMode,
+    ZonePosition,
+)
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+from .entity import ZONE_POSITION_MAP, LiebherrEntity
+
+PARALLEL_UPDATES = 1
+
+type SelectControl = IceMakerControl | HydroBreezeControl | BioFreshPlusControl
+
+
+@dataclass(frozen=True, kw_only=True)
+class LiebherrSelectEntityDescription(SelectEntityDescription):
+    """Describes a Liebherr select entity."""
+
+    control_type: type[SelectControl]
+    mode_enum: type[StrEnum]
+    current_mode_fn: Callable[[SelectControl], StrEnum | str | None]
+    options_fn: Callable[[SelectControl], list[str]]
+    set_fn: Callable[[LiebherrCoordinator, int, StrEnum], Coroutine[Any, Any, None]]
+
+
+def _ice_maker_options(control: SelectControl) -> list[str]:
+    """Return available ice maker options."""
+    if TYPE_CHECKING:
+        assert isinstance(control, IceMakerControl)
+    options = [IceMakerMode.OFF.value, IceMakerMode.ON.value]
+    if control.has_max_ice:
+        options.append(IceMakerMode.MAX_ICE.value)
+    return options
+
+
+def _hydro_breeze_options(control: SelectControl) -> list[str]:
+    """Return available HydroBreeze options."""
+    return [mode.value for mode in HydroBreezeMode]
+
+
+def _bio_fresh_plus_options(control: SelectControl) -> list[str]:
+    """Return available BioFresh-Plus options."""
+    if TYPE_CHECKING:
+        assert isinstance(control, BioFreshPlusControl)
+    return [
+        mode.value
+        for mode in control.supported_modes
+        if isinstance(mode, BioFreshPlusMode)
+    ]
+
+
+SELECT_TYPES: list[LiebherrSelectEntityDescription] = [
+    LiebherrSelectEntityDescription(
+        key="ice_maker",
+        translation_key="ice_maker",
+        control_type=IceMakerControl,
+        mode_enum=IceMakerMode,
+        current_mode_fn=lambda c: c.ice_maker_mode,  # type: ignore[union-attr]
+        options_fn=_ice_maker_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_ice_maker(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+    LiebherrSelectEntityDescription(
+        key="hydro_breeze",
+        translation_key="hydro_breeze",
+        control_type=HydroBreezeControl,
+        mode_enum=HydroBreezeMode,
+        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
+        options_fn=_hydro_breeze_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_hydro_breeze(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+    LiebherrSelectEntityDescription(
+        key="bio_fresh_plus",
+        translation_key="bio_fresh_plus",
+        control_type=BioFreshPlusControl,
+        mode_enum=BioFreshPlusMode,
+        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
+        options_fn=_bio_fresh_plus_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_bio_fresh_plus(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+]
+
+
+def _create_select_entities(
+    coordinators: list[LiebherrCoordinator],
+) -> list[LiebherrSelectEntity]:
+    """Create select entities for the given coordinators."""
+    entities: list[LiebherrSelectEntity] = []
+
+    for coordinator in coordinators:
+        has_multiple_zones = len(coordinator.data.get_temperature_controls()) > 1
+
+        for control in coordinator.data.controls:
+            for description in SELECT_TYPES:
+                if isinstance(control, description.control_type):
+                    if TYPE_CHECKING:
+                        assert isinstance(
+                            control,
+                            IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+                        )
+                    entities.append(
+                        LiebherrSelectEntity(
+                            coordinator=coordinator,
+                            description=description,
+                            zone_id=control.zone_id,
+                            has_multiple_zones=has_multiple_zones,
+                        )
+                    )
+
+    return entities
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LiebherrConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Liebherr select entities."""
+    async_add_entities(
+        _create_select_entities(list(entry.runtime_data.coordinators.values()))
+    )
+
+    @callback
+    def _async_new_device(coordinators: list[LiebherrCoordinator]) -> None:
+        """Add select entities for new devices."""
+        async_add_entities(_create_select_entities(coordinators))
+
+    entry.async_on_unload(
+        async_dispatcher_connect(
+            hass, f"{DOMAIN}_new_device_{entry.entry_id}", _async_new_device
+        )
+    )
+
+
+class LiebherrSelectEntity(LiebherrEntity, SelectEntity):
+    """Representation of a Liebherr select entity."""
+
+    entity_description: LiebherrSelectEntityDescription
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+        description: LiebherrSelectEntityDescription,
+        zone_id: int,
+        has_multiple_zones: bool,
+    ) -> None:
+        """Initialize the select entity."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._zone_id = zone_id
+        self._attr_unique_id = f"{coordinator.device_id}_{description.key}_{zone_id}"
+
+        # Set options from the control
+        control = self._select_control
+        if control is not None:
+            self._attr_options = description.options_fn(control)
+
+        # Add zone suffix only for multi-zone devices
+        if has_multiple_zones:
+            temp_controls = coordinator.data.get_temperature_controls()
+            if (
+                (tc := temp_controls.get(zone_id))
+                and isinstance(tc.zone_position, ZonePosition)
+                and (zone_key := ZONE_POSITION_MAP.get(tc.zone_position))
+            ):
+                self._attr_translation_key = f"{description.translation_key}_{zone_key}"
+
+    @property
+    def _select_control(self) -> SelectControl | None:
+        """Get the select control for this entity."""
+        for control in self.coordinator.data.controls:
+            if (
+                isinstance(control, self.entity_description.control_type)
+                and control.zone_id == self._zone_id
+            ):
+                if TYPE_CHECKING:
+                    assert isinstance(
+                        control,
+                        IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+                    )
+                return control
+        return None
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the current selected option."""
+        control = self._select_control
+        if TYPE_CHECKING:
+            assert isinstance(
+                control,
+                IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+            )
+        mode = self.entity_description.current_mode_fn(control)
+        if isinstance(mode, StrEnum):
+            return mode.value
+        return None
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._select_control is not None
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        mode = self.entity_description.mode_enum(option)
+        await self._async_send_command(
+            self.entity_description.set_fn(self.coordinator, self._zone_id, mode),
+        )

homeassistant/components/liebherr/sensor.py

@@ -14,10 +14,12 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
+from .const import DOMAIN
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 from .entity import LiebherrZoneEntity
 
@@ -48,22 +50,41 @@ SENSOR_TYPES: tuple[LiebherrSensorEntityDescription, ...] = (
 )
 
 
+def _create_sensor_entities(
+    coordinators: list[LiebherrCoordinator],
+) -> list[LiebherrSensor]:
+    """Create sensor entities for the given coordinators."""
+    return [
+        LiebherrSensor(
+            coordinator=coordinator,
+            zone_id=temp_control.zone_id,
+            description=description,
+        )
+        for coordinator in coordinators
+        for temp_control in coordinator.data.get_temperature_controls().values()
+        for description in SENSOR_TYPES
+    ]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: LiebherrConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Liebherr sensor entities."""
-    coordinators = entry.runtime_data
     async_add_entities(
-        LiebherrSensor(
-            coordinator=coordinator,
-            zone_id=temp_control.zone_id,
-            description=description,
+        _create_sensor_entities(list(entry.runtime_data.coordinators.values()))
+    )
+
+    @callback
+    def _async_new_device(coordinators: list[LiebherrCoordinator]) -> None:
+        """Add sensor entities for new devices."""
+        async_add_entities(_create_sensor_entities(coordinators))
+
+    entry.async_on_unload(
+        async_dispatcher_connect(
+            hass, f"{DOMAIN}_new_device_{entry.entry_id}", _async_new_device
         )
-        for coordinator in coordinators.values()
-        for temp_control in coordinator.data.get_temperature_controls().values()
-        for description in SENSOR_TYPES
     )
 
 

homeassistant/components/liebherr/strings.json

@@ -47,6 +47,112 @@
         "name": "Top zone setpoint"
       }
     },
+    "select": {
+      "bio_fresh_plus": {
+        "name": "BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "-2°C | -2°C",
+          "minus_two_zero": "-2°C | 0°C",
+          "zero_minus_two": "0°C | -2°C",
+          "zero_zero": "0°C | 0°C"
+        }
+      },
+      "bio_fresh_plus_bottom_zone": {
+        "name": "Bottom zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "bio_fresh_plus_middle_zone": {
+        "name": "Middle zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "bio_fresh_plus_top_zone": {
+        "name": "Top zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "hydro_breeze": {
+        "name": "HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_bottom_zone": {
+        "name": "Bottom zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_middle_zone": {
+        "name": "Middle zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_top_zone": {
+        "name": "Top zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "ice_maker": {
+        "name": "IceMaker",
+        "state": {
+          "max_ice": "MaxIce",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_bottom_zone": {
+        "name": "Bottom zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_middle_zone": {
+        "name": "Middle zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_top_zone": {
+        "name": "Top zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      }
+    },
     "sensor": {
       "bottom_zone": {
         "name": "Bottom zone"

homeassistant/components/liebherr/switch.py

@@ -15,9 +15,11 @@ from pyliebherrhomeapi.const import (
 )
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from .const import DOMAIN
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 from .entity import ZONE_POSITION_MAP, LiebherrEntity
 
@@ -90,15 +92,13 @@ DEVICE_SWITCH_TYPES: dict[str, LiebherrDeviceSwitchEntityDescription] = {
 }
 
 
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: LiebherrConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Liebherr switch entities."""
+def _create_switch_entities(
+    coordinators: list[LiebherrCoordinator],
+) -> list[LiebherrDeviceSwitch | LiebherrZoneSwitch]:
+    """Create switch entities for the given coordinators."""
     entities: list[LiebherrDeviceSwitch | LiebherrZoneSwitch] = []
 
-    for coordinator in entry.runtime_data.values():
+    for coordinator in coordinators:
         has_multiple_zones = len(coordinator.data.get_temperature_controls()) > 1
 
         for control in coordinator.data.controls:
@@ -127,7 +127,29 @@ async def async_setup_entry(
                     )
                 )
 
-    async_add_entities(entities)
+    return entities
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LiebherrConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Liebherr switch entities."""
+    async_add_entities(
+        _create_switch_entities(list(entry.runtime_data.coordinators.values()))
+    )
+
+    @callback
+    def _async_new_device(coordinators: list[LiebherrCoordinator]) -> None:
+        """Add switch entities for new devices."""
+        async_add_entities(_create_switch_entities(coordinators))
+
+    entry.async_on_unload(
+        async_dispatcher_connect(
+            hass, f"{DOMAIN}_new_device_{entry.entry_id}", _async_new_device
+        )
+    )
 
 
 class LiebherrDeviceSwitch(LiebherrEntity, SwitchEntity):

homeassistant/components/lunatone/light.py

@@ -109,14 +109,18 @@ class LunatoneLight(
         return self._device is not None and self._device.is_on
 
     @property
-    def brightness(self) -> int:
+    def brightness(self) -> int | None:
         """Return the brightness of this light between 0..255."""
-        return value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
+        return (
+            value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
+            if self._device.brightness is not None
+            else None
+        )
 
     @property
     def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
-        if self._device is not None and self._device.is_dimmable:
+        if self._device is not None and self._device.brightness is not None:
             return ColorMode.BRIGHTNESS
         return ColorMode.ONOFF
 
@@ -149,7 +153,8 @@ class LunatoneLight(
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
         if brightness_supported(self.supported_color_modes):
-            self._last_brightness = self.brightness
+            if self.brightness:
+                self._last_brightness = self.brightness
             await self._device.fade_to_brightness(0)
         else:
             await self._device.switch_off()

homeassistant/components/lunatone/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["lunatone-rest-api-client==0.6.3"]
+  "requirements": ["lunatone-rest-api-client==0.7.0"]
 }

homeassistant/components/media_extractor/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "calculated",
   "loggers": ["yt_dlp"],
   "quality_scale": "internal",
-  "requirements": ["yt-dlp[default]==2026.02.04"],
+  "requirements": ["yt-dlp[default]==2026.02.21"],
   "single_config_entry": true
 }

homeassistant/components/met/diagnostics.py

@@ -0,0 +1,30 @@
+"""Diagnostics support for Met.no integration."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.core import HomeAssistant
+
+from .coordinator import MetWeatherConfigEntry
+
+TO_REDACT = [
+    CONF_LATITUDE,
+    CONF_LONGITUDE,
+]
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: MetWeatherConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator_data = entry.runtime_data.data
+
+    return {
+        "entry_data": async_redact_data(entry.data, TO_REDACT),
+        "data": {
+            "current_weather_data": coordinator_data.current_weather_data,
+            "daily_forecast": coordinator_data.daily_forecast,
+            "hourly_forecast": coordinator_data.hourly_forecast,
+        },
+    }

homeassistant/components/mta/__init__.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
+
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN as DOMAIN
+from .const import DOMAIN as DOMAIN, SUBENTRY_TYPE_BUS, SUBENTRY_TYPE_SUBWAY
 from .coordinator import MTAConfigEntry, MTADataUpdateCoordinator
 
 PLATFORMS = [Platform.SENSOR]
@@ -13,16 +15,36 @@ PLATFORMS = [Platform.SENSOR]
 
 async def async_setup_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Set up MTA from a config entry."""
-    coordinator = MTADataUpdateCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
+    coordinators: dict[str, MTADataUpdateCoordinator] = {}
 
-    entry.runtime_data = coordinator
+    for subentry_id, subentry in entry.subentries.items():
+        if subentry.subentry_type not in (SUBENTRY_TYPE_SUBWAY, SUBENTRY_TYPE_BUS):
+            continue
+
+        coordinators[subentry_id] = MTADataUpdateCoordinator(hass, entry, subentry)
+
+    # Refresh all coordinators in parallel
+    await asyncio.gather(
+        *(
+            coordinator.async_config_entry_first_refresh()
+            for coordinator in coordinators.values()
+        )
+    )
+
+    entry.runtime_data = coordinators
+
+    entry.async_on_unload(entry.add_update_listener(async_update_entry))
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
+async def async_update_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> None:
+    """Handle config entry update (e.g., subentry changes)."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/mta/config_flow.py

@@ -2,22 +2,43 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
-from pymta import LINE_TO_FEED, MTAFeedError, SubwayFeed
+from pymta import LINE_TO_FEED, BusFeed, MTAFeedError, SubwayFeed
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.helpers import aiohttp_client
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
+)
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import callback
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
     SelectOptionDict,
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
 )
 
-from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
+from .const import (
+    CONF_LINE,
+    CONF_ROUTE,
+    CONF_STOP_ID,
+    CONF_STOP_NAME,
+    DOMAIN,
+    SUBENTRY_TYPE_BUS,
+    SUBENTRY_TYPE_SUBWAY,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,17 +49,79 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 1
     MINOR_VERSION = 1
 
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self.data: dict[str, Any] = {}
-        self.stops: dict[str, str] = {}
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this handler."""
+        return {
+            SUBENTRY_TYPE_SUBWAY: SubwaySubentryFlowHandler,
+            SUBENTRY_TYPE_BUS: BusSubentryFlowHandler,
+        }
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         errors: dict[str, str] = {}
+        if user_input is not None:
+            api_key = user_input.get(CONF_API_KEY)
+            self._async_abort_entries_match({CONF_API_KEY: api_key})
+            if api_key:
+                # Test the API key by trying to fetch bus data
+                session = async_get_clientsession(self.hass)
+                bus_feed = BusFeed(api_key=api_key, session=session)
+                try:
+                    # Try to get stops for a known route to validate the key
+                    await bus_feed.get_stops(route_id="M15")
+                except MTAFeedError:
+                    errors["base"] = "cannot_connect"
+                except Exception:
+                    _LOGGER.exception("Unexpected error validating API key")
+                    errors["base"] = "unknown"
+            if not errors:
+                if self.source == SOURCE_REAUTH:
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(),
+                        data_updates={CONF_API_KEY: api_key or None},
+                    )
+                return self.async_create_entry(
+                    title="MTA",
+                    data={CONF_API_KEY: api_key or None},
+                )
 
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(CONF_API_KEY): TextSelector(
+                        TextSelectorConfig(type=TextSelectorType.PASSWORD)
+                    ),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_reauth(
+        self, _entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauth when user wants to add or update API key."""
+        return await self.async_step_user()
+
+
+class SubwaySubentryFlowHandler(ConfigSubentryFlow):
+    """Handle subway stop subentry flow."""
+
+    def __init__(self) -> None:
+        """Initialize the subentry flow."""
+        self.data: dict[str, Any] = {}
+        self.stops: dict[str, str] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the line selection step."""
         if user_input is not None:
             self.data[CONF_LINE] = user_input[CONF_LINE]
             return await self.async_step_stop()
@@ -58,13 +141,12 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
                     ),
                 }
             ),
-            errors=errors,
         )
 
     async def async_step_stop(
         self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the stop step."""
+    ) -> SubentryFlowResult:
+        """Handle the stop selection step."""
         errors: dict[str, str] = {}
 
         if user_input is not None:
@@ -74,25 +156,30 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
             self.data[CONF_STOP_NAME] = stop_name
 
             unique_id = f"{self.data[CONF_LINE]}_{stop_id}"
-            await self.async_set_unique_id(unique_id)
-            self._abort_if_unique_id_configured()
 
-            # Test connection to real-time GTFS-RT feed (different from static GTFS used by get_stops)
+            # Check for duplicate subentries across all entries
+            for entry in self.hass.config_entries.async_entries(DOMAIN):
+                for subentry in entry.subentries.values():
+                    if subentry.unique_id == unique_id:
+                        return self.async_abort(reason="already_configured")
+
+            # Test connection to real-time GTFS-RT feed
             try:
                 await self._async_test_connection()
             except MTAFeedError:
                 errors["base"] = "cannot_connect"
             else:
-                title = f"{self.data[CONF_LINE]} Line - {stop_name}"
+                title = f"{self.data[CONF_LINE]} - {stop_name}"
                 return self.async_create_entry(
                     title=title,
                     data=self.data,
+                    unique_id=unique_id,
                 )
 
         try:
             self.stops = await self._async_get_stops(self.data[CONF_LINE])
         except MTAFeedError:
-            _LOGGER.exception("Error fetching stops for line %s", self.data[CONF_LINE])
+            _LOGGER.debug("Error fetching stops for line %s", self.data[CONF_LINE])
             return self.async_abort(reason="cannot_connect")
 
         if not self.stops:
@@ -123,7 +210,7 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     async def _async_get_stops(self, line: str) -> dict[str, str]:
         """Get stops for a line from the library."""
         feed_id = SubwayFeed.get_feed_id_for_route(line)
-        session = aiohttp_client.async_get_clientsession(self.hass)
+        session = async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         stops_list = await subway_feed.get_stops(route_id=line)
@@ -141,7 +228,7 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     async def _async_test_connection(self) -> None:
         """Test connection to MTA feed."""
         feed_id = SubwayFeed.get_feed_id_for_route(self.data[CONF_LINE])
-        session = aiohttp_client.async_get_clientsession(self.hass)
+        session = async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         await subway_feed.get_arrivals(
@@ -149,3 +236,133 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
             stop_id=self.data[CONF_STOP_ID],
             max_arrivals=1,
         )
+
+
+class BusSubentryFlowHandler(ConfigSubentryFlow):
+    """Handle bus stop subentry flow."""
+
+    def __init__(self) -> None:
+        """Initialize the subentry flow."""
+        self.data: dict[str, Any] = {}
+        self.stops: dict[str, str] = {}
+
+    def _get_api_key(self) -> str:
+        """Get API key from parent entry."""
+        return self._get_entry().data.get(CONF_API_KEY) or ""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the route input step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            route = user_input[CONF_ROUTE].upper().strip()
+            self.data[CONF_ROUTE] = route
+
+            # Validate route by fetching stops
+            try:
+                self.stops = await self._async_get_stops(route)
+                if not self.stops:
+                    errors["base"] = "invalid_route"
+                else:
+                    return await self.async_step_stop()
+            except MTAFeedError:
+                _LOGGER.debug("Error fetching stops for route %s", route)
+                errors["base"] = "invalid_route"
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ROUTE): TextSelector(),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_stop(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the stop selection step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            stop_id = user_input[CONF_STOP_ID]
+            self.data[CONF_STOP_ID] = stop_id
+            stop_name = self.stops.get(stop_id, stop_id)
+            self.data[CONF_STOP_NAME] = stop_name
+
+            unique_id = f"bus_{self.data[CONF_ROUTE]}_{stop_id}"
+
+            # Check for duplicate subentries across all entries
+            for entry in self.hass.config_entries.async_entries(DOMAIN):
+                for subentry in entry.subentries.values():
+                    if subentry.unique_id == unique_id:
+                        return self.async_abort(reason="already_configured")
+
+            # Test connection to real-time feed
+            try:
+                await self._async_test_connection()
+            except MTAFeedError:
+                errors["base"] = "cannot_connect"
+            else:
+                title = f"{self.data[CONF_ROUTE]} - {stop_name}"
+                return self.async_create_entry(
+                    title=title,
+                    data=self.data,
+                    unique_id=unique_id,
+                )
+
+        stop_options = [
+            SelectOptionDict(value=stop_id, label=stop_name)
+            for stop_id, stop_name in sorted(self.stops.items(), key=lambda x: x[1])
+        ]
+
+        return self.async_show_form(
+            step_id="stop",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_STOP_ID): SelectSelector(
+                        SelectSelectorConfig(
+                            options=stop_options,
+                            mode=SelectSelectorMode.DROPDOWN,
+                        )
+                    ),
+                }
+            ),
+            errors=errors,
+            description_placeholders={"route": self.data[CONF_ROUTE]},
+        )
+
+    async def _async_get_stops(self, route: str) -> dict[str, str]:
+        """Get stops for a bus route from the library."""
+        session = async_get_clientsession(self.hass)
+        api_key = self._get_api_key()
+
+        bus_feed = BusFeed(api_key=api_key, session=session)
+        stops_list = await bus_feed.get_stops(route_id=route)
+
+        stops = {}
+        for stop in stops_list:
+            stop_id = stop["stop_id"]
+            stop_name = stop["stop_name"]
+            # Add direction if available (e.g., "to South Ferry")
+            if direction := stop.get("direction_name"):
+                stops[stop_id] = f"{stop_name} (to {direction})"
+            else:
+                stops[stop_id] = stop_name
+
+        return stops
+
+    async def _async_test_connection(self) -> None:
+        """Test connection to MTA bus feed."""
+        session = async_get_clientsession(self.hass)
+        api_key = self._get_api_key()
+
+        bus_feed = BusFeed(api_key=api_key, session=session)
+        await bus_feed.get_arrivals(
+            route_id=self.data[CONF_ROUTE],
+            stop_id=self.data[CONF_STOP_ID],
+            max_arrivals=1,
+        )

homeassistant/components/mta/const.py

@@ -7,5 +7,9 @@ DOMAIN = "mta"
 CONF_LINE = "line"
 CONF_STOP_ID = "stop_id"
 CONF_STOP_NAME = "stop_name"
+CONF_ROUTE = "route"
+
+SUBENTRY_TYPE_SUBWAY = "subway"
+SUBENTRY_TYPE_BUS = "bus"
 
 UPDATE_INTERVAL = timedelta(seconds=30)

homeassistant/components/mta/coordinator.py

@@ -6,22 +6,30 @@ from dataclasses import dataclass
 from datetime import datetime
 import logging
 
-from pymta import MTAFeedError, SubwayFeed
+from pymta import BusFeed, MTAFeedError, SubwayFeed
 
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.const import CONF_API_KEY
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
-from .const import CONF_LINE, CONF_STOP_ID, DOMAIN, UPDATE_INTERVAL
+from .const import (
+    CONF_LINE,
+    CONF_ROUTE,
+    CONF_STOP_ID,
+    DOMAIN,
+    SUBENTRY_TYPE_BUS,
+    UPDATE_INTERVAL,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @dataclass
 class MTAArrival:
-    """Represents a single train arrival."""
+    """Represents a single transit arrival."""
 
     arrival_time: datetime
     minutes_until: int
@@ -36,7 +44,7 @@ class MTAData:
     arrivals: list[MTAArrival]
 
 
-type MTAConfigEntry = ConfigEntry[MTADataUpdateCoordinator]
+type MTAConfigEntry = ConfigEntry[dict[str, MTADataUpdateCoordinator]]
 
 
 class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
@@ -44,35 +52,48 @@ class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
 
     config_entry: MTAConfigEntry
 
-    def __init__(self, hass: HomeAssistant, config_entry: MTAConfigEntry) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: MTAConfigEntry,
+        subentry: ConfigSubentry,
+    ) -> None:
         """Initialize."""
-        self.line = config_entry.data[CONF_LINE]
-        self.stop_id = config_entry.data[CONF_STOP_ID]
+        self.subentry = subentry
+        self.stop_id = subentry.data[CONF_STOP_ID]
 
-        self.feed_id = SubwayFeed.get_feed_id_for_route(self.line)
         session = async_get_clientsession(hass)
-        self.subway_feed = SubwayFeed(feed_id=self.feed_id, session=session)
+
+        if subentry.subentry_type == SUBENTRY_TYPE_BUS:
+            api_key = config_entry.data.get(CONF_API_KEY) or ""
+            self.feed: BusFeed | SubwayFeed = BusFeed(api_key=api_key, session=session)
+            self.route_id = subentry.data[CONF_ROUTE]
+        else:
+            # Subway feed
+            line = subentry.data[CONF_LINE]
+            feed_id = SubwayFeed.get_feed_id_for_route(line)
+            self.feed = SubwayFeed(feed_id=feed_id, session=session)
+            self.route_id = line
 
         super().__init__(
             hass,
             _LOGGER,
             config_entry=config_entry,
-            name=DOMAIN,
+            name=f"{DOMAIN}_{subentry.subentry_id}",
             update_interval=UPDATE_INTERVAL,
         )
 
     async def _async_update_data(self) -> MTAData:
         """Fetch data from MTA."""
         _LOGGER.debug(
-            "Fetching data for line=%s, stop=%s, feed=%s",
-            self.line,
+            "Fetching data for route=%s, stop=%s",
+            self.route_id,
             self.stop_id,
-            self.feed_id,
         )
 
         try:
-            library_arrivals = await self.subway_feed.get_arrivals(
-                route_id=self.line,
+            library_arrivals = await self.feed.get_arrivals(
+                route_id=self.route_id,
                 stop_id=self.stop_id,
                 max_arrivals=3,
             )

homeassistant/components/mta/quality_scale.yaml

@@ -38,9 +38,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow:
-    status: exempt
-    comment: No authentication required.
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold

homeassistant/components/mta/sensor.py

@@ -11,12 +11,13 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
+from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
+from .const import CONF_LINE, CONF_ROUTE, CONF_STOP_NAME, DOMAIN, SUBENTRY_TYPE_BUS
 from .coordinator import MTAArrival, MTAConfigEntry, MTADataUpdateCoordinator
 
 PARALLEL_UPDATES = 0
@@ -97,16 +98,19 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up MTA sensor based on a config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        MTASensor(coordinator, entry, description)
-        for description in SENSOR_DESCRIPTIONS
-    )
+    for subentry_id, coordinator in entry.runtime_data.items():
+        subentry = entry.subentries[subentry_id]
+        async_add_entities(
+            (
+                MTASensor(coordinator, subentry, description)
+                for description in SENSOR_DESCRIPTIONS
+            ),
+            config_subentry_id=subentry_id,
+        )
 
 
 class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
-    """Sensor for MTA train arrivals."""
+    """Sensor for MTA transit arrivals."""
 
     _attr_has_entity_name = True
     entity_description: MTASensorEntityDescription
@@ -114,24 +118,32 @@ class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
     def __init__(
         self,
         coordinator: MTADataUpdateCoordinator,
-        entry: MTAConfigEntry,
+        subentry: ConfigSubentry,
         description: MTASensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
 
         self.entity_description = description
-        line = entry.data[CONF_LINE]
-        stop_id = entry.data[CONF_STOP_ID]
-        stop_name = entry.data.get(CONF_STOP_NAME, stop_id)
 
-        self._attr_unique_id = f"{entry.unique_id}-{description.key}"
+        is_bus = subentry.subentry_type == SUBENTRY_TYPE_BUS
+        if is_bus:
+            route = subentry.data[CONF_ROUTE]
+            model = "Bus"
+        else:
+            route = subentry.data[CONF_LINE]
+            model = "Subway"
+
+        stop_name = subentry.data.get(CONF_STOP_NAME, subentry.subentry_id)
+
+        unique_id = subentry.unique_id or subentry.subentry_id
+        self._attr_unique_id = f"{unique_id}-{description.key}"
 
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, entry.entry_id)},
-            name=f"{line} Line - {stop_name} ({stop_id})",
+            identifiers={(DOMAIN, unique_id)},
+            name=f"{route} - {stop_name}",
             manufacturer="MTA",
-            model="Subway",
+            model=model,
             entry_type=DeviceEntryType.SERVICE,
         )
 

homeassistant/components/mta/strings.json

@@ -2,32 +2,95 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "no_stops": "No stops found for this line. The line may not be currently running."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "stop": {
-        "data": {
-          "stop_id": "Stop and direction"
-        },
-        "data_description": {
-          "stop_id": "Select the stop and direction you want to track"
-        },
-        "description": "Choose a stop on the {line} line. The direction is included with each stop.",
-        "title": "Select stop and direction"
-      },
       "user": {
         "data": {
-          "line": "Line"
+          "api_key": "[%key:common::config_flow::data::api_key%]"
         },
         "data_description": {
-          "line": "The subway line to track"
+          "api_key": "API key from MTA Bus Time. Required for bus tracking, optional for subway only."
         },
-        "description": "Choose the subway line you want to track.",
-        "title": "Select subway line"
+        "description": "Enter your MTA Bus Time API key to enable bus tracking. Leave blank if you only want to track subways."
+      }
+    }
+  },
+  "config_subentries": {
+    "bus": {
+      "abort": {
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      },
+      "entry_type": "Bus stop",
+      "error": {
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "invalid_route": "Invalid bus route. Please check the route name and try again."
+      },
+      "initiate_flow": {
+        "user": "Add bus stop"
+      },
+      "step": {
+        "stop": {
+          "data": {
+            "stop_id": "Stop"
+          },
+          "data_description": {
+            "stop_id": "Select the stop you want to track"
+          },
+          "description": "Choose a stop on the {route} route.",
+          "title": "Select stop"
+        },
+        "user": {
+          "data": {
+            "route": "Route"
+          },
+          "data_description": {
+            "route": "The bus route identifier"
+          },
+          "description": "Enter the bus route you want to track (for example, M15, B46, Q10).",
+          "title": "Enter bus route"
+        }
+      }
+    },
+    "subway": {
+      "abort": {
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "no_stops": "No stops found for this line. The line may not be currently running."
+      },
+      "entry_type": "Subway stop",
+      "error": {
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      },
+      "initiate_flow": {
+        "user": "Add subway stop"
+      },
+      "step": {
+        "stop": {
+          "data": {
+            "stop_id": "Stop and direction"
+          },
+          "data_description": {
+            "stop_id": "Select the stop and direction you want to track"
+          },
+          "description": "Choose a stop on the {line} line. The direction is included with each stop.",
+          "title": "Select stop and direction"
+        },
+        "user": {
+          "data": {
+            "line": "Line"
+          },
+          "data_description": {
+            "line": "The subway line to track"
+          },
+          "description": "Choose the subway line you want to track.",
+          "title": "Select subway line"
+        }
       }
     }
   },