add dpt selector translations

Co-authored-by: Norbert Rittel <norbert@rittel.de>

.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
 

CODEOWNERS

@@ -571,6 +571,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 +1358,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 +1805,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/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/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/quality_scale.yaml

@@ -44,7 +44,7 @@ rules:
   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,7 +54,7 @@ rules:
     comment: Single device integration, no dynamic device discovery needed.
   entity-category: done
   entity-device-class: done
-  entity-disabled-by-default: todo
+  entity-disabled-by-default: done
   entity-translations: todo
   exception-translations: done
   icon-translations: todo

homeassistant/components/airobot/sensor.py

@@ -0,0 +1,134 @@
+"""Sensor platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+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 . 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]
+    supported_fn: Callable[[ThermostatStatus], bool] = lambda _: True
+
+
+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,
+    ),
+)
+
+
+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:
+        """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/anglian_water/config_flow.py

@@ -30,6 +30,7 @@ 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(),
     }
 )
 
@@ -68,34 +69,19 @@ class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
                         self.hass,
                         cookie_jar=CookieJar(quote_cookie=False),
                     ),
-                    account_number=user_input.get(CONF_ACCOUNT_NUMBER),
+                    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)
+                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(

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"]
 }

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")
@@ -26,7 +26,7 @@ class BangOlufsenSource:
     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,
@@ -40,19 +40,19 @@ 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"
@@ -63,7 +63,7 @@ class BangOlufsenMediaType(StrEnum):
     OVERLAY_TTS = "overlay_tts"
 
 
-class BangOlufsenModel(StrEnum):
+class BeoModel(StrEnum):
     """Enum for compatible model names."""
 
     # Mozart devices
@@ -82,7 +82,7 @@ class BangOlufsenModel(StrEnum):
     BEOREMOTE_ONE = "Beoremote One"
 
 
-class BangOlufsenAttribute(StrEnum):
+class BeoAttribute(StrEnum):
     """Enum for extra_state_attribute keys."""
 
     BEOLINK = "beolink"
@@ -93,7 +93,7 @@ class BangOlufsenAttribute(StrEnum):
 
 
 # Physical "buttons" on devices
-class BangOlufsenButtons(StrEnum):
+class BeoButtons(StrEnum):
     """Enum for device buttons."""
 
     BLUETOOTH = "Bluetooth"
@@ -140,7 +140,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 +148,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 +160,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 +246,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 +263,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
@@ -288,7 +286,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
@@ -408,8 +406,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 +448,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 +457,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 +484,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 +523,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 +583,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 +596,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 +607,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 +627,10 @@ 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.URI_STREAMER.id: MediaType.URL,
+            BeoSource.DEEZER.id: BeoMediaType.DEEZER,
+            BeoSource.TIDAL.id: BeoMediaType.TIDAL,
+            BeoSource.NET_RADIO.id: BeoMediaType.RADIO,
         }
         # Hard to determine content type.
         if self._source_change.id in content_type:
@@ -765,9 +761,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 +865,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 +882,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 +901,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/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/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/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",

homeassistant/components/device_automation/condition.py

@@ -56,7 +56,6 @@ class DeviceAutomationConditionProtocol(Protocol):
 class DeviceCondition(Condition):
     """Device condition."""
 
-    _hass: HomeAssistant
     _config: ConfigType
 
     @classmethod
@@ -87,7 +86,7 @@ class DeviceCondition(Condition):
 
     def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
         """Initialize condition."""
-        self._hass = hass
+        super().__init__(hass, config)
         assert config.options is not None
         self._config = config.options
 

homeassistant/components/dnsip/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/dnsip",
   "iot_class": "cloud_polling",
-  "requirements": ["aiodns==3.5.0"]
+  "requirements": ["aiodns==3.6.0"]
 }

homeassistant/components/doorbird/device.py

@@ -102,6 +102,12 @@ class ConfiguredDoorBird:
         """Get token for device."""
         return self._token
 
+    def _get_hass_url(self) -> str:
+        """Get the Home Assistant URL for this device."""
+        if custom_url := self.custom_url:
+            return custom_url
+        return get_url(self._hass, prefer_external=False)
+
     async def async_register_events(self) -> None:
         """Register events on device."""
         if not self.door_station_events:
@@ -146,13 +152,7 @@ class ConfiguredDoorBird:
 
     async def _async_register_events(self) -> dict[str, Any]:
         """Register events on device."""
-        # Override url if another is specified in the configuration
-        if custom_url := self.custom_url:
-            hass_url = custom_url
-        else:
-            # Get the URL of this server
-            hass_url = get_url(self._hass, prefer_external=False)
-
+        hass_url = self._get_hass_url()
         http_fav = await self._async_get_http_favorites()
         if any(
             # Note that a list comp is used here to ensure all
@@ -191,10 +191,14 @@ class ConfiguredDoorBird:
             self._get_event_name(event): event_type
             for event, event_type in DEFAULT_EVENT_TYPES
         }
+        hass_url = self._get_hass_url()
         for identifier, data in http_fav.items():
             title: str | None = data.get("title")
             if not title or not title.startswith("Home Assistant"):
                 continue
+            value: str | None = data.get("value")
+            if not value or not value.startswith(hass_url):
+                continue  # Not our favorite - different HA instance or stale
             event = title.partition("(")[2].strip(")")
             if input_type := favorite_input_type.get(identifier):
                 events.append(DoorbirdEvent(event, input_type))

homeassistant/components/duckdns/__init__.py

@@ -2,33 +2,22 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable, Coroutine, Sequence
-from datetime import datetime, timedelta
 import logging
-from typing import Any, cast
 
-from aiohttp import ClientSession
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
-from homeassistant.core import (
-    CALLBACK_TYPE,
-    HassJob,
-    HomeAssistant,
-    ServiceCall,
-    callback,
-)
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.selector import ConfigEntrySelector
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
-from homeassistant.util import dt as dt_util
 
 from .const import ATTR_CONFIG_ENTRY
+from .coordinator import DuckDnsConfigEntry, DuckDnsUpdateCoordinator
+from .helpers import update_duckdns
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,17 +25,8 @@ ATTR_TXT = "txt"
 
 DOMAIN = "duckdns"
 
-INTERVAL = timedelta(minutes=5)
-BACKOFF_INTERVALS = (
-    INTERVAL,
-    timedelta(minutes=1),
-    timedelta(minutes=5),
-    timedelta(minutes=15),
-    timedelta(minutes=30),
-)
 SERVICE_SET_TXT = "set_txt"
 
-UPDATE_URL = "https://www.duckdns.org/update"
 
 CONFIG_SCHEMA = vol.Schema(
     {
@@ -71,8 +51,6 @@ SERVICE_TXT_SCHEMA = vol.Schema(
     }
 )
 
-type DuckDnsConfigEntry = ConfigEntry
-
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Initialize the DuckDNS component."""
@@ -99,21 +77,12 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
     """Set up Duck DNS from a config entry."""
 
-    session = async_get_clientsession(hass)
+    coordinator = DuckDnsUpdateCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
 
-    async def update_domain_interval(_now: datetime) -> bool:
-        """Update the DuckDNS entry."""
-        return await _update_duckdns(
-            session,
-            entry.data[CONF_DOMAIN],
-            entry.data[CONF_ACCESS_TOKEN],
-        )
-
-    entry.async_on_unload(
-        async_track_time_interval_backoff(
-            hass, update_domain_interval, BACKOFF_INTERVALS
-        )
-    )
+    # Add a dummy listener as we do not have regular entities
+    entry.async_on_unload(coordinator.async_add_listener(lambda: None))
 
     return True
 
@@ -153,7 +122,7 @@ async def update_domain_service(call: ServiceCall) -> None:
 
     session = async_get_clientsession(call.hass)
 
-    await _update_duckdns(
+    await update_duckdns(
         session,
         entry.data[CONF_DOMAIN],
         entry.data[CONF_ACCESS_TOKEN],
@@ -164,73 +133,3 @@ async def update_domain_service(call: ServiceCall) -> None:
 async def async_unload_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
     """Unload a config entry."""
     return True
-
-
-_SENTINEL = object()
-
-
-async def _update_duckdns(
-    session: ClientSession,
-    domain: str,
-    token: str,
-    *,
-    txt: str | None | object = _SENTINEL,
-    clear: bool = False,
-) -> bool:
-    """Update DuckDNS."""
-    params = {"domains": domain, "token": token}
-
-    if txt is not _SENTINEL:
-        if txt is None:
-            # Pass in empty txt value to indicate it's clearing txt record
-            params["txt"] = ""
-            clear = True
-        else:
-            params["txt"] = cast(str, txt)
-
-    if clear:
-        params["clear"] = "true"
-
-    resp = await session.get(UPDATE_URL, params=params)
-    body = await resp.text()
-
-    if body != "OK":
-        _LOGGER.warning("Updating DuckDNS domain failed: %s", domain)
-        return False
-
-    return True
-
-
-@callback
-@bind_hass
-def async_track_time_interval_backoff(
-    hass: HomeAssistant,
-    action: Callable[[datetime], Coroutine[Any, Any, bool]],
-    intervals: Sequence[timedelta],
-) -> CALLBACK_TYPE:
-    """Add a listener that fires repetitively at every timedelta interval."""
-    remove: CALLBACK_TYPE | None = None
-    failed = 0
-
-    async def interval_listener(now: datetime) -> None:
-        """Handle elapsed intervals with backoff."""
-        nonlocal failed, remove
-        try:
-            failed += 1
-            if await action(now):
-                failed = 0
-        finally:
-            delay = intervals[failed] if failed < len(intervals) else intervals[-1]
-            remove = async_call_later(
-                hass, delay.total_seconds(), interval_listener_job
-            )
-
-    interval_listener_job = HassJob(interval_listener, cancel_on_shutdown=True)
-    hass.async_run_hass_job(interval_listener_job, dt_util.utcnow())
-
-    def remove_listener() -> None:
-        """Remove interval listener."""
-        if remove:
-            remove()
-
-    return remove_listener

homeassistant/components/duckdns/config_flow.py

@@ -8,7 +8,7 @@ from typing import Any
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN, CONF_NAME
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
     TextSelector,
@@ -16,8 +16,8 @@ from homeassistant.helpers.selector import (
     TextSelectorType,
 )
 
-from . import _update_duckdns
 from .const import DOMAIN
+from .helpers import update_duckdns
 from .issue import deprecate_yaml_issue
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,6 +31,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
     }
 )
 
+STEP_RECONFIGURE_DATA_SCHEMA = vol.Schema({vol.Required(CONF_ACCESS_TOKEN): str})
+
 
 class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Duck DNS."""
@@ -44,7 +46,7 @@ class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
             self._async_abort_entries_match({CONF_DOMAIN: user_input[CONF_DOMAIN]})
             session = async_get_clientsession(self.hass)
             try:
-                if not await _update_duckdns(
+                if not await update_duckdns(
                     session,
                     user_input[CONF_DOMAIN],
                     user_input[CONF_ACCESS_TOKEN],
@@ -79,3 +81,37 @@ class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
 
         deprecate_yaml_issue(self.hass, import_success=True)
         return result
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfigure flow."""
+        errors: dict[str, str] = {}
+
+        entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            session = async_get_clientsession(self.hass)
+            try:
+                if not await update_duckdns(
+                    session,
+                    entry.data[CONF_DOMAIN],
+                    user_input[CONF_ACCESS_TOKEN],
+                ):
+                    errors["base"] = "update_failed"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    entry,
+                    data_updates=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=STEP_RECONFIGURE_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={CONF_NAME: entry.title},
+        )

homeassistant/components/duckdns/coordinator.py

@@ -0,0 +1,83 @@
+"""Coordinator for the Duck DNS integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from aiohttp import ClientError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+from .helpers import update_duckdns
+
+_LOGGER = logging.getLogger(__name__)
+
+
+type DuckDnsConfigEntry = ConfigEntry[DuckDnsUpdateCoordinator]
+
+INTERVAL = timedelta(minutes=5)
+BACKOFF_INTERVALS = (
+    INTERVAL,
+    timedelta(minutes=1),
+    timedelta(minutes=5),
+    timedelta(minutes=15),
+    timedelta(minutes=30),
+)
+
+
+class DuckDnsUpdateCoordinator(DataUpdateCoordinator[None]):
+    """Duck DNS update coordinator."""
+
+    config_entry: DuckDnsConfigEntry
+
+    def __init__(self, hass: HomeAssistant, config_entry: DuckDnsConfigEntry) -> None:
+        """Initialize the Duck DNS update coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=INTERVAL,
+        )
+        self.session = async_get_clientsession(hass)
+        self.failed = 0
+
+    async def _async_update_data(self) -> None:
+        """Update Duck DNS."""
+
+        retry_after = BACKOFF_INTERVALS[
+            min(self.failed, len(BACKOFF_INTERVALS))
+        ].total_seconds()
+
+        try:
+            if not await update_duckdns(
+                self.session,
+                self.config_entry.data[CONF_DOMAIN],
+                self.config_entry.data[CONF_ACCESS_TOKEN],
+            ):
+                self.failed += 1
+                raise UpdateFailed(
+                    translation_domain=DOMAIN,
+                    translation_key="update_failed",
+                    translation_placeholders={
+                        CONF_DOMAIN: self.config_entry.data[CONF_DOMAIN],
+                    },
+                    retry_after=retry_after,
+                )
+        except ClientError as e:
+            self.failed += 1
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="connection_error",
+                translation_placeholders={
+                    CONF_DOMAIN: self.config_entry.data[CONF_DOMAIN],
+                },
+                retry_after=retry_after,
+            ) from e
+        self.failed = 0

homeassistant/components/duckdns/helpers.py

@@ -0,0 +1,35 @@
+"""Helpers for Duck DNS integration."""
+
+from aiohttp import ClientSession
+
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+
+UPDATE_URL = "https://www.duckdns.org/update"
+
+
+async def update_duckdns(
+    session: ClientSession,
+    domain: str,
+    token: str,
+    *,
+    txt: str | None | UndefinedType = UNDEFINED,
+    clear: bool = False,
+) -> bool:
+    """Update DuckDNS."""
+    params = {"domains": domain, "token": token}
+
+    if txt is not UNDEFINED:
+        if txt is None:
+            # Pass in empty txt value to indicate it's clearing txt record
+            params["txt"] = ""
+            clear = True
+        else:
+            params["txt"] = txt
+
+    if clear:
+        params["clear"] = "true"
+
+    resp = await session.get(UPDATE_URL, params=params)
+    body = await resp.text()
+
+    return body == "OK"

homeassistant/components/duckdns/strings.json

@@ -1,13 +1,23 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
       "unknown": "[%key:common::config_flow::error::unknown%]",
       "update_failed": "Updating Duck DNS failed"
     },
     "step": {
+      "reconfigure": {
+        "data": {
+          "access_token": "[%key:component::duckdns::config::step::user::data::access_token%]"
+        },
+        "data_description": {
+          "access_token": "[%key:component::duckdns::config::step::user::data_description::access_token%]"
+        },
+        "title": "Re-configure {name}"
+      },
       "user": {
         "data": {
           "access_token": "Token",
@@ -22,11 +32,17 @@
     }
   },
   "exceptions": {
+    "connection_error": {
+      "message": "Updating Duck DNS domain {domain} failed due to a connection error"
+    },
     "entry_not_found": {
       "message": "Duck DNS integration entry not found"
     },
     "entry_not_selected": {
       "message": "Duck DNS integration entry not selected"
+    },
+    "update_failed": {
+      "message": "Updating Duck DNS domain {domain} failed"
     }
   },
   "issues": {

homeassistant/components/ecovacs/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==16.4.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.0"]
 }

homeassistant/components/evohome/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["evohome", "evohomeasync", "evohomeasync2"],
   "quality_scale": "legacy",
-  "requirements": ["evohome-async==1.0.5"]
+  "requirements": ["evohome-async==1.0.6"]
 }

homeassistant/components/fressnapf_tracker/__init__.py

@@ -15,7 +15,9 @@ from .coordinator import (
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
     Platform.DEVICE_TRACKER,
+    Platform.LIGHT,
     Platform.SENSOR,
+    Platform.SWITCH,
 ]
 
 

homeassistant/components/fressnapf_tracker/binary_sensor.py

@@ -17,6 +17,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import FressnapfTrackerConfigEntry
 from .entity import FressnapfTrackerEntity
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 @dataclass(frozen=True, kw_only=True)
 class FressnapfTrackerBinarySensorDescription(BinarySensorEntityDescription):
@@ -34,13 +37,6 @@ BINARY_SENSOR_ENTITY_DESCRIPTIONS: tuple[
         entity_category=EntityCategory.DIAGNOSTIC,
         value_fn=lambda data: data.charging,
     ),
-    FressnapfTrackerBinarySensorDescription(
-        translation_key="deep_sleep",
-        key="deep_sleep_value",
-        device_class=BinarySensorDeviceClass.POWER,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: bool(data.deep_sleep_value),
-    ),
 )
 
 

homeassistant/components/fressnapf_tracker/device_tracker.py

@@ -8,6 +8,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import FressnapfTrackerConfigEntry, FressnapfTrackerDataUpdateCoordinator
 from .entity import FressnapfTrackerBaseEntity
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -39,6 +42,11 @@ class FressnapfTrackerDeviceTracker(FressnapfTrackerBaseEntity, TrackerEntity):
         """Return if entity is available."""
         return super().available and self.coordinator.data.position is not None
 
+    @property
+    def entity_picture(self) -> str | None:
+        """Return the entity picture url."""
+        return self.coordinator.data.icon
+
     @property
     def latitude(self) -> float | None:
         """Return latitude value of the device."""

homeassistant/components/fressnapf_tracker/icons.json

@@ -4,6 +4,14 @@
       "pet": {
         "default": "mdi:paw"
       }
+    },
+    "switch": {
+      "energy_saving": {
+        "default": "mdi:sleep",
+        "state": {
+          "off": "mdi:sleep-off"
+        }
+      }
     }
   }
 }

homeassistant/components/fressnapf_tracker/light.py

@@ -0,0 +1,95 @@
+"""Light platform for fressnapf_tracker."""
+
+from typing import TYPE_CHECKING, Any
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    ColorMode,
+    LightEntity,
+    LightEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import FressnapfTrackerConfigEntry
+from .const import DOMAIN
+from .entity import FressnapfTrackerEntity
+
+PARALLEL_UPDATES = 1
+
+LIGHT_ENTITY_DESCRIPTION = LightEntityDescription(
+    translation_key="led",
+    entity_category=EntityCategory.CONFIG,
+    key="led_brightness_value",
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FressnapfTrackerConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Fressnapf Tracker lights."""
+
+    async_add_entities(
+        FressnapfTrackerLight(coordinator, LIGHT_ENTITY_DESCRIPTION)
+        for coordinator in entry.runtime_data
+        if coordinator.data.led_activatable is not None
+        and coordinator.data.led_activatable.has_led
+        and coordinator.data.tracker_settings.features.flash_light
+    )
+
+
+class FressnapfTrackerLight(FressnapfTrackerEntity, LightEntity):
+    """Fressnapf Tracker light."""
+
+    _attr_color_mode: ColorMode = ColorMode.BRIGHTNESS
+    _attr_supported_color_modes: set[ColorMode] = {ColorMode.BRIGHTNESS}
+
+    @property
+    def brightness(self) -> int:
+        """Return the brightness of this light between 0..255."""
+        if TYPE_CHECKING:
+            # The entity is not created if led_brightness_value is None
+            assert self.coordinator.data.led_brightness_value is not None
+        return int(round((self.coordinator.data.led_brightness_value / 100) * 255))
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the device."""
+        self.raise_if_not_activatable()
+        brightness = kwargs.get(ATTR_BRIGHTNESS, 255)
+        brightness = int((brightness / 255) * 100)
+        await self.coordinator.client.set_led_brightness(brightness)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the device."""
+        await self.coordinator.client.set_led_brightness(0)
+        await self.coordinator.async_request_refresh()
+
+    def raise_if_not_activatable(self) -> None:
+        """Raise error with reasoning if light is not activatable."""
+        if TYPE_CHECKING:
+            # The entity is not created if led_activatable is None
+            assert self.coordinator.data.led_activatable is not None
+        error_type: str | None = None
+        if not self.coordinator.data.led_activatable.seen_recently:
+            error_type = "not_seen_recently"
+        elif not self.coordinator.data.led_activatable.not_charging:
+            error_type = "charging"
+        elif not self.coordinator.data.led_activatable.nonempty_battery:
+            error_type = "low_battery"
+        if error_type is not None:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key=error_type,
+            )
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if device is on."""
+        if self.coordinator.data.led_brightness_value is not None:
+            return self.coordinator.data.led_brightness_value > 0
+        return False

homeassistant/components/fressnapf_tracker/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["fressnapftracker==0.1.2"]
+  "requirements": ["fressnapftracker==0.2.0"]
 }

homeassistant/components/fressnapf_tracker/quality_scale.yaml

@@ -28,20 +28,26 @@ rules:
   # Silver
   action-exceptions: todo
   config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
   entity-unavailable: done
-  integration-owner: todo
-  log-when-unavailable: todo
-  parallel-updates: todo
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
   reauthentication-flow: todo
-  test-coverage: todo
+  test-coverage: done
 
   # Gold
   devices: done
   diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
+  discovery-update-info:
+    status: exempt
+    comment: |
+      This integration is a cloud service and thus does not support discovery.
+  discovery:
+    status: exempt
+    comment: |
+      This integration is a cloud service and thus does not support discovery.
   docs-data-update: todo
   docs-examples: todo
   docs-known-limitations: todo
@@ -50,12 +56,15 @@ rules:
   docs-troubleshooting: todo
   docs-use-cases: todo
   dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: |
+      This integration does not have many entities. All of them are fundamental.
   entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
+  exception-translations: done
+  icon-translations: done
   reconfiguration-flow: done
   repair-issues: todo
   stale-devices: todo

homeassistant/components/fressnapf_tracker/sensor.py

@@ -18,6 +18,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import FressnapfTrackerConfigEntry
 from .entity import FressnapfTrackerEntity
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 @dataclass(frozen=True, kw_only=True)
 class FressnapfTrackerSensorDescription(SensorEntityDescription):

homeassistant/components/fressnapf_tracker/strings.json

@@ -47,10 +47,26 @@
     }
   },
   "entity": {
-    "binary_sensor": {
-      "deep_sleep": {
-        "name": "Deep sleep"
+    "light": {
+      "led": {
+        "name": "Flashlight"
       }
+    },
+    "switch": {
+      "energy_saving": {
+        "name": "Sleep mode"
+      }
+    }
+  },
+  "exceptions": {
+    "charging": {
+      "message": "The flashlight cannot be activated while charging."
+    },
+    "low_battery": {
+      "message": "The flashlight cannot be activated due to low battery."
+    },
+    "not_seen_recently": {
+      "message": "The flashlight cannot be activated when the tracker has not moved recently."
     }
   }
 }

homeassistant/components/fressnapf_tracker/switch.py

@@ -0,0 +1,60 @@
+"""Switch platform for Fressnapf Tracker."""
+
+from typing import TYPE_CHECKING, Any
+
+from homeassistant.components.switch import (
+    SwitchDeviceClass,
+    SwitchEntity,
+    SwitchEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import FressnapfTrackerConfigEntry
+from .entity import FressnapfTrackerEntity
+
+PARALLEL_UPDATES = 1
+
+SWITCH_ENTITY_DESCRIPTION = SwitchEntityDescription(
+    translation_key="energy_saving",
+    entity_category=EntityCategory.CONFIG,
+    device_class=SwitchDeviceClass.SWITCH,
+    key="energy_saving",
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FressnapfTrackerConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Fressnapf Tracker switches."""
+
+    async_add_entities(
+        FressnapfTrackerSwitch(coordinator, SWITCH_ENTITY_DESCRIPTION)
+        for coordinator in entry.runtime_data
+        if coordinator.data.tracker_settings.features.energy_saving_mode
+    )
+
+
+class FressnapfTrackerSwitch(FressnapfTrackerEntity, SwitchEntity):
+    """Fressnapf Tracker switch."""
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the device."""
+        await self.coordinator.client.set_energy_saving(True)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the device."""
+        await self.coordinator.client.set_energy_saving(False)
+        await self.coordinator.async_request_refresh()
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if device is on."""
+        if TYPE_CHECKING:
+            # The entity is not created if energy_saving is None
+            assert self.coordinator.data.energy_saving is not None
+        return self.coordinator.data.energy_saving.value == 1

homeassistant/components/frontend/manifest.json

@@ -23,5 +23,5 @@
     "winter_mode": {}
   },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251202.0"]
+  "requirements": ["home-assistant-frontend==20251203.1"]
 }

homeassistant/components/gentex_homelink/__init__.py

@@ -0,0 +1,58 @@
+"""The homelink integration."""
+
+from __future__ import annotations
+
+from homelink.mqtt_provider import MQTTProvider
+
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
+
+from . import oauth2
+from .const import DOMAIN
+from .coordinator import HomeLinkConfigEntry, HomeLinkCoordinator, HomeLinkData
+
+PLATFORMS: list[Platform] = [Platform.EVENT]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: HomeLinkConfigEntry) -> bool:
+    """Set up homelink from a config entry."""
+    auth_implementation = oauth2.SRPAuthImplementation(hass, DOMAIN)
+
+    config_entry_oauth2_flow.async_register_implementation(
+        hass, DOMAIN, auth_implementation
+    )
+
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
+        )
+    )
+
+    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
+    authenticated_session = oauth2.AsyncConfigEntryAuth(
+        aiohttp_client.async_get_clientsession(hass), session
+    )
+
+    provider = MQTTProvider(authenticated_session)
+    coordinator = HomeLinkCoordinator(hass, provider, entry)
+
+    entry.async_on_unload(
+        hass.bus.async_listen_once(
+            EVENT_HOMEASSISTANT_STOP, coordinator.async_on_unload
+        )
+    )
+
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = HomeLinkData(
+        provider=provider, coordinator=coordinator, last_update_id=None
+    )
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: HomeLinkConfigEntry) -> bool:
+    """Unload a config entry."""
+    await entry.runtime_data.coordinator.async_on_unload(None)
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/gentex_homelink/application_credentials.py

@@ -0,0 +1,14 @@
+"""application_credentials platform for the gentex homelink integration."""
+
+from homeassistant.components.application_credentials import ClientCredential
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_entry_oauth2_flow
+
+from . import oauth2
+
+
+async def async_get_auth_implementation(
+    hass: HomeAssistant, auth_domain: str, _credential: ClientCredential
+) -> config_entry_oauth2_flow.AbstractOAuth2Implementation:
+    """Return custom SRPAuth implementation."""
+    return oauth2.SRPAuthImplementation(hass, auth_domain)

homeassistant/components/gentex_homelink/config_flow.py

@@ -0,0 +1,66 @@
+"""Config flow for homelink."""
+
+import logging
+from typing import Any
+
+import botocore.exceptions
+from homelink.auth.srp_auth import SRPAuth
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
+from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
+
+from .const import DOMAIN
+from .oauth2 import SRPAuthImplementation
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SRPFlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
+    """Config flow to handle homelink OAuth2 authentication."""
+
+    DOMAIN = DOMAIN
+
+    def __init__(self) -> None:
+        """Set up the flow handler."""
+        super().__init__()
+        self.flow_impl = SRPAuthImplementation(self.hass, DOMAIN)
+
+    @property
+    def logger(self):
+        """Get the logger."""
+        return _LOGGER
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> config_entries.ConfigFlowResult:
+        """Ask for username and password."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            self._async_abort_entries_match({CONF_EMAIL: user_input[CONF_EMAIL]})
+
+            srp_auth = SRPAuth()
+            try:
+                tokens = await self.hass.async_add_executor_job(
+                    srp_auth.async_get_access_token,
+                    user_input[CONF_EMAIL],
+                    user_input[CONF_PASSWORD],
+                )
+            except botocore.exceptions.ClientError:
+                _LOGGER.exception("Error authenticating homelink account")
+                errors["base"] = "srp_auth_failed"
+            except Exception:
+                _LOGGER.exception("An unexpected error occurred")
+                errors["base"] = "unknown"
+            else:
+                self.external_data = {"tokens": tokens}
+                return await self.async_step_creation()
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {vol.Required(CONF_EMAIL): str, vol.Required(CONF_PASSWORD): str}
+            ),
+            errors=errors,
+        )

homeassistant/components/gentex_homelink/const.py

@@ -0,0 +1,7 @@
+"""Constants for the homelink integration."""
+
+DOMAIN = "gentex_homelink"
+OAUTH2_TOKEN = "https://auth.homelinkcloud.com/oauth2/token"
+POLLING_INTERVAL = 5
+
+EVENT_PRESSED = "Pressed"

homeassistant/components/gentex_homelink/coordinator.py

@@ -0,0 +1,113 @@
+"""Makes requests to the state server and stores the resulting data so that the buttons can access it."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from functools import partial
+import logging
+from typing import TYPE_CHECKING, TypedDict
+
+from homelink.model.device import Device
+from homelink.mqtt_provider import MQTTProvider
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.util.ssl import get_default_context
+
+if TYPE_CHECKING:
+    from .event import HomeLinkEventEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+type HomeLinkConfigEntry = ConfigEntry[HomeLinkData]
+type EventCallback = Callable[[HomeLinkEventData], None]
+
+
+@dataclass
+class HomeLinkData:
+    """Class for HomeLink integration runtime data."""
+
+    provider: MQTTProvider
+    coordinator: HomeLinkCoordinator
+    last_update_id: str | None
+
+
+class HomeLinkEventData(TypedDict):
+    """Data for a single event."""
+
+    requestId: str
+    timestamp: int
+
+
+class HomeLinkMQTTMessage(TypedDict):
+    """HomeLink MQTT Event message."""
+
+    type: str
+    data: dict[str, HomeLinkEventData]  # Each key is a button id
+
+
+class HomeLinkCoordinator:
+    """HomeLink integration coordinator."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        provider: MQTTProvider,
+        config_entry: HomeLinkConfigEntry,
+    ) -> None:
+        """Initialize my coordinator."""
+        self.hass = hass
+        self.config_entry = config_entry
+        self.provider = provider
+        self.device_data: list[Device] = []
+        self.buttons: list[HomeLinkEventEntity] = []
+        self._listeners: dict[str, EventCallback] = {}
+
+    @callback
+    def async_add_event_listener(
+        self, update_callback: EventCallback, target_event_id: str
+    ) -> Callable[[], None]:
+        """Listen for updates."""
+        self._listeners[target_event_id] = update_callback
+        return partial(self.__async_remove_listener_internal, target_event_id)
+
+    def __async_remove_listener_internal(self, listener_id: str):
+        del self._listeners[listener_id]
+
+    @callback
+    def async_handle_state_data(self, data: dict[str, HomeLinkEventData]):
+        """Notify listeners."""
+        for button_id, event in data.items():
+            if listener := self._listeners.get(button_id):
+                listener(event)
+
+    async def async_config_entry_first_refresh(self) -> None:
+        """Refresh data for the first time when a config entry is setup."""
+        await self._async_setup()
+
+    async def async_on_unload(self, _event):
+        """Disconnect and unregister when unloaded."""
+        await self.provider.disable()
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator."""
+        await self.provider.enable(get_default_context())
+        await self.discover_devices()
+        self.provider.listen(self.on_message)
+
+    async def discover_devices(self):
+        """Discover devices and build the Entities."""
+        self.device_data = await self.provider.discover()
+
+    def on_message(
+        self: HomeLinkCoordinator, _topic: str, message: HomeLinkMQTTMessage
+    ):
+        "MQTT Callback function."
+        if message["type"] == "state":
+            self.hass.add_job(self.async_handle_state_data, message["data"])
+        if message["type"] == "requestSync":
+            self.hass.add_job(
+                self.hass.config_entries.async_reload,
+                self.config_entry.entry_id,
+            )

homeassistant/components/gentex_homelink/event.py

@@ -0,0 +1,83 @@
+"""Platform for Event integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.event import EventDeviceClass, EventEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN, EVENT_PRESSED
+from .coordinator import HomeLinkCoordinator, HomeLinkEventData
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add the entities for the binary sensor."""
+    coordinator = config_entry.runtime_data.coordinator
+    for device in coordinator.device_data:
+        buttons = [
+            HomeLinkEventEntity(b.id, b.name, device.id, device.name, coordinator)
+            for b in device.buttons
+        ]
+        coordinator.buttons.extend(buttons)
+
+    async_add_entities(coordinator.buttons)
+
+
+# Updates are centralized by the coordinator.
+PARALLEL_UPDATES = 0
+
+
+class HomeLinkEventEntity(EventEntity):
+    """Event Entity."""
+
+    _attr_has_entity_name = True
+    _attr_event_types = [EVENT_PRESSED]
+    _attr_device_class = EventDeviceClass.BUTTON
+
+    def __init__(
+        self,
+        id: str,
+        param_name: str,
+        device_id: str,
+        device_name: str,
+        coordinator: HomeLinkCoordinator,
+    ) -> None:
+        """Initialize the event entity."""
+
+        self.id: str = id
+        self._attr_name: str = param_name
+        self._attr_unique_id: str = id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, device_id)},
+            name=device_name,
+        )
+        self.coordinator = coordinator
+        self.last_request_id: str | None = None
+
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        self.async_on_remove(
+            self.coordinator.async_add_event_listener(
+                self._handle_event_data_update, self.id
+            )
+        )
+
+    @callback
+    def _handle_event_data_update(self, update_data: HomeLinkEventData) -> None:
+        """Update this button."""
+
+        if update_data["requestId"] != self.last_request_id:
+            self._trigger_event(EVENT_PRESSED)
+            self.last_request_id = update_data["requestId"]
+
+        self.async_write_ha_state()
+
+    async def async_update(self):
+        """Request early polling. Left intentionally blank because it's not possible in this implementation."""

homeassistant/components/gentex_homelink/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "gentex_homelink",
+  "name": "HomeLink",
+  "codeowners": ["@niaexa", "@ryanjones-gentex"],
+  "config_flow": true,
+  "dependencies": ["application_credentials"],
+  "documentation": "https://www.home-assistant.io/integrations/gentex_homelink",
+  "iot_class": "cloud_push",
+  "quality_scale": "bronze",
+  "requirements": ["homelink-integration-api==0.0.1"]
+}

homeassistant/components/gentex_homelink/oauth2.py

@@ -0,0 +1,114 @@
+"""API for homelink bound to Home Assistant OAuth."""
+
+from json import JSONDecodeError
+import logging
+import time
+from typing import cast
+
+from aiohttp import ClientError, ClientSession
+from homelink.auth.abstract_auth import AbstractAuth
+from homelink.settings import COGNITO_CLIENT_ID
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import OAUTH2_TOKEN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SRPAuthImplementation(config_entry_oauth2_flow.AbstractOAuth2Implementation):
+    """Base class to abstract OAuth2 authentication."""
+
+    def __init__(self, hass: HomeAssistant, domain) -> None:
+        """Initialize the SRP Auth implementation."""
+
+        self.hass = hass
+        self._domain = domain
+        self.client_id = COGNITO_CLIENT_ID
+
+    @property
+    def name(self) -> str:
+        """Name of the implementation."""
+        return "SRPAuth"
+
+    @property
+    def domain(self) -> str:
+        """Domain that is providing the implementation."""
+        return self._domain
+
+    async def async_generate_authorize_url(self, flow_id: str) -> str:
+        """Left intentionally blank because the auth is handled by SRP."""
+        return ""
+
+    async def async_resolve_external_data(self, external_data) -> dict:
+        """Format the token from the source appropriately for HomeAssistant."""
+        tokens = external_data["tokens"]
+        new_token = {}
+        new_token["access_token"] = tokens["AuthenticationResult"]["AccessToken"]
+        new_token["refresh_token"] = tokens["AuthenticationResult"]["RefreshToken"]
+        new_token["token_type"] = tokens["AuthenticationResult"]["TokenType"]
+        new_token["expires_in"] = tokens["AuthenticationResult"]["ExpiresIn"]
+        new_token["expires_at"] = (
+            time.time() + tokens["AuthenticationResult"]["ExpiresIn"]
+        )
+
+        return new_token
+
+    async def _token_request(self, data: dict) -> dict:
+        """Make a token request."""
+        session = async_get_clientsession(self.hass)
+
+        data["client_id"] = self.client_id
+
+        _LOGGER.debug("Sending token request to %s", OAUTH2_TOKEN)
+        resp = await session.post(OAUTH2_TOKEN, data=data)
+        if resp.status >= 400:
+            try:
+                error_response = await resp.json()
+            except (ClientError, JSONDecodeError):
+                error_response = {}
+                error_code = error_response.get("error", "unknown")
+                error_description = error_response.get(
+                    "error_description", "unknown error"
+                )
+                _LOGGER.error(
+                    "Token request for %s failed (%s): %s",
+                    self.domain,
+                    error_code,
+                    error_description,
+                )
+        resp.raise_for_status()
+        return cast(dict, await resp.json())
+
+    async def _async_refresh_token(self, token: dict) -> dict:
+        """Refresh tokens."""
+        new_token = await self._token_request(
+            {
+                "grant_type": "refresh_token",
+                "client_id": self.client_id,
+                "refresh_token": token["refresh_token"],
+            }
+        )
+        return {**token, **new_token}
+
+
+class AsyncConfigEntryAuth(AbstractAuth):
+    """Provide homelink authentication tied to an OAuth2 based config entry."""
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        oauth_session: config_entry_oauth2_flow.OAuth2Session,
+    ) -> None:
+        """Initialize homelink auth."""
+        super().__init__(websession)
+        self._oauth_session = oauth_session
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        if not self._oauth_session.valid_token:
+            await self._oauth_session.async_ensure_token_valid()
+
+        return self._oauth_session.token["access_token"]

homeassistant/components/gentex_homelink/quality_scale.yaml

@@ -0,0 +1,76 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register any service actions
+  appropriate-polling:
+    status: exempt
+    comment: Integration does not poll
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not register any service actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration does not register any service actions
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: It is not necessary to update IP addresses of devices or services in this Integration
+  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: done
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default:
+    status: exempt
+    comment: Entities are not noisy and are expected to be enabled by default
+  entity-translations:
+    status: exempt
+    comment: Entity properties are user-defined, and therefore cannot be translated
+  exception-translations: todo
+  icon-translations:
+    status: exempt
+    comment: Entities in this integration do not use icons, and therefore do not require translation
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: done
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/gentex_homelink/strings.json

@@ -0,0 +1,38 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+      "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
+      "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
+      "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
+      "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
+      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
+      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
+      "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]"
+    },
+    "create_entry": {
+      "default": "[%key:common::config_flow::create_entry::authenticated%]"
+    },
+    "error": {
+      "srp_auth_failed": "Error authenticating HomeLink account",
+      "unknown": "An unknown error occurred. Please try again later"
+    },
+    "step": {
+      "pick_implementation": {
+        "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
+      },
+      "user": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "Email address associated with your HomeLink account",
+          "password": "Password associated with your HomeLink account"
+        }
+      }
+    }
+  }
+}

homeassistant/components/google_air_quality/strings.json

@@ -59,9 +59,14 @@
         "user": "Add location"
       },
       "step": {
-        "user": {
+        "location": {
           "data": {
-            "location": "[%key:common::config_flow::data::location%]"
+            "location": "[%key:common::config_flow::data::location%]",
+            "name": "[%key:common::config_flow::data::name%]"
+          },
+          "data_description": {
+            "location": "[%key:component::google_air_quality::config::step::user::data_description::location%]",
+            "name": "[%key:component::google_air_quality::config::step::user::data_description::name%]"
           },
           "description": "Select the coordinates for which you want to create an entry.",
           "title": "Air quality data location"

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -149,6 +149,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             }
         ),
         supports_response=SupportsResponse.ONLY,
+        description_placeholders={"example_image_path": "/config/www/image.jpg"},
     )
     return True
 

homeassistant/components/google_generative_ai_conversation/const.py

@@ -23,7 +23,7 @@ CONF_CHAT_MODEL = "chat_model"
 RECOMMENDED_CHAT_MODEL = "models/gemini-2.5-flash"
 RECOMMENDED_STT_MODEL = RECOMMENDED_CHAT_MODEL
 RECOMMENDED_TTS_MODEL = "models/gemini-2.5-flash-preview-tts"
-RECOMMENDED_IMAGE_MODEL = "models/gemini-2.5-flash-image-preview"
+RECOMMENDED_IMAGE_MODEL = "models/gemini-2.5-flash-image"
 CONF_TEMPERATURE = "temperature"
 RECOMMENDED_TEMPERATURE = 1.0
 CONF_TOP_P = "top_p"

homeassistant/components/google_generative_ai_conversation/strings.json

@@ -162,7 +162,7 @@
       "fields": {
         "filenames": {
           "description": "Attachments to add to the prompt (images, PDFs, etc)",
-          "example": "/config/www/image.jpg",
+          "example": "{example_image_path}",
           "name": "Attachment filenames"
         },
         "prompt": {

homeassistant/components/google_photos/services.py

@@ -159,4 +159,5 @@ def async_setup_services(hass: HomeAssistant) -> None:
         _async_handle_upload,
         schema=UPLOAD_SERVICE_SCHEMA,
         supports_response=SupportsResponse.OPTIONAL,
+        description_placeholders={"example_image_path": "/config/www/image.jpg"},
     )

homeassistant/components/google_photos/strings.json

@@ -92,7 +92,7 @@
         },
         "filename": {
           "description": "Path to the image or video to upload.",
-          "example": "/config/www/image.jpg",
+          "example": "{example_image_path}",
           "name": "Filename"
         }
       },

homeassistant/components/growatt_server/__init__.py

@@ -1,9 +1,11 @@
 """The Growatt server PV inverter sensor integration."""
 
 from collections.abc import Mapping
+from json import JSONDecodeError
 import logging
 
 import growattServer
+from requests import RequestException
 
 from homeassistant.const import CONF_PASSWORD, CONF_TOKEN, CONF_URL, CONF_USERNAME
 from homeassistant.core import HomeAssistant
@@ -35,8 +37,7 @@ def get_device_list_classic(
     # Log in to api and fetch first plant if no plant id is defined.
     try:
         login_response = api.login(config[CONF_USERNAME], config[CONF_PASSWORD])
-        # DEBUG: Log the actual response structure
-    except Exception as ex:
+    except (RequestException, JSONDecodeError) as ex:
         raise ConfigEntryError(
             f"Error communicating with Growatt API during login: {ex}"
         ) from ex
@@ -53,7 +54,7 @@ def get_device_list_classic(
     if plant_id == DEFAULT_PLANT_ID:
         try:
             plant_info = api.plant_list(user_id)
-        except Exception as ex:
+        except (RequestException, JSONDecodeError) as ex:
             raise ConfigEntryError(
                 f"Error communicating with Growatt API during plant list: {ex}"
             ) from ex
@@ -64,7 +65,7 @@ def get_device_list_classic(
     # Get a list of devices for specified plant to add sensors for.
     try:
         devices = api.device_list(plant_id)
-    except Exception as ex:
+    except (RequestException, JSONDecodeError) as ex:
         raise ConfigEntryError(
             f"Error communicating with Growatt API during device list: {ex}"
         ) from ex

homeassistant/components/growatt_server/quality_scale.yaml

@@ -28,9 +28,7 @@ rules:
     status: todo
     comment: Update server URL dropdown to show regional descriptions (e.g., 'China', 'United States') instead of raw URLs.
   docs-installation-parameters: todo
-  entity-unavailable:
-    status: todo
-    comment: Replace bare Exception catches in __init__.py with specific growattServer exceptions.
+  entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done

homeassistant/components/home_connect/__init__.py

@@ -111,7 +111,7 @@ async def async_migrate_entry(
     hass: HomeAssistant, entry: HomeConnectConfigEntry
 ) -> bool:
     """Migrate old entry."""
-    _LOGGER.debug("Migrating from version %s", entry.version)
+    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
 
     if entry.version == 1:
         match entry.minor_version:
@@ -147,5 +147,7 @@ async def async_migrate_entry(
                     )["sub"],
                 )
 
-    _LOGGER.debug("Migration to version %s successful", entry.version)
+    _LOGGER.debug(
+        "Migration to version %s.%s successful", entry.version, entry.minor_version
+    )
     return True

homeassistant/components/intent/__init__.py

@@ -22,6 +22,7 @@ from homeassistant.components.cover import (
     SERVICE_CLOSE_COVER,
     SERVICE_OPEN_COVER,
     SERVICE_SET_COVER_POSITION,
+    SERVICE_STOP_COVER,
     CoverDeviceClass,
 )
 from homeassistant.components.http.data_validator import RequestDataValidator
@@ -38,6 +39,7 @@ from homeassistant.components.valve import (
     SERVICE_CLOSE_VALVE,
     SERVICE_OPEN_VALVE,
     SERVICE_SET_VALVE_POSITION,
+    SERVICE_STOP_VALVE,
     ValveDeviceClass,
 )
 from homeassistant.const import (
@@ -143,6 +145,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         NevermindIntentHandler(),
     )
     intent.async_register(hass, SetPositionIntentHandler())
+    intent.async_register(hass, StopMovingIntentHandler())
     intent.async_register(hass, StartTimerIntentHandler())
     intent.async_register(hass, CancelTimerIntentHandler())
     intent.async_register(hass, CancelAllTimersIntentHandler())
@@ -433,6 +436,31 @@ class SetPositionIntentHandler(intent.DynamicServiceIntentHandler):
         raise intent.IntentHandleError(f"Domain not supported: {state.domain}")
 
 
+class StopMovingIntentHandler(intent.DynamicServiceIntentHandler):
+    """Intent handler for stopping covers and valves."""
+
+    def __init__(self) -> None:
+        """Create stop moving handler."""
+        super().__init__(
+            intent.INTENT_STOP_MOVING,
+            description="Stops a moving device or entity",
+            platforms={COVER_DOMAIN, VALVE_DOMAIN},
+            device_classes={CoverDeviceClass, ValveDeviceClass},
+        )
+
+    def get_domain_and_service(
+        self, intent_obj: intent.Intent, state: State
+    ) -> tuple[str, str]:
+        """Get the domain and service name to call."""
+        if state.domain == COVER_DOMAIN:
+            return (COVER_DOMAIN, SERVICE_STOP_COVER)
+
+        if state.domain == VALVE_DOMAIN:
+            return (VALVE_DOMAIN, SERVICE_STOP_VALVE)
+
+        raise intent.IntentHandleError(f"Domain not supported: {state.domain}")
+
+
 class GetCurrentDateIntentHandler(intent.IntentHandler):
     """Gets the current date."""
 

homeassistant/components/kitchen_sink/strings.json

@@ -72,7 +72,7 @@
       "title": "The blinker fluid is empty and needs to be refilled"
     },
     "special_repair": {
-      "description": "This is a special repair created by a preview feature! This demonstrates how lab features can interact with the Home Assistant repair system. You can disable this by turning off the kitchen sink special repair feature in Settings > System > Labs.",
+      "description": "This is a special repair created by a preview feature! This demonstrates how Labs features can interact with the Home Assistant repair system. You can disable this by turning off the kitchen sink special repair feature in Settings > System > Labs.",
       "title": "Special repair feature preview"
     },
     "transmogrifier_deprecated": {
@@ -109,7 +109,7 @@
   },
   "preview_features": {
     "special_repair": {
-      "description": "Creates a **special repair issue** when enabled.\n\nThis demonstrates how lab features can interact with other Home Assistant integrations.",
+      "description": "Creates a **special repair issue** when enabled.\n\nThis demonstrates how Labs features can interact with other Home Assistant integrations.",
       "disable_confirmation": "This will remove the special repair issue. Don't worry, this is just a demonstration feature.",
       "enable_confirmation": "This will create a special repair issue to demonstrate Labs preview features. This is just an example and won't affect your actual system.",
       "name": "Special repair"

homeassistant/components/knx/const.py

@@ -94,8 +94,6 @@ SERVICE_KNX_EVENT_REGISTER: Final = "event_register"
 SERVICE_KNX_EXPOSURE_REGISTER: Final = "exposure_register"
 SERVICE_KNX_READ: Final = "read"
 
-REPAIR_ISSUE_DATA_SECURE_GROUP_KEY: Final = "data_secure_group_key_issue"
-
 
 class KNXConfigEntryData(TypedDict, total=False):
     """Config entry for the KNX integration."""
@@ -167,6 +165,7 @@ SUPPORTED_PLATFORMS_UI: Final = {
     Platform.DATE,
     Platform.DATETIME,
     Platform.LIGHT,
+    Platform.SENSOR,
     Platform.SWITCH,
     Platform.TIME,
 }

homeassistant/components/knx/dpt.py

@@ -0,0 +1,142 @@
+"""KNX DPT serializer."""
+
+from collections.abc import Mapping
+from functools import cache
+from typing import Literal, TypedDict
+
+from xknx.dpt import DPTBase, DPTComplex, DPTEnum, DPTNumeric
+from xknx.dpt.dpt_16 import DPTString
+
+from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
+
+HaDptClass = Literal["numeric", "enum", "complex", "string"]
+
+
+class DPTInfo(TypedDict):
+    """DPT information."""
+
+    dpt_class: HaDptClass
+    main: int
+    sub: int | None
+    name: str | None
+    unit: str | None
+    sensor_device_class: SensorDeviceClass | None
+    sensor_state_class: SensorStateClass | None
+
+
+@cache
+def get_supported_dpts() -> Mapping[str, DPTInfo]:
+    """Return a mapping of supported DPTs with HA specific attributes."""
+    dpts = {}
+    for dpt_class in DPTBase.dpt_class_tree():
+        dpt_number_str = dpt_class.dpt_number_str()
+        ha_dpt_class = _ha_dpt_class(dpt_class)
+        dpts[dpt_number_str] = DPTInfo(
+            dpt_class=ha_dpt_class,
+            main=dpt_class.dpt_main_number,  # type: ignore[typeddict-item] # checked in xknx unit tests
+            sub=dpt_class.dpt_sub_number,
+            name=dpt_class.value_type,
+            unit=dpt_class.unit,
+            sensor_device_class=_sensor_device_classes.get(dpt_number_str),
+            sensor_state_class=_get_sensor_state_class(ha_dpt_class, dpt_number_str),
+        )
+    return dpts
+
+
+def _ha_dpt_class(dpt_cls: type[DPTBase]) -> HaDptClass:
+    """Return the DPT class identifier string."""
+    if issubclass(dpt_cls, DPTNumeric):
+        return "numeric"
+    if issubclass(dpt_cls, DPTEnum):
+        return "enum"
+    if issubclass(dpt_cls, DPTComplex):
+        return "complex"
+    if issubclass(dpt_cls, DPTString):
+        return "string"
+    raise ValueError("Unsupported DPT class")
+
+
+_sensor_device_classes: Mapping[str, SensorDeviceClass] = {
+    "7.011": SensorDeviceClass.DISTANCE,
+    "7.012": SensorDeviceClass.CURRENT,
+    "7.013": SensorDeviceClass.ILLUMINANCE,
+    "8.012": SensorDeviceClass.DISTANCE,
+    "9.001": SensorDeviceClass.TEMPERATURE,
+    "9.002": SensorDeviceClass.TEMPERATURE_DELTA,
+    "9.004": SensorDeviceClass.ILLUMINANCE,
+    "9.005": SensorDeviceClass.WIND_SPEED,
+    "9.006": SensorDeviceClass.PRESSURE,
+    "9.007": SensorDeviceClass.HUMIDITY,
+    "9.020": SensorDeviceClass.VOLTAGE,
+    "9.021": SensorDeviceClass.CURRENT,
+    "9.024": SensorDeviceClass.POWER,
+    "9.025": SensorDeviceClass.VOLUME_FLOW_RATE,
+    "9.027": SensorDeviceClass.TEMPERATURE,
+    "9.028": SensorDeviceClass.WIND_SPEED,
+    "9.029": SensorDeviceClass.ABSOLUTE_HUMIDITY,
+    "12.1200": SensorDeviceClass.VOLUME,
+    "12.1201": SensorDeviceClass.VOLUME,
+    "13.002": SensorDeviceClass.VOLUME_FLOW_RATE,
+    "13.010": SensorDeviceClass.ENERGY,
+    "13.012": SensorDeviceClass.REACTIVE_ENERGY,
+    "13.013": SensorDeviceClass.ENERGY,
+    "13.015": SensorDeviceClass.REACTIVE_ENERGY,
+    "13.016": SensorDeviceClass.ENERGY,
+    "14.010": SensorDeviceClass.AREA,
+    "14.019": SensorDeviceClass.CURRENT,
+    "14.027": SensorDeviceClass.VOLTAGE,
+    "14.028": SensorDeviceClass.VOLTAGE,
+    "14.030": SensorDeviceClass.VOLTAGE,
+    "14.031": SensorDeviceClass.ENERGY,
+    "14.033": SensorDeviceClass.FREQUENCY,
+    "14.037": SensorDeviceClass.ENERGY_STORAGE,
+    "14.039": SensorDeviceClass.DISTANCE,
+    "14.051": SensorDeviceClass.WEIGHT,
+    "14.056": SensorDeviceClass.POWER,
+    "14.057": SensorDeviceClass.POWER_FACTOR,
+    "14.058": SensorDeviceClass.PRESSURE,
+    "14.065": SensorDeviceClass.SPEED,
+    "14.068": SensorDeviceClass.TEMPERATURE,
+    "14.069": SensorDeviceClass.TEMPERATURE,
+    "14.070": SensorDeviceClass.TEMPERATURE_DELTA,
+    "14.076": SensorDeviceClass.VOLUME,
+    "14.077": SensorDeviceClass.VOLUME_FLOW_RATE,
+    "14.080": SensorDeviceClass.APPARENT_POWER,
+    "29.010": SensorDeviceClass.ENERGY,
+    "29.012": SensorDeviceClass.REACTIVE_ENERGY,
+}
+
+_sensor_state_class_overrides: Mapping[str, SensorStateClass | None] = {
+    "5.003": SensorStateClass.MEASUREMENT_ANGLE,  # DPTAngle
+    "5.006": None,  # DPTTariff
+    "7.010": None,  # DPTPropDataType
+    "8.011": SensorStateClass.MEASUREMENT_ANGLE,  # DPTRotationAngle
+    "9.026": SensorStateClass.TOTAL_INCREASING,  # DPTRainAmount
+    "12.1200": SensorStateClass.TOTAL,  # DPTVolumeLiquidLitre
+    "12.1201": SensorStateClass.TOTAL,  # DPTVolumeM3
+    "13.010": SensorStateClass.TOTAL,  # DPTActiveEnergy
+    "13.011": SensorStateClass.TOTAL,  # DPTApparantEnergy
+    "13.012": SensorStateClass.TOTAL,  # DPTReactiveEnergy
+    "14.007": SensorStateClass.MEASUREMENT_ANGLE,  # DPTAngleDeg
+    "14.037": SensorStateClass.TOTAL,  # DPTHeatQuantity
+    "14.051": SensorStateClass.TOTAL,  # DPTMass
+    "14.055": SensorStateClass.MEASUREMENT_ANGLE,  # DPTPhaseAngleDeg
+    "14.031": SensorStateClass.TOTAL_INCREASING,  # DPTEnergy
+    "17.001": None,  # DPTSceneNumber
+    "29.010": SensorStateClass.TOTAL,  # DPTActiveEnergy8Byte
+    "29.011": SensorStateClass.TOTAL,  # DPTApparantEnergy8Byte
+    "29.012": SensorStateClass.TOTAL,  # DPTReactiveEnergy8Byte
+}
+
+
+def _get_sensor_state_class(
+    ha_dpt_class: HaDptClass, dpt_number_str: str
+) -> SensorStateClass | None:
+    """Return the SensorStateClass for a given DPT."""
+    if ha_dpt_class != "numeric":
+        return None
+
+    return _sensor_state_class_overrides.get(
+        dpt_number_str,
+        SensorStateClass.MEASUREMENT,
+    )

homeassistant/components/knx/entity.py

@@ -77,11 +77,6 @@ class _KnxEntityBase(Entity):
         """Store register state change callback and start device object."""
         self._device.register_device_updated_cb(self.after_update_callback)
         self._device.xknx.devices.async_add(self._device)
-        if uid := self.unique_id:
-            self._knx_module.add_to_group_address_entities(
-                group_addresses=self._device.group_addresses(),
-                identifier=(self.platform_data.domain, uid),
-            )
         # super call needed to have methods of multi-inherited classes called
         # eg. for restoring state (like _KNXSwitch)
         await super().async_added_to_hass()
@@ -90,11 +85,6 @@ class _KnxEntityBase(Entity):
         """Disconnect device object when removed."""
         self._device.unregister_device_updated_cb(self.after_update_callback)
         self._device.xknx.devices.async_remove(self._device)
-        if uid := self.unique_id:
-            self._knx_module.remove_from_group_address_entities(
-                group_addresses=self._device.group_addresses(),
-                identifier=(self.platform_data.domain, uid),
-            )
 
 
 class KnxYamlEntity(_KnxEntityBase):

homeassistant/components/knx/knx_module.py

@@ -56,7 +56,6 @@ from .const import (
 from .device import KNXInterfaceDevice
 from .expose import KNXExposeSensor, KNXExposeTime
 from .project import KNXProject
-from .repairs import data_secure_group_key_issue_dispatcher
 from .storage.config_store import KNXConfigStore
 from .telegrams import Telegrams
 
@@ -108,12 +107,8 @@ class KNXModule:
 
         self._address_filter_transcoder: dict[AddressFilter, type[DPTBase]] = {}
         self.group_address_transcoder: dict[DeviceGroupAddress, type[DPTBase]] = {}
-        self.group_address_entities: dict[
-            DeviceGroupAddress, set[tuple[str, str]]  # {(platform, unique_id),}
-        ] = {}
         self.knx_event_callback: TelegramQueue.Callback = self.register_event_callback()
 
-        self.entry.async_on_unload(data_secure_group_key_issue_dispatcher(self))
         self.entry.async_on_unload(
             self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.stop)
         )
@@ -230,29 +225,6 @@ class KNXModule:
             threaded=True,
         )
 
-    def add_to_group_address_entities(
-        self,
-        group_addresses: set[DeviceGroupAddress],
-        identifier: tuple[str, str],  # (platform, unique_id)
-    ) -> None:
-        """Register entity in group_address_entities map."""
-        for ga in group_addresses:
-            if ga not in self.group_address_entities:
-                self.group_address_entities[ga] = set()
-            self.group_address_entities[ga].add(identifier)
-
-    def remove_from_group_address_entities(
-        self,
-        group_addresses: set[DeviceGroupAddress],
-        identifier: tuple[str, str],
-    ) -> None:
-        """Unregister entity from group_address_entities map."""
-        for ga in group_addresses:
-            if ga in self.group_address_entities:
-                self.group_address_entities[ga].discard(identifier)
-                if not self.group_address_entities[ga]:
-                    del self.group_address_entities[ga]
-
     def connection_state_changed_cb(self, state: XknxConnectionState) -> None:
         """Call invoked after a KNX connection state change was received."""
         self.connected = state == XknxConnectionState.CONNECTED

homeassistant/components/knx/repairs.py

@@ -1,175 +0,0 @@
-"""Repairs for KNX integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from functools import partial
-from typing import TYPE_CHECKING, Any, Final
-
-import voluptuous as vol
-from xknx.exceptions.exception import InvalidSecureConfiguration
-from xknx.telegram import GroupAddress, IndividualAddress, Telegram
-
-from homeassistant import data_entry_flow
-from homeassistant.components.repairs import RepairsFlow
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import issue_registry as ir, selector
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
-
-if TYPE_CHECKING:
-    from .knx_module import KNXModule
-
-from .const import (
-    CONF_KNX_KNXKEY_PASSWORD,
-    DOMAIN,
-    REPAIR_ISSUE_DATA_SECURE_GROUP_KEY,
-    KNXConfigEntryData,
-)
-from .storage.keyring import DEFAULT_KNX_KEYRING_FILENAME, save_uploaded_knxkeys_file
-from .telegrams import SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM, TelegramDict
-
-CONF_KEYRING_FILE: Final = "knxkeys_file"
-
-
-async def async_create_fix_flow(
-    hass: HomeAssistant,
-    issue_id: str,
-    data: dict[str, str | int | float | None] | None,
-) -> RepairsFlow:
-    """Create flow."""
-    if issue_id == REPAIR_ISSUE_DATA_SECURE_GROUP_KEY:
-        return DataSecureGroupIssueRepairFlow()
-    # If KNX adds confirm-only repairs in the future, this should be changed
-    # to return a ConfirmRepairFlow instead of raising a ValueError
-    raise ValueError(f"unknown repair {issue_id}")
-
-
-######################
-# DataSecure key issue
-######################
-
-
-@callback
-def data_secure_group_key_issue_dispatcher(knx_module: KNXModule) -> Callable[[], None]:
-    """Watcher for DataSecure group key issues."""
-    return async_dispatcher_connect(
-        knx_module.hass,
-        signal=SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM,
-        target=partial(_data_secure_group_key_issue_handler, knx_module),
-    )
-
-
-@callback
-def _data_secure_group_key_issue_handler(
-    knx_module: KNXModule, telegram: Telegram, telegram_dict: TelegramDict
-) -> None:
-    """Handle DataSecure group key issue telegrams."""
-    if telegram.destination_address not in knx_module.group_address_entities:
-        # Only report issues for configured group addresses
-        return
-
-    issue_registry = ir.async_get(knx_module.hass)
-    new_ga = str(telegram.destination_address)
-    new_ia = str(telegram.source_address)
-    new_data = {new_ga: new_ia}
-
-    if existing_issue := issue_registry.async_get_issue(
-        DOMAIN, REPAIR_ISSUE_DATA_SECURE_GROUP_KEY
-    ):
-        assert isinstance(existing_issue.data, dict)
-        existing_data: dict[str, str] = existing_issue.data  # type: ignore[assignment]
-        if new_ga in existing_data:
-            current_ias = existing_data[new_ga].split(", ")
-            if new_ia in current_ias:
-                return
-            current_ias = sorted([*current_ias, new_ia], key=IndividualAddress)
-            new_data[new_ga] = ", ".join(current_ias)
-        new_data_unsorted = existing_data | new_data
-        new_data = {
-            key: new_data_unsorted[key]
-            for key in sorted(new_data_unsorted, key=GroupAddress)
-        }
-
-    issue_registry.async_get_or_create(
-        DOMAIN,
-        REPAIR_ISSUE_DATA_SECURE_GROUP_KEY,
-        data=new_data,  # type: ignore[arg-type]
-        is_fixable=True,
-        is_persistent=True,
-        severity=ir.IssueSeverity.ERROR,
-        translation_key=REPAIR_ISSUE_DATA_SECURE_GROUP_KEY,
-        translation_placeholders={
-            "addresses": "\n".join(
-                f"`{ga}` from {ias}" for ga, ias in new_data.items()
-            ),
-            "interface": str(knx_module.xknx.current_address),
-        },
-    )
-
-
-class DataSecureGroupIssueRepairFlow(RepairsFlow):
-    """Handler for an issue fixing flow for outdated DataSecure keys."""
-
-    @callback
-    def _async_get_placeholders(self) -> dict[str, str]:
-        issue_registry = ir.async_get(self.hass)
-        issue = issue_registry.async_get_issue(self.handler, self.issue_id)
-        assert issue is not None
-        return issue.translation_placeholders or {}
-
-    async def async_step_init(
-        self, user_input: dict[str, str] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Handle the first step of a fix flow."""
-        return await self.async_step_secure_knxkeys()
-
-    async def async_step_secure_knxkeys(
-        self, user_input: dict[str, Any] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Manage upload of new KNX Keyring file."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            password = user_input[CONF_KNX_KNXKEY_PASSWORD]
-            keyring = None
-            try:
-                keyring = await save_uploaded_knxkeys_file(
-                    self.hass,
-                    uploaded_file_id=user_input[CONF_KEYRING_FILE],
-                    password=password,
-                )
-            except InvalidSecureConfiguration:
-                errors[CONF_KNX_KNXKEY_PASSWORD] = "keyfile_invalid_signature"
-
-            if not errors and keyring:
-                new_entry_data = KNXConfigEntryData(
-                    knxkeys_filename=f"{DOMAIN}/{DEFAULT_KNX_KEYRING_FILENAME}",
-                    knxkeys_password=password,
-                )
-                return self.finish_flow(new_entry_data)
-
-        fields = {
-            vol.Required(CONF_KEYRING_FILE): selector.FileSelector(
-                config=selector.FileSelectorConfig(accept=".knxkeys")
-            ),
-            vol.Required(CONF_KNX_KNXKEY_PASSWORD): selector.TextSelector(),
-        }
-        return self.async_show_form(
-            step_id="secure_knxkeys",
-            data_schema=vol.Schema(fields),
-            description_placeholders=self._async_get_placeholders(),
-            errors=errors,
-        )
-
-    @callback
-    def finish_flow(
-        self, new_entry_data: KNXConfigEntryData
-    ) -> data_entry_flow.FlowResult:
-        """Finish the repair flow. Reload the config entry."""
-        knx_config_entries = self.hass.config_entries.async_entries(DOMAIN)
-        if knx_config_entries:
-            config_entry = knx_config_entries[0]  # single_config_entry
-            new_data = {**config_entry.data, **new_entry_data}
-            self.hass.config_entries.async_update_entry(config_entry, data=new_data)
-            self.hass.config_entries.async_schedule_reload(config_entry.entry_id)
-        return self.async_create_entry(data={})

homeassistant/components/knx/sensor.py

@@ -6,8 +6,8 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from functools import partial
+from typing import Any
 
-from xknx import XKNX
 from xknx.core.connection_state import XknxConnectionState, XknxConnectionType
 from xknx.devices import Device as XknxDevice, Sensor as XknxSensor
 
@@ -25,20 +25,32 @@ from homeassistant.const import (
     CONF_ENTITY_CATEGORY,
     CONF_NAME,
     CONF_TYPE,
+    CONF_UNIT_OF_MEASUREMENT,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     EntityCategory,
     Platform,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    async_get_current_platform,
+)
 from homeassistant.helpers.typing import ConfigType, StateType
 from homeassistant.util.enum import try_parse_enum
 
-from .const import ATTR_SOURCE, KNX_MODULE_KEY
-from .entity import KnxYamlEntity
+from .const import ATTR_SOURCE, CONF_SYNC_STATE, DOMAIN, KNX_MODULE_KEY
+from .dpt import get_supported_dpts
+from .entity import (
+    KnxUiEntity,
+    KnxUiEntityPlatformController,
+    KnxYamlEntity,
+    _KnxEntityBase,
+)
 from .knx_module import KNXModule
 from .schema import SensorSchema
+from .storage.const import CONF_ALWAYS_CALLBACK, CONF_ENTITY, CONF_GA_SENSOR
+from .storage.util import ConfigExtractor
 
 SCAN_INTERVAL = timedelta(seconds=10)
 
@@ -116,58 +128,41 @@ async def async_setup_entry(
     config_entry: config_entries.ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up sensor(s) for KNX platform."""
+    """Set up entities for KNX platform."""
     knx_module = hass.data[KNX_MODULE_KEY]
+    platform = async_get_current_platform()
+    knx_module.config_store.add_platform(
+        platform=Platform.SENSOR,
+        controller=KnxUiEntityPlatformController(
+            knx_module=knx_module,
+            entity_platform=platform,
+            entity_class=KnxUiSensor,
+        ),
+    )
+
     entities: list[SensorEntity] = []
     entities.extend(
         KNXSystemSensor(knx_module, description)
         for description in SYSTEM_ENTITY_DESCRIPTIONS
     )
-    config: list[ConfigType] | None = knx_module.config_yaml.get(Platform.SENSOR)
-    if config:
+    if yaml_platform_config := knx_module.config_yaml.get(Platform.SENSOR):
         entities.extend(
-            KNXSensor(knx_module, entity_config) for entity_config in config
+            KnxYamlSensor(knx_module, entity_config)
+            for entity_config in yaml_platform_config
+        )
+    if ui_config := knx_module.config_store.data["entities"].get(Platform.SENSOR):
+        entities.extend(
+            KnxUiSensor(knx_module, unique_id, config)
+            for unique_id, config in ui_config.items()
         )
     async_add_entities(entities)
 
 
-def _create_sensor(xknx: XKNX, config: ConfigType) -> XknxSensor:
-    """Return a KNX sensor to be used within XKNX."""
-    return XknxSensor(
-        xknx,
-        name=config[CONF_NAME],
-        group_address_state=config[SensorSchema.CONF_STATE_ADDRESS],
-        sync_state=config[SensorSchema.CONF_SYNC_STATE],
-        always_callback=True,
-        value_type=config[CONF_TYPE],
-    )
-
-
-class KNXSensor(KnxYamlEntity, RestoreSensor):
+class _KnxSensor(RestoreSensor, _KnxEntityBase):
     """Representation of a KNX sensor."""
 
     _device: XknxSensor
 
-    def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
-        """Initialize of a KNX sensor."""
-        super().__init__(
-            knx_module=knx_module,
-            device=_create_sensor(knx_module.xknx, config),
-        )
-        if device_class := config.get(CONF_DEVICE_CLASS):
-            self._attr_device_class = device_class
-        else:
-            self._attr_device_class = try_parse_enum(
-                SensorDeviceClass, self._device.ha_device_class()
-            )
-
-        self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.sensor_value.group_address_state)
-        self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
-        self._attr_state_class = config.get(CONF_STATE_CLASS)
-        self._attr_extra_state_attributes = {}
-
     async def async_added_to_hass(self) -> None:
         """Restore last state."""
         if (
@@ -192,6 +187,89 @@ class KNXSensor(KnxYamlEntity, RestoreSensor):
         super().after_update_callback(device)
 
 
+class KnxYamlSensor(_KnxSensor, KnxYamlEntity):
+    """Representation of a KNX sensor configured from YAML."""
+
+    _device: XknxSensor
+
+    def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
+        """Initialize of a KNX sensor."""
+        super().__init__(
+            knx_module=knx_module,
+            device=XknxSensor(
+                knx_module.xknx,
+                name=config[CONF_NAME],
+                group_address_state=config[SensorSchema.CONF_STATE_ADDRESS],
+                sync_state=config[CONF_SYNC_STATE],
+                always_callback=True,
+                value_type=config[CONF_TYPE],
+            ),
+        )
+        if device_class := config.get(CONF_DEVICE_CLASS):
+            self._attr_device_class = device_class
+        else:
+            self._attr_device_class = try_parse_enum(
+                SensorDeviceClass, self._device.ha_device_class()
+            )
+
+        self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
+        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+        self._attr_unique_id = str(self._device.sensor_value.group_address_state)
+        self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
+        self._attr_state_class = config.get(CONF_STATE_CLASS)
+        self._attr_extra_state_attributes = {}
+
+
+class KnxUiSensor(_KnxSensor, KnxUiEntity):
+    """Representation of a KNX sensor configured from the UI."""
+
+    _device: XknxSensor
+
+    def __init__(
+        self, knx_module: KNXModule, unique_id: str, config: dict[str, Any]
+    ) -> None:
+        """Initialize KNX sensor."""
+        super().__init__(
+            knx_module=knx_module,
+            unique_id=unique_id,
+            entity_config=config[CONF_ENTITY],
+        )
+        knx_conf = ConfigExtractor(config[DOMAIN])
+        dpt_string = knx_conf.get_dpt(CONF_GA_SENSOR)
+        assert dpt_string is not None  # required for sensor
+        dpt_info = get_supported_dpts()[dpt_string]
+
+        self._device = XknxSensor(
+            knx_module.xknx,
+            name=config[CONF_ENTITY][CONF_NAME],
+            group_address_state=knx_conf.get_state_and_passive(CONF_GA_SENSOR),
+            sync_state=knx_conf.get(CONF_SYNC_STATE),
+            always_callback=True,
+            value_type=dpt_string,
+        )
+
+        if device_class_override := knx_conf.get(CONF_DEVICE_CLASS):
+            self._attr_device_class = try_parse_enum(
+                SensorDeviceClass, device_class_override
+            )
+        else:
+            self._attr_device_class = dpt_info["sensor_device_class"]
+
+        if state_class_override := knx_conf.get(CONF_STATE_CLASS):
+            self._attr_state_class = try_parse_enum(
+                SensorStateClass, state_class_override
+            )
+        else:
+            self._attr_state_class = dpt_info["sensor_state_class"]
+
+        self._attr_native_unit_of_measurement = (
+            knx_conf.get(CONF_UNIT_OF_MEASUREMENT) or dpt_info["unit"]
+        )
+
+        self._attr_force_update = knx_conf.get(CONF_ALWAYS_CALLBACK, default=False)
+        self._attr_extra_state_attributes = {}
+
+
 class KNXSystemSensor(SensorEntity):
     """Representation of a KNX system sensor."""
 

homeassistant/components/knx/storage/const.py

@@ -65,3 +65,6 @@ CONF_GA_WHITE_BRIGHTNESS: Final = "ga_white_brightness"
 CONF_GA_WHITE_SWITCH: Final = "ga_white_switch"
 CONF_GA_HUE: Final = "ga_hue"
 CONF_GA_SATURATION: Final = "ga_saturation"
+
+# Sensor
+CONF_ALWAYS_CALLBACK: Final = "always_callback"

homeassistant/components/knx/storage/entity_store_schema.py

@@ -5,11 +5,21 @@ from enum import StrEnum, unique
 import voluptuous as vol
 
 from homeassistant.components.climate import HVACMode
+from homeassistant.components.sensor import (
+    CONF_STATE_CLASS as CONF_SENSOR_STATE_CLASS,
+    DEVICE_CLASS_STATE_CLASSES,
+    DEVICE_CLASS_UNITS,
+    STATE_CLASS_UNITS,
+    SensorDeviceClass,
+    SensorStateClass,
+)
 from homeassistant.const import (
+    CONF_DEVICE_CLASS,
     CONF_ENTITY_CATEGORY,
     CONF_ENTITY_ID,
     CONF_NAME,
     CONF_PLATFORM,
+    CONF_UNIT_OF_MEASUREMENT,
     Platform,
 )
 from homeassistant.helpers import config_validation as cv, selector
@@ -30,12 +40,15 @@ from ..const import (
     CoverConf,
     FanZeroMode,
 )
+from ..dpt import get_supported_dpts
 from .const import (
+    CONF_ALWAYS_CALLBACK,
     CONF_COLOR,
     CONF_COLOR_TEMP_MAX,
     CONF_COLOR_TEMP_MIN,
     CONF_DATA,
     CONF_DEVICE_INFO,
+    CONF_DPT,
     CONF_ENTITY,
     CONF_GA_ACTIVE,
     CONF_GA_ANGLE,
@@ -507,6 +520,114 @@ CLIMATE_KNX_SCHEMA = vol.Schema(
     },
 )
 
+
+def _validate_sensor_attributes(config: dict) -> dict:
+    """Validate that state_class is compatible with device_class and unit_of_measurement."""
+    dpt = config[CONF_GA_SENSOR][CONF_DPT]
+    dpt_metadata = get_supported_dpts()[dpt]
+    state_class = config.get(
+        CONF_SENSOR_STATE_CLASS,
+        dpt_metadata["sensor_state_class"],
+    )
+    device_class = config.get(
+        CONF_DEVICE_CLASS,
+        dpt_metadata["sensor_device_class"],
+    )
+    unit_of_measurement = config.get(
+        CONF_UNIT_OF_MEASUREMENT,
+        dpt_metadata["unit"],
+    )
+    if (
+        state_class
+        and device_class
+        and (state_classes := DEVICE_CLASS_STATE_CLASSES.get(device_class)) is not None
+        and state_class not in state_classes
+    ):
+        raise vol.Invalid(
+            f"State class '{state_class}' is not valid for device class '{device_class}'. "
+            f"Valid options are: {', '.join(sorted(map(str, state_classes), key=str.casefold))}",
+            path=[CONF_SENSOR_STATE_CLASS],
+        )
+    if (
+        device_class
+        and (d_c_units := DEVICE_CLASS_UNITS.get(device_class)) is not None
+        and unit_of_measurement not in d_c_units
+    ):
+        raise vol.Invalid(
+            f"Unit of measurement '{unit_of_measurement}' is not valid for device class '{device_class}'. "
+            f"Valid options are: {', '.join(sorted(map(str, d_c_units), key=str.casefold))}",
+            path=(
+                [CONF_DEVICE_CLASS]
+                if CONF_DEVICE_CLASS in config
+                else [CONF_UNIT_OF_MEASUREMENT]
+            ),
+        )
+    if (
+        state_class
+        and (s_c_units := STATE_CLASS_UNITS.get(state_class)) is not None
+        and unit_of_measurement not in s_c_units
+    ):
+        raise vol.Invalid(
+            f"Unit of measurement '{unit_of_measurement}' is not valid for state class '{state_class}'. "
+            f"Valid options are: {', '.join(sorted(map(str, s_c_units), key=str.casefold))}",
+            path=(
+                [CONF_SENSOR_STATE_CLASS]
+                if CONF_SENSOR_STATE_CLASS in config
+                else [CONF_UNIT_OF_MEASUREMENT]
+            ),
+        )
+    return config
+
+
+SENSOR_KNX_SCHEMA = AllSerializeFirst(
+    vol.Schema(
+        {
+            vol.Required(CONF_GA_SENSOR): GASelector(
+                write=False, state_required=True, dpt=["numeric", "string"]
+            ),
+            "section_advanced_options": KNXSectionFlat(collapsible=True),
+            vol.Optional(CONF_UNIT_OF_MEASUREMENT): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=sorted(
+                        {
+                            str(unit)
+                            for units in DEVICE_CLASS_UNITS.values()
+                            for unit in units
+                            if unit is not None
+                        }
+                    ),
+                    mode=selector.SelectSelectorMode.DROPDOWN,
+                    translation_key="component.knx.selector.sensor_unit_of_measurement",
+                    custom_value=True,
+                ),
+            ),
+            vol.Optional(CONF_DEVICE_CLASS): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=[
+                        cls.value
+                        for cls in SensorDeviceClass
+                        if cls != SensorDeviceClass.ENUM
+                    ],
+                    translation_key="component.knx.selector.sensor_device_class",
+                    sort=True,
+                )
+            ),
+            vol.Optional(CONF_SENSOR_STATE_CLASS): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=list(SensorStateClass),
+                    translation_key="component.knx.selector.sensor_state_class",
+                    mode=selector.SelectSelectorMode.DROPDOWN,
+                )
+            ),
+            vol.Optional(CONF_ALWAYS_CALLBACK): selector.BooleanSelector(),
+            vol.Required(CONF_SYNC_STATE, default=True): SyncStateSelector(
+                allow_false=True
+            ),
+        },
+    ),
+    _validate_sensor_attributes,
+)
+
 KNX_SCHEMA_FOR_PLATFORM = {
     Platform.BINARY_SENSOR: BINARY_SENSOR_KNX_SCHEMA,
     Platform.CLIMATE: CLIMATE_KNX_SCHEMA,
@@ -514,6 +635,7 @@ KNX_SCHEMA_FOR_PLATFORM = {
     Platform.DATE: DATE_KNX_SCHEMA,
     Platform.DATETIME: DATETIME_KNX_SCHEMA,
     Platform.LIGHT: LIGHT_KNX_SCHEMA,
+    Platform.SENSOR: SENSOR_KNX_SCHEMA,
     Platform.SWITCH: SWITCH_KNX_SCHEMA,
     Platform.TIME: TIME_KNX_SCHEMA,
 }

homeassistant/components/knx/storage/keyring.py

@@ -10,10 +10,9 @@ from xknx.secure.keyring import Keyring, sync_load_keyring
 
 from homeassistant.components.file_upload import process_uploaded_file
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.storage import STORAGE_DIR
 
-from ..const import DOMAIN, REPAIR_ISSUE_DATA_SECURE_GROUP_KEY
+from ..const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,11 +45,4 @@ async def save_uploaded_knxkeys_file(
             shutil.move(file_path, dest_file)
         return keyring
 
-    keyring = await hass.async_add_executor_job(_process_upload)
-
-    # If there is an existing DataSecure group key issue, remove it.
-    # GAs might not be DataSecure anymore after uploading a valid keyring,
-    # if they are, we raise the issue again when receiving a telegram.
-    ir.async_delete_issue(hass, DOMAIN, REPAIR_ISSUE_DATA_SECURE_GROUP_KEY)
-
-    return keyring
+    return await hass.async_add_executor_job(_process_upload)

homeassistant/components/knx/storage/knx_selector.py

@@ -6,6 +6,7 @@ from typing import Any
 
 import voluptuous as vol
 
+from ..dpt import HaDptClass, get_supported_dpts
 from ..validation import ga_validator, maybe_ga_validator, sync_state_validator
 from .const import CONF_DPT, CONF_GA_PASSIVE, CONF_GA_STATE, CONF_GA_WRITE
 from .util import dpt_string_to_dict
@@ -162,7 +163,7 @@ class GASelector(KNXSelectorBase):
         passive: bool = True,
         write_required: bool = False,
         state_required: bool = False,
-        dpt: type[Enum] | None = None,
+        dpt: type[Enum] | list[HaDptClass] | None = None,
         valid_dpt: str | Iterable[str] | None = None,
     ) -> None:
         """Initialize the group address selector."""
@@ -186,14 +187,17 @@ class GASelector(KNXSelectorBase):
             "passive": self.passive,
         }
         if self.dpt is not None:
-            options["dptSelect"] = [
-                {
-                    "value": item.value,
-                    "translation_key": item.value.replace(".", "_"),
-                    "dpt": dpt_string_to_dict(item.value),  # used for filtering GAs
-                }
-                for item in self.dpt
-            ]
+            if isinstance(self.dpt, list):
+                options["dptClasses"] = self.dpt
+            else:
+                options["dptSelect"] = [
+                    {
+                        "value": item.value,
+                        "translation_key": item.value.replace(".", "_"),
+                        "dpt": dpt_string_to_dict(item.value),  # used for filtering GAs
+                    }
+                    for item in self.dpt
+                ]
         if self.valid_dpt is not None:
             options["validDPTs"] = [dpt_string_to_dict(dpt) for dpt in self.valid_dpt]
 
@@ -254,7 +258,12 @@ class GASelector(KNXSelectorBase):
     def _add_dpt(self, schema: dict[vol.Marker, Any]) -> None:
         """Add DPT validator to the schema."""
         if self.dpt is not None:
-            schema[vol.Required(CONF_DPT)] = vol.In({item.value for item in self.dpt})
+            if isinstance(self.dpt, list):
+                schema[vol.Required(CONF_DPT)] = vol.In(get_supported_dpts())
+            else:
+                schema[vol.Required(CONF_DPT)] = vol.In(
+                    {item.value for item in self.dpt}
+                )
         else:
             schema[vol.Remove(CONF_DPT)] = object
 

homeassistant/components/knx/strings.json

@@ -558,6 +558,35 @@
             }
           }
         },
+        "sensor": {
+          "description": "Read-only entity for numeric or string datapoints. Temperature, percent etc.",
+          "knx": {
+            "always_callback": {
+              "description": "Write each update to the state machine, even if the data is the same.",
+              "label": "Force update"
+            },
+            "device_class": {
+              "description": "Override the DPTs default device class.",
+              "label": "Device class"
+            },
+            "ga_sensor": {
+              "description": "Group address representing state.",
+              "label": "State"
+            },
+            "section_advanced_options": {
+              "description": "Override default DPT-based sensor attributes.",
+              "title": "Overrides"
+            },
+            "state_class": {
+              "description": "Override the DPTs default state class.",
+              "label": "[%key:component::sensor::entity_component::_::state_attributes::state_class::name%]"
+            },
+            "unit_of_measurement": {
+              "description": "Override the DPTs default unit of measurement.",
+              "label": "Unit of measurement"
+            }
+          }
+        },
         "switch": {
           "description": "The KNX switch platform is used as an interface to switching actuators.",
           "knx": {
@@ -671,30 +700,6 @@
       "message": "Invalid type for `knx.send` service: {type}"
     }
   },
-  "issues": {
-    "data_secure_group_key_issue": {
-      "fix_flow": {
-        "error": {
-          "keyfile_invalid_signature": "[%key:component::knx::config::error::keyfile_invalid_signature%]"
-        },
-        "step": {
-          "secure_knxkeys": {
-            "data": {
-              "knxkeys_file": "[%key:component::knx::config::step::secure_knxkeys::data::knxkeys_file%]",
-              "knxkeys_password": "[%key:component::knx::config::step::secure_knxkeys::data::knxkeys_password%]"
-            },
-            "data_description": {
-              "knxkeys_file": "[%key:component::knx::config::step::secure_knxkeys::data_description::knxkeys_file%]",
-              "knxkeys_password": "[%key:component::knx::config::step::secure_knxkeys::data_description::knxkeys_password%]"
-            },
-            "description": "Telegrams for group addresses used in Home Assistant could not be decrypted because Data Secure keys are missing or invalid:\n\n{addresses}\n\nTo fix this, update the sending devices configurations via ETS and provide an updated KNX Keyring file. Make sure that the group addresses used in Home Assistant are associated with the interface used by Home Assistant (`{interface}` when the issue last occurred).",
-            "title": "Update KNX Keyring"
-          }
-        }
-      },
-      "title": "KNX Data Secure telegrams can't be decrypted"
-    }
-  },
   "options": {
     "step": {
       "communication_settings": {
@@ -712,6 +717,85 @@
       }
     }
   },
+  "selector": {
+    "dpt": {
+      "fields": {
+        "label": "Select a datapoint type",
+        "no_selection": "No DPT selected"
+      }
+    },
+    "sensor_device_class": {
+      "options": {
+        "absolute_humidity": "[%key:component::sensor::entity_component::absolute_humidity::name%]",
+        "apparent_power": "[%key:component::sensor::entity_component::apparent_power::name%]",
+        "aqi": "[%key:component::sensor::entity_component::aqi::name%]",
+        "area": "[%key:component::sensor::entity_component::area::name%]",
+        "atmospheric_pressure": "[%key:component::sensor::entity_component::atmospheric_pressure::name%]",
+        "battery": "[%key:component::sensor::entity_component::battery::name%]",
+        "blood_glucose_concentration": "[%key:component::sensor::entity_component::blood_glucose_concentration::name%]",
+        "carbon_dioxide": "[%key:component::sensor::entity_component::carbon_dioxide::name%]",
+        "carbon_monoxide": "[%key:component::sensor::entity_component::carbon_monoxide::name%]",
+        "conductivity": "[%key:component::sensor::entity_component::conductivity::name%]",
+        "current": "[%key:component::sensor::entity_component::current::name%]",
+        "data_rate": "[%key:component::sensor::entity_component::data_rate::name%]",
+        "data_size": "[%key:component::sensor::entity_component::data_size::name%]",
+        "date": "[%key:component::sensor::entity_component::date::name%]",
+        "distance": "[%key:component::sensor::entity_component::distance::name%]",
+        "duration": "[%key:component::sensor::entity_component::duration::name%]",
+        "energy": "[%key:component::sensor::entity_component::energy::name%]",
+        "energy_distance": "[%key:component::sensor::entity_component::energy_distance::name%]",
+        "energy_storage": "[%key:component::sensor::entity_component::energy_storage::name%]",
+        "frequency": "[%key:component::sensor::entity_component::frequency::name%]",
+        "gas": "[%key:component::sensor::entity_component::gas::name%]",
+        "humidity": "[%key:component::sensor::entity_component::humidity::name%]",
+        "illuminance": "[%key:component::sensor::entity_component::illuminance::name%]",
+        "irradiance": "[%key:component::sensor::entity_component::irradiance::name%]",
+        "moisture": "[%key:component::sensor::entity_component::moisture::name%]",
+        "monetary": "[%key:component::sensor::entity_component::monetary::name%]",
+        "nitrogen_dioxide": "[%key:component::sensor::entity_component::nitrogen_dioxide::name%]",
+        "nitrogen_monoxide": "[%key:component::sensor::entity_component::nitrogen_monoxide::name%]",
+        "nitrous_oxide": "[%key:component::sensor::entity_component::nitrous_oxide::name%]",
+        "ozone": "[%key:component::sensor::entity_component::ozone::name%]",
+        "ph": "[%key:component::sensor::entity_component::ph::name%]",
+        "pm1": "[%key:component::sensor::entity_component::pm1::name%]",
+        "pm10": "[%key:component::sensor::entity_component::pm10::name%]",
+        "pm25": "[%key:component::sensor::entity_component::pm25::name%]",
+        "pm4": "[%key:component::sensor::entity_component::pm4::name%]",
+        "power": "[%key:component::sensor::entity_component::power::name%]",
+        "power_factor": "[%key:component::sensor::entity_component::power_factor::name%]",
+        "precipitation": "[%key:component::sensor::entity_component::precipitation::name%]",
+        "precipitation_intensity": "[%key:component::sensor::entity_component::precipitation_intensity::name%]",
+        "pressure": "[%key:component::sensor::entity_component::pressure::name%]",
+        "reactive_energy": "[%key:component::sensor::entity_component::reactive_energy::name%]",
+        "reactive_power": "[%key:component::sensor::entity_component::reactive_power::name%]",
+        "signal_strength": "[%key:component::sensor::entity_component::signal_strength::name%]",
+        "sound_pressure": "[%key:component::sensor::entity_component::sound_pressure::name%]",
+        "speed": "[%key:component::sensor::entity_component::speed::name%]",
+        "sulphur_dioxide": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]",
+        "temperature": "[%key:component::sensor::entity_component::temperature::name%]",
+        "temperature_delta": "[%key:component::sensor::entity_component::temperature_delta::name%]",
+        "timestamp": "[%key:component::sensor::entity_component::timestamp::name%]",
+        "volatile_organic_compounds": "[%key:component::sensor::entity_component::volatile_organic_compounds::name%]",
+        "volatile_organic_compounds_parts": "[%key:component::sensor::entity_component::volatile_organic_compounds_parts::name%]",
+        "voltage": "[%key:component::sensor::entity_component::voltage::name%]",
+        "volume": "[%key:component::sensor::entity_component::volume::name%]",
+        "volume_flow_rate": "[%key:component::sensor::entity_component::volume_flow_rate::name%]",
+        "volume_storage": "[%key:component::sensor::entity_component::volume_storage::name%]",
+        "water": "[%key:component::sensor::entity_component::water::name%]",
+        "weight": "[%key:component::sensor::entity_component::weight::name%]",
+        "wind_direction": "[%key:component::sensor::entity_component::wind_direction::name%]",
+        "wind_speed": "[%key:component::sensor::entity_component::wind_speed::name%]"
+      }
+    },
+    "sensor_state_class": {
+      "options": {
+        "measurement": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::measurement%]",
+        "measurement_angle": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::measurement_angle%]",
+        "total": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total%]",
+        "total_increasing": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total_increasing%]"
+      }
+    }
+  },
   "services": {
     "event_register": {
       "description": "Adds or removes group addresses to knx_event filter for triggering `knx_event`s. Only addresses added with this action can be removed.",

homeassistant/components/knx/telegrams.py

@@ -26,9 +26,6 @@ STORAGE_KEY: Final = f"{DOMAIN}/telegrams_history.json"
 
 # dispatcher signal for KNX interface device triggers
 SIGNAL_KNX_TELEGRAM: SignalType[Telegram, TelegramDict] = SignalType("knx_telegram")
-SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM: SignalType[Telegram, TelegramDict] = SignalType(
-    "knx_data_secure_issue_telegram"
-)
 
 
 class DecodedTelegramPayload(TypedDict):
@@ -77,11 +74,6 @@ class Telegrams:
                 match_for_outgoing=True,
             )
         )
-        self._xknx_data_secure_group_key_issue_cb_handle = (
-            xknx.telegram_queue.register_data_secure_group_key_issue_cb(
-                self._xknx_data_secure_group_key_issue_cb,
-            )
-        )
         self.recent_telegrams: deque[TelegramDict] = deque(maxlen=log_size)
         self.last_ga_telegrams: dict[str, TelegramDict] = {}
 
@@ -115,14 +107,6 @@ class Telegrams:
             self.last_ga_telegrams[telegram_dict["destination"]] = telegram_dict
         async_dispatcher_send(self.hass, SIGNAL_KNX_TELEGRAM, telegram, telegram_dict)
 
-    def _xknx_data_secure_group_key_issue_cb(self, telegram: Telegram) -> None:
-        """Handle telegrams with undecodable data secure payload from xknx."""
-        telegram_dict = self.telegram_to_dict(telegram)
-        self.recent_telegrams.append(telegram_dict)
-        async_dispatcher_send(
-            self.hass, SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM, telegram, telegram_dict
-        )
-
     def telegram_to_dict(self, telegram: Telegram) -> TelegramDict:
         """Convert a Telegram to a dict."""
         dst_name = ""

homeassistant/components/knx/websocket.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from contextlib import ExitStack
 from functools import wraps
 import inspect
 from typing import TYPE_CHECKING, Any, Final, overload
@@ -23,6 +22,7 @@ from homeassistant.helpers.typing import UNDEFINED
 from homeassistant.util.ulid import ulid_now
 
 from .const import DOMAIN, KNX_MODULE_KEY, SUPPORTED_PLATFORMS_UI
+from .dpt import get_supported_dpts
 from .storage.config_store import ConfigStoreException
 from .storage.const import CONF_DATA
 from .storage.entity_store_schema import (
@@ -35,11 +35,7 @@ from .storage.entity_store_validation import (
     validate_entity_data,
 )
 from .storage.serialize import get_serialized_schema
-from .telegrams import (
-    SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM,
-    SIGNAL_KNX_TELEGRAM,
-    TelegramDict,
-)
+from .telegrams import SIGNAL_KNX_TELEGRAM, TelegramDict
 
 if TYPE_CHECKING:
     from .knx_module import KNXModule
@@ -191,6 +187,7 @@ def ws_get_base_data(
         msg["id"],
         {
             "connection_info": connection_info,
+            "dpt_metadata": get_supported_dpts(),
             "project_info": _project_info,
             "supported_platforms": sorted(SUPPORTED_PLATFORMS_UI),
         },
@@ -339,23 +336,11 @@ def ws_subscribe_telegram(
             telegram_dict,
         )
 
-    stack = ExitStack()
-    stack.callback(
-        async_dispatcher_connect(
-            hass,
-            signal=SIGNAL_KNX_TELEGRAM,
-            target=forward_telegram,
-        )
+    connection.subscriptions[msg["id"]] = async_dispatcher_connect(
+        hass,
+        signal=SIGNAL_KNX_TELEGRAM,
+        target=forward_telegram,
     )
-    stack.callback(
-        async_dispatcher_connect(
-            hass,
-            signal=SIGNAL_KNX_DATA_SECURE_ISSUE_TELEGRAM,
-            target=forward_telegram,
-        )
-    )
-
-    connection.subscriptions[msg["id"]] = stack.close
     connection.send_result(msg["id"])
 
 

homeassistant/components/labs/__init__.py

@@ -7,11 +7,10 @@ in the Home Assistant Labs UI for users to enable or disable.
 
 from __future__ import annotations
 
-from collections.abc import Callable
 import logging
 
 from homeassistant.const import EVENT_LABS_UPDATED
-from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.generated.labs import LABS_PREVIEW_FEATURES
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.storage import Store
@@ -19,6 +18,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import async_get_custom_components
 
 from .const import DOMAIN, LABS_DATA, STORAGE_KEY, STORAGE_VERSION
+from .helpers import async_is_preview_feature_enabled, async_listen
 from .models import (
     EventLabsUpdatedData,
     LabPreviewFeature,
@@ -135,55 +135,3 @@ async def _async_scan_all_preview_features(
 
     _LOGGER.debug("Loaded %d total lab preview features", len(preview_features))
     return preview_features
-
-
-@callback
-def async_is_preview_feature_enabled(
-    hass: HomeAssistant, domain: str, preview_feature: str
-) -> bool:
-    """Check if a lab preview feature is enabled.
-
-    Args:
-        hass: HomeAssistant instance
-        domain: Integration domain
-        preview_feature: Preview feature name
-
-    Returns:
-        True if the preview feature is enabled, False otherwise
-    """
-    if LABS_DATA not in hass.data:
-        return False
-
-    labs_data = hass.data[LABS_DATA]
-    return (domain, preview_feature) in labs_data.data.preview_feature_status
-
-
-@callback
-def async_listen(
-    hass: HomeAssistant,
-    domain: str,
-    preview_feature: str,
-    listener: Callable[[], None],
-) -> Callable[[], None]:
-    """Listen for changes to a specific preview feature.
-
-    Args:
-        hass: HomeAssistant instance
-        domain: Integration domain
-        preview_feature: Preview feature name
-        listener: Callback to invoke when the preview feature is toggled
-
-    Returns:
-        Callable to unsubscribe from the listener
-    """
-
-    @callback
-    def _async_feature_updated(event: Event[EventLabsUpdatedData]) -> None:
-        """Handle labs feature update event."""
-        if (
-            event.data["domain"] == domain
-            and event.data["preview_feature"] == preview_feature
-        ):
-            listener()
-
-    return hass.bus.async_listen(EVENT_LABS_UPDATED, _async_feature_updated)

homeassistant/components/labs/helpers.py

@@ -0,0 +1,63 @@
+"""Helper functions for the Home Assistant Labs integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from homeassistant.const import EVENT_LABS_UPDATED
+from homeassistant.core import Event, HomeAssistant, callback
+
+from .const import LABS_DATA
+from .models import EventLabsUpdatedData
+
+
+@callback
+def async_is_preview_feature_enabled(
+    hass: HomeAssistant, domain: str, preview_feature: str
+) -> bool:
+    """Check if a lab preview feature is enabled.
+
+    Args:
+        hass: HomeAssistant instance
+        domain: Integration domain
+        preview_feature: Preview feature name
+
+    Returns:
+        True if the preview feature is enabled, False otherwise
+    """
+    if LABS_DATA not in hass.data:
+        return False
+
+    labs_data = hass.data[LABS_DATA]
+    return (domain, preview_feature) in labs_data.data.preview_feature_status
+
+
+@callback
+def async_listen(
+    hass: HomeAssistant,
+    domain: str,
+    preview_feature: str,
+    listener: Callable[[], None],
+) -> Callable[[], None]:
+    """Listen for changes to a specific preview feature.
+
+    Args:
+        hass: HomeAssistant instance
+        domain: Integration domain
+        preview_feature: Preview feature name
+        listener: Callback to invoke when the preview feature is toggled
+
+    Returns:
+        Callable to unsubscribe from the listener
+    """
+
+    @callback
+    def _async_feature_updated(event: Event[EventLabsUpdatedData]) -> None:
+        """Handle labs feature update event."""
+        if (
+            event.data["domain"] == domain
+            and event.data["preview_feature"] == preview_feature
+        ):
+            listener()
+
+    return hass.bus.async_listen(EVENT_LABS_UPDATED, _async_feature_updated)

homeassistant/components/labs/websocket_api.py

@@ -12,6 +12,7 @@ from homeassistant.const import EVENT_LABS_UPDATED
 from homeassistant.core import HomeAssistant, callback
 
 from .const import LABS_DATA
+from .helpers import async_is_preview_feature_enabled, async_listen
 from .models import EventLabsUpdatedData
 
 
@@ -20,6 +21,7 @@ def async_setup(hass: HomeAssistant) -> None:
     """Set up the number websocket API."""
     websocket_api.async_register_command(hass, websocket_list_preview_features)
     websocket_api.async_register_command(hass, websocket_update_preview_feature)
+    websocket_api.async_register_command(hass, websocket_subscribe_feature)
 
 
 @callback
@@ -108,3 +110,52 @@ async def websocket_update_preview_feature(
     hass.bus.async_fire(EVENT_LABS_UPDATED, event_data)
 
     connection.send_result(msg["id"])
+
+
+@callback
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "labs/subscribe",
+        vol.Required("domain"): str,
+        vol.Required("preview_feature"): str,
+    }
+)
+def websocket_subscribe_feature(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to a specific lab preview feature updates."""
+    domain = msg["domain"]
+    preview_feature_key = msg["preview_feature"]
+    labs_data = hass.data[LABS_DATA]
+
+    preview_feature_id = f"{domain}.{preview_feature_key}"
+
+    if preview_feature_id not in labs_data.preview_features:
+        connection.send_error(
+            msg["id"],
+            websocket_api.ERR_NOT_FOUND,
+            f"Preview feature {preview_feature_id} not found",
+        )
+        return
+
+    preview_feature = labs_data.preview_features[preview_feature_id]
+
+    @callback
+    def send_event() -> None:
+        """Send feature state to client."""
+        enabled = async_is_preview_feature_enabled(hass, domain, preview_feature_key)
+        connection.send_message(
+            websocket_api.event_message(
+                msg["id"],
+                preview_feature.to_dict(enabled=enabled),
+            )
+        )
+
+    connection.subscriptions[msg["id"]] = async_listen(
+        hass, domain, preview_feature_key, send_event
+    )
+
+    connection.send_result(msg["id"])
+    send_event()

homeassistant/components/lametric/services.py

@@ -108,6 +108,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
         SERVICE_MESSAGE,
         _async_service_message,
         schema=SERVICE_MESSAGE_SCHEMA,
+        description_placeholders={"icons_url": "https://developer.lametric.com/icons"},
     )
 
 

homeassistant/components/lametric/strings.json

@@ -211,7 +211,7 @@
           "name": "[%key:common::config_flow::data::device%]"
         },
         "icon": {
-          "description": "The ID number of the icon or animation to display. List of all icons and their IDs can be found at: https://developer.lametric.com/icons.",
+          "description": "The ID number of the icon or animation to display. List of all icons and their IDs can be found at: {icons_url}.",
           "name": "Icon ID"
         },
         "icon_type": {

homeassistant/components/light/condition.py

@@ -52,7 +52,7 @@ class StateConditionBase(Condition):
         self, hass: HomeAssistant, config: ConditionConfig, state: str
     ) -> None:
         """Initialize condition."""
-        self._hass = hass
+        super().__init__(hass, config)
         if TYPE_CHECKING:
             assert config.target
             assert config.options

homeassistant/components/matter/icons.json

@@ -86,6 +86,12 @@
       "current_phase": {
         "default": "mdi:state-machine"
       },
+      "door_closed_events": {
+        "default": "mdi:door-closed"
+      },
+      "door_open_events": {
+        "default": "mdi:door-open"
+      },
       "esa_opt_out_state": {
         "default": "mdi:home-lightning-bolt"
       },

homeassistant/components/matter/sensor.py

@@ -1488,4 +1488,30 @@ DISCOVERY_SCHEMAS = [
         entity_class=MatterSensor,
         required_attributes=(clusters.ServiceArea.Attributes.EstimatedEndTime,),
     ),
+    MatterDiscoverySchema(
+        platform=Platform.SENSOR,
+        entity_description=MatterSensorEntityDescription(
+            key="DoorLockDoorOpenEvents",
+            translation_key="door_open_events",
+            entity_category=EntityCategory.DIAGNOSTIC,
+            entity_registry_enabled_default=False,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+        ),
+        entity_class=MatterSensor,
+        required_attributes=(clusters.DoorLock.Attributes.DoorOpenEvents,),
+        featuremap_contains=clusters.DoorLock.Bitmaps.Feature.kDoorPositionSensor,
+    ),
+    MatterDiscoverySchema(
+        platform=Platform.SENSOR,
+        entity_description=MatterSensorEntityDescription(
+            key="DoorLockDoorClosedEvents",
+            translation_key="door_closed_events",
+            entity_category=EntityCategory.DIAGNOSTIC,
+            entity_registry_enabled_default=False,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+        ),
+        entity_class=MatterSensor,
+        required_attributes=(clusters.DoorLock.Attributes.DoorClosedEvents,),
+        featuremap_contains=clusters.DoorLock.Bitmaps.Feature.kDoorPositionSensor,
+    ),
 ]

homeassistant/components/matter/strings.json

@@ -375,6 +375,12 @@
       "current_phase": {
         "name": "Current phase"
       },
+      "door_closed_events": {
+        "name": "Door closed events"
+      },
+      "door_open_events": {
+        "name": "Door open events"
+      },
       "energy_exported": {
         "name": "Energy exported"
       },

homeassistant/components/music_assistant/quality_scale.yaml

@@ -30,9 +30,7 @@ rules:
   integration-owner: done
   log-when-unavailable: todo
   parallel-updates: todo
-  reauthentication-flow:
-    status: exempt
-    comment: Devices don't require authentication
+  reauthentication-flow: done
   test-coverage: todo
 
   # Gold

homeassistant/components/ntfy/notify.py

@@ -81,6 +81,9 @@ async def async_setup_entry(
         SERVICE_PUBLISH,
         SERVICE_PUBLISH_SCHEMA,
         "publish",
+        description_placeholders={
+            "markdown_guide_url": "https://www.markdownguide.org/basic-syntax/"
+        },
     )
 
 

homeassistant/components/ntfy/strings.json

@@ -345,7 +345,7 @@
           "name": "Icon URL"
         },
         "markdown": {
-          "description": "Enable Markdown formatting for the message body. See the Markdown guide for syntax details: https://www.markdownguide.org/basic-syntax/.",
+          "description": "Enable Markdown formatting for the message body. See the Markdown guide for syntax details: {markdown_guide_url}.",
           "name": "Format as Markdown"
         },
         "message": {

homeassistant/components/onedrive/services.py

@@ -129,4 +129,5 @@ def async_setup_services(hass: HomeAssistant) -> None:
         async_handle_upload,
         schema=UPLOAD_SERVICE_SCHEMA,
         supports_response=SupportsResponse.OPTIONAL,
+        description_placeholders={"example_image_path": "/config/www/image.jpg"},
     )

homeassistant/components/onedrive/strings.json

@@ -156,7 +156,7 @@
         },
         "filename": {
           "description": "Path to the file to upload.",
-          "example": "/config/www/image.jpg",
+          "example": "{example_image_path}",
           "name": "Filename"
         }
       },

homeassistant/components/oralb/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["oralb_ble"],
-  "requirements": ["oralb-ble==0.17.6"]
+  "requirements": ["oralb-ble==1.0.2"]
 }

homeassistant/components/pilight/__init__.py

@@ -25,6 +25,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import track_point_in_utc_time
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
+from homeassistant.util.async_ import run_callback_threadsafe
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -101,7 +102,18 @@ def setup(hass: HomeAssistant, config: ConfigType) -> bool:
         except OSError:
             _LOGGER.error("Pilight send failed for %s", str(message_data))
 
-    hass.services.register(DOMAIN, SERVICE_NAME, send_code, schema=RF_CODE_SCHEMA)
+    def _register_service() -> None:
+        hass.services.async_register(
+            DOMAIN,
+            SERVICE_NAME,
+            send_code,
+            schema=RF_CODE_SCHEMA,
+            description_placeholders={
+                "pilight_protocols_docs_url": "https://manual.pilight.org/protocols/index.html"
+            },
+        )
+
+    run_callback_threadsafe(hass.loop, _register_service).result()
 
     # Publish received codes on the HA event bus
     # A whitelist of codes to be published in the event bus

homeassistant/components/pilight/strings.json

@@ -4,7 +4,7 @@
       "description": "Sends RF code to Pilight device.",
       "fields": {
         "protocol": {
-          "description": "Protocol that Pilight recognizes. See https://manual.pilight.org/protocols/index.html for supported protocols and additional parameters that each protocol supports.",
+          "description": "Protocol that Pilight recognizes. See {pilight_protocols_docs_url} for supported protocols and additional parameters that each protocol supports.",
           "name": "Protocol"
         }
       },

homeassistant/components/ping/helpers.py

@@ -64,10 +64,11 @@ class PingDataICMPLib(PingData):
             return
 
         _LOGGER.debug(
-            "async_ping returned: reachable=%s sent=%i received=%s",
+            "async_ping returned: reachable=%s sent=%i received=%s loss=%s",
             data.is_alive,
             data.packets_sent,
             data.packets_received,
+            data.packet_loss * 100,
         )
 
         self.is_alive = data.is_alive
@@ -80,6 +81,7 @@ class PingDataICMPLib(PingData):
             "max": data.max_rtt,
             "avg": data.avg_rtt,
             "jitter": data.jitter,
+            "loss": data.packet_loss * 100,
         }