improve tests

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.core_files.yaml

@@ -13,6 +13,7 @@ core: &core
 
 # Our base platforms, that are used by other integrations
 base_platforms: &base_platforms
+  - homeassistant/components/ai_task/**
   - homeassistant/components/air_quality/**
   - homeassistant/components/alarm_control_panel/**
   - homeassistant/components/assist_satellite/**

.devcontainer/devcontainer.json

@@ -27,7 +27,6 @@
         "charliermarsh.ruff",
         "ms-python.pylint",
         "ms-python.vscode-pylance",
-        "visualstudioexptteam.vscodeintellicode",
         "redhat.vscode-yaml",
         "esbenp.prettier-vscode",
         "GitHub.vscode-pull-request-github",

.github/workflows/builder.yml

@@ -416,9 +416,19 @@ jobs:
           ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
           for arch in $ARCHS; do
             echo "Copying ${arch} image to DockerHub..."
-            docker buildx imagetools create \
-              --tag "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}" \
-              "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
+            for attempt in 1 2 3; do
+              if docker buildx imagetools create \
+                --tag "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}" \
+                "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"; then
+                break
+              fi
+              echo "Attempt ${attempt} failed, retrying in 10 seconds..."
+              sleep 10
+              if [ "${attempt}" -eq 3 ]; then
+                echo "Failed after 3 attempts"
+                exit 1
+              fi
+            done
             cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
           done
 

.github/workflows/ci.yaml

@@ -41,8 +41,8 @@ env:
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2026.1"
-  DEFAULT_PYTHON: "3.13.9"
-  ALL_PYTHON_VERSIONS: "['3.13.9', '3.14.0']"
+  DEFAULT_PYTHON: "3.13.11"
+  ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
   # 10.6 is the current long-term-support
@@ -263,7 +263,7 @@ jobs:
           check-latest: true
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: &actions-cache actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: &actions-cache actions/cache@a7833574556fa59680c1b7cb190c1735db73ebf0 # v5.0.0
         with:
           path: venv
           key: &key-pre-commit-venv >-
@@ -304,7 +304,7 @@ jobs:
       - &cache-restore-pre-commit-venv
         name: Restore base Python virtual environment
         id: cache-venv
-        uses: &actions-cache-restore actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: &actions-cache-restore actions/cache/restore@a7833574556fa59680c1b7cb190c1735db73ebf0 # v5.0.0
         with:
           path: venv
           fail-on-cache-miss: true
@@ -511,7 +511,7 @@ jobs:
           fi
       - name: Save apt cache
         if: steps.cache-apt-check.outputs.cache-hit != 'true'
-        uses: &actions-cache-save actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: &actions-cache-save actions/cache/save@a7833574556fa59680c1b7cb190c1735db73ebf0 # v5.0.0
         with:
           path: *path-apt-cache
           key: *key-apt-cache
@@ -1188,7 +1188,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1313,7 +1313,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+        uses: github/codeql-action/init@cf1bb45a277cb3c205638b2cd5c984db1c46a412 # v4.31.7
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+        uses: github/codeql-action/analyze@cf1bb45a277cb3c205638b2cd5c984db1c46a412 # v4.31.7
         with:
           category: "/language:python"

CODEOWNERS

@@ -73,6 +73,8 @@ build.json @home-assistant/supervisor
 /tests/components/airobot/ @mettolen
 /homeassistant/components/airos/ @CoMPaTech
 /tests/components/airos/ @CoMPaTech
+/homeassistant/components/airpatrol/ @antondalgren
+/tests/components/airpatrol/ @antondalgren
 /homeassistant/components/airq/ @Sibgatulin @dl2080
 /tests/components/airq/ @Sibgatulin @dl2080
 /homeassistant/components/airthings/ @danielhiversen @LaStrada
@@ -218,8 +220,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/bizkaibus/ @UgaitzEtxebarria
 /homeassistant/components/blebox/ @bbx-a @swistakm
 /tests/components/blebox/ @bbx-a @swistakm
-/homeassistant/components/blink/ @fronzbot @mkmer
-/tests/components/blink/ @fronzbot @mkmer
+/homeassistant/components/blink/ @fronzbot
+/tests/components/blink/ @fronzbot
 /homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
 /tests/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
 /homeassistant/components/bluemaestro/ @bdraco
@@ -306,8 +308,8 @@ build.json @home-assistant/supervisor
 /tests/components/config/ @home-assistant/core
 /homeassistant/components/configurator/ @home-assistant/core
 /tests/components/configurator/ @home-assistant/core
-/homeassistant/components/control4/ @lawtancool
-/tests/components/control4/ @lawtancool
+/homeassistant/components/control4/ @lawtancool @davidrecordon
+/tests/components/control4/ @lawtancool @davidrecordon
 /homeassistant/components/conversation/ @home-assistant/core @synesthesiam @arturpragacz
 /tests/components/conversation/ @home-assistant/core @synesthesiam @arturpragacz
 /homeassistant/components/cookidoo/ @miaucl
@@ -418,6 +420,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/efergy/ @tkdrob
 /tests/components/efergy/ @tkdrob
 /homeassistant/components/egardia/ @jeroenterheerdt
+/homeassistant/components/egauge/ @neggert
+/tests/components/egauge/ @neggert
 /homeassistant/components/eheimdigital/ @autinerd
 /tests/components/eheimdigital/ @autinerd
 /homeassistant/components/ekeybionyx/ @richardpolzer
@@ -460,7 +464,7 @@ build.json @home-assistant/supervisor
 /tests/components/enigma2/ @autinerd
 /homeassistant/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
 /tests/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
-/homeassistant/components/entur_public_transport/ @hfurubotten
+/homeassistant/components/entur_public_transport/ @hfurubotten @SanderBlom
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
@@ -571,6 +575,8 @@ build.json @home-assistant/supervisor
 /tests/components/generic_hygrostat/ @Shulyaka
 /homeassistant/components/geniushub/ @manzanotti
 /tests/components/geniushub/ @manzanotti
+/homeassistant/components/gentex_homelink/ @niaexa @ryanjones-gentex
+/tests/components/gentex_homelink/ @niaexa @ryanjones-gentex
 /homeassistant/components/geo_json_events/ @exxamalte
 /tests/components/geo_json_events/ @exxamalte
 /homeassistant/components/geo_location/ @home-assistant/core
@@ -1356,8 +1362,8 @@ build.json @home-assistant/supervisor
 /tests/components/ring/ @sdb9696
 /homeassistant/components/risco/ @OnFreund
 /tests/components/risco/ @OnFreund
-/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck
-/tests/components/rituals_perfume_genie/ @milanmeu @frenck
+/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
+/tests/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
 /homeassistant/components/rmvtransport/ @cgtobi
 /tests/components/rmvtransport/ @cgtobi
 /homeassistant/components/roborock/ @Lash-L @allenporter
@@ -1803,6 +1809,8 @@ build.json @home-assistant/supervisor
 /tests/components/weatherflow_cloud/ @jeeftor
 /homeassistant/components/weatherkit/ @tjhorner
 /tests/components/weatherkit/ @tjhorner
+/homeassistant/components/web_rtc/ @home-assistant/core
+/tests/components/web_rtc/ @home-assistant/core
 /homeassistant/components/webdav/ @jpbede
 /tests/components/webdav/ @jpbede
 /homeassistant/components/webhook/ @home-assistant/core

homeassistant/components/actron_air/manifest.json

@@ -10,6 +10,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/actron_air",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
   "requirements": ["actron-neo-api==0.1.87"]

homeassistant/components/advantage_air/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@Bre77"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/advantage_air",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["advantage_air"],
   "requirements": ["advantage-air==0.4.4"]

homeassistant/components/aemet/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@Noltari"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aemet",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aemet_opendata"],
   "requirements": ["AEMET-OpenData==0.6.4"]

homeassistant/components/aftership/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aftership",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "requirements": ["pyaftership==21.11.0"]
 }

homeassistant/components/agent_dvr/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@ispysoftware"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/agent_dvr",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["agent"],
   "requirements": ["agent-py==0.0.24"]

homeassistant/components/ai_task/__init__.py

@@ -101,8 +101,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                     vol.Schema({str: STRUCTURE_FIELD_SCHEMA}),
                     _validate_structure_fields,
                 ),
-                vol.Optional(ATTR_ATTACHMENTS): vol.All(
-                    cv.ensure_list, [selector.MediaSelector({"accept": ["*/*"]})]
+                vol.Optional(ATTR_ATTACHMENTS): selector.MediaSelector(
+                    {"accept": ["*/*"], "multiple": True}
                 ),
             }
         ),
@@ -118,8 +118,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 vol.Required(ATTR_TASK_NAME): cv.string,
                 vol.Optional(ATTR_ENTITY_ID): cv.entity_id,
                 vol.Required(ATTR_INSTRUCTIONS): cv.string,
-                vol.Optional(ATTR_ATTACHMENTS): vol.All(
-                    cv.ensure_list, [selector.MediaSelector({"accept": ["*/*"]})]
+                vol.Optional(ATTR_ATTACHMENTS): selector.MediaSelector(
+                    {"accept": ["*/*"], "multiple": True}
                 ),
             }
         ),

homeassistant/components/airnow/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@asymworks"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airnow",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["pyairnow"],
   "requirements": ["pyairnow==1.3.1"]

homeassistant/components/airobot/__init__.py

@@ -7,7 +7,7 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.CLIMATE]
+PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:

homeassistant/components/airobot/diagnostics.py

@@ -0,0 +1,38 @@
+"""Diagnostics support for Airobot."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AirobotConfigEntry
+
+TO_REDACT_CONFIG = [CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME]
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: AirobotConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+
+    # Build device capabilities info
+    device_capabilities = None
+    if coordinator.data:
+        device_capabilities = {
+            "has_floor_sensor": coordinator.data.status.has_floor_sensor,
+            "has_co2_sensor": coordinator.data.status.has_co2_sensor,
+            "hw_version": coordinator.data.status.hw_version,
+            "fw_version": coordinator.data.status.fw_version,
+        }
+
+    return {
+        "entry_data": async_redact_data(entry.data, TO_REDACT_CONFIG),
+        "device_capabilities": device_capabilities,
+        "status": asdict(coordinator.data.status) if coordinator.data else None,
+        "settings": asdict(coordinator.data.settings) if coordinator.data else None,
+    }

homeassistant/components/airobot/quality_scale.yaml

@@ -39,12 +39,12 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info: done
   discovery: done
   docs-data-update: done
   docs-examples: todo
-  docs-known-limitations: todo
+  docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
@@ -54,8 +54,8 @@ rules:
     comment: Single device integration, no dynamic device discovery needed.
   entity-category: done
   entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: todo
+  entity-disabled-by-default: done
+  entity-translations: done
   exception-translations: done
   icon-translations: todo
   reconfiguration-flow: todo

homeassistant/components/airobot/sensor.py

@@ -0,0 +1,150 @@
+"""Sensor platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+from pyairobotrest.models import ThermostatStatus
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    CONCENTRATION_PARTS_PER_MILLION,
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfTemperature,
+    UnitOfTime,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+from homeassistant.util.dt import utcnow
+from homeassistant.util.variance import ignore_variance
+
+from . import AirobotConfigEntry
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotSensorEntityDescription(SensorEntityDescription):
+    """Describes Airobot sensor entity."""
+
+    value_fn: Callable[[ThermostatStatus], StateType | datetime]
+    supported_fn: Callable[[ThermostatStatus], bool] = lambda _: True
+
+
+uptime_to_stable_datetime = ignore_variance(
+    lambda value: utcnow().replace(microsecond=0) - timedelta(seconds=value),
+    timedelta(minutes=2),
+)
+
+SENSOR_TYPES: tuple[AirobotSensorEntityDescription, ...] = (
+    AirobotSensorEntityDescription(
+        key="air_temperature",
+        translation_key="air_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.temp_air,
+    ),
+    AirobotSensorEntityDescription(
+        key="humidity",
+        device_class=SensorDeviceClass.HUMIDITY,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.hum_air,
+    ),
+    AirobotSensorEntityDescription(
+        key="floor_temperature",
+        translation_key="floor_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.temp_floor,
+        supported_fn=lambda status: status.has_floor_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="co2",
+        device_class=SensorDeviceClass.CO2,
+        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.co2,
+        supported_fn=lambda status: status.has_co2_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="air_quality_index",
+        device_class=SensorDeviceClass.AQI,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.aqi,
+        supported_fn=lambda status: status.has_co2_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="heating_uptime",
+        translation_key="heating_uptime",
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        suggested_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda status: status.heating_uptime,
+        entity_registry_enabled_default=False,
+    ),
+    AirobotSensorEntityDescription(
+        key="errors",
+        translation_key="errors",
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda status: status.errors,
+    ),
+    AirobotSensorEntityDescription(
+        key="device_uptime",
+        translation_key="device_uptime",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda status: uptime_to_stable_datetime(status.device_uptime),
+        entity_registry_enabled_default=False,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot sensor platform."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        AirobotSensor(coordinator, description)
+        for description in SENSOR_TYPES
+        if description.supported_fn(coordinator.data.status)
+    )
+
+
+class AirobotSensor(AirobotEntity, SensorEntity):
+    """Representation of an Airobot sensor."""
+
+    entity_description: AirobotSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator,
+        description: AirobotSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    @property
+    def native_value(self) -> StateType | datetime:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator.data.status)

homeassistant/components/airobot/strings.json

@@ -43,6 +43,25 @@
       }
     }
   },
+  "entity": {
+    "sensor": {
+      "air_temperature": {
+        "name": "Air temperature"
+      },
+      "device_uptime": {
+        "name": "Device uptime"
+      },
+      "errors": {
+        "name": "Error count"
+      },
+      "floor_temperature": {
+        "name": "Floor temperature"
+      },
+      "heating_uptime": {
+        "name": "Heating uptime"
+      }
+    }
+  },
   "exceptions": {
     "authentication_failed": {
       "message": "Authentication failed, please reauthenticate."

homeassistant/components/airpatrol/__init__.py

@@ -0,0 +1,24 @@
+"""The AirPatrol integration."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+
+from .const import PLATFORMS
+from .coordinator import AirPatrolConfigEntry, AirPatrolDataUpdateCoordinator
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AirPatrolConfigEntry) -> bool:
+    """Set up AirPatrol from a config entry."""
+    coordinator = AirPatrolDataUpdateCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AirPatrolConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/airpatrol/climate.py

@@ -0,0 +1,208 @@
+"""Climate platform for AirPatrol integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.climate import (
+    FAN_AUTO,
+    FAN_HIGH,
+    FAN_LOW,
+    SWING_OFF,
+    SWING_ON,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirPatrolConfigEntry
+from .coordinator import AirPatrolDataUpdateCoordinator
+from .entity import AirPatrolEntity
+
+PARALLEL_UPDATES = 0
+
+AP_TO_HA_HVAC_MODES = {
+    "heat": HVACMode.HEAT,
+    "cool": HVACMode.COOL,
+    "off": HVACMode.OFF,
+}
+HA_TO_AP_HVAC_MODES = {value: key for key, value in AP_TO_HA_HVAC_MODES.items()}
+
+AP_TO_HA_FAN_MODES = {
+    "min": FAN_LOW,
+    "max": FAN_HIGH,
+    "auto": FAN_AUTO,
+}
+HA_TO_AP_FAN_MODES = {value: key for key, value in AP_TO_HA_FAN_MODES.items()}
+
+AP_TO_HA_SWING_MODES = {
+    "on": SWING_ON,
+    "off": SWING_OFF,
+}
+HA_TO_AP_SWING_MODES = {value: key for key, value in AP_TO_HA_SWING_MODES.items()}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AirPatrolConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AirPatrol climate entities."""
+    coordinator = config_entry.runtime_data
+    units = coordinator.data
+
+    async_add_entities(
+        AirPatrolClimate(coordinator, unit_id)
+        for unit_id, unit in units.items()
+        if "climate" in unit
+    )
+
+
+class AirPatrolClimate(AirPatrolEntity, ClimateEntity):
+    """AirPatrol climate entity."""
+
+    _attr_name = None
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.SWING_MODE
+        | ClimateEntityFeature.TURN_OFF
+        | ClimateEntityFeature.TURN_ON
+    )
+    _attr_hvac_modes = [HVACMode.HEAT, HVACMode.COOL, HVACMode.OFF]
+    _attr_fan_modes = [FAN_LOW, FAN_HIGH, FAN_AUTO]
+    _attr_swing_modes = [SWING_ON, SWING_OFF]
+    _attr_min_temp = 16.0
+    _attr_max_temp = 30.0
+
+    def __init__(
+        self,
+        coordinator: AirPatrolDataUpdateCoordinator,
+        unit_id: str,
+    ) -> None:
+        """Initialize the climate entity."""
+        super().__init__(coordinator, unit_id)
+        self._attr_unique_id = f"{coordinator.config_entry.unique_id}-{unit_id}"
+
+    @property
+    def climate_data(self) -> dict[str, Any]:
+        """Return the climate data."""
+        return self.device_data.get("climate") or {}
+
+    @property
+    def params(self) -> dict[str, Any]:
+        """Return the current parameters for the climate entity."""
+        return self.climate_data.get("ParametersData") or {}
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and bool(self.climate_data)
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        if humidity := self.climate_data.get("RoomHumidity"):
+            return float(humidity)
+        return None
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        if temp := self.climate_data.get("RoomTemp"):
+            return float(temp)
+        return None
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        if temp := self.params.get("PumpTemp"):
+            return float(temp)
+        return None
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        pump_power = self.params.get("PumpPower")
+        pump_mode = self.params.get("PumpMode")
+
+        if pump_power and pump_power == "on" and pump_mode:
+            return AP_TO_HA_HVAC_MODES.get(pump_mode)
+        return HVACMode.OFF
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        fan_speed = self.params.get("FanSpeed")
+        if fan_speed:
+            return AP_TO_HA_FAN_MODES.get(fan_speed)
+        return None
+
+    @property
+    def swing_mode(self) -> str | None:
+        """Return the current swing mode."""
+        swing = self.params.get("Swing")
+        if swing:
+            return AP_TO_HA_SWING_MODES.get(swing)
+        return None
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set new target temperature."""
+        params = self.params.copy()
+
+        if ATTR_TEMPERATURE in kwargs:
+            temp = kwargs[ATTR_TEMPERATURE]
+            params["PumpTemp"] = f"{temp:.3f}"
+
+        await self._async_set_params(params)
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set new target hvac mode."""
+        params = self.params.copy()
+
+        if hvac_mode == HVACMode.OFF:
+            params["PumpPower"] = "off"
+        else:
+            params["PumpPower"] = "on"
+            params["PumpMode"] = HA_TO_AP_HVAC_MODES.get(hvac_mode)
+
+        await self._async_set_params(params)
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Set new target fan mode."""
+        params = self.params.copy()
+        params["FanSpeed"] = HA_TO_AP_FAN_MODES.get(fan_mode)
+
+        await self._async_set_params(params)
+
+    async def async_set_swing_mode(self, swing_mode: str) -> None:
+        """Set new target swing mode."""
+        params = self.params.copy()
+        params["Swing"] = HA_TO_AP_SWING_MODES.get(swing_mode)
+
+        await self._async_set_params(params)
+
+    async def async_turn_on(self) -> None:
+        """Turn the entity on."""
+        params = self.params.copy()
+        if mode := AP_TO_HA_HVAC_MODES.get(params["PumpMode"]):
+            await self.async_set_hvac_mode(mode)
+
+    async def async_turn_off(self) -> None:
+        """Turn the entity off."""
+        await self.async_set_hvac_mode(HVACMode.OFF)
+
+    async def _async_set_params(self, params: dict[str, Any]) -> None:
+        """Set the unit to dry mode."""
+        new_climate_data = self.climate_data.copy()
+        new_climate_data["ParametersData"] = params
+
+        await self.coordinator.api.set_unit_climate_data(
+            self._unit_id, new_climate_data
+        )
+
+        await self.coordinator.async_request_refresh()

homeassistant/components/airpatrol/config_flow.py

@@ -0,0 +1,111 @@
+"""Config flow for the AirPatrol integration."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from airpatrol.api import AirPatrolAPI, AirPatrolAuthenticationError, AirPatrolError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from .const import DOMAIN
+
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_EMAIL): TextSelector(
+            TextSelectorConfig(
+                type=TextSelectorType.EMAIL,
+                autocomplete="email",
+            )
+        ),
+        vol.Required(CONF_PASSWORD): TextSelector(
+            TextSelectorConfig(
+                type=TextSelectorType.PASSWORD,
+                autocomplete="current-password",
+            )
+        ),
+    }
+)
+
+
+async def validate_api(
+    hass: HomeAssistant, user_input: dict[str, str]
+) -> tuple[str | None, str | None, dict[str, str]]:
+    """Validate the API connection."""
+    errors: dict[str, str] = {}
+    session = async_get_clientsession(hass)
+    access_token = None
+    unique_id = None
+    try:
+        api = await AirPatrolAPI.authenticate(
+            session, user_input[CONF_EMAIL], user_input[CONF_PASSWORD]
+        )
+    except AirPatrolAuthenticationError:
+        errors["base"] = "invalid_auth"
+    except AirPatrolError:
+        errors["base"] = "cannot_connect"
+    else:
+        access_token = api.get_access_token()
+        unique_id = api.get_unique_id()
+
+    return (access_token, unique_id, errors)
+
+
+class AirPatrolConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for AirPatrol."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            access_token, unique_id, errors = await validate_api(self.hass, user_input)
+            if access_token and unique_id:
+                user_input[CONF_ACCESS_TOKEN] = access_token
+                await self.async_set_unique_id(unique_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=user_input[CONF_EMAIL], data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=DATA_SCHEMA, errors=errors
+        )
+
+    async def async_step_reauth(
+        self, user_input: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication with new credentials."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauthentication confirmation."""
+        errors: dict[str, str] = {}
+
+        if user_input:
+            access_token, unique_id, errors = await validate_api(self.hass, user_input)
+            if access_token and unique_id:
+                await self.async_set_unique_id(unique_id)
+                self._abort_if_unique_id_mismatch()
+                user_input[CONF_ACCESS_TOKEN] = access_token
+                return self.async_update_reload_and_abort(
+                    self._get_reauth_entry(), data_updates=user_input
+                )
+        return self.async_show_form(
+            step_id="reauth_confirm", data_schema=DATA_SCHEMA, errors=errors
+        )

homeassistant/components/airpatrol/const.py

@@ -0,0 +1,16 @@
+"""Constants for the AirPatrol integration."""
+
+from datetime import timedelta
+import logging
+
+from airpatrol.api import AirPatrolAuthenticationError, AirPatrolError
+
+from homeassistant.const import Platform
+
+DOMAIN = "airpatrol"
+
+LOGGER = logging.getLogger(__package__)
+PLATFORMS = [Platform.CLIMATE]
+SCAN_INTERVAL = timedelta(minutes=1)
+
+AIRPATROL_ERRORS = (AirPatrolAuthenticationError, AirPatrolError)

homeassistant/components/airpatrol/coordinator.py

@@ -0,0 +1,100 @@
+"""Data update coordinator for AirPatrol."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from airpatrol.api import AirPatrolAPI, AirPatrolAuthenticationError, AirPatrolError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN, LOGGER, SCAN_INTERVAL
+
+type AirPatrolConfigEntry = ConfigEntry[AirPatrolDataUpdateCoordinator]
+
+
+class AirPatrolDataUpdateCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
+    """Class to manage fetching AirPatrol data."""
+
+    config_entry: AirPatrolConfigEntry
+    api: AirPatrolAPI
+
+    def __init__(self, hass: HomeAssistant, config_entry: AirPatrolConfigEntry) -> None:
+        """Initialize."""
+
+        super().__init__(
+            hass,
+            LOGGER,
+            name=f"{DOMAIN.capitalize()} {config_entry.title}",
+            update_interval=SCAN_INTERVAL,
+            config_entry=config_entry,
+        )
+
+    async def _async_setup(self) -> None:
+        try:
+            await self._setup_client()
+        except AirPatrolError as api_err:
+            raise UpdateFailed(
+                f"Error communicating with AirPatrol API: {api_err}"
+            ) from api_err
+
+    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
+        """Update unit data from AirPatrol API."""
+        return {unit_data["unit_id"]: unit_data for unit_data in await self._get_data()}
+
+    async def _get_data(self, retry: bool = False) -> list[dict[str, Any]]:
+        """Fetch data from API."""
+        try:
+            return await self.api.get_data()
+        except AirPatrolAuthenticationError as auth_err:
+            if retry:
+                raise ConfigEntryAuthFailed(
+                    "Authentication with AirPatrol failed"
+                ) from auth_err
+            await self._update_token()
+            return await self._get_data(retry=True)
+        except AirPatrolError as err:
+            raise UpdateFailed(
+                f"Error communicating with AirPatrol API: {err}"
+            ) from err
+
+    async def _update_token(self) -> None:
+        """Refresh the AirPatrol API client and update the access token."""
+        session = async_get_clientsession(self.hass)
+        try:
+            self.api = await AirPatrolAPI.authenticate(
+                session,
+                self.config_entry.data[CONF_EMAIL],
+                self.config_entry.data[CONF_PASSWORD],
+            )
+        except AirPatrolAuthenticationError as auth_err:
+            raise ConfigEntryAuthFailed(
+                "Authentication with AirPatrol failed"
+            ) from auth_err
+
+        self.hass.config_entries.async_update_entry(
+            self.config_entry,
+            data={
+                **self.config_entry.data,
+                CONF_ACCESS_TOKEN: self.api.get_access_token(),
+            },
+        )
+
+    async def _setup_client(self) -> None:
+        """Set up the AirPatrol API client from stored access_token."""
+        session = async_get_clientsession(self.hass)
+        api = AirPatrolAPI(
+            session,
+            self.config_entry.data[CONF_ACCESS_TOKEN],
+            self.config_entry.unique_id,
+        )
+        try:
+            await api.get_data()
+        except AirPatrolAuthenticationError:
+            await self._update_token()
+        self.api = api

homeassistant/components/airpatrol/entity.py

@@ -0,0 +1,44 @@
+"""Base entity for AirPatrol integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AirPatrolDataUpdateCoordinator
+
+
+class AirPatrolEntity(CoordinatorEntity[AirPatrolDataUpdateCoordinator]):
+    """Base entity for AirPatrol devices."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AirPatrolDataUpdateCoordinator,
+        unit_id: str,
+    ) -> None:
+        """Initialize the AirPatrol entity."""
+        super().__init__(coordinator)
+        self._unit_id = unit_id
+        device = coordinator.data[unit_id]
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, unit_id)},
+            name=device["name"],
+            manufacturer=device["manufacturer"],
+            model=device["model"],
+            serial_number=device["hwid"],
+        )
+
+    @property
+    def device_data(self) -> dict[str, Any]:
+        """Return the device data."""
+        return self.coordinator.data[self._unit_id]
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._unit_id in self.coordinator.data

homeassistant/components/airpatrol/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "airpatrol",
+  "name": "AirPatrol",
+  "codeowners": ["@antondalgren"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/airpatrol",
+  "integration_type": "device",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["airpatrol==0.1.0"]
+}

homeassistant/components/airpatrol/quality_scale.yaml

@@ -0,0 +1,65 @@
+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:
+    status: exempt
+    comment: Integration does not provide custom actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities doesn't 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: todo
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  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: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/airpatrol/strings.json

@@ -0,0 +1,38 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "unique_id_mismatch": "Login credentials do not match the configured account"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "reauth_confirm": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "[%key:component::airpatrol::config::step::user::data_description::email%]",
+          "password": "[%key:component::airpatrol::config::step::user::data_description::password%]"
+        },
+        "description": "Reauthenticate with AirPatrol"
+      },
+      "user": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "Your AirPatrol email address",
+          "password": "Your AirPatrol password"
+        },
+        "description": "Connect to AirPatrol"
+      }
+    }
+  }
+}

homeassistant/components/airthings/manifest.json

@@ -17,6 +17,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/airthings",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["airthings"],
   "requirements": ["airthings-cloud==0.2.0"]

homeassistant/components/airthings_ble/manifest.json

@@ -27,6 +27,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/airthings_ble",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["airthings-ble==1.2.0"]
 }

homeassistant/components/airtouch4/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@samsinnamon"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airtouch4",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["airtouch4pyapi"],
   "requirements": ["airtouch4pyapi==1.0.5"]

homeassistant/components/airtouch5/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@danzel"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airtouch5",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["airtouch5py"],
   "requirements": ["airtouch5py==0.3.0"]

homeassistant/components/airzone/manifest.json

@@ -9,7 +9,8 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/airzone",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==1.0.2"]
+  "requirements": ["aioairzone==1.0.4"]
 }

homeassistant/components/airzone_cloud/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@Noltari"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airzone_cloud",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["aioairzone_cloud"],
   "requirements": ["aioairzone-cloud==0.7.2"]

homeassistant/components/amberelectric/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@madpilot"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/amberelectric",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["amberelectric"],
   "requirements": ["amberelectric==2.0.12"]

homeassistant/components/android_ip_webcam/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@engrbm87"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/android_ip_webcam",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["pydroid-ipcam==3.0.0"]
 }

homeassistant/components/anglian_water/__init__.py

@@ -39,7 +39,6 @@ async def async_setup_entry(
             cookie_jar=CookieJar(quote_cookie=False),
         ),
         refresh_token=entry.data[CONF_ACCESS_TOKEN],
-        account_number=entry.data[CONF_ACCOUNT_NUMBER],
     )
     try:
         await auth.send_refresh_request()
@@ -49,7 +48,7 @@ async def async_setup_entry(
     _aw = AnglianWater(authenticator=auth)
 
     try:
-        await _aw.validate_smart_meter()
+        await _aw.validate_smart_meter(entry.data[CONF_ACCOUNT_NUMBER])
     except SmartMeterUnavailableError as err:
         raise ConfigEntryError(
             translation_domain=DOMAIN, translation_key="smart_meter_unavailable"

homeassistant/components/anglian_water/config_flow.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from aiohttp import CookieJar
 from pyanglianwater import AnglianWater
-from pyanglianwater.auth import BaseAuth, MSOB2CAuth
+from pyanglianwater.auth import MSOB2CAuth
 from pyanglianwater.exceptions import (
     InvalidAccountIdError,
     SelfAssertedError,
@@ -30,11 +30,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_PASSWORD): selector.TextSelector(
             selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
         ),
+        vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
     }
 )
 
 
-async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
+async def validate_credentials(
+    auth: MSOB2CAuth, account_number: str
+) -> str | MSOB2CAuth:
     """Validate the provided credentials."""
     try:
         await auth.send_login_request()
@@ -45,7 +48,7 @@ async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
         return "unknown"
     _aw = AnglianWater(authenticator=auth)
     try:
-        await _aw.validate_smart_meter()
+        await _aw.validate_smart_meter(account_number)
     except (InvalidAccountIdError, SmartMeterUnavailableError):
         return "smart_meter_unavailable"
     return auth
@@ -68,35 +71,21 @@ class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
                         self.hass,
                         cookie_jar=CookieJar(quote_cookie=False),
                     ),
-                    account_number=user_input.get(CONF_ACCOUNT_NUMBER),
-                )
+                ),
+                user_input[CONF_ACCOUNT_NUMBER],
             )
-            if isinstance(validation_response, BaseAuth):
-                account_number = (
-                    user_input.get(CONF_ACCOUNT_NUMBER)
-                    or validation_response.account_number
-                )
-                await self.async_set_unique_id(account_number)
+            if isinstance(validation_response, str):
+                errors["base"] = validation_response
+            else:
+                await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
                 self._abort_if_unique_id_configured()
                 return self.async_create_entry(
-                    title=account_number,
+                    title=user_input[CONF_ACCOUNT_NUMBER],
                     data={
                         **user_input,
                         CONF_ACCESS_TOKEN: validation_response.refresh_token,
-                        CONF_ACCOUNT_NUMBER: account_number,
                     },
                 )
-            if validation_response == "smart_meter_unavailable":
-                return self.async_show_form(
-                    step_id="user",
-                    data_schema=STEP_USER_DATA_SCHEMA.extend(
-                        {
-                            vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
-                        }
-                    ),
-                    errors={"base": validation_response},
-                )
-            errors["base"] = validation_response
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors

homeassistant/components/anglian_water/coordinator.py

@@ -12,7 +12,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import DOMAIN
+from .const import CONF_ACCOUNT_NUMBER, DOMAIN
 
 type AnglianWaterConfigEntry = ConfigEntry[AnglianWaterUpdateCoordinator]
 
@@ -44,6 +44,6 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
     async def _async_update_data(self) -> None:
         """Update data from Anglian Water's API."""
         try:
-            return await self.api.update()
+            return await self.api.update(self.config_entry.data[CONF_ACCOUNT_NUMBER])
         except (ExpiredAccessTokenError, UnknownEndpointError) as err:
             raise UpdateFailed from err

homeassistant/components/anglian_water/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/anglian_water",
   "iot_class": "cloud_polling",
+  "loggers": ["pyanglianwater"],
   "quality_scale": "bronze",
-  "requirements": ["pyanglianwater==2.1.0"]
+  "requirements": ["pyanglianwater==3.0.0"]
 }

homeassistant/components/anova/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@Lash-L"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/anova",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["anova_wifi"],
   "requirements": ["anova-wifi==0.17.0"]

homeassistant/components/anthemav/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@hyralex"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/anthemav",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["anthemav"],
   "requirements": ["anthemav==1.4.1"]

homeassistant/components/aosmith/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bdr99"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aosmith",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "requirements": ["py-aosmith==1.0.15"]
 }

homeassistant/components/arcam_fmj/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@elupus"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/arcam_fmj",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["arcam"],
   "requirements": ["arcam-fmj==1.8.2"],

homeassistant/components/arve/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@ikalnyi"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/arve",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "requirements": ["asyncarve==0.1.1"]
 }

homeassistant/components/aseko_pool_live/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@milanmeu"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aseko_pool_live",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["aioaseko"],
   "requirements": ["aioaseko==1.0.0"]

homeassistant/components/assist_pipeline/audio_enhancer.py

@@ -3,8 +3,9 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 import logging
+import math
 
-from pymicro_vad import MicroVad
+from pysilero_vad import SileroVoiceActivityDetector
 from pyspeex_noise import AudioProcessor
 
 from .const import BYTES_PER_CHUNK
@@ -42,8 +43,8 @@ class AudioEnhancer(ABC):
         """Enhance chunk of PCM audio @ 16Khz with 16-bit mono samples."""
 
 
-class MicroVadSpeexEnhancer(AudioEnhancer):
-    """Audio enhancer that runs microVAD and speex."""
+class SileroVadSpeexEnhancer(AudioEnhancer):
+    """Audio enhancer that runs Silero VAD and speex."""
 
     def __init__(
         self, auto_gain: int, noise_suppression: int, is_vad_enabled: bool
@@ -69,21 +70,49 @@ class MicroVadSpeexEnhancer(AudioEnhancer):
                 self.noise_suppression,
             )
 
-        self.vad: MicroVad | None = None
+        self.vad: SileroVoiceActivityDetector | None = None
+
+        # We get 10ms chunks but Silero works on 32ms chunks, so we have to
+        # buffer audio. The previous speech probability is used until enough
+        # audio has been buffered.
+        self._vad_buffer: bytearray | None = None
+        self._vad_buffer_chunks = 0
+        self._vad_buffer_chunk_idx = 0
+        self._last_speech_probability: float | None = None
 
         if self.is_vad_enabled:
-            self.vad = MicroVad()
-            _LOGGER.debug("Initialized microVAD")
+            self.vad = SileroVoiceActivityDetector()
+
+            # VAD buffer is a multiple of 10ms, but Silero VAD needs 32ms.
+            self._vad_buffer_chunks = int(
+                math.ceil(self.vad.chunk_bytes() / BYTES_PER_CHUNK)
+            )
+            self._vad_leftover_bytes = self.vad.chunk_bytes() - BYTES_PER_CHUNK
+            self._vad_buffer = bytearray(self.vad.chunk_bytes())
+            _LOGGER.debug("Initialized Silero VAD")
 
     def enhance_chunk(self, audio: bytes, timestamp_ms: int) -> EnhancedAudioChunk:
         """Enhance 10ms chunk of PCM audio @ 16Khz with 16-bit mono samples."""
-        speech_probability: float | None = None
-
         assert len(audio) == BYTES_PER_CHUNK
 
         if self.vad is not None:
             # Run VAD
-            speech_probability = self.vad.Process10ms(audio)
+            assert self._vad_buffer is not None
+            start_idx = self._vad_buffer_chunk_idx * BYTES_PER_CHUNK
+            self._vad_buffer[start_idx : start_idx + BYTES_PER_CHUNK] = audio
+
+            self._vad_buffer_chunk_idx += 1
+            if self._vad_buffer_chunk_idx >= self._vad_buffer_chunks:
+                # We have enough data to run Silero VAD (32 ms)
+                self._last_speech_probability = self.vad.process_chunk(
+                    self._vad_buffer[: self.vad.chunk_bytes()]
+                )
+
+                # Copy leftover audio that wasn't processed to start
+                self._vad_buffer[: self._vad_leftover_bytes] = self._vad_buffer[
+                    -self._vad_leftover_bytes :
+                ]
+                self._vad_buffer_chunk_idx = 0
 
         if self.audio_processor is not None:
             # Run noise suppression and auto gain
@@ -92,5 +121,5 @@ class MicroVadSpeexEnhancer(AudioEnhancer):
         return EnhancedAudioChunk(
             audio=audio,
             timestamp_ms=timestamp_ms,
-            speech_probability=speech_probability,
+            speech_probability=self._last_speech_probability,
         )

homeassistant/components/assist_pipeline/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "system",
   "iot_class": "local_push",
   "quality_scale": "internal",
-  "requirements": ["pymicro-vad==1.0.1", "pyspeex-noise==1.0.2"]
+  "requirements": ["pysilero-vad==3.0.1", "pyspeex-noise==1.0.2"]
 }

homeassistant/components/assist_pipeline/pipeline.py

@@ -55,7 +55,7 @@ from homeassistant.util import (
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.limited_size_dict import LimitedSizeDict
 
-from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, MicroVadSpeexEnhancer
+from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, SileroVadSpeexEnhancer
 from .const import (
     ACKNOWLEDGE_PATH,
     BYTES_PER_CHUNK,
@@ -633,7 +633,7 @@ class PipelineRun:
         # Initialize with audio settings
         if self.audio_settings.needs_processor and (self.audio_enhancer is None):
             # Default audio enhancer
-            self.audio_enhancer = MicroVadSpeexEnhancer(
+            self.audio_enhancer = SileroVadSpeexEnhancer(
                 self.audio_settings.auto_gain_dbfs,
                 self.audio_settings.noise_suppression_level,
                 self.audio_settings.is_vad_enabled,

homeassistant/components/asuswrt/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioasuswrt", "asusrouter", "asyncssh"],
-  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.0"]
+  "requirements": ["aioasuswrt==1.5.3", "asusrouter==1.21.3"]
 }

homeassistant/components/atag/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@MatsNL"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/atag",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyatag"],
   "requirements": ["pyatag==0.3.5.3"]

homeassistant/components/august/manifest.json

@@ -27,7 +27,8 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/august",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.1"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.2"]
 }

homeassistant/components/aurora/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@djtimca"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aurora",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["auroranoaa"],
   "requirements": ["auroranoaa==0.0.5"]

homeassistant/components/aussie_broadband/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@nickw444", "@Bre77"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/aussie_broadband",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aussiebb"],
   "requirements": ["pyaussiebb==0.1.5"]

homeassistant/components/autarco/quality_scale.yaml

@@ -6,10 +6,7 @@ rules:
       This integration does not provide additional actions.
   appropriate-polling: done
   brands: done
-  common-modules:
-    status: todo
-    comment: |
-      The entity.py file is not used in this integration.
+  common-modules: done
   config-flow-test-coverage: done
   config-flow: done
   dependency-transparency: done

homeassistant/components/autarco/sensor.py

@@ -204,13 +204,25 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class AutarcoBatterySensorEntity(
-    CoordinatorEntity[AutarcoDataUpdateCoordinator], SensorEntity
-):
+class AutarcoSensorBase(CoordinatorEntity[AutarcoDataUpdateCoordinator], SensorEntity):
+    """Base class for Autarco sensors."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AutarcoDataUpdateCoordinator,
+        description: SensorEntityDescription,
+    ) -> None:
+        """Initialize Autarco sensor base."""
+        super().__init__(coordinator)
+        self.entity_description = description
+
+
+class AutarcoBatterySensorEntity(AutarcoSensorBase):
     """Defines an Autarco battery sensor."""
 
     entity_description: AutarcoBatterySensorEntityDescription
-    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -218,10 +230,8 @@ class AutarcoBatterySensorEntity(
         coordinator: AutarcoDataUpdateCoordinator,
         description: AutarcoBatterySensorEntityDescription,
     ) -> None:
-        """Initialize Autarco sensor."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
+        """Initialize Autarco battery sensor."""
+        super().__init__(coordinator, description)
         self._attr_unique_id = (
             f"{coordinator.account_site.site_id}_battery_{description.key}"
         )
@@ -239,13 +249,10 @@ class AutarcoBatterySensorEntity(
         return self.entity_description.value_fn(self.coordinator.data.battery)
 
 
-class AutarcoSolarSensorEntity(
-    CoordinatorEntity[AutarcoDataUpdateCoordinator], SensorEntity
-):
+class AutarcoSolarSensorEntity(AutarcoSensorBase):
     """Defines an Autarco solar sensor."""
 
     entity_description: AutarcoSolarSensorEntityDescription
-    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -253,10 +260,8 @@ class AutarcoSolarSensorEntity(
         coordinator: AutarcoDataUpdateCoordinator,
         description: AutarcoSolarSensorEntityDescription,
     ) -> None:
-        """Initialize Autarco sensor."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
+        """Initialize Autarco solar sensor."""
+        super().__init__(coordinator, description)
         self._attr_unique_id = (
             f"{coordinator.account_site.site_id}_solar_{description.key}"
         )
@@ -273,13 +278,10 @@ class AutarcoSolarSensorEntity(
         return self.entity_description.value_fn(self.coordinator.data.solar)
 
 
-class AutarcoInverterSensorEntity(
-    CoordinatorEntity[AutarcoDataUpdateCoordinator], SensorEntity
-):
+class AutarcoInverterSensorEntity(AutarcoSensorBase):
     """Defines an Autarco inverter sensor."""
 
     entity_description: AutarcoInverterSensorEntityDescription
-    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -288,10 +290,8 @@ class AutarcoInverterSensorEntity(
         description: AutarcoInverterSensorEntityDescription,
         serial_number: str,
     ) -> None:
-        """Initialize Autarco sensor."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
+        """Initialize Autarco inverter sensor."""
+        super().__init__(coordinator, description)
         self._serial_number = serial_number
         self._attr_unique_id = f"{serial_number}_{description.key}"
         self._attr_device_info = DeviceInfo(

homeassistant/components/automation/__init__.py

@@ -131,6 +131,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "lawn_mower",
     "light",
     "media_player",
+    "switch",
     "text",
     "vacuum",
 }

homeassistant/components/azure_data_explorer/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@kaareseras"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/azure_data_explorer",
+  "integration_type": "service",
   "iot_class": "cloud_push",
   "loggers": ["azure"],
   "requirements": ["azure-kusto-ingest==4.5.1", "azure-kusto-data[aio]==4.5.1"]

homeassistant/components/azure_devops/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@timmo001"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/azure_devops",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aioazuredevops"],
   "requirements": ["aioazuredevops==2.2.2"]

homeassistant/components/azure_event_hub/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@eavanvalkenburg"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/azure_event_hub",
+  "integration_type": "service",
   "iot_class": "cloud_push",
   "loggers": ["azure"],
   "requirements": ["azure-eventhub==5.11.1"],

homeassistant/components/baf/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bdraco", "@jfroy"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/baf",
+  "integration_type": "device",
   "iot_class": "local_push",
   "requirements": ["aiobafi6==0.9.0"],
   "zeroconf": [

homeassistant/components/balboa/manifest.json

@@ -12,6 +12,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/balboa",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pybalboa"],
   "requirements": ["pybalboa==1.1.3"]

homeassistant/components/bang_olufsen/__init__.py

@@ -21,29 +21,29 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.util.ssl import get_default_context
 
 from .const import DOMAIN
-from .websocket import BangOlufsenWebsocket
+from .websocket import BeoWebsocket
 
 
 @dataclass
-class BangOlufsenData:
+class BeoData:
     """Dataclass for API client and WebSocket client."""
 
-    websocket: BangOlufsenWebsocket
+    websocket: BeoWebsocket
     client: MozartClient
 
 
-type BangOlufsenConfigEntry = ConfigEntry[BangOlufsenData]
+type BeoConfigEntry = ConfigEntry[BeoData]
 
 PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:
     """Set up from a config entry."""
 
     # Remove casts to str
     assert entry.unique_id
 
-    # Create device now as BangOlufsenWebsocket needs a device for debug logging, firing events etc.
+    # Create device now as BeoWebsocket needs a device for debug logging, firing events etc.
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
@@ -68,10 +68,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry)
         await client.close_api_client()
         raise ConfigEntryNotReady(f"Unable to connect to {entry.title}") from error
 
-    websocket = BangOlufsenWebsocket(hass, entry, client)
+    websocket = BeoWebsocket(hass, entry, client)
 
     # Add the websocket and API client
-    entry.runtime_data = BangOlufsenData(websocket, client)
+    entry.runtime_data = BeoData(websocket, client)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -82,9 +82,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry)
     return True
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, entry: BangOlufsenConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:
     """Unload a config entry."""
     # Close the API client and WebSocket notification listener
     entry.runtime_data.client.disconnect_notifications()

homeassistant/components/bang_olufsen/config_flow.py

@@ -47,7 +47,7 @@ _exception_map = {
 }
 
 
-class BangOlufsenConfigFlowHandler(ConfigFlow, domain=DOMAIN):
+class BeoConfigFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a config flow."""
 
     _beolink_jid = ""

homeassistant/components/bang_olufsen/const.py

@@ -14,7 +14,7 @@ from homeassistant.components.media_player import (
 )
 
 
-class BangOlufsenSource:
+class BeoSource:
     """Class used for associating device source ids with friendly names. May not include all sources."""
 
     DEEZER: Final[Source] = Source(name="Deezer", id="deezer")
@@ -22,17 +22,18 @@ class BangOlufsenSource:
     NET_RADIO: Final[Source] = Source(name="B&O Radio", id="netRadio")
     SPDIF: Final[Source] = Source(name="Optical", id="spdif")
     TIDAL: Final[Source] = Source(name="Tidal", id="tidal")
+    TV: Final[Source] = Source(name="TV", id="tv")
     UNKNOWN: Final[Source] = Source(name="Unknown Source", id="unknown")
     URI_STREAMER: Final[Source] = Source(name="Audio Streamer", id="uriStreamer")
 
 
-BANG_OLUFSEN_STATES: dict[str, MediaPlayerState] = {
+BEO_STATES: dict[str, MediaPlayerState] = {
     # Dict used for translating device states to Home Assistant states.
     "started": MediaPlayerState.PLAYING,
     "buffering": MediaPlayerState.PLAYING,
     "idle": MediaPlayerState.IDLE,
     "paused": MediaPlayerState.PAUSED,
-    "stopped": MediaPlayerState.PAUSED,
+    "stopped": MediaPlayerState.IDLE,
     "ended": MediaPlayerState.PAUSED,
     "error": MediaPlayerState.IDLE,
     # A device's initial state is "unknown" and should be treated as "idle"
@@ -40,30 +41,31 @@ BANG_OLUFSEN_STATES: dict[str, MediaPlayerState] = {
 }
 
 # Dict used for translating Home Assistant settings to device repeat settings.
-BANG_OLUFSEN_REPEAT_FROM_HA: dict[RepeatMode, str] = {
+BEO_REPEAT_FROM_HA: dict[RepeatMode, str] = {
     RepeatMode.ALL: "all",
     RepeatMode.ONE: "track",
     RepeatMode.OFF: "none",
 }
 # Dict used for translating device repeat settings to Home Assistant settings.
-BANG_OLUFSEN_REPEAT_TO_HA: dict[str, RepeatMode] = {
-    value: key for key, value in BANG_OLUFSEN_REPEAT_FROM_HA.items()
+BEO_REPEAT_TO_HA: dict[str, RepeatMode] = {
+    value: key for key, value in BEO_REPEAT_FROM_HA.items()
 }
 
 
 # Media types for play_media
-class BangOlufsenMediaType(StrEnum):
+class BeoMediaType(StrEnum):
     """Bang & Olufsen specific media types."""
 
-    FAVOURITE = "favourite"
     DEEZER = "deezer"
+    FAVOURITE = "favourite"
+    OVERLAY_TTS = "overlay_tts"
     RADIO = "radio"
     TIDAL = "tidal"
     TTS = "provider"
-    OVERLAY_TTS = "overlay_tts"
+    TV = "tv"
 
 
-class BangOlufsenModel(StrEnum):
+class BeoModel(StrEnum):
     """Enum for compatible model names."""
 
     # Mozart devices
@@ -82,7 +84,7 @@ class BangOlufsenModel(StrEnum):
     BEOREMOTE_ONE = "Beoremote One"
 
 
-class BangOlufsenAttribute(StrEnum):
+class BeoAttribute(StrEnum):
     """Enum for extra_state_attribute keys."""
 
     BEOLINK = "beolink"
@@ -93,7 +95,7 @@ class BangOlufsenAttribute(StrEnum):
 
 
 # Physical "buttons" on devices
-class BangOlufsenButtons(StrEnum):
+class BeoButtons(StrEnum):
     """Enum for device buttons."""
 
     BLUETOOTH = "Bluetooth"
@@ -140,7 +142,7 @@ class WebsocketNotification(StrEnum):
 DOMAIN: Final[str] = "bang_olufsen"
 
 # Default values for configuration.
-DEFAULT_MODEL: Final[str] = BangOlufsenModel.BEOSOUND_BALANCE
+DEFAULT_MODEL: Final[str] = BeoModel.BEOSOUND_BALANCE
 
 # Configuration.
 CONF_SERIAL_NUMBER: Final = "serial_number"
@@ -148,7 +150,7 @@ CONF_BEOLINK_JID: Final = "jid"
 
 # Models to choose from in manual configuration.
 SELECTABLE_MODELS: list[str] = [
-    model.value for model in BangOlufsenModel if model != BangOlufsenModel.BEOREMOTE_ONE
+    model.value for model in BeoModel if model != BeoModel.BEOREMOTE_ONE
 ]
 
 MANUFACTURER: Final[str] = "Bang & Olufsen"
@@ -160,15 +162,15 @@ ATTR_ITEM_NUMBER: Final[str] = "in"
 ATTR_FRIENDLY_NAME: Final[str] = "fn"
 
 # Power states.
-BANG_OLUFSEN_ON: Final[str] = "on"
+BEO_ON: Final[str] = "on"
 
 VALID_MEDIA_TYPES: Final[tuple] = (
-    BangOlufsenMediaType.FAVOURITE,
-    BangOlufsenMediaType.DEEZER,
-    BangOlufsenMediaType.RADIO,
-    BangOlufsenMediaType.TTS,
-    BangOlufsenMediaType.TIDAL,
-    BangOlufsenMediaType.OVERLAY_TTS,
+    BeoMediaType.FAVOURITE,
+    BeoMediaType.DEEZER,
+    BeoMediaType.RADIO,
+    BeoMediaType.TTS,
+    BeoMediaType.TIDAL,
+    BeoMediaType.OVERLAY_TTS,
     MediaType.MUSIC,
     MediaType.URL,
     MediaType.CHANNEL,
@@ -246,7 +248,7 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
 )
 
 # Device events
-BANG_OLUFSEN_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"
+BEO_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"
 
 # Dict used to translate native Bang & Olufsen event names to string.json compatible ones
 EVENT_TRANSLATION_MAP: dict[str, str] = {
@@ -263,7 +265,7 @@ EVENT_TRANSLATION_MAP: dict[str, str] = {
 
 CONNECTION_STATUS: Final[str] = "CONNECTION_STATUS"
 
-DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BangOlufsenButtons]
+DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BeoButtons]
 
 
 DEVICE_BUTTON_EVENTS: Final[list[str]] = [

homeassistant/components/bang_olufsen/diagnostics.py

@@ -10,13 +10,13 @@ from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import DOMAIN
 from .util import get_device_buttons
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: BangOlufsenConfigEntry
+    hass: HomeAssistant, config_entry: BeoConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
 

homeassistant/components/bang_olufsen/entity.py

@@ -24,8 +24,8 @@ from homeassistant.helpers.entity import Entity
 from .const import DOMAIN
 
 
-class BangOlufsenBase:
-    """Base class for BangOlufsen Home Assistant objects."""
+class BeoBase:
+    """Base class for Bang & Olufsen Home Assistant objects."""
 
     def __init__(self, entry: ConfigEntry, client: MozartClient) -> None:
         """Initialize the object."""
@@ -51,8 +51,8 @@ class BangOlufsenBase:
         )
 
 
-class BangOlufsenEntity(Entity, BangOlufsenBase):
-    """Base Entity for BangOlufsen entities."""
+class BeoEntity(Entity, BeoBase):
+    """Base Entity for Bang & Olufsen entities."""
 
     _attr_has_entity_name = True
     _attr_should_poll = False

homeassistant/components/bang_olufsen/event.py

@@ -14,7 +14,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import (
     BEO_REMOTE_CONTROL_KEYS,
     BEO_REMOTE_KEY_EVENTS,
@@ -25,10 +25,10 @@ from .const import (
     DEVICE_BUTTON_EVENTS,
     DOMAIN,
     MANUFACTURER,
-    BangOlufsenModel,
+    BeoModel,
     WebsocketNotification,
 )
-from .entity import BangOlufsenEntity
+from .entity import BeoEntity
 from .util import get_device_buttons, get_remotes
 
 PARALLEL_UPDATES = 0
@@ -36,14 +36,14 @@ PARALLEL_UPDATES = 0
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: BangOlufsenConfigEntry,
+    config_entry: BeoConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Event entities from config entry."""
-    entities: list[BangOlufsenEvent] = []
+    entities: list[BeoEvent] = []
 
     async_add_entities(
-        BangOlufsenButtonEvent(config_entry, button_type)
+        BeoButtonEvent(config_entry, button_type)
         for button_type in get_device_buttons(config_entry.data[CONF_MODEL])
     )
 
@@ -54,7 +54,7 @@ async def async_setup_entry(
         # Add Light keys
         entities.extend(
             [
-                BangOlufsenRemoteKeyEvent(
+                BeoRemoteKeyEvent(
                     config_entry,
                     remote,
                     f"{BEO_REMOTE_SUBMENU_LIGHT}/{key_type}",
@@ -66,7 +66,7 @@ async def async_setup_entry(
         # Add Control keys
         entities.extend(
             [
-                BangOlufsenRemoteKeyEvent(
+                BeoRemoteKeyEvent(
                     config_entry,
                     remote,
                     f"{BEO_REMOTE_SUBMENU_CONTROL}/{key_type}",
@@ -84,10 +84,9 @@ async def async_setup_entry(
         config_entry.entry_id
     )
     for device in devices:
-        if (
-            device.model == BangOlufsenModel.BEOREMOTE_ONE
-            and device.serial_number not in {remote.serial_number for remote in remotes}
-        ):
+        if device.model == BeoModel.BEOREMOTE_ONE and device.serial_number not in {
+            remote.serial_number for remote in remotes
+        }:
             device_registry.async_update_device(
                 device.id, remove_config_entry_id=config_entry.entry_id
             )
@@ -95,13 +94,13 @@ async def async_setup_entry(
     async_add_entities(new_entities=entities)
 
 
-class BangOlufsenEvent(BangOlufsenEntity, EventEntity):
+class BeoEvent(BeoEntity, EventEntity):
     """Base Event class."""
 
     _attr_device_class = EventDeviceClass.BUTTON
     _attr_entity_registry_enabled_default = False
 
-    def __init__(self, config_entry: BangOlufsenConfigEntry) -> None:
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
         """Initialize Event."""
         super().__init__(config_entry, config_entry.runtime_data.client)
 
@@ -112,12 +111,12 @@ class BangOlufsenEvent(BangOlufsenEntity, EventEntity):
         self.async_write_ha_state()
 
 
-class BangOlufsenButtonEvent(BangOlufsenEvent):
+class BeoButtonEvent(BeoEvent):
     """Event class for Button events."""
 
     _attr_event_types = DEVICE_BUTTON_EVENTS
 
-    def __init__(self, config_entry: BangOlufsenConfigEntry, button_type: str) -> None:
+    def __init__(self, config_entry: BeoConfigEntry, button_type: str) -> None:
         """Initialize Button."""
         super().__init__(config_entry)
 
@@ -146,14 +145,14 @@ class BangOlufsenButtonEvent(BangOlufsenEvent):
         )
 
 
-class BangOlufsenRemoteKeyEvent(BangOlufsenEvent):
+class BeoRemoteKeyEvent(BeoEvent):
     """Event class for Beoremote One key events."""
 
     _attr_event_types = BEO_REMOTE_KEY_EVENTS
 
     def __init__(
         self,
-        config_entry: BangOlufsenConfigEntry,
+        config_entry: BeoConfigEntry,
         remote: PairedRemote,
         key_type: str,
     ) -> None:
@@ -166,8 +165,8 @@ class BangOlufsenRemoteKeyEvent(BangOlufsenEvent):
         self._attr_unique_id = f"{remote.serial_number}_{self._unique_id}_{key_type}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")},
-            name=f"{BangOlufsenModel.BEOREMOTE_ONE}-{remote.serial_number}-{self._unique_id}",
-            model=BangOlufsenModel.BEOREMOTE_ONE,
+            name=f"{BeoModel.BEOREMOTE_ONE}-{remote.serial_number}-{self._unique_id}",
+            model=BeoModel.BEOREMOTE_ONE,
             serial_number=remote.serial_number,
             sw_version=remote.app_version,
             manufacturer=MANUFACTURER,

homeassistant/components/bang_olufsen/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/bang_olufsen",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["mozart-api==5.1.0.247.1"],
+  "requirements": ["mozart-api==5.3.1.108.0"],
   "zeroconf": ["_bangolufsen._tcp.local."]
 }

homeassistant/components/bang_olufsen/media_player.py

@@ -69,11 +69,11 @@ from homeassistant.helpers.entity_platform import (
 )
 from homeassistant.util.dt import utcnow
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import (
-    BANG_OLUFSEN_REPEAT_FROM_HA,
-    BANG_OLUFSEN_REPEAT_TO_HA,
-    BANG_OLUFSEN_STATES,
+    BEO_REPEAT_FROM_HA,
+    BEO_REPEAT_TO_HA,
+    BEO_STATES,
     BEOLINK_JOIN_SOURCES,
     BEOLINK_JOIN_SOURCES_TO_UPPER,
     CONF_BEOLINK_JID,
@@ -82,12 +82,12 @@ from .const import (
     FALLBACK_SOURCES,
     MANUFACTURER,
     VALID_MEDIA_TYPES,
-    BangOlufsenAttribute,
-    BangOlufsenMediaType,
-    BangOlufsenSource,
+    BeoAttribute,
+    BeoMediaType,
+    BeoSource,
     WebsocketNotification,
 )
-from .entity import BangOlufsenEntity
+from .entity import BeoEntity
 from .util import get_serial_number_from_jid
 
 PARALLEL_UPDATES = 0
@@ -96,7 +96,7 @@ SCAN_INTERVAL = timedelta(seconds=30)
 
 _LOGGER = logging.getLogger(__name__)
 
-BANG_OLUFSEN_FEATURES = (
+BEO_FEATURES = (
     MediaPlayerEntityFeature.BROWSE_MEDIA
     | MediaPlayerEntityFeature.CLEAR_PLAYLIST
     | MediaPlayerEntityFeature.GROUPING
@@ -119,15 +119,13 @@ BANG_OLUFSEN_FEATURES = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: BangOlufsenConfigEntry,
+    config_entry: BeoConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a Media Player entity from config entry."""
     # Add MediaPlayer entity
     async_add_entities(
-        new_entities=[
-            BangOlufsenMediaPlayer(config_entry, config_entry.runtime_data.client)
-        ],
+        new_entities=[BeoMediaPlayer(config_entry, config_entry.runtime_data.client)],
         update_before_add=True,
     )
 
@@ -187,7 +185,7 @@ async def async_setup_entry(
     )
 
 
-class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
+class BeoMediaPlayer(BeoEntity, MediaPlayerEntity):
     """Representation of a media player."""
 
     _attr_name = None
@@ -220,6 +218,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         self._sources: dict[str, str] = {}
         self._state: str = MediaPlayerState.IDLE
         self._video_sources: dict[str, str] = {}
+        self._video_source_id_map: dict[str, str] = {}
         self._sound_modes: dict[str, int] = {}
 
         # Beolink compatible sources
@@ -288,7 +287,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
             queue_settings = await self._client.get_settings_queue(_request_timeout=5)
 
             if queue_settings.repeat is not None:
-                self._attr_repeat = BANG_OLUFSEN_REPEAT_TO_HA[queue_settings.repeat]
+                self._attr_repeat = BEO_REPEAT_TO_HA[queue_settings.repeat]
 
             if queue_settings.shuffle is not None:
                 self._attr_shuffle = queue_settings.shuffle
@@ -357,6 +356,9 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                 and menu_item.label != "TV"
             ):
                 self._video_sources[key] = menu_item.label
+                self._video_source_id_map[
+                    menu_item.content.content_uri.removeprefix("tv://")
+                ] = menu_item.label
 
         # Combine the source dicts
         self._sources = self._audio_sources | self._video_sources
@@ -408,8 +410,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # Check if source is line-in or optical and progress should be updated
         if self._source_change.id in (
-            BangOlufsenSource.LINE_IN.id,
-            BangOlufsenSource.SPDIF.id,
+            BeoSource.LINE_IN.id,
+            BeoSource.SPDIF.id,
         ):
             self._playback_progress = PlaybackProgress(progress=0)
 
@@ -450,10 +452,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # Add Beolink self
         self._beolink_attributes = {
-            BangOlufsenAttribute.BEOLINK: {
-                BangOlufsenAttribute.BEOLINK_SELF: {
-                    self.device_entry.name: self._beolink_jid
-                }
+            BeoAttribute.BEOLINK: {
+                BeoAttribute.BEOLINK_SELF: {self.device_entry.name: self._beolink_jid}
             }
         }
 
@@ -461,12 +461,12 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         peers = await self._client.get_beolink_peers()
 
         if len(peers) > 0:
-            self._beolink_attributes[BangOlufsenAttribute.BEOLINK][
-                BangOlufsenAttribute.BEOLINK_PEERS
+            self._beolink_attributes[BeoAttribute.BEOLINK][
+                BeoAttribute.BEOLINK_PEERS
             ] = {}
             for peer in peers:
-                self._beolink_attributes[BangOlufsenAttribute.BEOLINK][
-                    BangOlufsenAttribute.BEOLINK_PEERS
+                self._beolink_attributes[BeoAttribute.BEOLINK][
+                    BeoAttribute.BEOLINK_PEERS
                 ][peer.friendly_name] = peer.jid
 
         # Add Beolink listeners / leader
@@ -488,8 +488,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
             # Add self
             group_members.append(self.entity_id)
 
-            self._beolink_attributes[BangOlufsenAttribute.BEOLINK][
-                BangOlufsenAttribute.BEOLINK_LEADER
+            self._beolink_attributes[BeoAttribute.BEOLINK][
+                BeoAttribute.BEOLINK_LEADER
             ] = {
                 self._remote_leader.friendly_name: self._remote_leader.jid,
             }
@@ -527,8 +527,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                                 beolink_listener.jid
                             )
                             break
-                self._beolink_attributes[BangOlufsenAttribute.BEOLINK][
-                    BangOlufsenAttribute.BEOLINK_LISTENERS
+                self._beolink_attributes[BeoAttribute.BEOLINK][
+                    BeoAttribute.BEOLINK_LISTENERS
                 ] = beolink_listeners_attribute
 
         self._attr_group_members = group_members
@@ -587,7 +587,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         for sound_mode in sound_modes:
             label = f"{sound_mode.name} ({sound_mode.id})"
 
-            self._sound_modes[label] = sound_mode.id
+            self._sound_modes[label] = cast(int, sound_mode.id)
 
             if sound_mode.id == active_sound_mode.id:
                 self._attr_sound_mode = label
@@ -600,7 +600,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     @property
     def supported_features(self) -> MediaPlayerEntityFeature:
         """Flag media player features that are supported."""
-        features = BANG_OLUFSEN_FEATURES
+        features = BEO_FEATURES
 
         # Add seeking if supported by the current source
         if self._source_change.is_seekable is True:
@@ -611,7 +611,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     @property
     def state(self) -> MediaPlayerState:
         """Return the current state of the media player."""
-        return BANG_OLUFSEN_STATES[self._state]
+        return BEO_STATES[self._state]
 
     @property
     def volume_level(self) -> float | None:
@@ -631,10 +631,11 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     def media_content_type(self) -> MediaType | str | None:
         """Return the current media type."""
         content_type = {
-            BangOlufsenSource.URI_STREAMER.id: MediaType.URL,
-            BangOlufsenSource.DEEZER.id: BangOlufsenMediaType.DEEZER,
-            BangOlufsenSource.TIDAL.id: BangOlufsenMediaType.TIDAL,
-            BangOlufsenSource.NET_RADIO.id: BangOlufsenMediaType.RADIO,
+            BeoSource.DEEZER.id: BeoMediaType.DEEZER,
+            BeoSource.NET_RADIO.id: BeoMediaType.RADIO,
+            BeoSource.TIDAL.id: BeoMediaType.TIDAL,
+            BeoSource.TV.id: BeoMediaType.TV,
+            BeoSource.URI_STREAMER.id: MediaType.URL,
         }
         # Hard to determine content type.
         if self._source_change.id in content_type:
@@ -694,7 +695,11 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
     @property
     def source(self) -> str | None:
-        """Return the current audio source."""
+        """Return the current audio/video source."""
+        # Associate TV content ID with a video source
+        if self.media_content_id in self._video_source_id_map:
+            return self._video_source_id_map[self.media_content_id]
+
         return self._source_change.name
 
     @property
@@ -765,9 +770,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     async def async_set_repeat(self, repeat: RepeatMode) -> None:
         """Set playback queues to repeat."""
         await self._client.set_settings_queue(
-            play_queue_settings=PlayQueueSettings(
-                repeat=BANG_OLUFSEN_REPEAT_FROM_HA[repeat]
-            )
+            play_queue_settings=PlayQueueSettings(repeat=BEO_REPEAT_FROM_HA[repeat])
         )
 
     async def async_set_shuffle(self, shuffle: bool) -> None:
@@ -871,7 +874,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                         self._volume.level.level + offset_volume, 100
                     )
 
-            if media_type == BangOlufsenMediaType.OVERLAY_TTS:
+            if media_type == BeoMediaType.OVERLAY_TTS:
                 # Bang & Olufsen cloud TTS
                 overlay_play_request.text_to_speech = (
                     OverlayPlayRequestTextToSpeechTextToSpeech(
@@ -888,14 +891,14 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # The "provider" media_type may not be suitable for overlay all the time.
         # Use it for now.
-        elif media_type == BangOlufsenMediaType.TTS:
+        elif media_type == BeoMediaType.TTS:
             await self._client.post_overlay_play(
                 overlay_play_request=OverlayPlayRequest(
                     uri=Uri(location=media_id),
                 )
             )
 
-        elif media_type == BangOlufsenMediaType.RADIO:
+        elif media_type == BeoMediaType.RADIO:
             await self._client.run_provided_scene(
                 scene_properties=SceneProperties(
                     action_list=[
@@ -907,13 +910,13 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                 )
             )
 
-        elif media_type == BangOlufsenMediaType.FAVOURITE:
+        elif media_type == BeoMediaType.FAVOURITE:
             await self._client.activate_preset(id=int(media_id))
 
-        elif media_type in (BangOlufsenMediaType.DEEZER, BangOlufsenMediaType.TIDAL):
+        elif media_type in (BeoMediaType.DEEZER, BeoMediaType.TIDAL):
             try:
                 # Play Deezer flow.
-                if media_id == "flow" and media_type == BangOlufsenMediaType.DEEZER:
+                if media_id == "flow" and media_type == BeoMediaType.DEEZER:
                     deezer_id = None
 
                     if "id" in kwargs[ATTR_MEDIA_EXTRA]:

homeassistant/components/bang_olufsen/util.py

@@ -11,7 +11,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DEVICE_BUTTONS, DOMAIN, BangOlufsenButtons, BangOlufsenModel
+from .const import DEVICE_BUTTONS, DOMAIN, BeoButtons, BeoModel
 
 
 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -40,16 +40,27 @@ async def get_remotes(client: MozartClient) -> list[PairedRemote]:
     ]
 
 
-def get_device_buttons(model: BangOlufsenModel) -> list[str]:
+def get_device_buttons(model: BeoModel) -> list[str]:
     """Get supported buttons for a given model."""
+    # Beoconnect Core does not have any buttons
+    if model == BeoModel.BEOCONNECT_CORE:
+        return []
+
     buttons = DEVICE_BUTTONS.copy()
 
-    # Beosound Premiere does not have a bluetooth button
-    if model == BangOlufsenModel.BEOSOUND_PREMIERE:
-        buttons.remove(BangOlufsenButtons.BLUETOOTH)
+    # Models that don't have a microphone button
+    if model in (
+        BeoModel.BEOSOUND_A5,
+        BeoModel.BEOSOUND_A9,
+        BeoModel.BEOSOUND_PREMIERE,
+    ):
+        buttons.remove(BeoButtons.MICROPHONE)
 
-    # Beoconnect Core does not have any buttons
-    elif model == BangOlufsenModel.BEOCONNECT_CORE:
-        buttons = []
+    # Models that don't have a Bluetooth button
+    if model in (
+        BeoModel.BEOSOUND_A9,
+        BeoModel.BEOSOUND_PREMIERE,
+    ):
+        buttons.remove(BeoButtons.BLUETOOTH)
 
     return buttons

homeassistant/components/bang_olufsen/websocket.py

@@ -27,20 +27,20 @@ from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.util.enum import try_parse_enum
 
 from .const import (
-    BANG_OLUFSEN_WEBSOCKET_EVENT,
+    BEO_WEBSOCKET_EVENT,
     CONNECTION_STATUS,
     DOMAIN,
     EVENT_TRANSLATION_MAP,
-    BangOlufsenModel,
+    BeoModel,
     WebsocketNotification,
 )
-from .entity import BangOlufsenBase
+from .entity import BeoBase
 from .util import get_device, get_remotes
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class BangOlufsenWebsocket(BangOlufsenBase):
+class BeoWebsocket(BeoBase):
     """The WebSocket listeners."""
 
     def __init__(
@@ -48,7 +48,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
     ) -> None:
         """Initialize the WebSocket listeners."""
 
-        BangOlufsenBase.__init__(self, entry, client)
+        BeoBase.__init__(self, entry, client)
 
         self.hass = hass
         self._device = get_device(hass, self._unique_id)
@@ -178,7 +178,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
                     self.entry.entry_id
                 )
                 if device.serial_number is not None
-                and device.model == BangOlufsenModel.BEOREMOTE_ONE
+                and device.model == BeoModel.BEOREMOTE_ONE
             ]
             # Get paired remotes from device
             remote_serial_numbers = [
@@ -274,4 +274,4 @@ class BangOlufsenWebsocket(BangOlufsenBase):
         }
 
         _LOGGER.debug("%s", debug_notification)
-        self.hass.bus.async_fire(BANG_OLUFSEN_WEBSOCKET_EVENT, debug_notification)
+        self.hass.bus.async_fire(BEO_WEBSOCKET_EVENT, debug_notification)

homeassistant/components/blebox/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bbx-a", "@swistakm"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/blebox",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["blebox_uniapi"],
   "requirements": ["blebox-uniapi==2.5.0"],

homeassistant/components/blink/__init__.py

@@ -64,6 +64,12 @@ async def async_migrate_entry(hass: HomeAssistant, entry: BlinkConfigEntry) -> b
     if entry.version == 2:
         await _reauth_flow_wrapper(hass, entry, data)
         return False
+    if entry.version == 3:
+        # Migrate device_id to hardware_id for blinkpy 0.25.x OAuth2 compatibility
+        if "device_id" in data:
+            data["hardware_id"] = data.pop("device_id")
+            hass.config_entries.async_update_entry(entry, data=data, version=4)
+        return True
     return True
 
 

homeassistant/components/blink/config_flow.py

@@ -21,7 +21,7 @@ from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEVICE_ID, DOMAIN
+from .const import DOMAIN, HARDWARE_ID
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,7 +43,7 @@ async def _send_blink_2fa_pin(blink: Blink, pin: str | None) -> bool:
 class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a Blink config flow."""
 
-    VERSION = 3
+    VERSION = 4
 
     def __init__(self) -> None:
         """Initialize the blink flow."""
@@ -53,7 +53,7 @@ class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
     async def _handle_user_input(self, user_input: dict[str, Any]):
         """Handle user input."""
         self.auth = Auth(
-            {**user_input, "device_id": DEVICE_ID},
+            {**user_input, "hardware_id": HARDWARE_ID},
             no_prompt=True,
             session=async_get_clientsession(self.hass),
         )

homeassistant/components/blink/const.py

@@ -3,7 +3,7 @@
 from homeassistant.const import Platform
 
 DOMAIN = "blink"
-DEVICE_ID = "Home Assistant"
+HARDWARE_ID = "Home Assistant"
 
 CONF_MIGRATE = "migrate"
 CONF_CAMERA = "camera"

homeassistant/components/blink/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "blink",
   "name": "Blink",
-  "codeowners": ["@fronzbot", "@mkmer"],
+  "codeowners": ["@fronzbot"],
   "config_flow": true,
   "dhcp": [
     {
@@ -18,7 +18,8 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/blink",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["blinkpy"],
-  "requirements": ["blinkpy==0.24.1"]
+  "requirements": ["blinkpy==0.25.1"]
 }

homeassistant/components/blue_current/__init__.py

@@ -13,32 +13,25 @@ from bluecurrent_api.exceptions import (
     RequestLimitReached,
     WebsocketError,
 )
-import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
-from homeassistant.const import CONF_API_TOKEN, CONF_DEVICE_ID, Platform
-from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    ServiceValidationError,
-)
-from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_TOKEN, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.typing import ConfigType
 
 from .const import (
-    BCU_APP,
     CHARGEPOINT_SETTINGS,
     CHARGEPOINT_STATUS,
-    CHARGING_CARD_ID,
     DOMAIN,
     EVSE_ID,
     LOGGER,
     PLUG_AND_CHARGE,
-    SERVICE_START_CHARGE_SESSION,
     VALUE,
 )
+from .services import async_setup_services
 
 type BlueCurrentConfigEntry = ConfigEntry[Connector]
 
@@ -54,13 +47,12 @@ VALUE_TYPES = [CHARGEPOINT_STATUS, CHARGEPOINT_SETTINGS]
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-SERVICE_START_CHARGE_SESSION_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_DEVICE_ID): cv.string,
-        # When no charging card is provided, use no charging card (BCU_APP = no charging card).
-        vol.Optional(CHARGING_CARD_ID, default=BCU_APP): cv.string,
-    }
-)
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up Blue Current."""
+
+    async_setup_services(hass)
+    return True
 
 
 async def async_setup_entry(
@@ -88,66 +80,6 @@ async def async_setup_entry(
     return True
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up Blue Current."""
-
-    async def start_charge_session(service_call: ServiceCall) -> None:
-        """Start a charge session with the provided device and charge card ID."""
-        # When no charge card is provided, use the default charge card set in the config flow.
-        charging_card_id = service_call.data[CHARGING_CARD_ID]
-        device_id = service_call.data[CONF_DEVICE_ID]
-
-        # Get the device based on the given device ID.
-        device = dr.async_get(hass).devices.get(device_id)
-
-        if device is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN, translation_key="invalid_device_id"
-            )
-
-        blue_current_config_entry: ConfigEntry | None = None
-
-        for config_entry_id in device.config_entries:
-            config_entry = hass.config_entries.async_get_entry(config_entry_id)
-            if not config_entry or config_entry.domain != DOMAIN:
-                # Not the blue_current config entry.
-                continue
-
-            if config_entry.state is not ConfigEntryState.LOADED:
-                raise ServiceValidationError(
-                    translation_domain=DOMAIN, translation_key="config_entry_not_loaded"
-                )
-
-            blue_current_config_entry = config_entry
-            break
-
-        if not blue_current_config_entry:
-            # The device is not connected to a valid blue_current config entry.
-            raise ServiceValidationError(
-                translation_domain=DOMAIN, translation_key="no_config_entry"
-            )
-
-        connector = blue_current_config_entry.runtime_data
-
-        # Get the evse_id from the identifier of the device.
-        evse_id = next(
-            identifier[1]
-            for identifier in device.identifiers
-            if identifier[0] == DOMAIN
-        )
-
-        await connector.client.start_session(evse_id, charging_card_id)
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_START_CHARGE_SESSION,
-        start_charge_session,
-        SERVICE_START_CHARGE_SESSION_SCHEMA,
-    )
-
-    return True
-
-
 async def async_unload_entry(
     hass: HomeAssistant, config_entry: BlueCurrentConfigEntry
 ) -> bool:

homeassistant/components/blue_current/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@gleeuwen", "@NickKoepr", "@jtodorova23"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/blue_current",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["bluecurrent_api"],
   "requirements": ["bluecurrent-api==1.3.2"]

homeassistant/components/blue_current/services.py

@@ -0,0 +1,79 @@
+"""The Blue Current integration."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntry, ConfigEntryState
+from homeassistant.const import CONF_DEVICE_ID
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+
+from .const import BCU_APP, CHARGING_CARD_ID, DOMAIN, SERVICE_START_CHARGE_SESSION
+
+SERVICE_START_CHARGE_SESSION_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_DEVICE_ID): cv.string,
+        # When no charging card is provided, use no charging card (BCU_APP = no charging card).
+        vol.Optional(CHARGING_CARD_ID, default=BCU_APP): cv.string,
+    }
+)
+
+
+async def start_charge_session(service_call: ServiceCall) -> None:
+    """Start a charge session with the provided device and charge card ID."""
+    # When no charge card is provided, use the default charge card set in the config flow.
+    charging_card_id = service_call.data[CHARGING_CARD_ID]
+    device_id = service_call.data[CONF_DEVICE_ID]
+
+    # Get the device based on the given device ID.
+    device = dr.async_get(service_call.hass).devices.get(device_id)
+
+    if device is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN, translation_key="invalid_device_id"
+        )
+
+    blue_current_config_entry: ConfigEntry | None = None
+
+    for config_entry_id in device.config_entries:
+        config_entry = service_call.hass.config_entries.async_get_entry(config_entry_id)
+        if not config_entry or config_entry.domain != DOMAIN:
+            # Not the blue_current config entry.
+            continue
+
+        if config_entry.state is not ConfigEntryState.LOADED:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN, translation_key="config_entry_not_loaded"
+            )
+
+        blue_current_config_entry = config_entry
+        break
+
+    if not blue_current_config_entry:
+        # The device is not connected to a valid blue_current config entry.
+        raise ServiceValidationError(
+            translation_domain=DOMAIN, translation_key="no_config_entry"
+        )
+
+    connector = blue_current_config_entry.runtime_data
+
+    # Get the evse_id from the identifier of the device.
+    evse_id = next(
+        identifier[1] for identifier in device.identifiers if identifier[0] == DOMAIN
+    )
+
+    await connector.client.start_session(evse_id, charging_card_id)
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Register the services."""
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_START_CHARGE_SESSION,
+        start_charge_session,
+        SERVICE_START_CHARGE_SESSION_SCHEMA,
+    )

homeassistant/components/bluemaestro/manifest.json

@@ -11,6 +11,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bluemaestro",
+  "integration_type": "device",
   "iot_class": "local_push",
   "requirements": ["bluemaestro-ble==0.4.1"]
 }

homeassistant/components/bluesound/manifest.json

@@ -5,6 +5,7 @@
   "codeowners": ["@thrawnarn", "@LouisChrist"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/bluesound",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["pyblu==2.0.5"],
   "zeroconf": [

homeassistant/components/bluetooth/manifest.json

@@ -15,7 +15,7 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "bleak==1.0.1",
+    "bleak==2.0.0",
     "bleak-retry-connector==4.4.3",
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",

homeassistant/components/bmw_connected_drive/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@gerard33", "@rikroe"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/bmw_connected_drive",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["bimmer_connected"],
   "requirements": ["bimmer-connected[china]==0.17.3"]

homeassistant/components/bond/manifest.json

@@ -14,6 +14,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/bond",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["bond_async"],
   "requirements": ["bond-async==0.2.1"],

homeassistant/components/bosch_shc/manifest.json

@@ -5,6 +5,7 @@
   "codeowners": ["@tschamm"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/bosch_shc",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["boschshcpy"],
   "requirements": ["boschshcpy==0.2.107"],

homeassistant/components/brottsplatskartan/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@gjohansson-ST"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/brottsplatskartan",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["brottsplatskartan"],
   "requirements": ["brottsplatskartan==1.0.5"]

homeassistant/components/brunt/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@eavanvalkenburg"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/brunt",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["brunt"],
   "requirements": ["brunt==1.2.0"]

homeassistant/components/bsblan/climate.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Final
 
 from bsblan import BSBLANError
 
@@ -17,7 +17,7 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+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
@@ -39,6 +39,22 @@ 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
+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
+BSBLAN_TO_HA_HVAC_MODE: Final[dict[int, HVACMode]] = {
+    0: HVACMode.OFF,
+    1: HVACMode.AUTO,
+    2: HVACMode.AUTO,  # eco/reduced maps to AUTO with preset
+    3: HVACMode.HEAT,
+}
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -98,17 +114,20 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
     @property
     def hvac_mode(self) -> HVACMode | None:
         """Return hvac operation ie. heat, cool mode."""
-        if self.coordinator.data.state.hvac_mode.value == PRESET_ECO:
-            return HVACMode.AUTO
-        return try_parse_enum(HVACMode, self.coordinator.data.state.hvac_mode.value)
+        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
+        if hvac_mode_value is None:
+            return None
+        # 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 preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        if (
-            self.hvac_mode == HVACMode.AUTO
-            and self.coordinator.data.state.hvac_mode.value == PRESET_ECO
-        ):
+        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
+        # BSB-Lan mode 2 is eco/reduced mode
+        if hvac_mode_value == 2:
             return PRESET_ECO
         return PRESET_NONE
 
@@ -118,13 +137,6 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set preset mode."""
-        if self.hvac_mode != HVACMode.AUTO and preset_mode != PRESET_NONE:
-            raise ServiceValidationError(
-                "Preset mode can only be set when HVAC mode is set to 'auto'",
-                translation_domain=DOMAIN,
-                translation_key="set_preset_mode_error",
-                translation_placeholders={"preset_mode": preset_mode},
-            )
         await self.async_set_data(preset_mode=preset_mode)
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
@@ -133,16 +145,17 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
 
     async def async_set_data(self, **kwargs: Any) -> None:
         """Set device settings using BSBLAN."""
-        data = {}
+        data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
             data[ATTR_TARGET_TEMPERATURE] = kwargs[ATTR_TEMPERATURE]
         if ATTR_HVAC_MODE in kwargs:
-            data[ATTR_HVAC_MODE] = kwargs[ATTR_HVAC_MODE]
+            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)
             if kwargs[ATTR_PRESET_MODE] == PRESET_ECO:
-                data[ATTR_HVAC_MODE] = PRESET_ECO
+                data[ATTR_HVAC_MODE] = 2
             elif kwargs[ATTR_PRESET_MODE] == PRESET_NONE:
-                data[ATTR_HVAC_MODE] = PRESET_NONE
+                data[ATTR_HVAC_MODE] = 1
 
         try:
             await self.coordinator.client.thermostat(**data)

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.1"],
+  "requirements": ["python-bsblan==3.1.4"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/water_heater.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from bsblan import BSBLANError
+from bsblan import BSBLANError, SetHotWaterParam
 
 from homeassistant.components.water_heater import (
     STATE_ECO,
@@ -131,7 +131,9 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
         """Set new target temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
         try:
-            await self.coordinator.client.set_hot_water(nominal_setpoint=temperature)
+            await self.coordinator.client.set_hot_water(
+                SetHotWaterParam(nominal_setpoint=temperature)
+            )
         except BSBLANError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
@@ -144,7 +146,9 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
         """Set new operation mode."""
         bsblan_mode = OPERATION_MODES_REVERSE.get(operation_mode)
         try:
-            await self.coordinator.client.set_hot_water(operating_mode=bsblan_mode)
+            await self.coordinator.client.set_hot_water(
+                SetHotWaterParam(operating_mode=bsblan_mode)
+            )
         except BSBLANError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,

homeassistant/components/buienradar/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@mjj4791", "@ties", "@Robbie1221"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/buienradar",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["buienradar", "vincenty"],
   "requirements": ["buienradar==1.0.6"]

homeassistant/components/caldav/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/caldav",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["caldav", "vobject"],
   "requirements": ["caldav==2.1.0", "icalendar==6.3.1", "vobject==0.9.9"]

homeassistant/components/camera/__init__.py

@@ -20,7 +20,7 @@ from aiohttp import hdrs, web
 import attr
 from propcache.api import cached_property, under_cached_property
 import voluptuous as vol
-from webrtc_models import RTCIceCandidateInit, RTCIceServer
+from webrtc_models import RTCIceCandidateInit
 
 from homeassistant.components import websocket_api
 from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
@@ -37,6 +37,7 @@ from homeassistant.components.stream import (
     Stream,
     create_stream,
 )
+from homeassistant.components.web_rtc import async_get_ice_servers
 from homeassistant.components.websocket_api import ActiveConnection
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -84,7 +85,6 @@ from .prefs import (
     get_dynamic_camera_stream_settings,
 )
 from .webrtc import (
-    DATA_ICE_SERVERS,
     CameraWebRTCProvider,
     WebRTCAnswer,  # noqa: F401
     WebRTCCandidate,  # noqa: F401
@@ -93,7 +93,6 @@ from .webrtc import (
     WebRTCMessage,  # noqa: F401
     WebRTCSendMessage,
     async_get_supported_provider,
-    async_register_ice_servers,
     async_register_webrtc_provider,  # noqa: F401
     async_register_ws,
 )
@@ -400,20 +399,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         SERVICE_RECORD, CAMERA_SERVICE_RECORD, async_handle_record_service
     )
 
-    @callback
-    def get_ice_servers() -> list[RTCIceServer]:
-        if hass.config.webrtc.ice_servers:
-            return hass.config.webrtc.ice_servers
-        return [
-            RTCIceServer(
-                urls=[
-                    "stun:stun.home-assistant.io:3478",
-                    "stun:stun.home-assistant.io:80",
-                ]
-            ),
-        ]
-
-    async_register_ice_servers(hass, get_ice_servers)
     return True
 
 
@@ -731,11 +716,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Return the WebRTC client configuration and extend it with the registered ice servers."""
         config = self._async_get_webrtc_client_configuration()
 
-        ice_servers = [
-            server
-            for servers in self.hass.data.get(DATA_ICE_SERVERS, [])
-            for server in servers()
-        ]
+        ice_servers = async_get_ice_servers(self.hass)
         config.configuration.ice_servers.extend(ice_servers)
 
         return config

homeassistant/components/camera/manifest.json

@@ -3,7 +3,7 @@
   "name": "Camera",
   "after_dependencies": ["media_player"],
   "codeowners": ["@home-assistant/core"],
-  "dependencies": ["http"],
+  "dependencies": ["http", "web_rtc"],
   "documentation": "https://www.home-assistant.io/integrations/camera",
   "integration_type": "entity",
   "quality_scale": "internal",

homeassistant/components/camera/webrtc.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 import asyncio
-from collections.abc import Awaitable, Callable, Iterable
+from collections.abc import Awaitable, Callable
 from dataclasses import asdict, dataclass, field
 from functools import cache, partial, wraps
 import logging
@@ -12,12 +12,7 @@ from typing import TYPE_CHECKING, Any
 
 from mashumaro import MissingField
 import voluptuous as vol
-from webrtc_models import (
-    RTCConfiguration,
-    RTCIceCandidate,
-    RTCIceCandidateInit,
-    RTCIceServer,
-)
+from webrtc_models import RTCConfiguration, RTCIceCandidate, RTCIceCandidateInit
 
 from homeassistant.components import websocket_api
 from homeassistant.core import HomeAssistant, callback
@@ -38,9 +33,6 @@ _LOGGER = logging.getLogger(__name__)
 DATA_WEBRTC_PROVIDERS: HassKey[set[CameraWebRTCProvider]] = HassKey(
     "camera_webrtc_providers"
 )
-DATA_ICE_SERVERS: HassKey[list[Callable[[], Iterable[RTCIceServer]]]] = HassKey(
-    "camera_webrtc_ice_servers"
-)
 
 
 _WEBRTC = "WebRTC"
@@ -367,21 +359,3 @@ async def async_get_supported_provider(
             return provider
 
     return None
-
-
-@callback
-def async_register_ice_servers(
-    hass: HomeAssistant,
-    get_ice_server_fn: Callable[[], Iterable[RTCIceServer]],
-) -> Callable[[], None]:
-    """Register a ICE server.
-
-    The registering integration is responsible to implement caching if needed.
-    """
-    servers = hass.data.setdefault(DATA_ICE_SERVERS, [])
-
-    def remove() -> None:
-        servers.remove(get_ice_server_fn)
-
-    servers.append(get_ice_server_fn)
-    return remove

homeassistant/components/canary/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["ffmpeg"],
   "documentation": "https://www.home-assistant.io/integrations/canary",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["canary"],
   "requirements": ["py-canary==0.5.4"],

homeassistant/components/ccm15/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@ocalvo"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/ccm15",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "requirements": ["py_ccm15==0.1.2"]
 }

homeassistant/components/cert_expiry/manifest.json

@@ -4,5 +4,6 @@
   "codeowners": ["@jjlawren"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/cert_expiry",
+  "integration_type": "service",
   "iot_class": "cloud_polling"
 }

homeassistant/components/cloud/client.py

@@ -19,8 +19,8 @@ from homeassistant.components.alexa import (
     errors as alexa_errors,
     smart_home as alexa_smart_home,
 )
-from homeassistant.components.camera import async_register_ice_servers
 from homeassistant.components.google_assistant import smart_home as ga
+from homeassistant.components.web_rtc import async_register_ice_servers
 from homeassistant.const import __version__ as HA_VERSION
 from homeassistant.core import Context, HassJob, HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import SERVER_SOFTWARE

homeassistant/components/cloud/manifest.json

@@ -8,7 +8,7 @@
     "google_assistant"
   ],
   "codeowners": ["@home-assistant/cloud"],
-  "dependencies": ["auth", "http", "repairs", "webhook"],
+  "dependencies": ["auth", "http", "repairs", "webhook", "web_rtc"],
   "documentation": "https://www.home-assistant.io/integrations/cloud",
   "integration_type": "system",
   "iot_class": "cloud_push",