Drop ignore-missing-annotations from pylint

.core_files.yaml

@@ -34,7 +34,6 @@ base_platforms: &base_platforms
   - homeassistant/components/humidifier/**
   - homeassistant/components/image/**
   - homeassistant/components/image_processing/**
-  - homeassistant/components/infrared/**
   - homeassistant/components/lawn_mower/**
   - homeassistant/components/light/**
   - homeassistant/components/lock/**

.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: ${{ matrix.runs-on }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read # To check out the repository
       packages: write # To push to GHCR
@@ -294,21 +294,6 @@ 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
@@ -336,9 +321,8 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build base image
-        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
+        uses: home-assistant/builder@21bc64d76dad7a5184c67826aab41c6b6f89023a # 2025.11.0
         with:
-          image: ${{ matrix.arch }}
           args: |
             $BUILD_ARGS \
             --target /data/machine \

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 3
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.4"
+  HA_SHORT_VERSION: "2026.3"
   DEFAULT_PYTHON: "3.14.2"
   ALL_PYTHON_VERSIONS: "['3.14.2']"
   # 10.3 is the oldest supported version
@@ -705,7 +705,7 @@ jobs:
         run: |
           . venv/bin/activate
           python --version
-          pylint --ignore-missing-annotations=y homeassistant
+          pylint homeassistant
       - name: Run pylint (partially)
         if: needs.info.outputs.test_full_suite == 'false'
         shell: bash
@@ -714,7 +714,7 @@ jobs:
         run: |
           . venv/bin/activate
           python --version
-          pylint --ignore-missing-annotations=y $(printf "homeassistant/components/%s " ${INTEGRATIONS_GLOB})
+          pylint $(printf "homeassistant/components/%s " ${INTEGRATIONS_GLOB})
 
   pylint-tests:
     name: Check pylint on tests

.github/workflows/wheels.yml

@@ -110,7 +110,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        abi: ["cp314"]
+        abi: ["cp313", "cp314"]
         arch: ["amd64", "aarch64"]
         include:
           - arch: amd64
@@ -161,7 +161,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        abi: ["cp314"]
+        abi: ["cp313", "cp314"]
         arch: ["amd64", "aarch64"]
         include:
           - arch: amd64

.strict-typing

@@ -289,7 +289,6 @@ homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.inels.*
-homeassistant.components.infrared.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*
@@ -584,7 +583,6 @@ homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
-homeassistant.components.velux.*
 homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*

CODEOWNERS

@@ -242,8 +242,6 @@ build.json @home-assistant/supervisor
 /tests/components/bosch_alarm/ @mag1024 @sanjay900
 /homeassistant/components/bosch_shc/ @tschamm
 /tests/components/bosch_shc/ @tschamm
-/homeassistant/components/brands/ @home-assistant/core
-/tests/components/brands/ @home-assistant/core
 /homeassistant/components/braviatv/ @bieniu @Drafteed
 /tests/components/braviatv/ @bieniu @Drafteed
 /homeassistant/components/bring/ @miaucl @tr4nt0r
@@ -557,6 +555,8 @@ 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
@@ -719,8 +719,8 @@ build.json @home-assistant/supervisor
 /tests/components/homematic/ @pvizeli
 /homeassistant/components/homematicip_cloud/ @hahn-th @lackas
 /tests/components/homematicip_cloud/ @hahn-th @lackas
-/homeassistant/components/homevolt/ @danielhiversen @liudger
-/tests/components/homevolt/ @danielhiversen @liudger
+/homeassistant/components/homevolt/ @danielhiversen
+/tests/components/homevolt/ @danielhiversen
 /homeassistant/components/homewizard/ @DCSBL
 /tests/components/homewizard/ @DCSBL
 /homeassistant/components/honeywell/ @rdfurman @mkmer
@@ -794,8 +794,6 @@ build.json @home-assistant/supervisor
 /tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01 @Robbie1221
 /tests/components/influxdb/ @mdegat01 @Robbie1221
-/homeassistant/components/infrared/ @home-assistant/core
-/tests/components/infrared/ @home-assistant/core
 /homeassistant/components/inkbird/ @bdraco
 /tests/components/inkbird/ @bdraco
 /homeassistant/components/input_boolean/ @home-assistant/core
@@ -1084,8 +1082,6 @@ build.json @home-assistant/supervisor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core
 /tests/components/my/ @home-assistant/core
-/homeassistant/components/myneomitis/ @l-pr
-/tests/components/myneomitis/ @l-pr
 /homeassistant/components/mysensors/ @MartinHjelmare @functionpointer
 /tests/components/mysensors/ @MartinHjelmare @functionpointer
 /homeassistant/components/mystrom/ @fabaff
@@ -1970,7 +1966,6 @@ 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

Dockerfile

@@ -30,7 +30,7 @@ RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
     # Install uv
-    && pip3 install uv==0.10.6
+    && pip3 install uv==0.9.26
 
 WORKDIR /usr/src
 

codecov.yml

@@ -10,7 +10,6 @@ coverage:
         target: auto
         threshold: 1
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py
@@ -29,7 +28,6 @@ coverage:
         target: 100
         threshold: 0
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py

homeassistant/bootstrap.py

@@ -210,7 +210,6 @@ DEFAULT_INTEGRATIONS = {
     "analytics",  # Needed for onboarding
     "application_credentials",
     "backup",
-    "brands",
     "frontend",
     "hardware",
     "labs",

homeassistant/components/abode/services.py

@@ -12,6 +12,10 @@ from homeassistant.helpers.dispatcher import dispatcher_send
 
 from .const import DOMAIN, DOMAIN_DATA, LOGGER
 
+SERVICE_SETTINGS = "change_setting"
+SERVICE_CAPTURE_IMAGE = "capture_image"
+SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
+
 ATTR_SETTING = "setting"
 ATTR_VALUE = "value"
 
@@ -71,13 +75,16 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Home Assistant services."""
 
     hass.services.async_register(
-        DOMAIN, "change_setting", _change_setting, schema=CHANGE_SETTING_SCHEMA
+        DOMAIN, SERVICE_SETTINGS, _change_setting, schema=CHANGE_SETTING_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "capture_image", _capture_image, schema=CAPTURE_IMAGE_SCHEMA
+        DOMAIN, SERVICE_CAPTURE_IMAGE, _capture_image, schema=CAPTURE_IMAGE_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "trigger_automation", _trigger_automation, schema=AUTOMATION_SCHEMA
+        DOMAIN,
+        SERVICE_TRIGGER_AUTOMATION,
+        _trigger_automation,
+        schema=AUTOMATION_SCHEMA,
     )

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.1.0"]
+  "requirements": ["accuweather==5.0.0"]
 }

homeassistant/components/accuweather/system_health.py

@@ -30,8 +30,6 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     return {
-        "can_reach_server": system_health.async_check_can_reach_url(
-            hass, str(ENDPOINT)
-        ),
+        "can_reach_server": system_health.async_check_can_reach_url(hass, ENDPOINT),
         "remaining_requests": remaining_requests,
     }

homeassistant/components/advantage_air/services.py

@@ -10,6 +10,8 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
+ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
+
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -18,7 +20,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "set_time_to",
+        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
         entity_domain=SENSOR_DOMAIN,
         schema={vol.Required("minutes"): cv.positive_int},
         func="set_time_to",

homeassistant/components/agent_dvr/services.py

@@ -8,12 +8,18 @@ from homeassistant.helpers import service
 
 from .const import DOMAIN
 
+_DEV_EN_ALT = "enable_alerts"
+_DEV_DS_ALT = "disable_alerts"
+_DEV_EN_REC = "start_recording"
+_DEV_DS_REC = "stop_recording"
+_DEV_SNAP = "snapshot"
+
 CAMERA_SERVICES = {
-    "enable_alerts": "async_enable_alerts",
-    "disable_alerts": "async_disable_alerts",
-    "start_recording": "async_start_recording",
-    "stop_recording": "async_stop_recording",
-    "snapshot": "async_snapshot",
+    _DEV_EN_ALT: "async_enable_alerts",
+    _DEV_DS_ALT: "async_disable_alerts",
+    _DEV_EN_REC: "async_start_recording",
+    _DEV_DS_REC: "async_stop_recording",
+    _DEV_SNAP: "async_snapshot",
 }
 
 

homeassistant/components/airos/__init__.py

@@ -4,16 +4,7 @@ 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,
@@ -24,11 +15,6 @@ 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
 
@@ -37,7 +23,6 @@ from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
-    Platform.BUTTON,
     Platform.SENSOR,
 ]
 
@@ -53,40 +38,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
         hass, verify_ssl=entry.data[SECTION_ADVANCED_SETTINGS][CONF_VERIFY_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
+    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],
     )
 
-    airos_device = airos_class(**conn_data)
-
-    coordinator = AirOSDataUpdateCoordinator(hass, entry, device_data, airos_device)
+    coordinator = AirOSDataUpdateCoordinator(hass, entry, airos_device)
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator

homeassistant/components/airos/binary_sensor.py

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

homeassistant/components/airos/button.py

@@ -1,69 +0,0 @@
-"""AirOS button component for Home Assistant."""
-
-from __future__ import annotations
-
-from airos.exceptions import AirOSException
-
-from homeassistant.components.button import (
-    ButtonDeviceClass,
-    ButtonEntity,
-    ButtonEntityDescription,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import DOMAIN, AirOSConfigEntry, AirOSDataUpdateCoordinator
-from .entity import AirOSEntity
-
-PARALLEL_UPDATES = 0
-
-REBOOT_BUTTON = ButtonEntityDescription(
-    key="reboot",
-    device_class=ButtonDeviceClass.RESTART,
-    entity_registry_enabled_default=False,
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: AirOSConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the AirOS button from a config entry."""
-    async_add_entities([AirOSRebootButton(config_entry.runtime_data, REBOOT_BUTTON)])
-
-
-class AirOSRebootButton(AirOSEntity, ButtonEntity):
-    """Button to reboot device."""
-
-    entity_description: ButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: AirOSDataUpdateCoordinator,
-        description: ButtonEntityDescription,
-    ) -> None:
-        """Initialize the AirOS client button."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press to reboot the device."""
-        try:
-            await self.coordinator.airos_device.login()
-            result = await self.coordinator.airos_device.reboot()
-
-        except AirOSException as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-            ) from err
-
-        if not result:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="reboot_failed",
-            ) from None

homeassistant/components/airos/config_flow.py

@@ -2,24 +2,17 @@
 
 from __future__ import annotations
 
-import asyncio
 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,
     AirOSConnectionSetupError,
     AirOSDataMissingError,
     AirOSDeviceConnectionError,
-    AirOSEndpointError,
     AirOSKeyDataMissingError,
-    AirOSListenerError,
 )
-from airos.helpers import DetectDeviceData, async_get_firmware_data
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -37,36 +30,21 @@ 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,
-    DEFAULT_USERNAME,
-    DEFAULT_VERIFY_SSL,
-    DEVICE_NAME,
-    DOMAIN,
-    HOSTNAME,
-    IP_ADDRESS,
-    MAC_ADDRESS,
-    SECTION_ADVANCED_SETTINGS,
-)
+from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, 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
-
-STEP_DISCOVERY_DATA_SCHEMA = vol.Schema(
+STEP_USER_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): str,
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_USERNAME, default="ubnt"): str,
         vol.Required(CONF_PASSWORD): str,
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
@@ -80,10 +58,6 @@ STEP_DISCOVERY_DATA_SCHEMA = vol.Schema(
     }
 )
 
-STEP_MANUAL_DATA_SCHEMA = STEP_DISCOVERY_DATA_SCHEMA.extend(
-    {vol.Required(CONF_HOST): str}
-)
-
 
 class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ubiquiti airOS."""
@@ -91,29 +65,14 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 2
     MINOR_VERSION = 1
 
-    _discovery_task: asyncio.Task | None = None
-
     def __init__(self) -> None:
         """Initialize the config flow."""
         super().__init__()
-        self.airos_device: AirOSDeviceDetect
+        self.airos_device: AirOS8
         self.errors: dict[str, str] = {}
-        self.discovered_devices: dict[str, dict[str, Any]] = {}
-        self.discovery_abort_reason: str | None = None
-        self.selected_device_info: dict[str, Any] = {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        self.errors = {}
-
-        return self.async_show_menu(
-            step_id="user", menu_options=["discovery", "manual"]
-        )
-
-    async def async_step_manual(
-        self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the manual input of host and credentials."""
         self.errors = {}
@@ -125,7 +84,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
                     data=validated_info["data"],
                 )
         return self.async_show_form(
-            step_id="manual", data_schema=STEP_MANUAL_DATA_SCHEMA, errors=self.errors
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=self.errors
         )
 
     async def _validate_and_get_device_info(
@@ -139,14 +98,16 @@ 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:
-            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],
-            )
+            await airos_device.login()
+            airos_data = await airos_device.status()
 
         except (
             AirOSConnectionSetupError,
@@ -161,14 +122,14 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.exception("Unexpected exception during credential validation")
             self.errors["base"] = "unknown"
         else:
-            await self.async_set_unique_id(device_data["mac"])
+            await self.async_set_unique_id(airos_data.derived.mac)
 
             if self.source in [SOURCE_REAUTH, SOURCE_RECONFIGURE]:
                 self._abort_if_unique_id_mismatch()
             else:
                 self._abort_if_unique_id_configured()
 
-            return {"title": device_data["hostname"], "data": config_data}
+            return {"title": airos_data.host.hostname, "data": config_data}
 
         return None
 
@@ -259,175 +220,3 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             ),
             errors=self.errors,
         )
-
-    async def async_step_discovery(
-        self,
-        discovery_info: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Start the discovery process."""
-        if self._discovery_task and self._discovery_task.done():
-            self._discovery_task = None
-
-            # Handle appropriate 'errors' as abort through progress_done
-            if self.discovery_abort_reason:
-                return self.async_show_progress_done(
-                    next_step_id=self.discovery_abort_reason
-                )
-
-            # Abort through progress_done if no devices were found
-            if not self.discovered_devices:
-                _LOGGER.debug(
-                    "No (new or unconfigured) airOS devices found during discovery"
-                )
-                return self.async_show_progress_done(
-                    next_step_id="discovery_no_devices"
-                )
-
-            # Skip selecting a device if only one new/unconfigured device was found
-            if len(self.discovered_devices) == 1:
-                self.selected_device_info = list(self.discovered_devices.values())[0]
-                return self.async_show_progress_done(next_step_id="configure_device")
-
-            return self.async_show_progress_done(next_step_id="select_device")
-
-        if not self._discovery_task:
-            self.discovered_devices = {}
-            self._discovery_task = self.hass.async_create_task(
-                self._async_run_discovery_with_progress()
-            )
-
-        # Show the progress bar and wait for discovery to complete
-        return self.async_show_progress(
-            step_id="discovery",
-            progress_action="discovering",
-            progress_task=self._discovery_task,
-            description_placeholders={"seconds": str(DISCOVER_INTERVAL)},
-        )
-
-    async def async_step_select_device(
-        self,
-        discovery_info: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Select a discovered device."""
-        if discovery_info is not None:
-            selected_mac = discovery_info[MAC_ADDRESS]
-            self.selected_device_info = self.discovered_devices[selected_mac]
-            return await self.async_step_configure_device()
-
-        list_options = {
-            mac: f"{device.get(HOSTNAME, mac)} ({device.get(IP_ADDRESS, DEVICE_NAME)})"
-            for mac, device in self.discovered_devices.items()
-        }
-
-        return self.async_show_form(
-            step_id="select_device",
-            data_schema=vol.Schema({vol.Required(MAC_ADDRESS): vol.In(list_options)}),
-        )
-
-    async def async_step_configure_device(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Configure the selected device."""
-        self.errors = {}
-
-        if user_input is not None:
-            config_data = {
-                **user_input,
-                CONF_HOST: self.selected_device_info[IP_ADDRESS],
-            }
-            validated_info = await self._validate_and_get_device_info(config_data)
-
-            if validated_info:
-                return self.async_create_entry(
-                    title=validated_info["title"],
-                    data=validated_info["data"],
-                )
-
-        device_name = self.selected_device_info.get(
-            HOSTNAME, self.selected_device_info.get(IP_ADDRESS, DEVICE_NAME)
-        )
-        return self.async_show_form(
-            step_id="configure_device",
-            data_schema=STEP_DISCOVERY_DATA_SCHEMA,
-            errors=self.errors,
-            description_placeholders={"device_name": device_name},
-        )
-
-    async def _async_run_discovery_with_progress(self) -> None:
-        """Run discovery with an embedded progress update loop."""
-        progress_bar = self.hass.async_create_task(self._async_update_progress_bar())
-
-        known_mac_addresses = {
-            entry.unique_id.lower()
-            for entry in self.hass.config_entries.async_entries(DOMAIN)
-            if entry.unique_id
-        }
-
-        try:
-            devices = await airos_discover_devices(DISCOVER_INTERVAL)
-        except AirOSEndpointError:
-            self.discovery_abort_reason = "discovery_detect_error"
-        except AirOSListenerError:
-            self.discovery_abort_reason = "discovery_listen_error"
-        except Exception:
-            self.discovery_abort_reason = "discovery_failed"
-            _LOGGER.exception("An error occurred during discovery")
-        else:
-            self.discovered_devices = {
-                mac_addr: info
-                for mac_addr, info in devices.items()
-                if mac_addr.lower() not in known_mac_addresses
-            }
-            _LOGGER.debug(
-                "Discovery task finished. Found %s new devices",
-                len(self.discovered_devices),
-            )
-        finally:
-            progress_bar.cancel()
-
-    async def _async_update_progress_bar(self) -> None:
-        """Update progress bar every second."""
-        try:
-            for i in range(DISCOVER_INTERVAL):
-                progress = (i + 1) / DISCOVER_INTERVAL
-                self.async_update_progress(progress)
-                await asyncio.sleep(1)
-        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:
-        """Abort if discovery finds no (unconfigured) devices."""
-        return self.async_abort(reason="no_devices_found")
-
-    async def async_step_discovery_listen_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery is unable to listen on the port."""
-        return self.async_abort(reason="listen_error")
-
-    async def async_step_discovery_detect_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery receives incorrect broadcasts."""
-        return self.async_abort(reason="detect_error")
-
-    async def async_step_discovery_failed(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery fails for other reasons."""
-        return self.async_abort(reason="discovery_failed")

homeassistant/components/airos/const.py

@@ -12,10 +12,3 @@ DEFAULT_VERIFY_SSL = False
 DEFAULT_SSL = True
 
 SECTION_ADVANCED_SETTINGS = "advanced_settings"
-
-# Discovery related
-DEFAULT_USERNAME = "ubnt"
-HOSTNAME = "hostname"
-IP_ADDRESS = "ip_address"
-MAC_ADDRESS = "mac_address"
-DEVICE_NAME = "airOS device"

homeassistant/components/airos/coordinator.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from airos.airos6 import AirOS6, AirOS6Data
 from airos.airos8 import AirOS8, AirOS8Data
 from airos.exceptions import (
     AirOSConnectionAuthenticationError,
@@ -12,7 +11,6 @@ from airos.exceptions import (
     AirOSDataMissingError,
     AirOSDeviceConnectionError,
 )
-from airos.helpers import DetectDeviceData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -23,28 +21,19 @@ from .const import DOMAIN, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
-AirOSDeviceDetect = AirOS8 | AirOS6
-AirOSDataDetect = AirOS8Data | AirOS6Data
-
 type AirOSConfigEntry = ConfigEntry[AirOSDataUpdateCoordinator]
 
 
-class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
+class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOS8Data]):
     """Class to manage fetching AirOS data from single endpoint."""
 
-    airos_device: AirOSDeviceDetect
     config_entry: AirOSConfigEntry
 
     def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: AirOSConfigEntry,
-        device_data: DetectDeviceData,
-        airos_device: AirOSDeviceDetect,
+        self, hass: HomeAssistant, config_entry: AirOSConfigEntry, airos_device: AirOS8
     ) -> None:
         """Initialize the coordinator."""
         self.airos_device = airos_device
-        self.device_data = device_data
         super().__init__(
             hass,
             _LOGGER,
@@ -53,7 +42,7 @@ class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
             update_interval=SCAN_INTERVAL,
         )
 
-    async def _async_update_data(self) -> AirOSDataDetect:
+    async def _async_update_data(self) -> AirOS8Data:
         """Fetch data from AirOS."""
         try:
             await self.airos_device.login()
@@ -73,7 +62,7 @@ class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
                 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,10 +3,9 @@
   "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": "platinum",
+  "quality_scale": "silver",
   "requirements": ["airos==0.6.4"]
 }

homeassistant/components/airos/quality_scale.yaml

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

homeassistant/components/airos/sensor.py

@@ -5,14 +5,8 @@ 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,
-    DerivedWirelessMode,
-    DerivedWirelessRole,
-    NetRole,
-)
+from airos.data import DerivedWirelessMode, DerivedWirelessRole, NetRole
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -43,19 +37,15 @@ 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, Generic[AirOSDataModel]):
+class AirOSSensorEntityDescription(SensorEntityDescription):
     """Describe an AirOS sensor."""
 
-    value_fn: Callable[[AirOSDataModel], StateType]
+    value_fn: Callable[[AirOS8Data], StateType]
 
 
-AirOS8SensorEntityDescription = AirOSSensorEntityDescription[AirOS8Data]
-
-COMMON_SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
+SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
     AirOSSensorEntityDescription(
         key="host_cpuload",
         translation_key="host_cpuload",
@@ -85,6 +75,54 @@ COMMON_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",
@@ -120,57 +158,6 @@ COMMON_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,
-    ),
 )
 
 
@@ -182,14 +169,7 @@ async def async_setup_entry(
     """Set up the AirOS sensors from a config entry."""
     coordinator = config_entry.runtime_data
 
-    entities = [AirOSSensor(coordinator, description) for description in COMMON_SENSORS]
-
-    if coordinator.device_data["fw_major"] == 8:
-        entities.extend(
-            AirOSSensor(coordinator, description) for description in AIROS8_SENSORS
-        )
-
-    async_add_entities(entities)
+    async_add_entities(AirOSSensor(coordinator, description) for description in SENSORS)
 
 
 class AirOSSensor(AirOSEntity, SensorEntity):

homeassistant/components/airos/strings.json

@@ -2,10 +2,6 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "detect_error": "Unable to process discovered devices data, check the documentation for supported devices",
-      "discovery_failed": "Unable to start discovery, check logs for details",
-      "listen_error": "Unable to start listening for devices",
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "Re-authentication should be used for the same device not a new one"
@@ -17,36 +13,37 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "flow_title": "Ubiquiti airOS device",
-    "progress": {
-      "connecting": "Connecting to the airOS device",
-      "discovering": "Listening for any airOS devices for {seconds} seconds"
-    },
     "step": {
-      "configure_device": {
+      "reauth_confirm": {
         "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
+          "password": "[%key:common::config_flow::data::password%]"
         },
         "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]",
-          "username": "[%key:component::airos::config::step::manual::data_description::username%]"
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
+        }
+      },
+      "reconfigure": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
         },
-        "description": "Enter the username and password for {device_name}",
         "sections": {
           "advanced_settings": {
             "data": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data::ssl%]",
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data::ssl%]",
               "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
             },
             "data_description": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::ssl%]",
-              "verify_ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::verify_ssl%]"
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::ssl%]",
+              "verify_ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::verify_ssl%]"
             },
-            "name": "[%key:component::airos::config::step::manual::sections::advanced_settings::name%]"
+            "name": "[%key:component::airos::config::step::user::sections::advanced_settings::name%]"
           }
         }
       },
-      "manual": {
+      "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "password": "[%key:common::config_flow::data::password%]",
@@ -70,49 +67,6 @@
             "name": "Advanced settings"
           }
         }
-      },
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]"
-        }
-      },
-      "reconfigure": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]"
-        },
-        "sections": {
-          "advanced_settings": {
-            "data": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data::ssl%]",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::ssl%]",
-              "verify_ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::verify_ssl%]"
-            },
-            "name": "[%key:component::airos::config::step::manual::sections::advanced_settings::name%]"
-          }
-        }
-      },
-      "select_device": {
-        "data": {
-          "mac_address": "Select the device to configure"
-        },
-        "data_description": {
-          "mac_address": "Select the device MAC address"
-        }
-      },
-      "user": {
-        "menu_options": {
-          "discovery": "Listen for airOS devices on the network",
-          "manual": "Manually configure airOS device"
-        }
       }
     }
   },
@@ -203,9 +157,6 @@
     },
     "key_data_missing": {
       "message": "Key data not returned from device"
-    },
-    "reboot_failed": {
-      "message": "The device did not accept the reboot request. Try again, or check your device web interface for errors."
     }
   }
 }

homeassistant/components/aladdin_connect/__init__.py

@@ -2,12 +2,10 @@
 
 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,
@@ -33,27 +31,11 @@ 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)
     )
 
-    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
+    doors = await client.get_doors()
 
     entry.runtime_data = {
         door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)

homeassistant/components/aladdin_connect/api.py

@@ -11,18 +11,6 @@ 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,14 +4,12 @@ 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 aiohttp_client, config_entry_oauth2_flow
+from homeassistant.helpers import config_entry_oauth2_flow
 
-from .api import AsyncConfigFlowAuth
 from .const import CONFIG_FLOW_MINOR_VERSION, CONFIG_FLOW_VERSION, DOMAIN
 
 
@@ -54,25 +52,11 @@ class OAuth2FlowHandler(
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an oauth config entry or update existing entry for reauth."""
-        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"],
-            )
+        # Extract the user ID from the JWT token's 'sub' field
+        token = jwt.decode(
+            data["token"]["access_token"], options={"verify_signature": False}
         )
-        try:
-            await client.get_doors()
-        except Exception:  # noqa: BLE001
-            return self.async_abort(reason="cannot_connect")
-
+        user_id = token["sub"]
         await self.async_set_unique_id(user_id)
 
         if self.source == SOURCE_REAUTH:

homeassistant/components/aladdin_connect/coordinator.py

@@ -5,13 +5,12 @@ from __future__ import annotations
 from datetime import timedelta
 import logging
 
-import aiohttp
 from genie_partner_sdk.client import AladdinConnectClient
 from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 type AladdinConnectConfigEntry = ConfigEntry[dict[str, AladdinConnectCoordinator]]
@@ -41,10 +40,7 @@ class AladdinConnectCoordinator(DataUpdateCoordinator[GarageDoor]):
 
     async def _async_update_data(self) -> GarageDoor:
         """Fetch data from the Aladdin Connect API."""
-        try:
-            await self.client.update_door(self.data.device_id, self.data.door_number)
-        except aiohttp.ClientError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
+        await self.client.update_door(self.data.device_id, self.data.door_number)
         self.data.status = self.client.get_door_status(
             self.data.device_id, self.data.door_number
         )

homeassistant/components/aladdin_connect/cover.py

@@ -4,19 +4,14 @@ from __future__ import annotations
 
 from typing import Any
 
-import aiohttp
-
 from homeassistant.components.cover import CoverDeviceClass, CoverEntity
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN, SUPPORTED_FEATURES
+from .const import SUPPORTED_FEATURES
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
 from .entity import AladdinConnectEntity
 
-PARALLEL_UPDATES = 1
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -45,23 +40,11 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Issue open command to cover."""
-        try:
-            await self.client.open_door(self._device_id, self._number)
-        except aiohttp.ClientError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="open_door_failed",
-            ) from err
+        await self.client.open_door(self._device_id, self._number)
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Issue close command to cover."""
-        try:
-            await self.client.close_door(self._device_id, self._number)
-        except aiohttp.ClientError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="close_door_failed",
-            ) from err
+        await self.client.close_door(self._device_id, self._number)
 
     @property
     def is_closed(self) -> bool | None:

homeassistant/components/aladdin_connect/diagnostics.py

@@ -1,32 +0,0 @@
-"""Diagnostics support for Aladdin Connect."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from .coordinator import AladdinConnectConfigEntry
-
-TO_REDACT = {"access_token", "refresh_token"}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: AladdinConnectConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    return {
-        "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
-        "doors": {
-            uid: {
-                "device_id": coordinator.data.device_id,
-                "door_number": coordinator.data.door_number,
-                "name": coordinator.data.name,
-                "status": coordinator.data.status,
-                "link_status": coordinator.data.link_status,
-                "battery_level": coordinator.data.battery_level,
-            }
-            for uid, coordinator in config_entry.runtime_data.items()
-        },
-    }

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -7,56 +7,74 @@ rules:
   brands: done
   common-modules: done
   config-flow: done
-  config-flow-test-coverage: done
+  config-flow-test-coverage: todo
   dependency-transparency: done
   docs-actions:
     status: exempt
     comment: Integration does not register any service actions.
   docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
+  docs-installation-instructions:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-removal-instructions:
+    status: todo
+    comment: Documentation needs to be created.
   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: done
-  test-before-setup: done
+  test-before-configure:
+    status: todo
+    comment: Config flow does not currently test connection during setup.
+  test-before-setup: todo
   unique-config-entry: done
 
   # Silver
-  action-exceptions: done
+  action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
-    status: exempt
-    comment: Integration does not have an options flow.
-  docs-installation-parameters: done
-  entity-unavailable:
-    status: done
-    comment: Handled by the coordinator.
+    status: todo
+    comment: Documentation needs to be created.
+  docs-installation-parameters:
+    status: todo
+    comment: Documentation needs to be created.
+  entity-unavailable: todo
   integration-owner: done
-  log-when-unavailable:
-    status: done
-    comment: Handled by the coordinator.
-  parallel-updates: done
+  log-when-unavailable: todo
+  parallel-updates: todo
   reauthentication-flow: done
-  test-coverage: done
+  test-coverage:
+    status: todo
+    comment: Platform tests for cover and sensor need to be implemented to reach 95% coverage.
 
   # Gold
   devices: done
-  diagnostics: done
-  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
+  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.
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
@@ -68,7 +86,7 @@ rules:
   repair-issues: todo
   stale-devices:
     status: todo
-    comment: We can automatically remove removed devices
+    comment: Stale devices can be done dynamically
 
   # Platinum
   async-dependency: todo

homeassistant/components/aladdin_connect/sensor.py

@@ -20,8 +20,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
 from .entity import AladdinConnectEntity
 
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class AladdinConnectSensorEntityDescription(SensorEntityDescription):

homeassistant/components/aladdin_connect/strings.json

@@ -4,7 +4,6 @@
       "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%]",
@@ -32,13 +31,5 @@
         "title": "[%key:common::config_flow::title::reauth%]"
       }
     }
-  },
-  "exceptions": {
-    "close_door_failed": {
-      "message": "Failed to close the garage door"
-    },
-    "open_door_failed": {
-      "message": "Failed to open the garage door"
-    }
   }
 }

homeassistant/components/alarmdecoder/services.py

@@ -13,6 +13,9 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
+SERVICE_ALARM_TOGGLE_CHIME = "alarm_toggle_chime"
+
+SERVICE_ALARM_KEYPRESS = "alarm_keypress"
 ATTR_KEYPRESS = "keypress"
 
 
@@ -23,7 +26,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "alarm_toggle_chime",
+        SERVICE_ALARM_TOGGLE_CHIME,
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_CODE): cv.string,
@@ -34,7 +37,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "alarm_keypress",
+        SERVICE_ALARM_KEYPRESS,
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_KEYPRESS): cv.string,

homeassistant/components/alexa_devices/services.py

@@ -16,6 +16,9 @@ from .coordinator import AmazonConfigEntry
 ATTR_TEXT_COMMAND = "text_command"
 ATTR_SOUND = "sound"
 ATTR_INFO_SKILL = "info_skill"
+SERVICE_TEXT_COMMAND = "send_text_command"
+SERVICE_SOUND_NOTIFICATION = "send_sound"
+SERVICE_INFO_SKILL = "send_info_skill"
 
 SCHEMA_SOUND_SERVICE = vol.Schema(
     {
@@ -125,17 +128,17 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Amazon Devices integration."""
     for service_name, method, schema in (
         (
-            "send_sound",
+            SERVICE_SOUND_NOTIFICATION,
             async_send_sound_notification,
             SCHEMA_SOUND_SERVICE,
         ),
         (
-            "send_text_command",
+            SERVICE_TEXT_COMMAND,
             async_send_text_command,
             SCHEMA_CUSTOM_COMMAND,
         ),
         (
-            "send_info_skill",
+            SERVICE_INFO_SKILL,
             async_send_info_skill,
             SCHEMA_INFO_SKILL,
         ),

homeassistant/components/amberelectric/const.py

@@ -16,6 +16,8 @@ ATTRIBUTION = "Data provided by Amber Electric"
 LOGGER = logging.getLogger(__package__)
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 
+SERVICE_GET_FORECASTS = "get_forecasts"
+
 GENERAL_CHANNEL = "general"
 CONTROLLED_LOAD_CHANNEL = "controlled_load"
 FEED_IN_CHANNEL = "feed_in"

homeassistant/components/amberelectric/services.py

@@ -22,6 +22,7 @@ from .const import (
     DOMAIN,
     FEED_IN_CHANNEL,
     GENERAL_CHANNEL,
+    SERVICE_GET_FORECASTS,
 )
 from .coordinator import AmberConfigEntry
 from .helpers import format_cents_to_dollars, normalize_descriptor
@@ -100,7 +101,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
     hass.services.async_register(
         DOMAIN,
-        "get_forecasts",
+        SERVICE_GET_FORECASTS,
         handle_get_forecasts,
         GET_FORECASTS_SCHEMA,
         supports_response=SupportsResponse.ONLY,

homeassistant/components/amcrest/camera.py

@@ -49,6 +49,18 @@ SCAN_INTERVAL = timedelta(seconds=15)
 
 STREAM_SOURCE_LIST = ["snapshot", "mjpeg", "rtsp"]
 
+_SRV_EN_REC = "enable_recording"
+_SRV_DS_REC = "disable_recording"
+_SRV_EN_AUD = "enable_audio"
+_SRV_DS_AUD = "disable_audio"
+_SRV_EN_MOT_REC = "enable_motion_recording"
+_SRV_DS_MOT_REC = "disable_motion_recording"
+_SRV_GOTO = "goto_preset"
+_SRV_CBW = "set_color_bw"
+_SRV_TOUR_ON = "start_tour"
+_SRV_TOUR_OFF = "stop_tour"
+
+_SRV_PTZ_CTRL = "ptz_control"
 _ATTR_PTZ_TT = "travel_time"
 _ATTR_PTZ_MOV = "movement"
 _MOV = [
@@ -91,17 +103,17 @@ _SRV_PTZ_SCHEMA = _SRV_SCHEMA.extend(
 )
 
 CAMERA_SERVICES = {
-    "enable_recording": (_SRV_SCHEMA, "async_enable_recording", ()),
-    "disable_recording": (_SRV_SCHEMA, "async_disable_recording", ()),
-    "enable_audio": (_SRV_SCHEMA, "async_enable_audio", ()),
-    "disable_audio": (_SRV_SCHEMA, "async_disable_audio", ()),
-    "enable_motion_recording": (_SRV_SCHEMA, "async_enable_motion_recording", ()),
-    "disable_motion_recording": (_SRV_SCHEMA, "async_disable_motion_recording", ()),
-    "goto_preset": (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
-    "set_color_bw": (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
-    "start_tour": (_SRV_SCHEMA, "async_start_tour", ()),
-    "stop_tour": (_SRV_SCHEMA, "async_stop_tour", ()),
-    "ptz_control": (
+    _SRV_EN_REC: (_SRV_SCHEMA, "async_enable_recording", ()),
+    _SRV_DS_REC: (_SRV_SCHEMA, "async_disable_recording", ()),
+    _SRV_EN_AUD: (_SRV_SCHEMA, "async_enable_audio", ()),
+    _SRV_DS_AUD: (_SRV_SCHEMA, "async_disable_audio", ()),
+    _SRV_EN_MOT_REC: (_SRV_SCHEMA, "async_enable_motion_recording", ()),
+    _SRV_DS_MOT_REC: (_SRV_SCHEMA, "async_disable_motion_recording", ()),
+    _SRV_GOTO: (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
+    _SRV_CBW: (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
+    _SRV_TOUR_ON: (_SRV_SCHEMA, "async_start_tour", ()),
+    _SRV_TOUR_OFF: (_SRV_SCHEMA, "async_stop_tour", ()),
+    _SRV_PTZ_CTRL: (
         _SRV_PTZ_SCHEMA,
         "async_ptz_control",
         (_ATTR_PTZ_MOV, _ATTR_PTZ_TT),

homeassistant/components/androidtv/media_player.py

@@ -36,7 +36,7 @@ from .const import (
     SIGNAL_CONFIG_ENTITY,
 )
 from .entity import AndroidTVEntity, adb_decorator
-from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT
+from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT, SERVICE_LEARN_SENDEVENT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -271,7 +271,7 @@ class ADBDevice(AndroidTVEntity, MediaPlayerEntity):
             self.async_write_ha_state()
 
             msg = (
-                f"Output from service 'learn_sendevent' from"
+                f"Output from service '{SERVICE_LEARN_SENDEVENT}' from"
                 f" {self.entity_id}: '{output}'"
             )
             persistent_notification.async_create(

homeassistant/components/androidtv/services.py

@@ -16,6 +16,11 @@ ATTR_DEVICE_PATH = "device_path"
 ATTR_HDMI_INPUT = "hdmi_input"
 ATTR_LOCAL_PATH = "local_path"
 
+SERVICE_ADB_COMMAND = "adb_command"
+SERVICE_DOWNLOAD = "download"
+SERVICE_LEARN_SENDEVENT = "learn_sendevent"
+SERVICE_UPLOAD = "upload"
+
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -24,7 +29,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "adb_command",
+        SERVICE_ADB_COMMAND,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={vol.Required(ATTR_COMMAND): cv.string},
         func="adb_command",
@@ -32,7 +37,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "learn_sendevent",
+        SERVICE_LEARN_SENDEVENT,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema=None,
         func="learn_sendevent",
@@ -40,7 +45,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "download",
+        SERVICE_DOWNLOAD,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,
@@ -51,7 +56,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "upload",
+        SERVICE_UPLOAD,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,

homeassistant/components/anthropic/ai_task.py

@@ -46,7 +46,6 @@ class AnthropicTaskEntity(
         ai_task.AITaskEntityFeature.GENERATE_DATA
         | ai_task.AITaskEntityFeature.SUPPORT_ATTACHMENTS
     )
-    _attr_translation_key = "ai_task_data"
 
     async def _async_generate_data(
         self,

homeassistant/components/anthropic/config_flow.py

@@ -43,9 +43,7 @@ from homeassistant.helpers.selector import (
 from homeassistant.helpers.typing import VolDictType
 
 from .const import (
-    CODE_EXECUTION_UNSUPPORTED_MODELS,
     CONF_CHAT_MODEL,
-    CONF_CODE_EXECUTION,
     CONF_MAX_TOKENS,
     CONF_PROMPT,
     CONF_RECOMMENDED,
@@ -114,12 +112,19 @@ 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 != "claude-3-haiku-20240307"
+            if model_info.id
+            not in (
+                "claude-3-haiku-20240307",
+                "claude-3-5-haiku-20241022",
+                "claude-3-opus-20240229",
+            )
             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,
@@ -417,16 +422,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         else:
             self.options.pop(CONF_THINKING_EFFORT, None)
 
-        if not model.startswith(tuple(CODE_EXECUTION_UNSUPPORTED_MODELS)):
-            step_schema[
-                vol.Optional(
-                    CONF_CODE_EXECUTION,
-                    default=DEFAULT[CONF_CODE_EXECUTION],
-                )
-            ] = bool
-        else:
-            self.options.pop(CONF_CODE_EXECUTION, None)
-
         if not model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
             step_schema.update(
                 {

homeassistant/components/anthropic/const.py

@@ -11,7 +11,6 @@ DEFAULT_AI_TASK_NAME = "Claude AI Task"
 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"
-CONF_CODE_EXECUTION = "code_execution"
 CONF_MAX_TOKENS = "max_tokens"
 CONF_TEMPERATURE = "temperature"
 CONF_THINKING_BUDGET = "thinking_budget"
@@ -26,7 +25,6 @@ CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
 DEFAULT = {
     CONF_CHAT_MODEL: "claude-haiku-4-5",
-    CONF_CODE_EXECUTION: False,
     CONF_MAX_TOKENS: 3000,
     CONF_TEMPERATURE: 1.0,
     CONF_THINKING_BUDGET: 0,
@@ -39,6 +37,8 @@ DEFAULT = {
 MIN_THINKING_BUDGET = 1024
 
 NON_THINKING_MODELS = [
+    "claude-3-5",  # Both sonnet and haiku
+    "claude-3-opus",
     "claude-3-haiku",
 ]
 
@@ -51,7 +51,7 @@ NON_ADAPTIVE_THINKING_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3-haiku",
+    "claude-3",
 ]
 
 UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
@@ -60,17 +60,19 @@ UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3-haiku",
+    "claude-3",
 ]
 
 WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
-]
-
-CODE_EXECUTION_UNSUPPORTED_MODELS = [
-    "claude-3-haiku",
+    "claude-3-opus",
+    "claude-3-5-sonnet-20240620",
+    "claude-3-5-sonnet-20241022",
 ]
 
 DEPRECATED_MODELS = [
-    "claude-3",
+    "claude-3-5-haiku",
+    "claude-3-7-sonnet",
+    "claude-3-5-sonnet",
+    "claude-3-opus",
 ]

homeassistant/components/anthropic/conversation.py

@@ -37,7 +37,6 @@ class AnthropicConversationEntity(
     """Anthropic conversation agent."""
 
     _attr_supports_streaming = True
-    _attr_translation_key = "conversation"
 
     def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""

homeassistant/components/anthropic/entity.py

@@ -3,23 +3,19 @@
 import base64
 from collections.abc import AsyncGenerator, Callable, Iterable
 from dataclasses import dataclass, field
-from datetime import UTC, datetime
 import json
 from mimetypes import guess_file_type
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Any
 
 import anthropic
 from anthropic import AsyncStream
 from anthropic.types import (
     Base64ImageSourceParam,
     Base64PDFSourceParam,
-    BashCodeExecutionToolResultBlock,
     CitationsDelta,
     CitationsWebSearchResultLocation,
     CitationWebSearchResultLocationParam,
-    CodeExecutionTool20250825Param,
-    Container,
     ContentBlockParam,
     DocumentBlockParam,
     ImageBlockParam,
@@ -45,7 +41,6 @@ from anthropic.types import (
     TextCitation,
     TextCitationParam,
     TextDelta,
-    TextEditorCodeExecutionToolResultBlock,
     ThinkingBlock,
     ThinkingBlockParam,
     ThinkingConfigAdaptiveParam,
@@ -56,21 +51,18 @@ from anthropic.types import (
     ToolChoiceAutoParam,
     ToolChoiceToolParam,
     ToolParam,
+    ToolResultBlockParam,
     ToolUnionParam,
     ToolUseBlock,
     ToolUseBlockParam,
     Usage,
     WebSearchTool20250305Param,
+    WebSearchToolRequestErrorParam,
     WebSearchToolResultBlock,
-    WebSearchToolResultBlockParamContentParam,
-)
-from anthropic.types.bash_code_execution_tool_result_block_param import (
-    Content as BashCodeExecutionToolResultContentParam,
+    WebSearchToolResultBlockParam,
+    WebSearchToolResultError,
 )
 from anthropic.types.message_create_params import MessageCreateParamsStreaming
-from anthropic.types.text_editor_code_execution_tool_result_block_param import (
-    Content as TextEditorCodeExecutionToolResultContentParam,
-)
 import voluptuous as vol
 from voluptuous_openapi import convert
 
@@ -82,12 +74,10 @@ from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.json import json_dumps
 from homeassistant.util import slugify
-from homeassistant.util.json import JsonObjectType
 
 from . import AnthropicConfigEntry
 from .const import (
     CONF_CHAT_MODEL,
-    CONF_CODE_EXECUTION,
     CONF_MAX_TOKENS,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
@@ -142,23 +132,11 @@ class ContentDetails:
     """Native data for AssistantContent."""
 
     citation_details: list[CitationDetails] = field(default_factory=list)
-    thinking_signature: str | None = None
-    redacted_thinking: str | None = None
-    container: Container | None = None
 
     def has_content(self) -> bool:
-        """Check if there is any text content."""
+        """Check if there is any content."""
         return any(detail.length > 0 for detail in self.citation_details)
 
-    def __bool__(self) -> bool:
-        """Check if there is any thinking content or citations."""
-        return (
-            self.thinking_signature is not None
-            or self.redacted_thinking is not None
-            or self.container is not None
-            or self.has_citations()
-        )
-
     def has_citations(self) -> bool:
         """Check if there are any citations."""
         return any(detail.citations for detail in self.citation_details)
@@ -200,53 +178,30 @@ class ContentDetails:
 
 def _convert_content(
     chat_content: Iterable[conversation.Content],
-) -> tuple[list[MessageParam], str | None]:
+) -> list[MessageParam]:
     """Transform HA chat_log content into Anthropic API format."""
     messages: list[MessageParam] = []
-    container_id: str | None = None
 
     for content in chat_content:
         if isinstance(content, conversation.ToolResultContent):
-            external_tool = True
             if content.tool_name == "web_search":
-                tool_result_block: ContentBlockParam = {
-                    "type": "web_search_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        WebSearchToolResultBlockParamContentParam,
-                        content.tool_result["content"]
-                        if "content" in content.tool_result
-                        else {
-                            "type": "web_search_tool_result_error",
-                            "error_code": content.tool_result.get(
-                                "error_code", "unavailable"
-                            ),
-                        },
+                tool_result_block: ContentBlockParam = WebSearchToolResultBlockParam(
+                    type="web_search_tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=content.tool_result["content"]
+                    if "content" in content.tool_result
+                    else WebSearchToolRequestErrorParam(
+                        type="web_search_tool_result_error",
+                        error_code=content.tool_result.get("error_code", "unavailable"),  # type: ignore[typeddict-item]
                     ),
-                }
-            elif content.tool_name == "bash_code_execution":
-                tool_result_block = {
-                    "type": "bash_code_execution_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        BashCodeExecutionToolResultContentParam, content.tool_result
-                    ),
-                }
-            elif content.tool_name == "text_editor_code_execution":
-                tool_result_block = {
-                    "type": "text_editor_code_execution_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        TextEditorCodeExecutionToolResultContentParam,
-                        content.tool_result,
-                    ),
-                }
+                )
+                external_tool = True
             else:
-                tool_result_block = {
-                    "type": "tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": json_dumps(content.tool_result),
-                }
+                tool_result_block = ToolResultBlockParam(
+                    type="tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=json_dumps(content.tool_result),
+                )
                 external_tool = False
             if not messages or messages[-1]["role"] != (
                 "assistant" if external_tool else "user"
@@ -291,33 +246,29 @@ def _convert_content(
                         content=[],
                     )
                 )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                ]
 
-            if isinstance(content.native, ContentDetails):
-                if content.native.thinking_signature:
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        ThinkingBlockParam(
-                            type="thinking",
-                            thinking=content.thinking_content or "",
-                            signature=content.native.thinking_signature,
-                        )
+            if isinstance(content.native, ThinkingBlock):
+                messages[-1]["content"].append(  # type: ignore[union-attr]
+                    ThinkingBlockParam(
+                        type="thinking",
+                        thinking=content.thinking_content or "",
+                        signature=content.native.signature,
                     )
-                if content.native.redacted_thinking:
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        RedactedThinkingBlockParam(
-                            type="redacted_thinking",
-                            data=content.native.redacted_thinking,
-                        )
+                )
+            elif isinstance(content.native, RedactedThinkingBlock):
+                redacted_thinking_block = RedactedThinkingBlockParam(
+                    type="redacted_thinking",
+                    data=content.native.data,
+                )
+                if isinstance(messages[-1]["content"], str):
+                    messages[-1]["content"] = [
+                        TextBlockParam(type="text", text=messages[-1]["content"]),
+                        redacted_thinking_block,
+                    ]
+                else:
+                    messages[-1]["content"].append(  # type: ignore[attr-defined]
+                        redacted_thinking_block
                     )
-                if (
-                    content.native.container is not None
-                    and content.native.container.expires_at > datetime.now(UTC)
-                ):
-                    container_id = content.native.container.id
-
             if content.content:
                 current_index = 0
                 for detail in (
@@ -358,30 +309,16 @@ def _convert_content(
                             text=content.content[current_index:],
                         )
                     )
-
             if content.tool_calls:
                 messages[-1]["content"].extend(  # type: ignore[union-attr]
                     [
                         ServerToolUseBlockParam(
                             type="server_tool_use",
                             id=tool_call.id,
-                            name=cast(
-                                Literal[
-                                    "web_search",
-                                    "bash_code_execution",
-                                    "text_editor_code_execution",
-                                ],
-                                tool_call.tool_name,
-                            ),
+                            name="web_search",
                             input=tool_call.tool_args,
                         )
-                        if tool_call.external
-                        and tool_call.tool_name
-                        in [
-                            "web_search",
-                            "bash_code_execution",
-                            "text_editor_code_execution",
-                        ]
+                        if tool_call.external and tool_call.tool_name == "web_search"
                         else ToolUseBlockParam(
                             type="tool_use",
                             id=tool_call.id,
@@ -391,19 +328,11 @@ def _convert_content(
                         for tool_call in content.tool_calls
                     ]
                 )
-
-            if (
-                isinstance(messages[-1]["content"], list)
-                and len(messages[-1]["content"]) == 1
-                and messages[-1]["content"][0]["type"] == "text"
-            ):
-                # If there is only one text block, simplify the content to a string
-                messages[-1]["content"] = messages[-1]["content"][0]["text"]
         else:
             # Note: We don't pass SystemContent here as its passed to the API as the prompt
             raise TypeError(f"Unexpected content type: {type(content)}")
 
-    return messages, container_id
+    return messages
 
 
 async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
@@ -450,7 +379,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
     content_details = ContentDetails()
     content_details.add_citation_detail()
     input_usage: Usage | None = None
-    first_block: bool = True
+    has_native = False
+    first_block: bool
 
     async for response in stream:
         LOGGER.debug("Received response: %s", response)
@@ -471,12 +401,13 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 current_tool_args = ""
                 if response.content_block.name == output_tool:
                     if first_block or content_details.has_content():
-                        if content_details:
+                        if content_details.has_citations():
                             content_details.delete_empty()
                             yield {"native": content_details}
                         content_details = ContentDetails()
                         content_details.add_citation_detail()
                         yield {"role": "assistant"}
+                        has_native = False
                         first_block = False
             elif isinstance(response.content_block, TextBlock):
                 if (  # Do not start a new assistant content just for citations, concatenate consecutive blocks with citations instead.
@@ -487,11 +418,12 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                         and content_details.has_content()
                     )
                 ):
-                    if content_details:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
                 content_details.add_citation_detail()
                 if response.content_block.text:
@@ -500,13 +432,14 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     )
                     yield {"content": response.content_block.text}
             elif isinstance(response.content_block, ThinkingBlock):
-                if first_block or content_details.thinking_signature:
-                    if content_details:
+                if first_block or has_native:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     content_details.add_citation_detail()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
             elif isinstance(response.content_block, RedactedThinkingBlock):
                 LOGGER.debug(
@@ -514,15 +447,17 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     "encrypted for safety reasons. This doesn’t affect the quality of "
                     "responses"
                 )
-                if first_block or content_details.redacted_thinking:
-                    if content_details:
+                if has_native:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     content_details.add_citation_detail()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
-                content_details.redacted_thinking = response.content_block.data
+                yield {"native": response.content_block}
+                has_native = True
             elif isinstance(response.content_block, ServerToolUseBlock):
                 current_tool_block = ServerToolUseBlockParam(
                     type="server_tool_use",
@@ -531,15 +466,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     input={},
                 )
                 current_tool_args = ""
-            elif isinstance(
-                response.content_block,
-                (
-                    WebSearchToolResultBlock,
-                    BashCodeExecutionToolResultBlock,
-                    TextEditorCodeExecutionToolResultBlock,
-                ),
-            ):
-                if content_details:
+            elif isinstance(response.content_block, WebSearchToolResultBlock):
+                if content_details.has_citations():
                     content_details.delete_empty()
                     yield {"native": content_details}
                 content_details = ContentDetails()
@@ -547,16 +475,26 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 yield {
                     "role": "tool_result",
                     "tool_call_id": response.content_block.tool_use_id,
-                    "tool_name": response.content_block.type.removesuffix(
-                        "_tool_result"
-                    ),
+                    "tool_name": "web_search",
                     "tool_result": {
-                        "content": cast(
-                            JsonObjectType, response.content_block.to_dict()["content"]
-                        )
+                        "type": "web_search_tool_result_error",
+                        "error_code": response.content_block.content.error_code,
                     }
-                    if isinstance(response.content_block.content, list)
-                    else cast(JsonObjectType, response.content_block.content.to_dict()),
+                    if isinstance(
+                        response.content_block.content, WebSearchToolResultError
+                    )
+                    else {
+                        "content": [
+                            {
+                                "type": "web_search_result",
+                                "encrypted_content": block.encrypted_content,
+                                "page_age": block.page_age,
+                                "title": block.title,
+                                "url": block.url,
+                            }
+                            for block in response.content_block.content
+                        ]
+                    },
                 }
                 first_block = True
         elif isinstance(response, RawContentBlockDeltaEvent):
@@ -572,16 +510,19 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 else:
                     current_tool_args += response.delta.partial_json
             elif isinstance(response.delta, TextDelta):
-                if response.delta.text:
-                    content_details.citation_details[-1].length += len(
-                        response.delta.text
-                    )
-                    yield {"content": response.delta.text}
+                content_details.citation_details[-1].length += len(response.delta.text)
+                yield {"content": response.delta.text}
             elif isinstance(response.delta, ThinkingDelta):
-                if response.delta.thinking:
-                    yield {"thinking_content": response.delta.thinking}
+                yield {"thinking_content": response.delta.thinking}
             elif isinstance(response.delta, SignatureDelta):
-                content_details.thinking_signature = response.delta.signature
+                yield {
+                    "native": ThinkingBlock(
+                        type="thinking",
+                        thinking="",
+                        signature=response.delta.signature,
+                    )
+                }
+                has_native = True
             elif isinstance(response.delta, CitationsDelta):
                 content_details.add_citation(response.delta.citation)
         elif isinstance(response, RawContentBlockStopEvent):
@@ -605,11 +546,10 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
         elif isinstance(response, RawMessageDeltaEvent):
             if (usage := response.usage) is not None:
                 chat_log.async_trace(_create_token_stats(input_usage, usage))
-            content_details.container = response.delta.container
             if response.delta.stop_reason == "refusal":
                 raise HomeAssistantError("Potential policy violation detected")
         elif isinstance(response, RawMessageStopEvent):
-            if content_details:
+            if content_details.has_citations():
                 content_details.delete_empty()
                 yield {"native": content_details}
             content_details = ContentDetails()
@@ -677,7 +617,7 @@ class AnthropicBaseLLMEntity(Entity):
             )
         ]
 
-        messages, container_id = _convert_content(chat_log.content[1:])
+        messages = _convert_content(chat_log.content[1:])
 
         model = options.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
 
@@ -687,7 +627,6 @@ class AnthropicBaseLLMEntity(Entity):
             max_tokens=options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
             system=system_prompt,
             stream=True,
-            container=container_id,
         )
 
         if not model.startswith(tuple(NON_ADAPTIVE_THINKING_MODELS)):
@@ -726,14 +665,6 @@ class AnthropicBaseLLMEntity(Entity):
                 for tool in chat_log.llm_api.tools
             ]
 
-        if options.get(CONF_CODE_EXECUTION):
-            tools.append(
-                CodeExecutionTool20250825Param(
-                    name="code_execution",
-                    type="code_execution_20250825",
-                ),
-            )
-
         if options.get(CONF_WEB_SEARCH):
             web_search = WebSearchTool20250305Param(
                 name="web_search",
@@ -844,25 +775,21 @@ class AnthropicBaseLLMEntity(Entity):
             try:
                 stream = await client.messages.create(**model_args)
 
-                new_messages, model_args["container"] = _convert_content(
-                    [
-                        content
-                        async for content in chat_log.async_add_delta_content_stream(
-                            self.entity_id,
-                            _transform_stream(
-                                chat_log,
-                                stream,
-                                output_tool=structure_name or None,
-                            ),
-                        )
-                    ]
+                messages.extend(
+                    _convert_content(
+                        [
+                            content
+                            async for content in chat_log.async_add_delta_content_stream(
+                                self.entity_id,
+                                _transform_stream(
+                                    chat_log,
+                                    stream,
+                                    output_tool=structure_name or None,
+                                ),
+                            )
+                        ]
+                    )
                 )
-                messages.extend(new_messages)
-            except anthropic.AuthenticationError as err:
-                self.entry.async_start_reauth(self.hass)
-                raise HomeAssistantError(
-                    "Authentication error with Anthropic API, reauthentication required"
-                ) from err
             except anthropic.AnthropicError as err:
                 raise HomeAssistantError(
                     f"Sorry, I had a problem talking to Anthropic: {err}"

homeassistant/components/anthropic/icons.json

@@ -1,14 +0,0 @@
-{
-  "entity": {
-    "ai_task": {
-      "ai_task_data": {
-        "default": "mdi:asterisk"
-      }
-    },
-    "conversation": {
-      "conversation": {
-        "default": "mdi:asterisk"
-      }
-    }
-  }
-}

homeassistant/components/anthropic/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "anthropic",
-  "name": "Anthropic",
+  "name": "Anthropic Conversation",
   "after_dependencies": ["assist_pipeline", "intent"],
   "codeowners": ["@Shulyaka"],
   "config_flow": true,
@@ -8,6 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["anthropic==0.83.0"]
+  "requirements": ["anthropic==0.78.0"]
 }

homeassistant/components/anthropic/quality_scale.yaml

@@ -10,7 +10,15 @@ rules:
       Integration does not poll.
   brands: done
   common-modules: done
-  config-flow-test-coverage: done
+  config-flow-test-coverage:
+    status: todo
+    comment: |
+      * Remove integration setup from the config flow init test
+      * Make `mock_setup_entry` a separate fixture
+      * Use the mock_config_entry fixture in `test_duplicate_entry`
+      * `test_duplicate_entry`: Patch `homeassistant.components.anthropic.config_flow.anthropic.resources.models.AsyncModels.list`
+      * Fix docstring and name for `test_form_invalid_auth` (does not only test auth)
+      * In `test_form_invalid_auth`, make sure the test run until CREATE_ENTRY to test that the flow is able to recover
   config-flow: done
   dependency-transparency: done
   docs-actions:
@@ -92,7 +100,7 @@ rules:
       No entities disabled by default.
   entity-translations: todo
   exception-translations: todo
-  icon-translations: done
+  icon-translations: todo
   reconfiguration-flow: done
   repair-issues: done
   stale-devices:

homeassistant/components/anthropic/repairs.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 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, DEPRECATED_MODELS, DOMAIN
+from .const import CONF_CHAT_MODEL, DEFAULT, DEPRECATED_MODELS, DOMAIN
 
 if TYPE_CHECKING:
     from . import AnthropicConfigEntry
@@ -67,23 +67,13 @@ class ModelDeprecatedRepairFlow(RepairsFlow):
             self._model_list_cache[entry.entry_id] = model_list
 
         if "opus" in model:
-            family = "claude-opus"
+            suggested_model = "claude-opus-4-5"
+        elif "haiku" in model:
+            suggested_model = "claude-haiku-4-5"
         elif "sonnet" in model:
-            family = "claude-sonnet"
+            suggested_model = "claude-sonnet-4-5"
         else:
-            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,
-        )
+            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
 
         schema = vol.Schema(
             {

homeassistant/components/anthropic/strings.json

@@ -69,7 +69,6 @@
         },
         "model": {
           "data": {
-            "code_execution": "[%key:component::anthropic::config_subentries::conversation::step::model::data::code_execution%]",
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_budget%]",
             "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data::user_location%]",
@@ -77,7 +76,6 @@
             "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search_max_uses%]"
           },
           "data_description": {
-            "code_execution": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::code_execution%]",
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_budget%]",
             "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::user_location%]",
@@ -129,7 +127,6 @@
         },
         "model": {
           "data": {
-            "code_execution": "Code execution",
             "thinking_budget": "Thinking budget",
             "thinking_effort": "Thinking effort",
             "user_location": "Include home location",
@@ -137,7 +134,6 @@
             "web_search_max_uses": "Maximum web searches"
           },
           "data_description": {
-            "code_execution": "Allow the model to execute code in a secure sandbox environment, enabling it to analyze data and perform complex calculations.",
             "thinking_budget": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking.",
             "thinking_effort": "Control how many tokens Claude uses when responding, trading off between response thoroughness and token efficiency",
             "user_location": "Localize search results based on home location",

homeassistant/components/aws_s3/backup.py

@@ -19,7 +19,7 @@ from homeassistant.components.backup import (
 from homeassistant.core import HomeAssistant, callback
 
 from . import S3ConfigEntry
-from .const import CONF_BUCKET, CONF_PREFIX, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import CONF_BUCKET, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 _LOGGER = logging.getLogger(__name__)
@@ -100,13 +100,6 @@ class S3BackupAgent(BackupAgent):
         self.unique_id = entry.entry_id
         self._backup_cache: dict[str, AgentBackup] = {}
         self._cache_expiration = time()
-        self._prefix: str = entry.data.get(CONF_PREFIX, "")
-
-    def _with_prefix(self, key: str) -> str:
-        """Add prefix to a key if configured."""
-        if not self._prefix:
-            return key
-        return f"{self._prefix}/{key}"
 
     @handle_boto_errors
     async def async_download_backup(
@@ -122,9 +115,7 @@ class S3BackupAgent(BackupAgent):
         backup = await self._find_backup_by_id(backup_id)
         tar_filename, _ = suggested_filenames(backup)
 
-        response = await self._client.get_object(
-            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
-        )
+        response = await self._client.get_object(Bucket=self._bucket, Key=tar_filename)
         return response["Body"].iter_chunks()
 
     async def async_upload_backup(
@@ -151,7 +142,7 @@ class S3BackupAgent(BackupAgent):
             metadata_content = json.dumps(backup.as_dict())
             await self._client.put_object(
                 Bucket=self._bucket,
-                Key=self._with_prefix(metadata_filename),
+                Key=metadata_filename,
                 Body=metadata_content,
             )
         except BotoCoreError as err:
@@ -178,7 +169,7 @@ class S3BackupAgent(BackupAgent):
 
         await self._client.put_object(
             Bucket=self._bucket,
-            Key=self._with_prefix(tar_filename),
+            Key=tar_filename,
             Body=bytes(file_data),
         )
 
@@ -195,7 +186,7 @@ class S3BackupAgent(BackupAgent):
         _LOGGER.debug("Starting multipart upload for %s", tar_filename)
         multipart_upload = await self._client.create_multipart_upload(
             Bucket=self._bucket,
-            Key=self._with_prefix(tar_filename),
+            Key=tar_filename,
         )
         upload_id = multipart_upload["UploadId"]
         try:
@@ -225,7 +216,7 @@ class S3BackupAgent(BackupAgent):
                         )
                         part = await cast(Any, self._client).upload_part(
                             Bucket=self._bucket,
-                            Key=self._with_prefix(tar_filename),
+                            Key=tar_filename,
                             PartNumber=part_number,
                             UploadId=upload_id,
                             Body=part_data.tobytes(),
@@ -253,7 +244,7 @@ class S3BackupAgent(BackupAgent):
                 )
                 part = await cast(Any, self._client).upload_part(
                     Bucket=self._bucket,
-                    Key=self._with_prefix(tar_filename),
+                    Key=tar_filename,
                     PartNumber=part_number,
                     UploadId=upload_id,
                     Body=remaining_data.tobytes(),
@@ -262,7 +253,7 @@ class S3BackupAgent(BackupAgent):
 
             await cast(Any, self._client).complete_multipart_upload(
                 Bucket=self._bucket,
-                Key=self._with_prefix(tar_filename),
+                Key=tar_filename,
                 UploadId=upload_id,
                 MultipartUpload={"Parts": parts},
             )
@@ -271,7 +262,7 @@ class S3BackupAgent(BackupAgent):
             try:
                 await self._client.abort_multipart_upload(
                     Bucket=self._bucket,
-                    Key=self._with_prefix(tar_filename),
+                    Key=tar_filename,
                     UploadId=upload_id,
                 )
             except BotoCoreError:
@@ -292,12 +283,8 @@ class S3BackupAgent(BackupAgent):
         tar_filename, metadata_filename = suggested_filenames(backup)
 
         # Delete both the backup file and its metadata file
-        await self._client.delete_object(
-            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
-        )
-        await self._client.delete_object(
-            Bucket=self._bucket, Key=self._with_prefix(metadata_filename)
-        )
+        await self._client.delete_object(Bucket=self._bucket, Key=tar_filename)
+        await self._client.delete_object(Bucket=self._bucket, Key=metadata_filename)
 
         # Reset cache after successful deletion
         self._cache_expiration = time()
@@ -330,9 +317,7 @@ class S3BackupAgent(BackupAgent):
         if time() <= self._cache_expiration:
             return self._backup_cache
 
-        backups_list = await async_list_backups_from_s3(
-            self._client, self._bucket, self._prefix
-        )
+        backups_list = await async_list_backups_from_s3(self._client, self._bucket)
         self._backup_cache = {b.backup_id: b for b in backups_list}
         self._cache_expiration = time() + CACHE_TTL
 

homeassistant/components/aws_s3/config_flow.py

@@ -22,7 +22,6 @@ from .const import (
     CONF_ACCESS_KEY_ID,
     CONF_BUCKET,
     CONF_ENDPOINT_URL,
-    CONF_PREFIX,
     CONF_SECRET_ACCESS_KEY,
     DEFAULT_ENDPOINT_URL,
     DESCRIPTION_AWS_S3_DOCS_URL,
@@ -40,7 +39,6 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_ENDPOINT_URL, default=DEFAULT_ENDPOINT_URL): TextSelector(
             config=TextSelectorConfig(type=TextSelectorType.URL)
         ),
-        vol.Optional(CONF_PREFIX, default=""): cv.string,
     }
 )
 
@@ -55,20 +53,16 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
 
         if user_input is not None:
-            normalized_prefix = user_input.get(CONF_PREFIX, "").strip("/")
-            # Check for existing entries, treating missing prefix as empty
-            for entry in self._async_current_entries(include_ignore=False):
-                entry_prefix = (entry.data.get(CONF_PREFIX) or "").strip("/")
-                if (
-                    entry.data.get(CONF_BUCKET) == user_input[CONF_BUCKET]
-                    and entry.data.get(CONF_ENDPOINT_URL)
-                    == user_input[CONF_ENDPOINT_URL]
-                    and entry_prefix == normalized_prefix
-                ):
-                    return self.async_abort(reason="already_configured")
+            self._async_abort_entries_match(
+                {
+                    CONF_BUCKET: user_input[CONF_BUCKET],
+                    CONF_ENDPOINT_URL: user_input[CONF_ENDPOINT_URL],
+                }
+            )
 
-            hostname = urlparse(user_input[CONF_ENDPOINT_URL]).hostname
-            if not hostname or not hostname.endswith(AWS_DOMAIN):
+            if not urlparse(user_input[CONF_ENDPOINT_URL]).hostname.endswith(
+                AWS_DOMAIN
+            ):
                 errors[CONF_ENDPOINT_URL] = "invalid_endpoint_url"
             else:
                 try:
@@ -90,18 +84,9 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
                 except ConnectionError:
                     errors[CONF_ENDPOINT_URL] = "cannot_connect"
                 else:
-                    data = dict(user_input)
-                    if not normalized_prefix:
-                        # Do not persist empty optional values
-                        data.pop(CONF_PREFIX, None)
-                    else:
-                        data[CONF_PREFIX] = normalized_prefix
-
-                    title = user_input[CONF_BUCKET]
-                    if normalized_prefix:
-                        title = f"{title} - {normalized_prefix}"
-
-                    return self.async_create_entry(title=title, data=data)
+                    return self.async_create_entry(
+                        title=user_input[CONF_BUCKET], data=user_input
+                    )
 
         return self.async_show_form(
             step_id="user",

homeassistant/components/aws_s3/const.py

@@ -11,7 +11,6 @@ CONF_ACCESS_KEY_ID = "access_key_id"
 CONF_SECRET_ACCESS_KEY = "secret_access_key"
 CONF_ENDPOINT_URL = "endpoint_url"
 CONF_BUCKET = "bucket"
-CONF_PREFIX = "prefix"
 
 AWS_DOMAIN = "amazonaws.com"
 DEFAULT_ENDPOINT_URL = f"https://s3.eu-central-1.{AWS_DOMAIN}/"

homeassistant/components/aws_s3/coordinator.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_BUCKET, CONF_PREFIX, DOMAIN
+from .const import CONF_BUCKET, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 SCAN_INTERVAL = timedelta(hours=6)
@@ -53,14 +53,11 @@ class S3DataUpdateCoordinator(DataUpdateCoordinator[SensorData]):
         )
         self.client = client
         self._bucket: str = entry.data[CONF_BUCKET]
-        self._prefix: str = entry.data.get(CONF_PREFIX, "")
 
     async def _async_update_data(self) -> SensorData:
         """Fetch data from AWS S3."""
         try:
-            backups = await async_list_backups_from_s3(
-                self.client, self._bucket, self._prefix
-            )
+            backups = await async_list_backups_from_s3(self.client, self._bucket)
         except BotoCoreError as error:
             raise UpdateFailed(
                 translation_domain=DOMAIN,

homeassistant/components/aws_s3/helpers.py

@@ -17,17 +17,11 @@ _LOGGER = logging.getLogger(__name__)
 async def async_list_backups_from_s3(
     client: S3Client,
     bucket: str,
-    prefix: str,
 ) -> list[AgentBackup]:
     """List backups from an S3 bucket by reading metadata files."""
     paginator = client.get_paginator("list_objects_v2")
     metadata_files: list[dict[str, Any]] = []
-
-    list_kwargs: dict[str, Any] = {"Bucket": bucket}
-    if prefix:
-        list_kwargs["Prefix"] = prefix + "/"
-
-    async for page in paginator.paginate(**list_kwargs):
+    async for page in paginator.paginate(Bucket=bucket):
         metadata_files.extend(
             obj
             for obj in page.get("Contents", [])

homeassistant/components/aws_s3/quality_scale.yaml

@@ -23,9 +23,7 @@ rules:
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
-  unique-config-entry:
-    status: exempt
-    comment: Hassfest does not recognize the duplicate prevention logic. Duplicate entries are prevented by checking bucket, endpoint URL, and prefix in the config flow.
+  unique-config-entry: done
 
   # Silver
   action-exceptions:
@@ -38,7 +36,7 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: done
+  log-when-unavailable: todo
   parallel-updates: done
   reauthentication-flow: todo
   test-coverage: done

homeassistant/components/aws_s3/strings.json

@@ -15,14 +15,12 @@
           "access_key_id": "Access key ID",
           "bucket": "Bucket name",
           "endpoint_url": "Endpoint URL",
-          "prefix": "Prefix",
           "secret_access_key": "Secret access key"
         },
         "data_description": {
           "access_key_id": "Access key ID to connect to AWS S3 API",
           "bucket": "Bucket must already exist and be writable by the provided credentials.",
           "endpoint_url": "Endpoint URL provided to [Boto3 Session]({boto3_docs_url}). Region-specific [AWS S3 endpoints]({aws_s3_docs_url}) are available in their docs.",
-          "prefix": "Folder or prefix to store backups in, for example `backups`",
           "secret_access_key": "Secret access key to connect to AWS S3 API"
         },
         "title": "Add AWS S3 bucket"

homeassistant/components/backup/strings.json

@@ -43,11 +43,11 @@
       "title": "The backup location {agent_id} is unavailable"
     },
     "automatic_backup_failed_addons": {
-      "description": "Apps {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
-      "title": "Not all apps could be included in automatic backup"
+      "description": "Add-ons {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "title": "Not all add-ons could be included in automatic backup"
     },
     "automatic_backup_failed_agents_addons_folders": {
-      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Apps which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Add-ons which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
       "title": "Automatic backup was created with errors"
     },
     "automatic_backup_failed_create": {

homeassistant/components/backup/util.py

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

homeassistant/components/brands/__init__.py

@@ -1,291 +0,0 @@
-"""The Brands integration."""
-
-from __future__ import annotations
-
-from collections import deque
-from http import HTTPStatus
-import logging
-from pathlib import Path
-from random import SystemRandom
-import time
-from typing import Any, Final
-
-from aiohttp import ClientError, hdrs, web
-import voluptuous as vol
-
-from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
-from homeassistant.core import HomeAssistant, callback, valid_domain
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.event import async_track_time_interval
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import async_get_custom_components
-
-from .const import (
-    ALLOWED_IMAGES,
-    BRANDS_CDN_URL,
-    CACHE_TTL,
-    CATEGORY_RE,
-    CDN_TIMEOUT,
-    DOMAIN,
-    HARDWARE_IMAGE_RE,
-    IMAGE_FALLBACKS,
-    PLACEHOLDER,
-    TOKEN_CHANGE_INTERVAL,
-)
-
-_LOGGER = logging.getLogger(__name__)
-_RND: Final = SystemRandom()
-
-CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Brands integration."""
-    access_tokens: deque[str] = deque([], 2)
-    access_tokens.append(hex(_RND.getrandbits(256))[2:])
-    hass.data[DOMAIN] = access_tokens
-
-    @callback
-    def _rotate_token(_now: Any) -> None:
-        """Rotate the access token."""
-        access_tokens.append(hex(_RND.getrandbits(256))[2:])
-
-    async_track_time_interval(hass, _rotate_token, TOKEN_CHANGE_INTERVAL)
-
-    hass.http.register_view(BrandsIntegrationView(hass))
-    hass.http.register_view(BrandsHardwareView(hass))
-    websocket_api.async_register_command(hass, ws_access_token)
-    return True
-
-
-@callback
-@websocket_api.websocket_command({vol.Required("type"): "brands/access_token"})
-def ws_access_token(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Return the current brands access token."""
-    access_tokens: deque[str] = hass.data[DOMAIN]
-    connection.send_result(msg["id"], {"token": access_tokens[-1]})
-
-
-def _read_cached_file_with_marker(
-    cache_path: Path,
-) -> tuple[bytes | None, float] | None:
-    """Read a cached file, distinguishing between content and 404 markers.
-
-    Returns (content, mtime) where content is None for 404 markers (empty files).
-    Returns None if the file does not exist at all.
-    """
-    if not cache_path.is_file():
-        return None
-    mtime = cache_path.stat().st_mtime
-    data = cache_path.read_bytes()
-    if not data:
-        # Empty file is a 404 marker
-        return (None, mtime)
-    return (data, mtime)
-
-
-def _write_cache_file(cache_path: Path, data: bytes) -> None:
-    """Write data to cache file, creating directories as needed."""
-    cache_path.parent.mkdir(parents=True, exist_ok=True)
-    cache_path.write_bytes(data)
-
-
-def _read_brand_file(brand_dir: Path, image: str) -> bytes | None:
-    """Read a brand image, trying fallbacks in a single I/O pass."""
-    for candidate in (image, *IMAGE_FALLBACKS.get(image, ())):
-        file_path = brand_dir / candidate
-        if file_path.is_file():
-            return file_path.read_bytes()
-    return None
-
-
-class _BrandsBaseView(HomeAssistantView):
-    """Base view for serving brand images."""
-
-    requires_auth = False
-
-    def __init__(self, hass: HomeAssistant) -> None:
-        """Initialize the view."""
-        self._hass = hass
-        self._cache_dir = Path(hass.config.cache_path(DOMAIN))
-
-    def _authenticate(self, request: web.Request) -> None:
-        """Authenticate the request using Bearer token or query token."""
-        access_tokens: deque[str] = self._hass.data[DOMAIN]
-        authenticated = (
-            request[KEY_AUTHENTICATED] or request.query.get("token") in access_tokens
-        )
-        if not authenticated:
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            raise web.HTTPForbidden
-
-    async def _serve_from_custom_integration(
-        self,
-        domain: str,
-        image: str,
-    ) -> web.Response | None:
-        """Try to serve a brand image from a custom integration."""
-        custom_components = await async_get_custom_components(self._hass)
-        if (integration := custom_components.get(domain)) is None:
-            return None
-        if not integration.has_branding:
-            return None
-
-        brand_dir = Path(integration.file_path) / "brand"
-
-        data = await self._hass.async_add_executor_job(
-            _read_brand_file, brand_dir, image
-        )
-        if data is not None:
-            return self._build_response(data)
-
-        return None
-
-    async def _serve_from_cache_or_cdn(
-        self,
-        cdn_path: str,
-        cache_subpath: str,
-        *,
-        fallback_placeholder: bool = True,
-    ) -> web.Response:
-        """Serve from disk cache, fetching from CDN if needed."""
-        cache_path = self._cache_dir / cache_subpath
-        now = time.time()
-
-        # Try disk cache
-        result = await self._hass.async_add_executor_job(
-            _read_cached_file_with_marker, cache_path
-        )
-        if result is not None:
-            data, mtime = result
-            # Schedule background refresh if stale
-            if now - mtime > CACHE_TTL:
-                self._hass.async_create_background_task(
-                    self._fetch_and_cache(cdn_path, cache_path),
-                    f"brands_refresh_{cache_subpath}",
-                )
-        else:
-            # Cache miss - fetch from CDN
-            data = await self._fetch_and_cache(cdn_path, cache_path)
-
-        if data is None:
-            if fallback_placeholder:
-                return await self._serve_placeholder(
-                    image=cache_subpath.rsplit("/", 1)[-1]
-                )
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-        return self._build_response(data)
-
-    async def _fetch_and_cache(
-        self,
-        cdn_path: str,
-        cache_path: Path,
-    ) -> bytes | None:
-        """Fetch from CDN and write to cache. Returns data or None on 404."""
-        url = f"{BRANDS_CDN_URL}/{cdn_path}"
-        session = async_get_clientsession(self._hass)
-        try:
-            resp = await session.get(url, timeout=CDN_TIMEOUT)
-        except ClientError, TimeoutError:
-            _LOGGER.debug("Failed to fetch brand from CDN: %s", cdn_path)
-            return None
-
-        if resp.status == HTTPStatus.NOT_FOUND:
-            # Cache the 404 as empty file
-            await self._hass.async_add_executor_job(_write_cache_file, cache_path, b"")
-            return None
-
-        if resp.status != HTTPStatus.OK:
-            _LOGGER.debug("Unexpected CDN response %s for %s", resp.status, cdn_path)
-            return None
-
-        data = await resp.read()
-        await self._hass.async_add_executor_job(_write_cache_file, cache_path, data)
-        return data
-
-    async def _serve_placeholder(self, image: str) -> web.Response:
-        """Serve a placeholder image."""
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=f"_/{PLACEHOLDER}/{image}",
-            cache_subpath=f"integrations/{PLACEHOLDER}/{image}",
-            fallback_placeholder=False,
-        )
-
-    @staticmethod
-    def _build_response(data: bytes) -> web.Response:
-        """Build a response with proper headers."""
-        return web.Response(
-            body=data,
-            content_type="image/png",
-        )
-
-
-class BrandsIntegrationView(_BrandsBaseView):
-    """Serve integration brand images."""
-
-    name = "api:brands:integration"
-    url = "/api/brands/integration/{domain}/{image}"
-
-    async def get(
-        self,
-        request: web.Request,
-        domain: str,
-        image: str,
-    ) -> web.Response:
-        """Handle GET request for an integration brand image."""
-        self._authenticate(request)
-
-        if not valid_domain(domain) or image not in ALLOWED_IMAGES:
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-
-        use_placeholder = request.query.get("placeholder") != "no"
-
-        # 1. Try custom integration local files
-        if (
-            response := await self._serve_from_custom_integration(domain, image)
-        ) is not None:
-            return response
-
-        # 2. Try cache / CDN (always use direct path for proper 404 caching)
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=f"brands/{domain}/{image}",
-            cache_subpath=f"integrations/{domain}/{image}",
-            fallback_placeholder=use_placeholder,
-        )
-
-
-class BrandsHardwareView(_BrandsBaseView):
-    """Serve hardware brand images."""
-
-    name = "api:brands:hardware"
-    url = "/api/brands/hardware/{category}/{image:.+}"
-
-    async def get(
-        self,
-        request: web.Request,
-        category: str,
-        image: str,
-    ) -> web.Response:
-        """Handle GET request for a hardware brand image."""
-        self._authenticate(request)
-
-        if not CATEGORY_RE.match(category):
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-        # Hardware images have dynamic names like "manufacturer_model.png"
-        # Validate it ends with .png and contains only safe characters
-        if not HARDWARE_IMAGE_RE.match(image):
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-
-        cache_subpath = f"hardware/{category}/{image}"
-
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=cache_subpath,
-            cache_subpath=cache_subpath,
-        )

homeassistant/components/brands/const.py

@@ -1,57 +0,0 @@
-"""Constants for the Brands integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import re
-from typing import Final
-
-from aiohttp import ClientTimeout
-
-DOMAIN: Final = "brands"
-
-# CDN
-BRANDS_CDN_URL: Final = "https://brands.home-assistant.io"
-CDN_TIMEOUT: Final = ClientTimeout(total=10)
-PLACEHOLDER: Final = "_placeholder"
-
-# Caching
-CACHE_TTL: Final = 30 * 24 * 60 * 60  # 30 days in seconds
-
-# Access token
-TOKEN_CHANGE_INTERVAL: Final = timedelta(minutes=30)
-
-# Validation
-CATEGORY_RE: Final = re.compile(r"^[a-z0-9_]+$")
-HARDWARE_IMAGE_RE: Final = re.compile(r"^[a-z0-9_-]+\.png$")
-
-# Images and fallback chains
-ALLOWED_IMAGES: Final = frozenset(
-    {
-        "icon.png",
-        "logo.png",
-        "icon@2x.png",
-        "logo@2x.png",
-        "dark_icon.png",
-        "dark_logo.png",
-        "dark_icon@2x.png",
-        "dark_logo@2x.png",
-    }
-)
-
-# Fallback chains for image resolution, mirroring the brands CDN build logic.
-# When a requested image is not found, we try each fallback in order.
-IMAGE_FALLBACKS: Final[dict[str, list[str]]] = {
-    "logo.png": ["icon.png"],
-    "icon@2x.png": ["icon.png"],
-    "logo@2x.png": ["logo.png", "icon.png"],
-    "dark_icon.png": ["icon.png"],
-    "dark_logo.png": ["dark_icon.png", "logo.png", "icon.png"],
-    "dark_icon@2x.png": ["icon@2x.png", "icon.png"],
-    "dark_logo@2x.png": [
-        "dark_icon@2x.png",
-        "logo@2x.png",
-        "logo.png",
-        "icon.png",
-    ],
-}

homeassistant/components/brands/manifest.json

@@ -1,10 +0,0 @@
-{
-  "domain": "brands",
-  "name": "Brands",
-  "codeowners": ["@home-assistant/core"],
-  "config_flow": false,
-  "dependencies": ["http", "websocket_api"],
-  "documentation": "https://www.home-assistant.io/integrations/brands",
-  "integration_type": "system",
-  "quality_scale": "internal"
-}

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.BUTTON, Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
+PLATFORMS = [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

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

@@ -21,6 +21,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.enum import try_parse_enum
 
 from . import BSBLanConfigEntry, BSBLanData
 from .const import ATTR_TARGET_TEMPERATURE, DOMAIN
@@ -39,15 +40,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,6 +70,7 @@ 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 = (
@@ -111,7 +113,7 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         return target_temp.value
 
     @property
-    def _hvac_mode_value(self) -> int | None:
+    def _hvac_mode_value(self) -> int | str | None:
         """Return the raw hvac_mode value from the coordinator."""
         if (hvac_mode := self.coordinator.data.state.hvac_mode) is None:
             return None
@@ -122,14 +124,16 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         """Return hvac operation ie. heat, cool mode."""
         if (hvac_mode_value := self._hvac_mode_value) is None:
             return None
-        return BSBLAN_TO_HA_HVAC_MODE.get(hvac_mode_value)
+        # BSB-Lan returns integer values: 0=off, 1=auto, 2=eco, 3=heat
+        if isinstance(hvac_mode_value, int):
+            return BSBLAN_TO_HA_HVAC_MODE.get(hvac_mode_value)
+        return try_parse_enum(HVACMode, hvac_mode_value)
 
     @property
     def hvac_action(self) -> HVACAction | None:
         """Return the current running hvac action."""
-        if (
-            action := self.coordinator.data.state.hvac_action
-        ) is None or action.value is None:
+        action = self.coordinator.data.state.hvac_action
+        if not action or not isinstance(action.value, int):
             return None
         category = get_hvac_action_category(action.value)
         return HVACAction(category.name.lower())
@@ -137,7 +141,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
@@ -162,7 +166,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,13 +29,8 @@ 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",
-    "hvac_action",
-]
-SENSOR_INCLUDE = ["current_temperature", "outside_temperature", "total_energy"]
+STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
 DHW_STATE_INCLUDE = [
     "operating_mode",
     "nominal_setpoint",
@@ -62,7 +57,7 @@ class BSBLanSlowData:
 
 
 class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
-    """Base BSB-LAN coordinator."""
+    """Base BSB-Lan coordinator."""
 
     config_entry: BSBLanConfigEntry
 
@@ -74,7 +69,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,
@@ -86,7 +81,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,
@@ -94,7 +89,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,
@@ -104,7 +99,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
@@ -115,15 +110,12 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
 
         except BSBLANAuthError as err:
             raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="coordinator_auth_error",
+                "Authentication failed for BSB-Lan device"
             ) from err
         except BSBLANConnectionError as err:
             host = self.config_entry.data[CONF_HOST]
             raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="coordinator_connection_error",
-                translation_placeholders={"host": host},
+                f"Error while establishing connection with BSB-Lan device at {host}"
             ) from err
 
         return BSBLanFastData(
@@ -134,7 +126,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,
@@ -142,7 +134,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,
@@ -152,7 +144,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/diagnostics.py

@@ -17,24 +17,24 @@ async def async_get_config_entry_diagnostics(
 
     # Build diagnostic data from both coordinators
     diagnostics = {
-        "info": data.info.model_dump(),
-        "device": data.device.model_dump(),
+        "info": data.info.to_dict(),
+        "device": data.device.to_dict(),
         "fast_coordinator_data": {
-            "state": data.fast_coordinator.data.state.model_dump(),
-            "sensor": data.fast_coordinator.data.sensor.model_dump(),
-            "dhw": data.fast_coordinator.data.dhw.model_dump(),
+            "state": data.fast_coordinator.data.state.to_dict(),
+            "sensor": data.fast_coordinator.data.sensor.to_dict(),
+            "dhw": data.fast_coordinator.data.dhw.to_dict(),
         },
-        "static": data.static.model_dump(),
+        "static": data.static.to_dict(),
     }
 
     # Add DHW config and schedule from slow coordinator if available
     if data.slow_coordinator.data:
         slow_data = {}
         if data.slow_coordinator.data.dhw_config:
-            slow_data["dhw_config"] = data.slow_coordinator.data.dhw_config.model_dump()
+            slow_data["dhw_config"] = data.slow_coordinator.data.dhw_config.to_dict()
         if data.slow_coordinator.data.dhw_schedule:
             slow_data["dhw_schedule"] = (
-                data.slow_coordinator.data.dhw_schedule.model_dump()
+                data.slow_coordinator.data.dhw_schedule.to_dict()
             )
         if slow_data:
             diagnostics["slow_coordinator_data"] = slow_data

homeassistant/components/bsblan/entity.py

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

@@ -1,42 +0,0 @@
-"""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,11 +1,4 @@
 {
-  "entity": {
-    "button": {
-      "sync_time": {
-        "default": "mdi:timer-sync-outline"
-      }
-    }
-  },
   "services": {
     "set_hot_water_schedule": {
       "service": "mdi:calendar-clock"

homeassistant/components/bsblan/manifest.json

@@ -1,14 +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.1.0"],
+  "requirements": ["python-bsblan==4.2.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/quality_scale.yaml

@@ -1,74 +0,0 @@
-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 UnitOfEnergy, UnitOfTemperature
+from homeassistant.const import 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,19 +58,6 @@ 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,
-    ),
 )
 
 
@@ -79,7 +66,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
@@ -94,7 +81,7 @@ async def async_setup_entry(
 
 
 class BSBLanSensor(BSBLanEntity, SensorEntity):
-    """Defines a BSB-LAN sensor."""
+    """Defines a BSB-Lan sensor."""
 
     entity_description: BSBLanSensorEntityDescription
 
@@ -103,7 +90,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,7 +245,25 @@ async def async_sync_time(service_call: ServiceCall) -> None:
         )
 
     client = entry.runtime_data.client
-    await async_sync_device_time(client, device_entry.name or device_id)
+
+    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
 
 
 SYNC_TIME_SCHEMA = vol.Schema(
@@ -257,7 +275,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,32 +48,24 @@
           "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"
       }
     }
   },
@@ -81,12 +73,6 @@
     "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})"
     },
@@ -97,11 +83,14 @@
       "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}"
     },
@@ -112,7 +101,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"
@@ -161,7 +150,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,7 +63,6 @@ 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
@@ -74,6 +73,7 @@ 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
@@ -110,11 +110,12 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
     @property
     def current_operation(self) -> str | None:
         """Return current operation."""
-        if (
-            operating_mode := self.coordinator.data.dhw.operating_mode
-        ) is None or operating_mode.value is None:
+        if (operating_mode := self.coordinator.data.dhw.operating_mode) is None:
             return None
-        return BSBLAN_TO_HA_OPERATION_MODE.get(operating_mode.value)
+        # The operating_mode.value is an integer (0=Off, 1=On, 2=Eco)
+        if isinstance(operating_mode.value, int):
+            return BSBLAN_TO_HA_OPERATION_MODE.get(operating_mode.value)
+        return None
 
     @property
     def current_temperature(self) -> float | None:

homeassistant/components/cambridge_audio/media_browser.py

@@ -38,7 +38,7 @@ async def _root_payload(
                 media_class=MediaClass.DIRECTORY,
                 media_content_id="",
                 media_content_type="presets",
-                thumbnail="/api/brands/integration/cambridge_audio/logo.png",
+                thumbnail="https://brands.home-assistant.io/_/cambridge_audio/logo.png",
                 can_play=False,
                 can_expand=True,
             )

homeassistant/components/compit/__init__.py

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

homeassistant/components/compit/binary_sensor.py

@@ -1,189 +0,0 @@
-"""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/fan.py

@@ -1,172 +0,0 @@
-"""Fan platform for Compit integration."""
-
-from typing import Any
-
-from compit_inext_api import PARAM_VALUES
-from compit_inext_api.consts import CompitParameter
-
-from homeassistant.components.fan import (
-    FanEntity,
-    FanEntityDescription,
-    FanEntityFeature,
-)
-from homeassistant.const import STATE_OFF, STATE_ON
-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 homeassistant.util.percentage import (
-    ordered_list_item_to_percentage,
-    percentage_to_ordered_list_item,
-)
-
-from .const import DOMAIN, MANUFACTURER_NAME
-from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
-
-PARALLEL_UPDATES = 0
-
-COMPIT_GEAR_TO_HA = PARAM_VALUES[CompitParameter.VENTILATION_GEAR_TARGET]
-HA_STATE_TO_COMPIT = {value: key for key, value in COMPIT_GEAR_TO_HA.items()}
-
-
-DEVICE_DEFINITIONS: dict[int, FanEntityDescription] = {
-    223: FanEntityDescription(
-        key="Nano Color 2",
-        translation_key="ventilation",
-    ),
-    12: FanEntityDescription(
-        key="Nano Color",
-        translation_key="ventilation",
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CompitConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Compit fan entities from a config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        CompitFan(
-            coordinator,
-            device_id,
-            device_definition,
-        )
-        for device_id, device in coordinator.connector.all_devices.items()
-        if (device_definition := DEVICE_DEFINITIONS.get(device.definition.code))
-    )
-
-
-class CompitFan(CoordinatorEntity[CompitDataUpdateCoordinator], FanEntity):
-    """Representation of a Compit fan entity."""
-
-    _attr_speed_count = len(COMPIT_GEAR_TO_HA)
-    _attr_has_entity_name = True
-    _attr_name = None
-    _attr_supported_features = (
-        FanEntityFeature.TURN_ON
-        | FanEntityFeature.TURN_OFF
-        | FanEntityFeature.SET_SPEED
-    )
-
-    def __init__(
-        self,
-        coordinator: CompitDataUpdateCoordinator,
-        device_id: int,
-        entity_description: FanEntityDescription,
-    ) -> None:
-        """Initialize the fan 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=entity_description.key,
-            manufacturer=MANUFACTURER_NAME,
-            model=entity_description.key,
-        )
-
-    @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 true if the fan is on."""
-        value = self.coordinator.connector.get_current_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF
-        )
-
-        return True if value == STATE_ON else False if value == STATE_OFF else None
-
-    async def async_turn_on(
-        self,
-        percentage: int | None = None,
-        preset_mode: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """Turn on the fan."""
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_ON
-        )
-
-        if percentage is None:
-            self.async_write_ha_state()
-            return
-
-        await self.async_set_percentage(percentage)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off the fan."""
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_OFF
-        )
-        self.async_write_ha_state()
-
-    @property
-    def percentage(self) -> int | None:
-        """Return the current fan speed as a percentage."""
-        if self.is_on is False:
-            return 0
-        mode = self.coordinator.connector.get_current_option(
-            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET
-        )
-        if mode is None:
-            return None
-        gear = COMPIT_GEAR_TO_HA.get(mode)
-        return (
-            None
-            if gear is None
-            else ordered_list_item_to_percentage(
-                list(COMPIT_GEAR_TO_HA.values()),
-                gear,
-            )
-        )
-
-    async def async_set_percentage(self, percentage: int) -> None:
-        """Set the fan speed."""
-        if percentage == 0:
-            await self.async_turn_off()
-            return
-
-        gear = int(
-            percentage_to_ordered_list_item(
-                list(COMPIT_GEAR_TO_HA.values()),
-                percentage,
-            )
-        )
-        mode = HA_STATE_TO_COMPIT.get(gear)
-        if mode is None:
-            return
-
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET, mode
-        )
-        self.async_write_ha_state()

homeassistant/components/compit/icons.json

@@ -1,33 +1,5 @@
 {
   "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"
-      }
-    },
-    "fan": {
-      "ventilation": {
-        "default": "mdi:fan",
-        "state": {
-          "off": "mdi:fan-off"
-        }
-      }
-    },
     "number": {
       "boiler_target_temperature": {
         "default": "mdi:water-boiler"
@@ -166,119 +138,6 @@
           "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,31 +33,6 @@
     }
   },
   "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"
-      }
-    },
-    "fan": {
-      "ventilation": {
-        "name": "[%key:component::fan::title%]"
-      }
-    },
     "number": {
       "boiler_target_temperature": {
         "name": "Boiler target temperature"
@@ -208,219 +183,6 @@
           "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": "[%key:common::state::off%]",
-          "on": "[%key:common::state::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": "[%key:common::state::off%]",
-          "on": "[%key:common::state::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/daikin/climate.py

@@ -115,7 +115,7 @@ def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     try:
         heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
         cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError, KeyError:
+    except AttributeError:
         return ([], [])
     return (list(heating or []), list(cooling or []))
 

homeassistant/components/dwd_weather_warnings/sensor.py

@@ -11,7 +11,6 @@ Wetterwarnungen (Stufe 1)
 
 from __future__ import annotations
 
-from datetime import UTC, datetime
 from typing import Any
 
 from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
@@ -96,25 +95,13 @@ class DwdWeatherWarningsSensor(
             entry_type=DeviceEntryType.SERVICE,
         )
 
-    def _filter_expired_warnings(
-        self, warnings: list[dict[str, Any]] | None
-    ) -> list[dict[str, Any]]:
-        if warnings is None:
-            return []
-
-        now = datetime.now(UTC)
-        return [warning for warning in warnings if warning[API_ATTR_WARNING_END] > now]
-
     @property
     def native_value(self) -> int | None:
         """Return the state of the sensor."""
         if self.entity_description.key == CURRENT_WARNING_SENSOR:
-            warnings = self.coordinator.api.current_warnings
-        else:
-            warnings = self.coordinator.api.expected_warnings
+            return self.coordinator.api.current_warning_level
 
-        warnings = self._filter_expired_warnings(warnings)
-        return max((w.get(API_ATTR_WARNING_LEVEL, 0) for w in warnings), default=0)
+        return self.coordinator.api.expected_warning_level
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
@@ -130,7 +117,6 @@ class DwdWeatherWarningsSensor(
         else:
             searched_warnings = self.coordinator.api.expected_warnings
 
-        searched_warnings = self._filter_expired_warnings(searched_warnings)
         data[ATTR_WARNING_COUNT] = len(searched_warnings)
 
         for i, warning in enumerate(searched_warnings, 1):

homeassistant/components/ecobee/__init__.py

@@ -2,17 +2,10 @@
 
 from datetime import timedelta
 
-from pyecobee import (
-    ECOBEE_API_KEY,
-    ECOBEE_PASSWORD,
-    ECOBEE_REFRESH_TOKEN,
-    ECOBEE_USERNAME,
-    Ecobee,
-    ExpiredTokenError,
-)
+from pyecobee import ECOBEE_API_KEY, ECOBEE_REFRESH_TOKEN, Ecobee, ExpiredTokenError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import CONF_API_KEY
 from homeassistant.core import HomeAssistant
 from homeassistant.util import Throttle
 
@@ -25,19 +18,10 @@ 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.get(CONF_API_KEY)
-    username = entry.data.get(CONF_USERNAME)
-    password = entry.data.get(CONF_PASSWORD)
+    api_key = entry.data[CONF_API_KEY]
     refresh_token = entry.data[CONF_REFRESH_TOKEN]
 
-    runtime_data = EcobeeData(
-        hass,
-        entry,
-        api_key=api_key,
-        username=username,
-        password=password,
-        refresh_token=refresh_token,
-    )
+    runtime_data = EcobeeData(hass, entry, api_key=api_key, refresh_token=refresh_token)
 
     if not await runtime_data.refresh():
         return False
@@ -62,32 +46,14 @@ class EcobeeData:
     """
 
     def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: ConfigEntry,
-        api_key: str | None = None,
-        username: str | None = None,
-        password: str | None = None,
-        refresh_token: str | None = None,
+        self, hass: HomeAssistant, entry: ConfigEntry, api_key: str, refresh_token: str
     ) -> None:
         """Initialize the Ecobee data object."""
         self._hass = hass
         self.entry = entry
-
-        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")
+        self.ecobee = Ecobee(
+            config={ECOBEE_API_KEY: api_key, ECOBEE_REFRESH_TOKEN: refresh_token}
+        )
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     async def update(self):
@@ -103,23 +69,12 @@ 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):
-            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,
+                data={
+                    CONF_API_KEY: self.ecobee.config[ECOBEE_API_KEY],
+                    CONF_REFRESH_TOKEN: self.ecobee.config[ECOBEE_REFRESH_TOKEN],
+                },
             )
             return True
         _LOGGER.error("Error refreshing ecobee tokens")

homeassistant/components/ecobee/config_flow.py

@@ -2,21 +2,15 @@
 
 from typing import Any
 
-from pyecobee import ECOBEE_API_KEY, ECOBEE_PASSWORD, ECOBEE_USERNAME, Ecobee
+from pyecobee import ECOBEE_API_KEY, Ecobee
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import CONF_API_KEY
 
 from .const import CONF_REFRESH_TOKEN, DOMAIN
 
-_USER_SCHEMA = vol.Schema(
-    {
-        vol.Optional(CONF_API_KEY): str,
-        vol.Optional(CONF_USERNAME): str,
-        vol.Optional(CONF_PASSWORD): str,
-    }
-)
+_USER_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
 
 
 class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
@@ -33,34 +27,13 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
         errors = {}
 
         if user_input is not None:
-            api_key = user_input.get(CONF_API_KEY)
-            username = user_input.get(CONF_USERNAME)
-            password = user_input.get(CONF_PASSWORD)
+            # 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]})
 
-            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"
+            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"
 
         return self.async_show_form(
             step_id="user",

homeassistant/components/ecobee/strings.json

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

homeassistant/components/econet/select.py

@@ -1,53 +0,0 @@
-"""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,20 +23,19 @@ async def async_setup_entry(
     entry: EconetConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the econet thermostat switch entity."""
+    """Set up the ecobee 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 an aux_heat_only EcoNet switch."""
+    """Representation of a aux_heat_only EcoNet switch."""
 
     def __init__(self, thermostat: Thermostat) -> None:
-        """Initialize EcoNet platform."""
+        """Initialize EcoNet ventilator platform."""
         super().__init__(thermostat)
         self._attr_name = f"{thermostat.device_name} emergency heat"
         self._attr_unique_id = (

homeassistant/components/ecovacs/vacuum.py

@@ -8,24 +8,17 @@ from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import Capabilities, DeviceType
 from deebot_client.device import Device
-from deebot_client.events import (
-    CachedMapInfoEvent,
-    FanSpeedEvent,
-    RoomsEvent,
-    StateEvent,
-)
-from deebot_client.events.map import Map
-from deebot_client.models import CleanAction, CleanMode, State
+from deebot_client.events import FanSpeedEvent, RoomsEvent, StateEvent
+from deebot_client.models import CleanAction, CleanMode, Room, State
 import sucks
 
 from homeassistant.components.vacuum import (
-    Segment,
     StateVacuumEntity,
     StateVacuumEntityDescription,
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
@@ -36,7 +29,6 @@ from .entity import EcovacsEntity, EcovacsLegacyEntity
 from .util import get_name_key
 
 _LOGGER = logging.getLogger(__name__)
-_SEGMENTS_SEPARATOR = "_"
 
 ATTR_ERROR = "error"
 
@@ -226,8 +218,7 @@ class EcovacsVacuum(
         """Initialize the vacuum."""
         super().__init__(device, device.capabilities)
 
-        self._room_event: RoomsEvent | None = None
-        self._maps: dict[str, Map] = {}
+        self._rooms: list[Room] = []
 
         if fan_speed := self._capability.fan_speed:
             self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
@@ -235,13 +226,14 @@ 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()
@@ -257,20 +249,8 @@ 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.
@@ -279,10 +259,7 @@ class EcovacsVacuum(
         is lowercase snake_case.
         """
         rooms: dict[str, Any] = {}
-        if self._room_event is None:
-            return rooms
-
-        for room in self._room_event.rooms:
+        for room in self._rooms:
             # convert room name to snake_case to meet the convention
             room_name = slugify(room.name)
             room_values = rooms.get(room_name)
@@ -397,116 +374,3 @@ 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,23 +4,17 @@ 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 ATTR_MANUFACTURER, CONF_DEVICE, CONF_NAME
+from homeassistant.const import CONF_DEVICE
 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, MANUFACTURER
+from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER
 
 MANUAL_SCHEMA = vol.Schema(
     {
@@ -37,48 +31,8 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the EnOcean config flow."""
-        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, ""),
-            },
-        )
+        self.dongle_path = None
+        self.discovery_info = None
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Import a yaml configuration."""
@@ -150,4 +104,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=MANUFACTURER, data=user_input)
+        return self.async_create_entry(title="EnOcean", data=user_input)

homeassistant/components/enocean/const.py

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

homeassistant/components/enocean/strings.json

@@ -25,9 +25,6 @@
           "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?"
       }
     }
   },