Disable instead of fixing in lg_thinq

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/check-requirements.lock.yml

@@ -36,7 +36,7 @@
 #   - actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
 #   - actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
 #   - actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-#   - github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+#   - github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
 #
 # Container images used:
 #   - ghcr.io/github/gh-aw-firewall/agent:0.25.46
@@ -90,7 +90,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -352,7 +352,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -961,7 +961,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1100,7 +1100,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1325,7 +1325,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1383,7 +1383,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}

.github/workflows/wheels.yml

@@ -137,7 +137,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
@@ -195,7 +195,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.14
+    rev: v0.15.15
     hooks:
       - id: ruff-check
         args:

homeassistant/components/airvisual_pro/entity.py

@@ -1,6 +1,10 @@
 """The AirVisual Pro integration."""
 
-from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.device_registry import (
+    CONNECTION_NETWORK_MAC,
+    DeviceInfo,
+    format_mac,
+)
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -25,6 +29,12 @@ class AirVisualProEntity(CoordinatorEntity[AirVisualProCoordinator]):
         """Return device registry information for this entity."""
         return DeviceInfo(
             identifiers={(DOMAIN, self.coordinator.data["serial_number"])},
+            connections={
+                (
+                    CONNECTION_NETWORK_MAC,
+                    format_mac(self.coordinator.data["status"]["mac_address"]),
+                )
+            },
             manufacturer="AirVisual",
             model=self.coordinator.data["status"]["model"],
             name=self.coordinator.data["settings"]["node_name"],

homeassistant/components/api/__init__.py

@@ -59,7 +59,6 @@ ATTR_EXTERNAL_URL = "external_url"
 ATTR_INTERNAL_URL = "internal_url"
 ATTR_LOCATION_NAME = "location_name"
 ATTR_INSTALLATION_TYPE = "installation_type"
-ATTR_REQUIRES_API_PASSWORD = "requires_api_password"
 ATTR_UUID = "uuid"
 ATTR_VERSION = "version"
 
@@ -222,7 +221,7 @@ class APIStatesView(HomeAssistantView):
             states = (
                 state.as_dict_json
                 for state in hass.states.async_all()
-                if entity_perm(state.entity_id, "read")
+                if entity_perm(state.entity_id, POLICY_READ)
             )
         response = web.Response(
             body=b"".join((b"[", b",".join(states), b"]")),
@@ -294,8 +293,10 @@ class APIEntityStateView(HomeAssistantView):
 
         # Read the state back for our response
         status_code = HTTPStatus.CREATED if is_new_state else HTTPStatus.OK
-        state = hass.states.get(entity_id)
-        assert state
+        if (state := hass.states.get(entity_id)) is None:
+            return self.json_message(
+                "Error storing state.", HTTPStatus.INTERNAL_SERVER_ERROR
+            )
         resp = self.json(state.as_dict(), status_code)
 
         resp.headers.add("Location", f"/api/states/{entity_id}")

homeassistant/components/assist_satellite/__init__.py

@@ -5,6 +5,8 @@ import logging
 from pathlib import Path
 from typing import Any
 
+from hassil.parse_expression import parse_sentence
+from hassil.parser import ParseError
 from hassil.util import (
     PUNCTUATION_END,
     PUNCTUATION_END_WORD,
@@ -164,6 +166,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                             [cv.string],
                             has_one_non_empty_item,
                             has_no_punctuation,
+                            is_valid_sentence,
                         ),
                     }
                 ],
@@ -212,6 +215,17 @@ def has_no_punctuation(value: list[str]) -> list[str]:
     return value
 
 
+def is_valid_sentence(value: list[str]) -> list[str]:
+    """Validate result can be parsed by hassil."""
+    for sentence in value:
+        try:
+            parse_sentence(sentence)
+        except ParseError as err:
+            raise vol.Invalid(f"invalid sentence: {err}") from err
+
+    return value
+
+
 def has_one_non_empty_item(value: list[str]) -> list[str]:
     """Validate result has at least one item."""
     if len(value) < 1:

homeassistant/components/assist_satellite/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/assist_satellite",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0"]
+  "requirements": ["hassil==3.6.0"]
 }

homeassistant/components/blebox/binary_sensor.py

@@ -21,6 +21,10 @@ BINARY_SENSOR_TYPES = (
         key="moisture",
         device_class=BinarySensorDeviceClass.MOISTURE,
     ),
+    BinarySensorEntityDescription(
+        key="open",
+        device_class=BinarySensorDeviceClass.WINDOW,
+    ),
 )
 
 

homeassistant/components/blebox/const.py

@@ -14,6 +14,13 @@ UNKNOWN = "unknown"
 DEFAULT_HOST = "192.168.0.2"
 DEFAULT_PORT = 80
 
+OPEN_STATUS: dict[int, str] = {
+    0: "open",
+    1: "unclosed_or_unlocked",
+    2: "ajar",
+    3: "closed_but_unlocked",
+    4: "closed",
+}
 
 LIGHT_MAX_KELVINS = 6500  # 154 Mireds
 LIGHT_MIN_KELVINS = 2700  # 370 Mireds

homeassistant/components/blebox/coordinator.py

@@ -43,6 +43,6 @@ class BleBoxCoordinator(DataUpdateCoordinator[None]):
         except Error as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
-                translation_key="update_failed",
+                translation_key="data_update_failed",
                 translation_placeholders={"error": str(err)},
             ) from err

homeassistant/components/blebox/diagnostics.py

@@ -0,0 +1,33 @@
+"""Diagnostics support for BleBox devices."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from . import BleBoxConfigEntry
+
+TO_REDACT = {CONF_PASSWORD, CONF_USERNAME}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: BleBoxConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    product = entry.runtime_data.box
+
+    return {
+        "entry": async_redact_data(entry.as_dict(), TO_REDACT),
+        "device": {
+            "name": product.name,
+            "type": product.type,
+            "model": product.model,
+            "unique_id": product.unique_id,
+            "firmware_version": product.firmware_version,
+            "hardware_version": product.hardware_version,
+            "available_firmware_version": product.available_firmware_version,
+            "api_version": product.api_version,
+            "last_data": product.last_data,
+        },
+    }

homeassistant/components/blebox/light.py

@@ -19,10 +19,11 @@ from homeassistant.components.light import (
     LightEntityFeature,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BleBoxConfigEntry
-from .const import LIGHT_MAX_KELVINS, LIGHT_MIN_KELVINS
+from .const import DOMAIN, LIGHT_MAX_KELVINS, LIGHT_MIN_KELVINS
 from .coordinator import BleBoxCoordinator
 from .entity import BleBoxEntity
 from .util import blebox_command
@@ -215,8 +216,10 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
         try:
             await self._feature.async_on(value)
         except ValueError as exc:
-            raise ValueError(
-                f"Turning on '{self.name}' failed: Bad value {value}"
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="bad_value",
+                translation_placeholders={"error": str(exc)},
             ) from exc
 
         if effect is not None:
@@ -224,9 +227,10 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
                 effect_value = self.effect_list.index(effect)
                 await self._feature.async_api_command("effect", effect_value)
             except ValueError as exc:
-                raise ValueError(
-                    f"Turning on with effect '{self.name}' failed: {effect} not in"
-                    " effect list."
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="effect_not_found",
+                    translation_placeholders={"error": str(exc)},
                 ) from exc
 
     @blebox_command

homeassistant/components/blebox/sensor.py

@@ -1,5 +1,7 @@
 """BleBox sensor entities."""
 
+from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import datetime
 
 import blebox_uniapi.sensor
@@ -26,96 +28,113 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
 
 from . import BleBoxConfigEntry
+from .const import OPEN_STATUS
 from .coordinator import BleBoxCoordinator
 from .entity import BleBoxEntity
 
 PARALLEL_UPDATES = 0
 
 
-SENSOR_TYPES = (
-    SensorEntityDescription(
+@dataclass(kw_only=True, frozen=True)
+class BleBoxSensorEntityDescription(SensorEntityDescription):
+    """Describes a BleBox sensor entity."""
+
+    value_fn: Callable[[StateType], StateType] = lambda v: v
+
+
+SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
+    BleBoxSensorEntityDescription(
         key="pm1",
         device_class=SensorDeviceClass.PM1,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="pm2_5",
         device_class=SensorDeviceClass.PM25,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="pm10",
         device_class=SensorDeviceClass.PM10,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="temperature",
         device_class=SensorDeviceClass.TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="powerConsumption",
         translation_key="power_consumption",
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=2,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="humidity",
         device_class=SensorDeviceClass.HUMIDITY,
         native_unit_of_measurement=PERCENTAGE,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="wind",
         device_class=SensorDeviceClass.WIND_SPEED,
         native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="illuminance",
         device_class=SensorDeviceClass.ILLUMINANCE,
         native_unit_of_measurement=LIGHT_LUX,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="forwardActiveEnergy",
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="reverseActiveEnergy",
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="reactivePower",
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfReactivePower.VOLT_AMPERE_REACTIVE,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="activePower",
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="apparentPower",
         device_class=SensorDeviceClass.APPARENT_POWER,
         native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="voltage",
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="current",
         device_class=SensorDeviceClass.CURRENT,
         native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
     ),
-    SensorEntityDescription(
+    BleBoxSensorEntityDescription(
         key="frequency",
         device_class=SensorDeviceClass.FREQUENCY,
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
     ),
+    BleBoxSensorEntityDescription(
+        key="openStatus",
+        translation_key="open_status",
+        device_class=SensorDeviceClass.ENUM,
+        icon="mdi:window-open",
+        options=list(OPEN_STATUS.values()),
+        value_fn=lambda v: OPEN_STATUS.get(int(v)) if v is not None else None,
+    ),
 )
 
 
@@ -138,20 +157,22 @@ async def async_setup_entry(
 class BleBoxSensorEntity(BleBoxEntity[blebox_uniapi.sensor.BaseSensor], SensorEntity):
     """Representation of a BleBox sensor feature."""
 
+    entity_description: BleBoxSensorEntityDescription
+
     def __init__(
         self,
         coordinator: BleBoxCoordinator,
         feature: blebox_uniapi.sensor.BaseSensor,
-        description: SensorEntityDescription,
+        description: BleBoxSensorEntityDescription,
     ) -> None:
         """Initialize a BleBox sensor feature."""
         super().__init__(coordinator, feature)
         self.entity_description = description
 
     @property
-    def native_value(self):
+    def native_value(self) -> StateType:
         """Return the state."""
-        return self._feature.native_value
+        return self.entity_description.value_fn(self._feature.native_value)
 
     @property
     def last_reset(self) -> datetime | None:

homeassistant/components/blebox/strings.json

@@ -35,9 +35,37 @@
       }
     }
   },
+  "entity": {
+    "sensor": {
+      "open_status": {
+        "state": {
+          "ajar": "Ajar",
+          "closed": "[%key:common::state::closed%]",
+          "closed_but_unlocked": "Closed but unlocked",
+          "open": "[%key:common::state::open%]",
+          "unclosed_or_unlocked": "Unclosed or unlocked"
+        }
+      }
+    }
+  },
   "exceptions": {
-    "update_failed": {
+    "bad_value": {
+      "message": "Turning on the light failed: {error}"
+    },
+    "command_failed": {
+      "message": "Failed to execute command on the BleBox device: {error}"
+    },
+    "data_update_failed": {
       "message": "An error occurred while communicating with the BleBox device: {error}"
+    },
+    "effect_not_found": {
+      "message": "The specified light effect is not available on this device: {error}"
+    },
+    "install_failed": {
+      "message": "Failed to install firmware update on the BleBox device: {error}"
+    },
+    "update_failed": {
+      "message": "Failed to fetch firmware update information from the BleBox device: {error}"
     }
   }
 }

homeassistant/components/blebox/update.py

@@ -18,6 +18,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
 
 from . import BleBoxConfigEntry
+from .const import DOMAIN
 from .coordinator import BleBoxCoordinator
 from .entity import BleBoxEntity
 
@@ -86,7 +87,11 @@ class BleBoxUpdateEntity(BleBoxEntity[blebox_uniapi.update.Update], UpdateEntity
         try:
             await self._feature.async_update()
         except Error as ex:
-            raise HomeAssistantError(ex) from ex
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="update_failed",
+                translation_placeholders={"error": str(ex)},
+            ) from ex
         self._sync_sw_version()
 
     @property
@@ -121,7 +126,11 @@ class BleBoxUpdateEntity(BleBoxEntity[blebox_uniapi.update.Update], UpdateEntity
             await self._feature.async_install()
         except Error as ex:
             self._reset_progress()
-            raise HomeAssistantError(ex) from ex
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="install_failed",
+                translation_placeholders={"error": str(ex)},
+            ) from ex
         self._poll_cancel = async_call_later(
             self.hass, _POLL_INTERVAL_SECONDS, self._poll_until_updated
         )

homeassistant/components/blebox/util.py

@@ -7,6 +7,7 @@ from blebox_uniapi.error import Error
 
 from homeassistant.exceptions import HomeAssistantError
 
+from .const import DOMAIN
 from .entity import BleBoxEntity
 
 
@@ -22,7 +23,11 @@ def blebox_command[_BleBoxEntityT: BleBoxEntity, **_P, _R](
         try:
             return await func(self, *args, **kwargs)
         except Error as err:
-            raise HomeAssistantError(str(err)) from err
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_failed",
+                translation_placeholders={"error": str(err)},
+            ) from err
         finally:
             await self.coordinator.async_refresh()
 

homeassistant/components/bluetooth/api.py

@@ -6,6 +6,7 @@ These APIs are the only documented way to interact with the bluetooth integratio
 import asyncio
 from asyncio import Future
 from collections.abc import Callable, Iterable
+from contextlib import ExitStack
 from typing import TYPE_CHECKING, cast
 
 from bleak import BleakScanner
@@ -178,15 +179,20 @@ async def async_process_advertisements(
         if not done.done() and callback(service_info):
             done.set_result(service_info)
 
-    unload = _get_manager(hass).async_register_callback(
-        _async_discovered_device, match_dict, mode, scan_duration=timeout
-    )
+    manager = _get_manager(hass)
+
+    with ExitStack() as stack:
+        unload = manager.async_register_callback(
+            _async_discovered_device, match_dict, mode
+        )
+        stack.callback(unload)
+
+        if mode == BluetoothScanningMode.ACTIVE:
+            task = hass.async_create_task(manager.async_request_active_scan(timeout))
+            stack.callback(task.cancel)
 
-    try:
         async with asyncio.timeout(timeout):
             return await done
-    finally:
-        unload()
 
 
 @hass_callback

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.6.4",
     "bluetooth-data-tools==1.29.18",
     "dbus-fast==5.0.16",
-    "habluetooth==6.8.1"
+    "habluetooth==6.8.3"
   ]
 }

homeassistant/components/brands/__init__.py

@@ -1,18 +1,19 @@
 """The Brands integration."""
 
 from collections import deque
+from collections.abc import Container, Mapping
 from http import HTTPStatus
 import logging
 from pathlib import Path
 from random import SystemRandom
 import time
-from typing import Any, Final
+from typing import Any, Final, override
 
-from aiohttp import ClientError, hdrs, web
+from aiohttp import ClientError, web
 import voluptuous as vol
 
 from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.core import HomeAssistant, callback, valid_domain
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -108,23 +109,18 @@ def _read_brand_file(brand_dir: Path, image: str) -> bytes | None:
 class _BrandsBaseView(HomeAssistantView):
     """Base view for serving brand images."""
 
-    requires_auth = False
+    use_query_token_for_auth = True
 
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the view."""
         self._hass = hass
         self._cache_dir = Path(hass.config.cache_path(DOMAIN))
 
-    def _authenticate(self, request: web.Request) -> None:
-        """Authenticate the request using Bearer token or query token."""
-        access_tokens: deque[str] = self._hass.data[DOMAIN]
-        authenticated = (
-            request[KEY_AUTHENTICATED] or request.query.get("token") in access_tokens
-        )
-        if not authenticated:
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            raise web.HTTPForbidden
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        return self._hass.data[DOMAIN]
 
     async def _serve_from_custom_integration(
         self,
@@ -240,8 +236,6 @@ class BrandsIntegrationView(_BrandsBaseView):
         image: str,
     ) -> web.Response:
         """Handle GET request for an integration brand image."""
-        self._authenticate(request)
-
         if not valid_domain(domain) or image not in ALLOWED_IMAGES:
             return web.Response(status=HTTPStatus.NOT_FOUND)
 
@@ -274,8 +268,6 @@ class BrandsHardwareView(_BrandsBaseView):
         image: str,
     ) -> web.Response:
         """Handle GET request for a hardware brand image."""
-        self._authenticate(request)
-
         if not CATEGORY_RE.match(category):
             return web.Response(status=HTTPStatus.NOT_FOUND)
         # Hardware images have dynamic names like "manufacturer_model.png"

homeassistant/components/cambridge_audio/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["aiostreammagic"],
   "quality_scale": "platinum",
-  "requirements": ["aiostreammagic==2.13.1"],
+  "requirements": ["aiostreammagic==2.13.2"],
   "zeroconf": ["_stream-magic._tcp.local.", "_smoip._tcp.local."]
 }

homeassistant/components/camera/__init__.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import collections
-from collections.abc import Awaitable, Callable, Coroutine
+from collections.abc import Awaitable, Callable, Container, Coroutine, Mapping
 from contextlib import suppress
 from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta
@@ -12,16 +12,16 @@ import logging
 import os
 from random import SystemRandom
 import time
-from typing import Any, Final, final
+from typing import Any, Final, final, override
 
-from aiohttp import hdrs, web
+from aiohttp import web
 import attr
 from propcache.api import cached_property, under_cached_property
 import voluptuous as vol
 from webrtc_models import RTCIceCandidateInit
 
 from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.media_player import (
     ATTR_MEDIA_CONTENT_ID,
     ATTR_MEDIA_CONTENT_TYPE,
@@ -776,30 +776,26 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
 class CameraView(HomeAssistantView):
     """Base CameraView."""
 
-    requires_auth = False
+    use_query_token_for_auth = True
 
     def __init__(self, component: EntityComponent[Camera]) -> None:
         """Initialize a basic camera view."""
         self.component = component
 
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        if (camera := self.component.get_entity(match_info["entity_id"])) is None:
+            return ()
+
+        return camera.access_tokens
+
     async def get(self, request: web.Request, entity_id: str) -> web.StreamResponse:
         """Start a GET request."""
         if (camera := self.component.get_entity(entity_id)) is None:
             raise web.HTTPNotFound
 
-        authenticated = (
-            request[KEY_AUTHENTICATED]
-            or request.query.get("token") in camera.access_tokens
-        )
-
-        if not authenticated:
-            # Attempt with invalid bearer token, raise unauthorized
-            # so ban middleware can handle it.
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            # Invalid sigAuth or camera access token
-            raise web.HTTPForbidden
-
         if not camera.is_on:
             _LOGGER.debug("Camera is off")
             raise web.HTTPServiceUnavailable

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.6.1"]
+  "requirements": ["hassil==3.6.0", "home-assistant-intents==2026.6.1"]
 }

homeassistant/components/conversation/trigger.py

@@ -3,6 +3,8 @@
 from collections.abc import Awaitable, Callable
 from typing import Any
 
+from hassil.parse_expression import parse_sentence
+from hassil.parser import ParseError
 from hassil.recognize import RecognizeResult
 from hassil.util import (
     PUNCTUATION_END,
@@ -42,6 +44,17 @@ def has_no_punctuation(value: list[str]) -> list[str]:
     return value
 
 
+def is_valid_sentence(value: list[str]) -> list[str]:
+    """Validate result can be parsed by hassil."""
+    for sentence in value:
+        try:
+            parse_sentence(sentence)
+        except ParseError as err:
+            raise vol.Invalid(f"invalid sentence: {err}") from err
+
+    return value
+
+
 def has_one_non_empty_item(value: list[str]) -> list[str]:
     """Validate result has at least one item."""
     if len(value) < 1:
@@ -58,7 +71,11 @@ TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend(
     {
         vol.Required(CONF_PLATFORM): DOMAIN,
         vol.Required(CONF_COMMAND): vol.All(
-            cv.ensure_list, [cv.string], has_one_non_empty_item, has_no_punctuation
+            cv.ensure_list,
+            [cv.string],
+            has_one_non_empty_item,
+            has_no_punctuation,
+            is_valid_sentence,
         ),
     }
 )

homeassistant/components/daikin/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.17.2"],
+  "requirements": ["pydaikin==2.18.1"],
   "zeroconf": ["_dkapi._tcp.local."]
 }

homeassistant/components/data_grand_lyon/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["data-grand-lyon-ha==0.7.0"]
+  "requirements": ["data-grand-lyon-ha==0.8.0"]
 }

homeassistant/components/demo/binary_sensor.py

@@ -5,6 +5,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntity,
 )
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -27,7 +28,19 @@ async def async_setup_entry(
                 BinarySensorDeviceClass.MOISTURE,
             ),
             DemoBinarySensor(
-                "binary_2", "Movement Backyard", True, BinarySensorDeviceClass.MOTION
+                "binary_2",
+                "Movement Backyard",
+                True,
+                BinarySensorDeviceClass.MOTION,
+            ),
+            DemoBinarySensor(
+                "binary_3",
+                "Outside Temperature",
+                False,
+                BinarySensorDeviceClass.BATTERY_CHARGING,
+                device_id="sensor_1",
+                entity_category=EntityCategory.DIAGNOSTIC,
+                entity_name="Battery Charging",
             ),
         ]
     )
@@ -46,6 +59,9 @@ class DemoBinarySensor(BinarySensorEntity):
         device_name: str,
         state: bool,
         device_class: BinarySensorDeviceClass,
+        device_id: str | None = None,
+        entity_category: EntityCategory | None = None,
+        entity_name: str | None = None,
     ) -> None:
         """Initialize the demo sensor."""
         self._unique_id = unique_id
@@ -54,10 +70,12 @@ class DemoBinarySensor(BinarySensorEntity):
         self._attr_device_info = DeviceInfo(
             identifiers={
                 # Serial numbers are unique identifiers within a specific domain
-                (DOMAIN, self.unique_id)
+                (DOMAIN, device_id or unique_id)
             },
             name=device_name,
         )
+        self._attr_entity_category = entity_category
+        self._attr_name = entity_name
 
     @property
     def unique_id(self) -> str:

homeassistant/components/device_tracker/__init__.py

@@ -22,6 +22,7 @@ from .const import (  # noqa: F401
     ATTR_LOCATION_NAME,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
+    ATTR_TRACKING_TYPE,
     CONF_ASSOCIATED_ZONE,
     CONF_CONSIDER_HOME,
     CONF_NEW_DEVICE_DEFAULTS,
@@ -36,6 +37,7 @@ from .const import (  # noqa: F401
     PLATFORM_TYPE_LEGACY,
     SCAN_INTERVAL,
     SourceType,
+    TrackingType,
 )
 from .entity import (  # noqa: F401
     BaseScannerEntity,

homeassistant/components/device_tracker/const.py

@@ -25,6 +25,18 @@ class SourceType(StrEnum):
     BLUETOOTH_LE = "bluetooth_le"
 
 
+class TrackingType(StrEnum):
+    """Tracking type for device trackers.
+
+    Describes how the tracker determines presence: by the device's geographic
+    position (e.g. GPS) or by its connection to a known endpoint (e.g. a router
+    or beacon associated with a zone).
+    """
+
+    CONNECTION = "connection"
+    POSITION = "position"
+
+
 CONF_SCAN_INTERVAL: Final = "interval_seconds"
 SCAN_INTERVAL: Final = timedelta(seconds=12)
 
@@ -47,6 +59,7 @@ ATTR_IN_ZONES: Final = "in_zones"
 ATTR_LOCATION_NAME: Final = "location_name"
 ATTR_MAC: Final = "mac"
 ATTR_SOURCE_TYPE: Final = "source_type"
+ATTR_TRACKING_TYPE: Final = "tracking_type"
 ATTR_CONSIDER_HOME: Final = "consider_home"
 ATTR_IP: Final = "ip"
 

homeassistant/components/device_tracker/entity.py

@@ -48,11 +48,13 @@ from .const import (
     ATTR_IP,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
+    ATTR_TRACKING_TYPE,
     CONF_ASSOCIATED_ZONE,
     CONNECTED_DEVICE_REGISTERED,
     DOMAIN,
     LOGGER,
     SourceType,
+    TrackingType,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -238,6 +240,9 @@ class TrackerEntity(
     """Base class for a tracked device."""
 
     entity_description: TrackerEntityDescription
+    _attr_capability_attributes: dict[str, Any] = {
+        ATTR_TRACKING_TYPE: TrackingType.POSITION
+    }
     _attr_in_zones: list[str] | None = None
     _attr_latitude: float | None = None
     _attr_location_accuracy: float = 0
@@ -411,6 +416,9 @@ class BaseScannerEntity(BaseTrackerEntity):
     addresses being used to identify the device.
     """
 
+    _attr_capability_attributes: dict[str, Any] = {
+        ATTR_TRACKING_TYPE: TrackingType.CONNECTION
+    }
     _scanner_option_associated_zone: str = zone.ENTITY_ID_HOME
     _scanner_option_associated_zone_unsub: CALLBACK_TYPE | None = None
 

homeassistant/components/device_tracker/strings.json

@@ -40,6 +40,13 @@
             "gps": "GPS",
             "router": "Router"
           }
+        },
+        "tracking_type": {
+          "name": "Tracking type",
+          "state": {
+            "connection": "Connection",
+            "position": "Position"
+          }
         }
       }
     }

homeassistant/components/dsmr/config_flow.py

@@ -13,7 +13,6 @@ from dsmr_parser.clients.rfxtrx_protocol import (
 from dsmr_parser.objects import DSMRObject
 import voluptuous as vol
 
-from homeassistant.components import usb
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
@@ -23,6 +22,7 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_PROTOCOL, CONF_TYPE
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.selector import SerialPortSelector
 
 from .const import (
     CONF_DSMR_VERSION,
@@ -37,8 +37,6 @@ from .const import (
     RFXTRX_DSMR_PROTOCOL,
 )
 
-CONF_MANUAL_PATH = "Enter Manually"
-
 
 class DSMRConnection:
     """Test the connection to DSMR and receive telegram to read serial ids."""
@@ -165,8 +163,6 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    _dsmr_version: str | None = None
-
     @staticmethod
     @callback
     def async_get_options_flow(
@@ -222,34 +218,13 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
         """Step when setting up serial configuration."""
         errors: dict[str, str] = {}
         if user_input is not None:
-            user_selection = user_input[CONF_PORT]
-            if user_selection == CONF_MANUAL_PATH:
-                self._dsmr_version = user_input[CONF_DSMR_VERSION]
-                return await self.async_step_setup_serial_manual_path()
-
-            dev_path = user_selection
-
-            validate_data = {
-                CONF_PORT: dev_path,
-                CONF_DSMR_VERSION: user_input[CONF_DSMR_VERSION],
-            }
-
-            data = await self.async_validate_dsmr(validate_data, errors)
+            data = await self.async_validate_dsmr(user_input, errors)
             if not errors:
                 return self.async_create_entry(title=data[CONF_PORT], data=data)
 
-        ports = await usb.async_scan_serial_ports(self.hass)
-        list_of_ports = {
-            port.device: f"{port.device} - {port.description or 'n/a'}"
-            f", s/n: {port.serial_number or 'n/a'}"
-            + (f" - {port.manufacturer}" if port.manufacturer else "")
-            for port in ports
-        }
-        list_of_ports[CONF_MANUAL_PATH] = CONF_MANUAL_PATH
-
         schema = vol.Schema(
             {
-                vol.Required(CONF_PORT): vol.In(list_of_ports),
+                vol.Required(CONF_PORT): SerialPortSelector(),
                 vol.Required(CONF_DSMR_VERSION): vol.In(DSMR_VERSIONS),
             }
         )
@@ -259,27 +234,6 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_setup_serial_manual_path(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Select path manually."""
-        if user_input is not None:
-            validate_data = {
-                CONF_PORT: user_input[CONF_PORT],
-                CONF_DSMR_VERSION: self._dsmr_version,
-            }
-
-            errors: dict[str, str] = {}
-            data = await self.async_validate_dsmr(validate_data, errors)
-            if not errors:
-                return self.async_create_entry(title=data[CONF_PORT], data=data)
-
-        schema = vol.Schema({vol.Required(CONF_PORT): str})
-        return self.async_show_form(
-            step_id="setup_serial_manual_path",
-            data_schema=schema,
-        )
-
     async def async_validate_dsmr(
         self, input_data: dict[str, Any], errors: dict[str, str]
     ) -> dict[str, Any]:

homeassistant/components/dsmr/strings.json

@@ -26,12 +26,6 @@
         },
         "title": "[%key:common::config_flow::data::device%]"
       },
-      "setup_serial_manual_path": {
-        "data": {
-          "port": "[%key:common::config_flow::data::usb_path%]"
-        },
-        "title": "[%key:common::config_flow::data::path%]"
-      },
       "user": {
         "data": {
           "type": "Connection type"

homeassistant/components/duco/const.py

@@ -7,3 +7,4 @@ from homeassistant.const import Platform
 DOMAIN = "duco"
 PLATFORMS = [Platform.FAN, Platform.SENSOR]
 SCAN_INTERVAL = timedelta(seconds=10)
+BOX_NODE_ID = 1

homeassistant/components/duco/diagnostics.py

@@ -3,7 +3,7 @@
 from dataclasses import asdict
 from typing import Any
 
-from duco_connectivity.exceptions import DucoConnectionError
+from duco_connectivity.exceptions import DucoConnectionError, DucoError
 
 from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import CONF_HOST
@@ -52,6 +52,12 @@ async def async_get_config_entry_diagnostics(
             translation_domain=DOMAIN,
             translation_key="connection_error",
         ) from err
+    except DucoError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="api_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
 
     api_info: dict[str, Any] = {"public_api_version": api_info_obj.public_api_version}
     if api_info_obj.reported_api_version is not None:

homeassistant/components/duco/entity.py

@@ -1,6 +1,6 @@
 """Base entity for the Duco integration."""
 
-from duco_connectivity.models import Node
+from duco_connectivity.models import Node, NodeType
 
 from homeassistant.const import ATTR_VIA_DEVICE
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
@@ -25,7 +25,7 @@ class DucoEntity(CoordinatorEntity[DucoCoordinator]):
             identifiers={(DOMAIN, f"{mac}_{node.node_id}")},
             manufacturer="Duco",
             model=coordinator.board_info.box_name
-            if node.general.node_type == "BOX"
+            if node.general.node_type == NodeType.BOX
             else node.general.node_type,
             name=node.general.name or f"Node {node.node_id}",
         )
@@ -34,7 +34,7 @@ class DucoEntity(CoordinatorEntity[DucoCoordinator]):
                 "connections": {(CONNECTION_NETWORK_MAC, mac)},
                 "serial_number": coordinator.board_info.serial_board_box,
             }
-            if node.general.node_type == "BOX"
+            if node.general.node_type == NodeType.BOX
             else {ATTR_VIA_DEVICE: (DOMAIN, f"{mac}_1")}
         )
         self._attr_device_info = device_info

homeassistant/components/duco/sensor.py

@@ -24,7 +24,7 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN
+from .const import BOX_NODE_ID, DOMAIN
 from .coordinator import DucoConfigEntry, DucoCoordinator
 from .entity import DucoEntity
 
@@ -158,7 +158,13 @@ async def async_setup_entry(
         # The firmware removes deregistered RF/wired nodes automatically.
         # BSRH box sensors that are physically unplugged from the PCB are
         # not deregistered by the firmware and will never appear here as stale.
-        stale_node_ids = known_nodes - coordinator.data.nodes.keys()
+        # The BOX node can transiently disappear from the API response, so keep
+        # node 1 to avoid removing the main controller device.
+        stale_node_ids = {
+            node_id
+            for node_id in known_nodes - coordinator.data.nodes.keys()
+            if node_id != BOX_NODE_ID
+        }
         if stale_node_ids:
             device_reg = dr.async_get(hass)
             mac = entry.unique_id

homeassistant/components/duco/strings.json

@@ -59,7 +59,7 @@
         "name": "Target flow level"
       },
       "time_state_end": {
-        "name": "Mode end time"
+        "name": "State end time"
       },
       "ventilation_state": {
         "name": "Ventilation state",

homeassistant/components/dwd_weather_warnings/sensor.py

@@ -9,7 +9,6 @@ Warnungen vor markantem Wetter (Stufe 2)  # codespell:ignore vor
 Wetterwarnungen (Stufe 1)
 """
 
-from datetime import UTC, datetime
 from typing import Any
 
 from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
@@ -17,6 +16,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util import dt as dt_util
 
 from .const import (
     ADVANCE_WARNING_SENSOR,
@@ -100,7 +100,7 @@ class DwdWeatherWarningsSensor(
         if warnings is None:
             return []
 
-        now = datetime.now(UTC)  # pylint: disable=home-assistant-enforce-utcnow
+        now = dt_util.utcnow()
         return [warning for warning in warnings if warning[API_ATTR_WARNING_END] > now]
 
     @property

homeassistant/components/energyid/__init__.py

@@ -26,6 +26,7 @@ from homeassistant.helpers.event import (
     async_track_state_change_event,
     async_track_time_interval,
 )
+from homeassistant.util import dt as dt_util
 
 from .const import (
     CONF_DEVICE_NAME,
@@ -221,8 +222,7 @@ def update_listeners(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> None:
             ):
                 try:
                     value = float(current_state.state)
-                    # pylint: disable-next=home-assistant-enforce-utcnow
-                    timestamp = current_state.last_updated or dt.datetime.now(dt.UTC)
+                    timestamp = current_state.last_updated or dt_util.utcnow()
                     client.get_or_create_sensor(energyid_key).update(value, timestamp)
                 except ValueError, TypeError:
                     _LOGGER.debug(

homeassistant/components/esphome/entry_data.py

@@ -166,6 +166,8 @@ class RuntimeEntryData:
     )
     loaded_platforms: set[Platform] = field(default_factory=set)
     platform_load_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    # Set once the first connection has finished scanner setup or teardown.
+    first_connect_done: asyncio.Event = field(default_factory=asyncio.Event)
     _storage_contents: StoreData | None = None
     _pending_storage: Callable[[], StoreData] | None = None
     assist_pipeline_update_callbacks: list[CALLBACK_TYPE] = field(default_factory=list)

homeassistant/components/esphome/manager.py

@@ -1,11 +1,12 @@
 """Manager for esphome devices."""
 
+import asyncio
 import base64
 from functools import partial
 import logging
 import secrets
 import struct
-from typing import TYPE_CHECKING, Any, NamedTuple
+from typing import TYPE_CHECKING, Any, Final, NamedTuple
 
 from aioesphomeapi import (
     APIClient,
@@ -106,6 +107,9 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# Max time to wait at startup for a BLE proxy to register its scanner.
+STARTUP_SCANNER_WAIT: Final = 3.0
+
 LOG_LEVEL_TO_LOGGER = {
     LogLevel.LOG_LEVEL_NONE: logging.DEBUG,
     LogLevel.LOG_LEVEL_ERROR: logging.ERROR,
@@ -677,6 +681,8 @@ class ESPHomeManager:
                 hass, device_info.bluetooth_mac_address or device_info.mac_address
             )
 
+        entry_data.first_connect_done.set()
+
         if device_info.voice_assistant_feature_flags_compat(api_version) and (
             Platform.ASSIST_SATELLITE not in entry_data.loaded_platforms
         ):
@@ -988,6 +994,21 @@ class ESPHomeManager:
 
         await reconnect_logic.start()
 
+        # Wait for a cached BLE proxy to register its scanner before finishing setup.
+        if (
+            device_info := entry_data.device_info
+        ) is not None and device_info.bluetooth_proxy_feature_flags_compat(
+            entry_data.api_version
+        ):
+            try:
+                async with asyncio.timeout(STARTUP_SCANNER_WAIT):
+                    await entry_data.first_connect_done.wait()
+            except TimeoutError:
+                _LOGGER.debug(
+                    "%s: Timed out waiting for Bluetooth scanner to register",
+                    self.host,
+                )
+
 
 @callback
 def _async_setup_device_registry(

homeassistant/components/evohome/const.py

@@ -24,6 +24,8 @@ ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 ATTR_PERIOD: Final = "period"  # number of days
 ATTR_SETPOINT: Final = "setpoint"
 
+# Support for the refresh_system service is being deprecated
+REFRESH_BREAKS_IN_HA_VERSION: Final = "2027.1.0"
 # Support for the reset service calls/presets is being deprecated
 RESET_BREAKS_IN_HA_VERSION: Final = "2026.11.0"
 # Support for untargeted service calls to controllers is being deprecated

homeassistant/components/evohome/services.py

@@ -29,6 +29,7 @@ from .const import (
     ATTR_PERIOD,
     ATTR_SETPOINT,
     DOMAIN,
+    REFRESH_BREAKS_IN_HA_VERSION,
     RESET_BREAKS_IN_HA_VERSION,
     SERVICE_BREAKS_IN_HA_VERSION,
     EvoService,
@@ -204,6 +205,11 @@ def setup_service_functions(
     @verify_domain_control(DOMAIN)
     async def force_refresh(call: ServiceCall) -> None:
         """Obtain the latest state data via the vendor's RESTful API."""
+        async_create_deprecation_issue_once(
+            hass,
+            "deprecated_refresh_system_service",
+            REFRESH_BREAKS_IN_HA_VERSION,
+        )
         await coordinator.async_refresh()
 
     @verify_domain_control(DOMAIN)

homeassistant/components/evohome/strings.json

@@ -31,13 +31,17 @@
       "title": "Evohome 'Clear zone override' action is deprecated"
     },
     "deprecated_controller_service": {
-      "description": "The `{service}` action without `entity_id` is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Update any automation or script to include the Evohome controller climate entity `entity_id`.",
+      "description": "The `{service}` action without `entity_id` is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Update any automation or script to include `entity_id`, targeting the controller's climate entity.",
       "title": "Untargeted Evohome controller action is deprecated"
     },
     "deprecated_preset_reset": {
       "description": "Using the `Reset` preset on an Evohome controller is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Use the system's Reset button instead.",
       "title": "Evohome Reset preset is deprecated"
     },
+    "deprecated_refresh_system_service": {
+      "description": "The `refresh_system` action is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Instead, use the `homeassistant.update_entity` action, targeting the controller's climate entity.",
+      "title": "Evohome 'Refresh system' action is deprecated"
+    },
     "deprecated_reset_system_service": {
       "description": "The `reset_system` action is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Use the system's Reset button instead.",
       "title": "Evohome 'Reset system' action is deprecated"
@@ -49,7 +53,7 @@
       "name": "Clear zone override"
     },
     "refresh_system": {
-      "description": "Pulls the latest data from the vendor's servers now, rather than waiting for the next scheduled update.",
+      "description": "Pulls the latest data from the vendor's servers now, rather than waiting for the next scheduled update (deprecated).",
       "name": "Refresh system"
     },
     "reset_system": {

homeassistant/components/fluss/coordinator.py

@@ -7,6 +7,7 @@ from fluss_api import (
     FlussApiClient,
     FlussApiClientAuthenticationError,
     FlussApiClientError,
+    FlussDeviceOfflineError,
 )
 
 from homeassistant.config_entries import ConfigEntry
@@ -45,11 +46,13 @@ class FlussDataUpdateCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]
         )
 
     async def _async_get_status(self, device_id: str) -> dict[str, Any]:
-        """Return per-device status."""
+        """Return per-device status, treating an offline device as disconnected."""
         try:
             response = await self.api.async_get_device_status(device_id)
+        except FlussDeviceOfflineError:
+            return {"internetConnected": False}
         except FlussApiClientError as err:
-            raise UpdateFailed(f"Error fetching status for {device_id}: {err}") from err
+            raise UpdateFailed(f"Error fetching Fluss device status: {err}") from err
         return response["status"]
 
     async def _async_update_data(self) -> dict[str, dict[str, Any]]:

homeassistant/components/fluss/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["fluss-api"],
   "quality_scale": "bronze",
-  "requirements": ["fluss-api==0.2.4"]
+  "requirements": ["fluss-api==0.2.5"]
 }

homeassistant/components/forecast_solar/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/forecast_solar",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["forecast-solar==5.0.0"]
+  "requirements": ["forecast-solar==5.0.1"]
 }

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260527.4"]
+  "requirements": ["home-assistant-frontend==20260527.5"]
 }

homeassistant/components/gardena_bluetooth/__init__.py

@@ -1,17 +1,20 @@
 """The Gardena Bluetooth integration."""
 
+from contextlib import suppress
 import logging
 
 from bleak.backends.device import BLEDevice
 from gardena_bluetooth.client import CachedConnection, Client
-from gardena_bluetooth.const import ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.const import ScanService
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+from habluetooth import BluetoothServiceInfoBleak
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
+from .const import CONF_PRODUCT_TYPE
 from .coordinator import (
     DeviceUnavailable,
     GardenaBluetoothConfigEntry,
@@ -30,6 +33,79 @@ PLATFORMS: list[Platform] = [
 ]
 LOGGER = logging.getLogger(__name__)
 DISCONNECT_DELAY = 5
+PRODUCTS_SCAN_TIMEOUT = 10
+PRODUCT_TYPE_TIMEOUT = 30
+
+
+async def async_get_product(hass: HomeAssistant, address: str) -> ManufacturerData:
+    """Get manufacturer data for the given address via active scan."""
+
+    data = ManufacturerData()
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if info.device.address != address:
+            return False
+
+        data.update(info.manufacturer_data.get(ManufacturerData.company, b""))
+        return data.product_type is not ProductType.UNKNOWN
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                address=address, manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCT_TYPE_TIMEOUT,
+        )
+    return data
+
+
+async def async_get_products(hass: HomeAssistant) -> dict[str, ManufacturerData]:
+    """Get all products that are currently advertising."""
+    products: dict[str, ManufacturerData] = {}
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if ScanService not in info.service_uuids:
+            return False
+
+        raw = info.manufacturer_data.get(ManufacturerData.company, b"")
+        if (data := products.get(info.device.address)) is None:
+            data = ManufacturerData()
+            products[info.device.address] = data
+
+        data.update(raw)
+        return False
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCTS_SCAN_TIMEOUT,
+        )
+    return products
+
+
+async def async_migrate_product_type(
+    hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
+) -> GardenaBluetoothConfigEntry:
+    """Discover product type for old entries and upgrade them to minor version 2."""
+    mfg = await async_get_product(hass, entry.data[CONF_ADDRESS])
+    if mfg.product_type is ProductType.UNKNOWN:
+        raise ConfigEntryNotReady("Unable to find product type")
+    hass.config_entries.async_update_entry(
+        entry,
+        data={**entry.data, CONF_PRODUCT_TYPE: mfg.product_type.name},
+        minor_version=2,
+    )
+    return entry
 
 
 def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
@@ -51,16 +127,11 @@ async def async_setup_entry(
 ) -> bool:
     """Set up Gardena Bluetooth from a config entry."""
 
+    if entry.minor_version < 2:
+        entry = await async_migrate_product_type(hass, entry)
+
     address = entry.data[CONF_ADDRESS]
-
-    try:
-        mfg_data = await async_get_manufacturer_data({address})
-    except TimeoutError as exc:
-        raise ConfigEntryNotReady("Unable to find product type") from exc
-
-    product_type = mfg_data[address].product_type
-    if product_type is ProductType.UNKNOWN:
-        raise ConfigEntryNotReady("Unable to find product type")
+    product_type = ProductType[entry.data[CONF_PRODUCT_TYPE]]
 
     client = Client(get_connection(hass, address), product_type)
 

homeassistant/components/gardena_bluetooth/config_flow.py

@@ -4,22 +4,18 @@ import logging
 from typing import Any
 
 from gardena_bluetooth.client import Client
-from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
+from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
 from gardena_bluetooth.parse import ManufacturerData, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
 import voluptuous as vol
 
-from homeassistant.components.bluetooth import (
-    BluetoothServiceInfo,
-    async_discovered_service_info,
-)
+from homeassistant.components.bluetooth import BluetoothServiceInfo
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.data_entry_flow import AbortFlow
 
-from . import get_connection
-from .const import DOMAIN
+from . import async_get_product, async_get_products, get_connection
+from .const import CONF_PRODUCT_TYPE, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,26 +29,16 @@ _SUPPORTED_PRODUCT_TYPES = {
 }
 
 
-def _is_supported(discovery_info: BluetoothServiceInfo):
-    """Check if device is supported."""
-    if ScanService not in discovery_info.service_uuids:
-        return False
-
-    if discovery_info.manufacturer_data.get(ManufacturerData.company) is None:
-        _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
-        return False
-    return True
-
-
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Gardena Bluetooth."""
 
     VERSION = 1
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         """Initialize the config flow."""
-        self.devices: dict[str, str] = {}
         self.address: str | None
+        self.devices: dict[str, ManufacturerData] = {}
 
     async def async_read_data(self):
         """Try to connect to device and extract information."""
@@ -68,20 +54,23 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
         finally:
             await client.disconnect()
 
-        return {CONF_ADDRESS: self.address}
+        assert self.address in self.devices
+        return {
+            CONF_ADDRESS: self.address,
+            CONF_PRODUCT_TYPE: self.devices[self.address].product_type.name,
+        }
 
     async def async_step_bluetooth(
         self, discovery_info: BluetoothServiceInfo
     ) -> ConfigFlowResult:
         """Handle the bluetooth discovery step."""
         _LOGGER.debug("Discovered device: %s", discovery_info)
-        data = await async_get_manufacturer_data({discovery_info.address})
-        product_type = data[discovery_info.address].product_type
-        if product_type not in _SUPPORTED_PRODUCT_TYPES:
+        mfg = await async_get_product(self.hass, discovery_info.address)
+        self.devices[discovery_info.address] = mfg
+        if mfg.product_type not in _SUPPORTED_PRODUCT_TYPES:
             return self.async_abort(reason="no_devices_found")
 
         self.address = discovery_info.address
-        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
         await self.async_set_unique_id(self.address)
         self._abort_if_unique_id_configured()
         return await self.async_step_confirm()
@@ -91,7 +80,7 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Confirm discovery."""
         assert self.address
-        title = self.devices[self.address]
+        title = PRODUCT_NAMES[self.devices[self.address].product_type]
 
         if user_input is not None:
             data = await self.async_read_data()
@@ -117,31 +106,25 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             self._abort_if_unique_id_configured()
             return await self.async_step_confirm()
 
-        current_addresses = self._async_current_ids(include_ignore=False)
-        candidates = set()
-        for discovery_info in async_discovered_service_info(self.hass):
-            address = discovery_info.address
-            if address in current_addresses or not _is_supported(discovery_info):
-                continue
-            candidates.add(address)
-
-        data = await async_get_manufacturer_data(candidates)
-        for address, mfg_data in data.items():
-            if mfg_data.product_type not in _SUPPORTED_PRODUCT_TYPES:
-                continue
-            self.devices[address] = PRODUCT_NAMES[mfg_data.product_type]
+        current = self._async_current_ids(include_ignore=False)
+        self.devices = await async_get_products(self.hass)
 
         # Keep selection sorted by address to ensure stable tests
-        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
+        devices = {
+            address: PRODUCT_NAMES[data.product_type]
+            for address in sorted(self.devices)
+            if address not in current
+            and (data := self.devices[address]).product_type in _SUPPORTED_PRODUCT_TYPES
+        }
 
-        if not self.devices:
+        if not devices:
             return self.async_abort(reason="no_devices_found")
 
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema(
                 {
-                    vol.Required(CONF_ADDRESS): vol.In(self.devices),
+                    vol.Required(CONF_ADDRESS): vol.In(devices),
                 },
             ),
         )

homeassistant/components/gardena_bluetooth/const.py

@@ -1,3 +1,4 @@
 """Constants for the Gardena Bluetooth integration."""
 
 DOMAIN = "gardena_bluetooth"
+CONF_PRODUCT_TYPE = "product_type"

homeassistant/components/goodwe/config_flow.py

@@ -24,7 +24,7 @@ _LOGGER = logging.getLogger(__name__)
 class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Goodwe config flow."""
 
-    MINOR_VERSION = 2
+    VERSION = 2
 
     async def async_handle_successful_connection(
         self,

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.97", "babel==2.15.0"]
+  "requirements": ["holidays==0.98", "babel==2.15.0"]
 }

homeassistant/components/home_connect/common.py

@@ -108,27 +108,32 @@ def _handle_paired_or_connected_appliance(
                 )
                 if entity.unique_id not in known_entity_unique_ids
             )
-            for event_key in (
-                EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
-                EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
+            if not (
+                callbacks_for_appliance := changed_options_listener_remove_callbacks[
+                    appliance_ha_id
+                ]
             ):
-                changed_options_listener_remove_callback = (
-                    appliance_coordinator.async_add_listener(
-                        partial(
-                            _create_option_entities,
-                            entity_registry,
-                            appliance_coordinator,
-                            known_entity_unique_ids,
-                            get_option_entities_for_appliance,
-                            async_add_entities,
-                        ),
-                        event_key,
+                for event_key in (
+                    EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
+                    EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
+                ):
+                    changed_options_listener_remove_callback = (
+                        appliance_coordinator.async_add_listener(
+                            partial(
+                                _create_option_entities,
+                                entity_registry,
+                                appliance_coordinator,
+                                known_entity_unique_ids,
+                                get_option_entities_for_appliance,
+                                async_add_entities,
+                            ),
+                            event_key,
+                        )
+                    )
+                    entry.async_on_unload(changed_options_listener_remove_callback)
+                    callbacks_for_appliance.append(
+                        changed_options_listener_remove_callback
                     )
-                )
-                entry.async_on_unload(changed_options_listener_remove_callback)
-                changed_options_listener_remove_callbacks[appliance_ha_id].append(
-                    changed_options_listener_remove_callback
-                )
         known_entity_unique_ids.update(
             {cast(str, entity.unique_id): appliance_ha_id for entity in entities_to_add}
         )

homeassistant/components/home_connect/services.yaml

@@ -22,141 +22,147 @@ set_program_and_options:
           custom_value: false
           translation_key: programs
           options:
+            - consumer_products_cleaning_robot_program_basic_go_home
             - consumer_products_cleaning_robot_program_cleaning_clean_all
             - consumer_products_cleaning_robot_program_cleaning_clean_map
-            - consumer_products_cleaning_robot_program_basic_go_home
-            - consumer_products_coffee_maker_program_beverage_ristretto
+            - consumer_products_coffee_maker_program_beverage_caffe_grande
+            - consumer_products_coffee_maker_program_beverage_caffe_latte
+            - consumer_products_coffee_maker_program_beverage_cappuccino
+            - consumer_products_coffee_maker_program_beverage_coffee
             - consumer_products_coffee_maker_program_beverage_espresso
             - consumer_products_coffee_maker_program_beverage_espresso_doppio
-            - consumer_products_coffee_maker_program_beverage_coffee
-            - consumer_products_coffee_maker_program_beverage_x_l_coffee
-            - consumer_products_coffee_maker_program_beverage_caffe_grande
             - consumer_products_coffee_maker_program_beverage_espresso_macchiato
-            - consumer_products_coffee_maker_program_beverage_cappuccino
+            - consumer_products_coffee_maker_program_beverage_hot_water
             - consumer_products_coffee_maker_program_beverage_latte_macchiato
-            - consumer_products_coffee_maker_program_beverage_caffe_latte
             - consumer_products_coffee_maker_program_beverage_milk_froth
+            - consumer_products_coffee_maker_program_beverage_ristretto
             - consumer_products_coffee_maker_program_beverage_warm_milk
-            - consumer_products_coffee_maker_program_coffee_world_kleiner_brauner
+            - consumer_products_coffee_maker_program_beverage_x_l_coffee
+            - consumer_products_coffee_maker_program_coffee_world_americano
+            - consumer_products_coffee_maker_program_coffee_world_black_eye
+            - consumer_products_coffee_maker_program_coffee_world_cafe_au_lait
+            - consumer_products_coffee_maker_program_coffee_world_cafe_con_leche
+            - consumer_products_coffee_maker_program_coffee_world_cafe_cortado
+            - consumer_products_coffee_maker_program_coffee_world_cortado
+            - consumer_products_coffee_maker_program_coffee_world_dead_eye
+            - consumer_products_coffee_maker_program_coffee_world_doppio
+            - consumer_products_coffee_maker_program_coffee_world_flat_white
+            - consumer_products_coffee_maker_program_coffee_world_galao
+            - consumer_products_coffee_maker_program_coffee_world_garoto
             - consumer_products_coffee_maker_program_coffee_world_grosser_brauner
+            - consumer_products_coffee_maker_program_coffee_world_kaapi
+            - consumer_products_coffee_maker_program_coffee_world_kleiner_brauner
+            - consumer_products_coffee_maker_program_coffee_world_koffie_verkeerd
+            - consumer_products_coffee_maker_program_coffee_world_red_eye
             - consumer_products_coffee_maker_program_coffee_world_verlaengerter
             - consumer_products_coffee_maker_program_coffee_world_verlaengerter_braun
             - consumer_products_coffee_maker_program_coffee_world_wiener_melange
-            - consumer_products_coffee_maker_program_coffee_world_flat_white
-            - consumer_products_coffee_maker_program_coffee_world_cortado
-            - consumer_products_coffee_maker_program_coffee_world_cafe_cortado
-            - consumer_products_coffee_maker_program_coffee_world_cafe_con_leche
-            - consumer_products_coffee_maker_program_coffee_world_cafe_au_lait
-            - consumer_products_coffee_maker_program_coffee_world_doppio
-            - consumer_products_coffee_maker_program_coffee_world_kaapi
-            - consumer_products_coffee_maker_program_coffee_world_koffie_verkeerd
-            - consumer_products_coffee_maker_program_coffee_world_galao
-            - consumer_products_coffee_maker_program_coffee_world_garoto
-            - consumer_products_coffee_maker_program_coffee_world_americano
-            - consumer_products_coffee_maker_program_coffee_world_red_eye
-            - consumer_products_coffee_maker_program_coffee_world_black_eye
-            - consumer_products_coffee_maker_program_coffee_world_dead_eye
-            - consumer_products_coffee_maker_program_beverage_hot_water
-            - dishcare_dishwasher_program_pre_rinse
+            - cooking_common_program_hood_automatic
+            - cooking_common_program_hood_delayed_shut_off
+            - cooking_common_program_hood_venting
+            - cooking_oven_program_heating_mode_3_d_hot_air
+            - cooking_oven_program_heating_mode_air_fry
+            - cooking_oven_program_heating_mode_bottom_heating
+            - cooking_oven_program_heating_mode_bread_baking
+            - cooking_oven_program_heating_mode_defrost
+            - cooking_oven_program_heating_mode_desiccation
+            - cooking_oven_program_heating_mode_dough_proving
+            - cooking_oven_program_heating_mode_frozen_heatup_special
+            - cooking_oven_program_heating_mode_grill_large_area
+            - cooking_oven_program_heating_mode_grill_small_area
+            - cooking_oven_program_heating_mode_hot_air
+            - cooking_oven_program_heating_mode_hot_air_100_steam
+            - cooking_oven_program_heating_mode_hot_air_30_steam
+            - cooking_oven_program_heating_mode_hot_air_60_steam
+            - cooking_oven_program_heating_mode_hot_air_80_steam
+            - cooking_oven_program_heating_mode_hot_air_eco
+            - cooking_oven_program_heating_mode_hot_air_gentle
+            - cooking_oven_program_heating_mode_hot_air_grilling
+            - cooking_oven_program_heating_mode_intensive_heat
+            - cooking_oven_program_heating_mode_keep_warm
+            - cooking_oven_program_heating_mode_pizza_setting
+            - cooking_oven_program_heating_mode_pre_heating
+            - cooking_oven_program_heating_mode_preheat_ovenware
+            - cooking_oven_program_heating_mode_proof
+            - cooking_oven_program_heating_mode_sabbath_programme
+            - cooking_oven_program_heating_mode_slow_cook
+            - cooking_oven_program_heating_mode_top_bottom_heating
+            - cooking_oven_program_heating_mode_top_bottom_heating_eco
+            - cooking_oven_program_heating_mode_warming_drawer
+            - cooking_oven_program_microwave_1000_watt
+            - cooking_oven_program_microwave_180_watt
+            - cooking_oven_program_microwave_360_watt
+            - cooking_oven_program_microwave_450_watt
+            - cooking_oven_program_microwave_600_watt
+            - cooking_oven_program_microwave_900_watt
+            - cooking_oven_program_microwave_90_watt
+            - cooking_oven_program_microwave_max
+            - cooking_oven_program_steam_modes_steam
             - dishcare_dishwasher_program_auto_1
             - dishcare_dishwasher_program_auto_2
             - dishcare_dishwasher_program_auto_3
+            - dishcare_dishwasher_program_auto_half_load
             - dishcare_dishwasher_program_eco_50
-            - dishcare_dishwasher_program_quick_45
-            - dishcare_dishwasher_program_intensiv_70
-            - dishcare_dishwasher_program_normal_65
+            - dishcare_dishwasher_program_express_sparkle_65
             - dishcare_dishwasher_program_glas_40
             - dishcare_dishwasher_program_glass_care
-            - dishcare_dishwasher_program_night_wash
-            - dishcare_dishwasher_program_quick_65
-            - dishcare_dishwasher_program_normal_45
             - dishcare_dishwasher_program_intensiv_45
-            - dishcare_dishwasher_program_auto_half_load
+            - dishcare_dishwasher_program_intensiv_70
             - dishcare_dishwasher_program_intensiv_power
             - dishcare_dishwasher_program_intensive_fixed_zone
-            - dishcare_dishwasher_program_magic_daily
-            - dishcare_dishwasher_program_super_60
             - dishcare_dishwasher_program_kurz_60
-            - dishcare_dishwasher_program_express_sparkle_65
+            - dishcare_dishwasher_program_learning_dishwasher
             - dishcare_dishwasher_program_machine_care
-            - dishcare_dishwasher_program_steam_fresh
+            - dishcare_dishwasher_program_magic_daily
             - dishcare_dishwasher_program_maximum_cleaning
             - dishcare_dishwasher_program_mixed_load
-            - dishcare_dishwasher_program_learning_dishwasher
+            - dishcare_dishwasher_program_night_wash
+            - dishcare_dishwasher_program_normal_45
+            - dishcare_dishwasher_program_normal_65
+            - dishcare_dishwasher_program_pre_rinse
+            - dishcare_dishwasher_program_quick_45
+            - dishcare_dishwasher_program_quick_65
+            - dishcare_dishwasher_program_steam_fresh
+            - dishcare_dishwasher_program_super_60
             - heating_ventilation_air_conditioning_air_conditioner_program_active_clean
             - heating_ventilation_air_conditioning_air_conditioner_program_auto
             - heating_ventilation_air_conditioning_air_conditioner_program_cool
             - heating_ventilation_air_conditioning_air_conditioner_program_dry
             - heating_ventilation_air_conditioning_air_conditioner_program_fan
             - heating_ventilation_air_conditioning_air_conditioner_program_heat
-            - laundry_care_dryer_program_cotton
-            - laundry_care_dryer_program_synthetic
-            - laundry_care_dryer_program_mix
+            - laundry_care_dryer_program_anti_shrink
             - laundry_care_dryer_program_blankets
             - laundry_care_dryer_program_business_shirts
+            - laundry_care_dryer_program_cotton
+            - laundry_care_dryer_program_delicates
+            - laundry_care_dryer_program_dessous
             - laundry_care_dryer_program_down_feathers
             - laundry_care_dryer_program_hygiene
-            - laundry_care_dryer_program_jeans
-            - laundry_care_dryer_program_outdoor
-            - laundry_care_dryer_program_synthetic_refresh
-            - laundry_care_dryer_program_towels
-            - laundry_care_dryer_program_delicates
-            - laundry_care_dryer_program_super_40
-            - laundry_care_dryer_program_shirts_15
-            - laundry_care_dryer_program_pillow
-            - laundry_care_dryer_program_anti_shrink
-            - laundry_care_dryer_program_my_time_my_drying_time
-            - laundry_care_dryer_program_time_cold
-            - laundry_care_dryer_program_time_warm
             - laundry_care_dryer_program_in_basket
+            - laundry_care_dryer_program_jeans
+            - laundry_care_dryer_program_mix
+            - laundry_care_dryer_program_my_time_my_drying_time
+            - laundry_care_dryer_program_outdoor
+            - laundry_care_dryer_program_pillow
+            - laundry_care_dryer_program_shirts_15
+            - laundry_care_dryer_program_super_40
+            - laundry_care_dryer_program_synthetic
+            - laundry_care_dryer_program_synthetic_refresh
+            - laundry_care_dryer_program_time_cold
             - laundry_care_dryer_program_time_cold_fix_time_cold_20
             - laundry_care_dryer_program_time_cold_fix_time_cold_30
             - laundry_care_dryer_program_time_cold_fix_time_cold_60
+            - laundry_care_dryer_program_time_warm
             - laundry_care_dryer_program_time_warm_fix_time_warm_30
             - laundry_care_dryer_program_time_warm_fix_time_warm_40
             - laundry_care_dryer_program_time_warm_fix_time_warm_60
-            - laundry_care_dryer_program_dessous
-            - cooking_common_program_hood_automatic
-            - cooking_common_program_hood_venting
-            - cooking_common_program_hood_delayed_shut_off
-            - cooking_oven_program_heating_mode_3_d_hot_air
-            - cooking_oven_program_heating_mode_air_fry
-            - cooking_oven_program_heating_mode_grill_large_area
-            - cooking_oven_program_heating_mode_grill_small_area
-            - cooking_oven_program_heating_mode_pre_heating
-            - cooking_oven_program_heating_mode_hot_air
-            - cooking_oven_program_heating_mode_hot_air_eco
-            - cooking_oven_program_heating_mode_hot_air_gentle
-            - cooking_oven_program_heating_mode_hot_air_grilling
-            - cooking_oven_program_heating_mode_top_bottom_heating
-            - cooking_oven_program_heating_mode_top_bottom_heating_eco
-            - cooking_oven_program_heating_mode_bottom_heating
-            - cooking_oven_program_heating_mode_bread_baking
-            - cooking_oven_program_heating_mode_pizza_setting
-            - cooking_oven_program_heating_mode_slow_cook
-            - cooking_oven_program_heating_mode_intensive_heat
-            - cooking_oven_program_heating_mode_keep_warm
-            - cooking_oven_program_heating_mode_preheat_ovenware
-            - cooking_oven_program_heating_mode_frozen_heatup_special
-            - cooking_oven_program_heating_mode_desiccation
-            - cooking_oven_program_heating_mode_defrost
-            - cooking_oven_program_heating_mode_dough_proving
-            - cooking_oven_program_heating_mode_proof
-            - cooking_oven_program_heating_mode_hot_air_30_steam
-            - cooking_oven_program_heating_mode_hot_air_60_steam
-            - cooking_oven_program_heating_mode_hot_air_80_steam
-            - cooking_oven_program_heating_mode_hot_air_100_steam
-            - cooking_oven_program_heating_mode_sabbath_programme
-            - cooking_oven_program_microwave_90_watt
-            - cooking_oven_program_microwave_180_watt
-            - cooking_oven_program_microwave_360_watt
-            - cooking_oven_program_microwave_450_watt
-            - cooking_oven_program_microwave_600_watt
-            - cooking_oven_program_microwave_900_watt
-            - cooking_oven_program_microwave_1000_watt
-            - cooking_oven_program_microwave_max
-            - cooking_oven_program_steam_modes_steam
-            - cooking_oven_program_heating_mode_warming_drawer
+            - laundry_care_dryer_program_towels
+            - laundry_care_washer_dryer_program_cotton
+            - laundry_care_washer_dryer_program_cotton_eco_4060
+            - laundry_care_washer_dryer_program_easy_care
+            - laundry_care_washer_dryer_program_mix
+            - laundry_care_washer_dryer_program_wash_and_dry_60
+            - laundry_care_washer_dryer_program_wash_and_dry_90
             - laundry_care_washer_program_auto_30
             - laundry_care_washer_program_auto_40
             - laundry_care_washer_program_auto_60
@@ -190,12 +196,6 @@ set_program_and_options:
             - laundry_care_washer_program_towels
             - laundry_care_washer_program_water_proof
             - laundry_care_washer_program_wool
-            - laundry_care_washer_dryer_program_cotton
-            - laundry_care_washer_dryer_program_cotton_eco_4060
-            - laundry_care_washer_dryer_program_mix
-            - laundry_care_washer_dryer_program_easy_care
-            - laundry_care_washer_dryer_program_wash_and_dry_60
-            - laundry_care_washer_dryer_program_wash_and_dry_90
     air_conditioner_options:
       collapsed: true
       fields:

homeassistant/components/image/__init__.py

@@ -2,20 +2,21 @@
 
 import asyncio
 import collections
+from collections.abc import Container, Mapping
 from contextlib import suppress
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 import logging
 import os
 from random import SystemRandom
-from typing import Final, final
+from typing import Final, final, override
 
-from aiohttp import hdrs, web
+from aiohttp import web
 import httpx
 from propcache.api import cached_property
 import voluptuous as vol
 
-from homeassistant.components.http import KEY_AUTHENTICATED, KEY_HASS, HomeAssistantView
+from homeassistant.components.http import KEY_HASS, HomeAssistantView
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONTENT_TYPE_MULTIPART, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import (
@@ -314,33 +315,28 @@ class ImageView(HomeAssistantView):
     """View to serve an image."""
 
     name = "api:image:image"
-    requires_auth = False
+    use_query_token_for_auth = True
     url = "/api/image_proxy/{entity_id}"
 
     def __init__(self, component: EntityComponent[ImageEntity]) -> None:
         """Initialize an image view."""
         self.component = component
 
-    async def _authenticate_request(
-        self, request: web.Request, entity_id: str
-    ) -> ImageEntity:
-        """Authenticate request and return image entity."""
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        if (image_entity := self.component.get_entity(match_info["entity_id"])) is None:
+            return ()
+
+        return image_entity.access_tokens
+
+    @callback
+    def _get_image_entity(self, entity_id: str) -> ImageEntity:
+        """Get image entity from request."""
         if (image_entity := self.component.get_entity(entity_id)) is None:
             raise web.HTTPNotFound
 
-        authenticated = (
-            request[KEY_AUTHENTICATED]
-            or request.query.get("token") in image_entity.access_tokens
-        )
-
-        if not authenticated:
-            # Attempt with invalid bearer token, raise unauthorized
-            # so ban middleware can handle it.
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            # Invalid sigAuth or image entity access token
-            raise web.HTTPForbidden
-
         return image_entity
 
     async def head(self, request: web.Request, entity_id: str) -> web.Response:
@@ -349,7 +345,7 @@ class ImageView(HomeAssistantView):
         This is sent by some DLNA renderers, like Samsung ones, prior to sending
         the GET request.
         """
-        image_entity = await self._authenticate_request(request, entity_id)
+        image_entity = self._get_image_entity(entity_id)
 
         # Don't use `handle` as we don't care about the stream case, we only want
         # to verify that the image exists.
@@ -365,7 +361,7 @@ class ImageView(HomeAssistantView):
 
     async def get(self, request: web.Request, entity_id: str) -> web.StreamResponse:
         """Start a GET request."""
-        image_entity = await self._authenticate_request(request, entity_id)
+        image_entity = self._get_image_entity(entity_id)
         return await self.handle(request, image_entity)
 
     async def handle(

homeassistant/components/indevolt/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["indevolt-api==1.8.3"],
+  "requirements": ["indevolt-api==1.8.5"],
   "zeroconf": [{ "name": "igen_fw*", "type": "_http._tcp.local." }]
 }

homeassistant/components/indevolt/services.py

@@ -30,7 +30,7 @@ RT_ACTION_SERVICE_SCHEMA: Final = vol.Schema(
         ),
         vol.Required("power"): vol.All(
             vol.Coerce(int),
-            vol.Range(min=1, max=2400),
+            vol.Range(min=0, max=2400),
         ),
     }
 )

homeassistant/components/indevolt/services.yaml

@@ -18,7 +18,7 @@ charge:
       required: true
       selector:
         number:
-          min: 1
+          min: 0
           max: 2400
           step: 1
           unit_of_measurement: "W"
@@ -43,7 +43,7 @@ discharge:
       required: true
       selector:
         number:
-          min: 1
+          min: 0
           max: 2400
           step: 1
           unit_of_measurement: "W"

homeassistant/components/kiosker/button.py

@@ -72,6 +72,11 @@ BUTTONS: tuple[KioskerButtonEntityDescription, ...] = (
         translation_key="screensaver_interact",
         action_fn=lambda api: api.screensaver_interact(),
     ),
+    KioskerButtonEntityDescription(
+        key="blackoutClear",
+        translation_key="blackout_clear",
+        action_fn=lambda api: api.blackout_clear(),
+    ),
 )
 
 

homeassistant/components/kiosker/icons.json

@@ -15,6 +15,9 @@
       }
     },
     "button": {
+      "blackout_clear": {
+        "default": "mdi:monitor"
+      },
       "clear_cache": {
         "default": "mdi:cached"
       },

homeassistant/components/kiosker/strings.json

@@ -57,6 +57,9 @@
       }
     },
     "button": {
+      "blackout_clear": {
+        "name": "Clear blackout"
+      },
       "clear_cache": {
         "name": "Clear cache"
       },

homeassistant/components/landisgyr_heat_meter/config_flow.py

@@ -8,21 +8,19 @@ import serialx
 import ultraheat_api
 import voluptuous as vol
 
-from homeassistant.components import usb
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_DEVICE
-from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.selector import SerialPortSelector
 
 from .const import DOMAIN, ULTRAHEAT_TIMEOUT
 
 _LOGGER = logging.getLogger(__name__)
 
-CONF_MANUAL_PATH = "Enter Manually"
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_DEVICE): str,
+        vol.Required(CONF_DEVICE): SerialPortSelector(),
     }
 )
 
@@ -39,9 +37,6 @@ class LandisgyrConfigFlow(ConfigFlow, domain=DOMAIN):
         errors = {}
 
         if user_input is not None:
-            if user_input[CONF_DEVICE] == CONF_MANUAL_PATH:
-                return await self.async_step_setup_serial_manual_path()
-
             dev_path = user_input[CONF_DEVICE]
             _LOGGER.debug("Using this path : %s", dev_path)
 
@@ -50,30 +45,8 @@ class LandisgyrConfigFlow(ConfigFlow, domain=DOMAIN):
             except CannotConnect:
                 errors["base"] = "cannot_connect"
 
-        ports = await get_usb_ports(self.hass)
-        ports[CONF_MANUAL_PATH] = CONF_MANUAL_PATH
-
-        schema = vol.Schema({vol.Required(CONF_DEVICE): vol.In(ports)})
-        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
-
-    async def async_step_setup_serial_manual_path(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Set path manually."""
-        errors = {}
-
-        if user_input is not None:
-            dev_path = user_input[CONF_DEVICE]
-            try:
-                return await self.validate_and_create_entry(dev_path)
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-
-        schema = vol.Schema({vol.Required(CONF_DEVICE): str})
         return self.async_show_form(
-            step_id="setup_serial_manual_path",
-            data_schema=schema,
-            errors=errors,
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
     async def validate_and_create_entry(self, dev_path):
@@ -111,24 +84,5 @@ class LandisgyrConfigFlow(ConfigFlow, domain=DOMAIN):
         return data.model, data.device_number
 
 
-async def get_usb_ports(hass: HomeAssistant) -> dict[str, str]:
-    """Return a dict of USB ports and their friendly names."""
-    ports = await usb.async_scan_serial_ports(hass)
-    port_descriptions = {}
-    for port in ports:
-        if isinstance(port, usb.USBDevice):
-            human_name = usb.human_readable_device_name(
-                port.device,
-                port.serial_number,
-                port.manufacturer,
-                port.description,
-                port.vid,
-                port.pid,
-            )
-            port_descriptions[port.device] = human_name
-
-    return port_descriptions
-
-
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/landisgyr_heat_meter/const.py

@@ -4,5 +4,5 @@ from datetime import timedelta
 
 DOMAIN = "landisgyr_heat_meter"
 
-ULTRAHEAT_TIMEOUT = 30  # reading the IR port can take some time
+ULTRAHEAT_TIMEOUT = 60  # reading the IR port can take some time
 POLLING_INTERVAL = timedelta(days=1)  # Polling is only daily to prevent battery drain.

homeassistant/components/landisgyr_heat_meter/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/landisgyr_heat_meter",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["ultraheat-api==0.6.0"]
+  "requirements": ["ultraheat-api==0.6.1"]
 }

homeassistant/components/landisgyr_heat_meter/strings.json

@@ -7,11 +7,6 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "step": {
-      "setup_serial_manual_path": {
-        "data": {
-          "device": "[%key:common::config_flow::data::usb_path%]"
-        }
-      },
       "user": {
         "data": {
           "device": "Select device"

homeassistant/components/lg_thinq/sensor.py

@@ -735,6 +735,7 @@ class ThinQSensorEntity(ThinQEntity, SensorEntity):
         value = self.data.value
 
         if isinstance(value, time):
+            # pylint: disable-next=home-assistant-enforce-now
             local_now = datetime.now(
                 tz=dt_util.get_time_zone(self.coordinator.hass.config.time_zone)
             )
@@ -847,6 +848,7 @@ class ThinQEnergySensorEntity(ThinQEntity, SensorEntity):
 
     async def _async_update_and_schedule(self) -> None:
         """Update the state of the sensor."""
+        # pylint: disable-next=home-assistant-enforce-now
         local_now = datetime.now(
             dt_util.get_time_zone(self.coordinator.hass.config.time_zone)
         )

homeassistant/components/linkplay/entity.py

@@ -51,7 +51,7 @@ class LinkPlayBaseEntity(Entity):
             )
 
         self._attr_device_info = dr.DeviceInfo(
-            configuration_url=bridge.endpoint,
+            configuration_url=str(bridge.endpoint),
             connections=connections,
             hw_version=bridge.device.properties["hardware"],
             identifiers={(DOMAIN, bridge.device.uuid)},

homeassistant/components/media_player/__init__.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import collections
-from collections.abc import Callable
+from collections.abc import Callable, Container, Mapping
 from contextlib import suppress
 import datetime as dt
 from enum import StrEnum
@@ -12,7 +12,7 @@ import hashlib
 from http import HTTPStatus
 import logging
 import secrets
-from typing import Any, Final, Required, TypedDict, final
+from typing import Any, Final, Required, TypedDict, final, override
 from urllib.parse import quote, urlparse
 
 import aiohttp
@@ -24,7 +24,7 @@ import voluptuous as vol
 from yarl import URL
 
 from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.websocket_api import ERR_NOT_SUPPORTED, ERR_UNKNOWN_ERROR
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (  # noqa: F401
@@ -50,7 +50,7 @@ from homeassistant.const import (  # noqa: F401
     STATE_PLAYING,
     STATE_STANDBY,
 )
-from homeassistant.core import HomeAssistant, SupportsResponse
+from homeassistant.core import HomeAssistant, SupportsResponse, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import Entity, EntityDescription
@@ -1249,7 +1249,7 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
 class MediaPlayerImageView(HomeAssistantView):
     """Media player view to serve an image."""
 
-    requires_auth = False
+    use_query_token_for_auth = True
     url = "/api/media_player_proxy/{entity_id}"
     name = "api:media_player:image"
     extra_urls = [
@@ -1262,6 +1262,15 @@ class MediaPlayerImageView(HomeAssistantView):
         """Initialize a media player view."""
         self.component = component
 
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        if (player := self.component.get_entity(match_info["entity_id"])) is None:
+            return ()
+
+        return (player.access_token,)
+
     async def get(
         self,
         request: web.Request,
@@ -1271,21 +1280,9 @@ class MediaPlayerImageView(HomeAssistantView):
     ) -> web.Response:
         """Start a get request."""
         if (player := self.component.get_entity(entity_id)) is None:
-            status = (
-                HTTPStatus.NOT_FOUND
-                if request[KEY_AUTHENTICATED]
-                else HTTPStatus.UNAUTHORIZED
-            )
-            return web.Response(status=status)
+            return web.Response(status=HTTPStatus.NOT_FOUND)
 
         assert isinstance(player, MediaPlayerEntity)
-        authenticated = (
-            request[KEY_AUTHENTICATED]
-            or request.query.get("token") == player.access_token
-        )
-
-        if not authenticated:
-            return web.Response(status=HTTPStatus.UNAUTHORIZED)
 
         if media_content_type and media_content_id:
             media_image_id = request.query.get("media_image_id")

homeassistant/components/metoffice/weather.py

@@ -264,9 +264,9 @@ class MetOfficeWeather(
             self.forecast_coordinators["daily"],
         )
         timesteps = coordinator.data.timesteps
-        start_datetime = datetime.now(tz=timesteps[0]["time"].tzinfo).replace(
-            hour=0, minute=0, second=0, microsecond=0
-        )
+        start_datetime = datetime.now(  # pylint: disable=home-assistant-enforce-now
+            tz=timesteps[0]["time"].tzinfo
+        ).replace(hour=0, minute=0, second=0, microsecond=0)
         return [
             _build_daily_forecast_data(timestep)
             for timestep in timesteps
@@ -282,9 +282,9 @@ class MetOfficeWeather(
         )
 
         timesteps = coordinator.data.timesteps
-        start_datetime = datetime.now(tz=timesteps[0]["time"].tzinfo).replace(
-            minute=0, second=0, microsecond=0
-        )
+        start_datetime = datetime.now(  # pylint: disable=home-assistant-enforce-now
+            tz=timesteps[0]["time"].tzinfo
+        ).replace(minute=0, second=0, microsecond=0)
         return [
             _build_hourly_forecast_data(timestep)
             for timestep in timesteps
@@ -299,9 +299,9 @@ class MetOfficeWeather(
             self.forecast_coordinators["twice_daily"],
         )
         timesteps = coordinator.data.timesteps
-        start_datetime = datetime.now(tz=timesteps[0]["time"].tzinfo).replace(
-            hour=0, minute=0, second=0, microsecond=0
-        )
+        start_datetime = datetime.now(  # pylint: disable=home-assistant-enforce-now
+            tz=timesteps[0]["time"].tzinfo
+        ).replace(hour=0, minute=0, second=0, microsecond=0)
         return [
             _build_twice_daily_forecast_data(timestep)
             for timestep in timesteps

homeassistant/components/mitsubishi_comfort/__init__.py

@@ -14,9 +14,16 @@ from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionE
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_CONNECT_TIMEOUT, DEFAULT_RESPONSE_TIMEOUT, DOMAIN, PLATFORMS
+from .const import (
+    CONF_ADDRESSES,
+    DEFAULT_CONNECT_TIMEOUT,
+    DEFAULT_RESPONSE_TIMEOUT,
+    DOMAIN,
+    PLATFORMS,
+)
 from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -25,13 +32,14 @@ _LOGGER = logging.getLogger(__name__)
 def _make_device(
     info: DeviceInfo,
     serial: str,
+    address: str,
     session,
 ) -> IndoorUnit | KumoStation:
     """Create the appropriate device instance from DeviceInfo."""
     cls = IndoorUnit if info.is_indoor_unit else KumoStation
     return cls(
         name=info.label,
-        address=info.address,
+        address=address,
         password_b64=info.password,
         crypto_serial_hex=info.crypto_serial,
         serial=serial,
@@ -64,12 +72,39 @@ async def async_setup_entry(
             translation_key="no_devices",
         )
 
+    # The cloud provides each device's MAC but never its LAN IP. Register every
+    # device with its MAC so the manifest's "registered_devices" DHCP matcher
+    # tracks it; DHCP discovery then supplies the IP via async_step_dhcp.
+    device_registry = dr.async_get(hass)
+    owned_macs = {dr.format_mac(info.mac) for info in devices.values()}
+    for serial, info in devices.items():
+        device_registry.async_get_or_create(
+            config_entry_id=entry.entry_id,
+            identifiers={(DOMAIN, serial)},
+            connections={(dr.CONNECTION_NETWORK_MAC, dr.format_mac(info.mac))},
+            manufacturer="Mitsubishi",
+            name=info.label,
+            serial_number=serial,
+        )
+
+    # Resolved IPs are stored keyed by MAC. Drop any for devices that are no
+    # longer on the account.
+    stored: dict[str, str] = entry.data.get(CONF_ADDRESSES, {})
+    addresses = {mac: ip for mac, ip in stored.items() if mac in owned_macs}
+    if addresses != stored:
+        hass.config_entries.async_update_entry(
+            entry, data={**entry.data, CONF_ADDRESSES: addresses}
+        )
+
     coordinators: dict[str, MitsubishiComfortCoordinator] = {}
     for serial, info in devices.items():
-        if not info.address or not info.password or not info.crypto_serial:
-            _LOGGER.warning("Device %s missing credentials, skipping", info.label)
+        address = addresses.get(dr.format_mac(info.mac))
+        if not address or not info.password or not info.crypto_serial:
+            # No LAN address yet: the device is registered, so DHCP discovery
+            # supplies its IP and reloads the entry to add it.
+            _LOGGER.debug("Device %s has no known LAN address yet", info.label)
             continue
-        device = _make_device(info, serial, session)
+        device = _make_device(info, serial, address, session)
         coordinators[serial] = MitsubishiComfortCoordinator(
             hass, entry, device, info.mac
         )

homeassistant/components/mitsubishi_comfort/config_flow.py

@@ -9,9 +9,11 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
-from .const import DOMAIN
+from .const import CONF_ADDRESSES, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -71,3 +73,41 @@ class MitsubishiComfortConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user", data_schema=USER_SCHEMA, errors=errors
         )
+
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle a registered device discovered on the local network via DHCP.
+
+        The cloud API never returns a device's LAN IP, so DHCP discovery is the
+        source of addresses. Each device is registered with its MAC during setup,
+        so "registered_devices" discovery only fires for our own devices: record
+        the IP on the owning entry and reload to set the device up or recover a
+        changed IP.
+        """
+        mac = dr.format_mac(discovery_info.macaddress)
+        device = dr.async_get(self.hass).async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, mac)}
+        )
+        entry = next(
+            (
+                entry
+                for entry in self._async_current_entries(include_ignore=False)
+                if device is not None and entry.entry_id in device.config_entries
+            ),
+            None,
+        )
+        if entry is None:
+            return self.async_abort(reason="already_configured")
+
+        addresses = entry.data.get(CONF_ADDRESSES, {})
+        if addresses.get(mac) != discovery_info.ip:
+            self.hass.config_entries.async_update_entry(
+                entry,
+                data={
+                    **entry.data,
+                    CONF_ADDRESSES: {**addresses, mac: discovery_info.ip},
+                },
+            )
+            self.hass.config_entries.async_schedule_reload(entry.entry_id)
+        return self.async_abort(reason="already_configured")

homeassistant/components/mitsubishi_comfort/const.py

@@ -7,6 +7,13 @@ from homeassistant.const import Platform
 
 DOMAIN: Final = "mitsubishi_comfort"
 PLATFORMS: Final = [Platform.CLIMATE]
+
+# Config entry data key holding the per-device LAN address cache, keyed by the
+# device's formatted MAC. The cloud API only returns each device's MAC, never
+# its LAN IP, so addresses are resolved from DHCP discovery and persisted here
+# to survive restarts without re-discovery.
+CONF_ADDRESSES: Final = "addresses"
+
 DEFAULT_SCAN_INTERVAL = timedelta(seconds=60)
 DEFAULT_CONNECT_TIMEOUT: Final = 1.2
 DEFAULT_RESPONSE_TIMEOUT: Final = 8.0

homeassistant/components/mitsubishi_comfort/manifest.json

@@ -3,9 +3,10 @@
   "name": "Mitsubishi Comfort",
   "codeowners": ["@nikolairahimi"],
   "config_flow": true,
+  "dhcp": [{ "registered_devices": true }],
   "documentation": "https://www.home-assistant.io/integrations/mitsubishi_comfort",
   "integration_type": "hub",
-  "iot_class": "cloud_polling",
+  "iot_class": "local_polling",
   "quality_scale": "bronze",
   "requirements": ["mitsubishi-comfort==0.3.0"]
 }

homeassistant/components/mitsubishi_comfort/quality_scale.yaml

@@ -56,7 +56,7 @@ rules:
   icon-translations: todo
   reconfiguration-flow: todo
   dynamic-devices: todo
-  discovery-update-info: todo
+  discovery-update-info: done
   repair-issues: todo
   docs-use-cases: done
   docs-supported-devices: done

homeassistant/components/mqtt/__init__.py

@@ -504,6 +504,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Can be removed with HA Core 2027.1
         new_entry_data = entry.data.copy()
         new_entry_data[CONF_PROTOCOL] = PROTOCOL_5
+        # Create temporary certificate files from entry
+        await async_create_certificate_temp_files(hass, new_entry_data)
         # Try the connection with protocol version 5
         # And update the protocol if successful
         if await hass.async_add_executor_job(

homeassistant/components/mqtt/config_flow.py

@@ -70,13 +70,6 @@ from homeassistant.config_entries import (
     SubentryFlowResult,
 )
 from homeassistant.const import (
-    ATTR_CONFIGURATION_URL,
-    ATTR_HW_VERSION,
-    ATTR_MANUFACTURER,
-    ATTR_MODEL,
-    ATTR_MODEL_ID,
-    ATTR_NAME,
-    ATTR_SW_VERSION,
     CONF_BRIGHTNESS,
     CONF_CLIENT_ID,
     CONF_CODE,
@@ -87,6 +80,8 @@ from homeassistant.const import (
     CONF_ENTITY_CATEGORY,
     CONF_HOST,
     CONF_MODE,
+    CONF_MODEL,
+    CONF_MODEL_ID,
     CONF_NAME,
     CONF_OPTIMISTIC,
     CONF_OPTIONS,
@@ -181,6 +176,7 @@ from .const import (
     CONF_COMMAND_ON_TEMPLATE,
     CONF_COMMAND_TEMPLATE,
     CONF_COMMAND_TOPIC,
+    CONF_CONFIGURATION_URL,
     CONF_CONTENT_TYPE,
     CONF_CURRENT_HUMIDITY_TEMPLATE,
     CONF_CURRENT_HUMIDITY_TOPIC,
@@ -221,10 +217,12 @@ from .const import (
     CONF_HUMIDITY_MIN,
     CONF_HUMIDITY_STATE_TEMPLATE,
     CONF_HUMIDITY_STATE_TOPIC,
+    CONF_HW_VERSION,
     CONF_IMAGE_ENCODING,
     CONF_IMAGE_TOPIC,
     CONF_KEEPALIVE,
     CONF_LAST_RESET_VALUE_TEMPLATE,
+    CONF_MANUFACTURER,
     CONF_MAX,
     CONF_MAX_KELVIN,
     CONF_MESSAGE_EXPIRY_INTERVAL,
@@ -317,6 +315,7 @@ from .const import (
     CONF_SUPPORT_VOLUME_SET,
     CONF_SUPPORTED_COLOR_MODES,
     CONF_SUPPORTED_FEATURES,
+    CONF_SW_VERSION,
     CONF_SWING_HORIZONTAL_MODE_COMMAND_TEMPLATE,
     CONF_SWING_HORIZONTAL_MODE_COMMAND_TOPIC,
     CONF_SWING_HORIZONTAL_MODE_LIST,
@@ -2451,7 +2450,7 @@ PLATFORM_MQTT_FIELDS: dict[Platform, dict[str, PlatformField]] = {
             validator=valid_subscribe_topic,
             error="invalid_subscribe_topic",
         ),
-        CONF_VALUE_TEMPLATE: PlatformField(
+        CONF_STATE_VALUE_TEMPLATE: PlatformField(
             selector=TEMPLATE_SELECTOR,
             required=False,
             validator=validate(cv.template),
@@ -3395,7 +3394,7 @@ PLATFORM_MQTT_FIELDS: dict[Platform, dict[str, PlatformField]] = {
             validator=valid_subscribe_topic,
             error="invalid_subscribe_topic",
         ),
-        CONF_VALUE_TEMPLATE: PlatformField(
+        CONF_STATE_VALUE_TEMPLATE: PlatformField(
             selector=TEMPLATE_SELECTOR,
             required=False,
             validator=validate(cv.template),
@@ -3797,17 +3796,17 @@ PLATFORM_MQTT_FIELDS: dict[Platform, dict[str, PlatformField]] = {
     },
 }
 MQTT_DEVICE_PLATFORM_FIELDS = {
-    ATTR_NAME: PlatformField(selector=TEXT_SELECTOR, required=True),
-    ATTR_SW_VERSION: PlatformField(
+    CONF_NAME: PlatformField(selector=TEXT_SELECTOR, required=True),
+    CONF_SW_VERSION: PlatformField(
         selector=TEXT_SELECTOR, required=False, section="advanced_settings"
     ),
-    ATTR_HW_VERSION: PlatformField(
+    CONF_HW_VERSION: PlatformField(
         selector=TEXT_SELECTOR, required=False, section="advanced_settings"
     ),
-    ATTR_MODEL: PlatformField(selector=TEXT_SELECTOR, required=False),
-    ATTR_MODEL_ID: PlatformField(selector=TEXT_SELECTOR, required=False),
-    ATTR_MANUFACTURER: PlatformField(selector=TEXT_SELECTOR, required=False),
-    ATTR_CONFIGURATION_URL: PlatformField(
+    CONF_MODEL: PlatformField(selector=TEXT_SELECTOR, required=False),
+    CONF_MODEL_ID: PlatformField(selector=TEXT_SELECTOR, required=False),
+    CONF_MANUFACTURER: PlatformField(selector=TEXT_SELECTOR, required=False),
+    CONF_CONFIGURATION_URL: PlatformField(
         selector=TEXT_SELECTOR, required=False, validator=cv.url, error="invalid_url"
     ),
     CONF_QOS: PlatformField(

homeassistant/components/mqtt/config_integration.py

@@ -2,31 +2,9 @@
 
 import voluptuous as vol
 
-from homeassistant.const import (
-    CONF_CLIENT_ID,
-    CONF_DISCOVERY,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_PROTOCOL,
-    CONF_USERNAME,
-    Platform,
-)
+from homeassistant.const import Platform
 from homeassistant.helpers import config_validation as cv
 
-from .const import (
-    CONF_BIRTH_MESSAGE,
-    CONF_BROKER,
-    CONF_CERTIFICATE,
-    CONF_CLIENT_CERT,
-    CONF_CLIENT_KEY,
-    CONF_DISCOVERY_PREFIX,
-    CONF_KEEPALIVE,
-    CONF_TLS_INSECURE,
-    CONF_WILL_MESSAGE,
-)
-
-DEFAULT_TLS_PROTOCOL = "auto"
-
 CONFIG_SCHEMA_BASE = vol.Schema(
     {
         Platform.ALARM_CONTROL_PANEL.value: vol.All(cv.ensure_list, [dict]),
@@ -60,29 +38,3 @@ CONFIG_SCHEMA_BASE = vol.Schema(
         Platform.WATER_HEATER.value: vol.All(cv.ensure_list, [dict]),
     }
 )
-
-
-CLIENT_KEY_AUTH_MSG = (
-    "client_key and client_cert must both be present in the MQTT broker configuration"
-)
-
-DEPRECATED_CONFIG_KEYS = [
-    CONF_BIRTH_MESSAGE,
-    CONF_BROKER,
-    CONF_CLIENT_ID,
-    CONF_DISCOVERY,
-    CONF_DISCOVERY_PREFIX,
-    CONF_KEEPALIVE,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_PROTOCOL,
-    CONF_TLS_INSECURE,
-    CONF_USERNAME,
-    CONF_WILL_MESSAGE,
-]
-
-DEPRECATED_CERTIFICATE_CONFIG_KEYS = [
-    CONF_CERTIFICATE,
-    CONF_CLIENT_CERT,
-    CONF_CLIENT_KEY,
-]

homeassistant/components/ollama/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ollama",
   "integration_type": "service",
   "iot_class": "local_polling",
-  "requirements": ["ollama==0.5.1"]
+  "requirements": ["ollama==0.6.2"]
 }

homeassistant/components/openevse/__init__.py

@@ -40,7 +40,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenEVSEConfigEntry) ->
     await coordinator.async_config_entry_first_refresh()
 
     # Start websocket listener for push updates
-    coordinator.start_websocket()
+    await coordinator.async_start_websocket()
 
     entry.runtime_data = coordinator
 

homeassistant/components/openevse/coordinator.py

@@ -48,9 +48,9 @@ class OpenEVSEDataUpdateCoordinator(DataUpdateCoordinator[None]):
         """Handle websocket data update."""
         self.async_set_updated_data(None)
 
-    def start_websocket(self) -> None:
+    async def async_start_websocket(self) -> None:
         """Start the websocket listener."""
-        self.charger.ws_start()
+        await self.charger.ws_start()
 
     async def async_stop_websocket(self) -> None:
         """Stop the websocket listener."""

homeassistant/components/openevse/manifest.json

@@ -9,6 +9,6 @@
   "iot_class": "local_push",
   "loggers": ["openevsehttp"],
   "quality_scale": "bronze",
-  "requirements": ["python-openevse-http==0.3.4"],
+  "requirements": ["python-openevse-http==1.0.1"],
   "zeroconf": ["_openevse._tcp.local."]
 }

homeassistant/components/openevse/number.py

@@ -43,10 +43,10 @@ NUMBER_TYPES: tuple[OpenEVSENumberDescription, ...] = (
     OpenEVSENumberDescription(
         key="charge_rate",
         translation_key="charge_rate",
-        value_fn=lambda ev: ev.max_current_soft,
-        min_value_fn=lambda ev: ev.min_amps,
-        max_value_fn=lambda ev: ev.max_amps,
-        set_value_fn=lambda ev, value: ev.set_current(value),
+        value_fn=lambda ev: ev.max_current_soft or 0,
+        min_value_fn=lambda ev: ev.min_amps or 0,
+        max_value_fn=lambda ev: ev.max_amps or 0,
+        set_value_fn=lambda ev, value: ev.set_current(int(value)),
         native_step=1.0,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,

homeassistant/components/openevse/sensor.py

@@ -75,7 +75,7 @@ SENSOR_TYPES: tuple[OpenEVSESensorDescription, ...] = (
             "1": "level_1",
             "2": "level_2",
             "a": "automatic",
-        }.get(ev.service_level.lower()),
+        }.get(str(ev.service_level).lower()),
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
     ),

homeassistant/components/opentherm_gw/__init__.py

@@ -8,13 +8,7 @@ import pyotgw.vars as gw_vars
 from serial import SerialException
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_DEVICE,
-    CONF_ID,
-    CONF_NAME,
-    EVENT_HOMEASSISTANT_STOP,
-    Platform,
-)
+from homeassistant.const import CONF_DEVICE, CONF_ID, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
@@ -100,7 +94,6 @@ class OpenThermGatewayHub:
         self.hass = hass
         self.device_path = config_entry.data[CONF_DEVICE]
         self.hub_id = config_entry.data[CONF_ID]
-        self.name = config_entry.data[CONF_NAME]
         self.options = config_entry.options
         self.config_entry_id = config_entry.entry_id
         self.update_signal = f"{DATA_OPENTHERM_GW}_{self.hub_id}_update"
@@ -159,11 +152,14 @@ class OpenThermGatewayHub:
             _LOGGER.debug("Received report: %s", status)
             async_dispatcher_send(self.hass, self.update_signal, status)
 
+            boiler_manufacturer = status[OpenThermDataSource.BOILER].get(
+                gw_vars.DATA_SLAVE_MEMBERID
+            )
             dev_reg.async_update_device(
                 boiler_device.id,
-                manufacturer=status[OpenThermDataSource.BOILER].get(
-                    gw_vars.DATA_SLAVE_MEMBERID
-                ),
+                manufacturer=str(boiler_manufacturer)
+                if boiler_manufacturer is not None
+                else None,
                 model_id=status[OpenThermDataSource.BOILER].get(
                     gw_vars.DATA_SLAVE_PRODUCT_TYPE
                 ),
@@ -175,11 +171,14 @@ class OpenThermGatewayHub:
                 ),
             )
 
+            thermostat_manufacturer = status[OpenThermDataSource.THERMOSTAT].get(
+                gw_vars.DATA_MASTER_MEMBERID
+            )
             dev_reg.async_update_device(
                 thermostat_device.id,
-                manufacturer=status[OpenThermDataSource.THERMOSTAT].get(
-                    gw_vars.DATA_MASTER_MEMBERID
-                ),
+                manufacturer=str(thermostat_manufacturer)
+                if thermostat_manufacturer is not None
+                else None,
                 model_id=status[OpenThermDataSource.THERMOSTAT].get(
                     gw_vars.DATA_MASTER_PRODUCT_TYPE
                 ),

homeassistant/components/opentherm_gw/config_flow.py

@@ -17,7 +17,6 @@ from homeassistant.config_entries import (
 from homeassistant.const import (
     CONF_DEVICE,
     CONF_ID,
-    CONF_NAME,
     PRECISION_HALVES,
     PRECISION_TENTHS,
     PRECISION_WHOLE,
@@ -54,9 +53,8 @@ class OpenThermGwConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle config flow initiation."""
         if info:
-            name = info[CONF_NAME]
             device = info[CONF_DEVICE]
-            gw_id = cv.slugify(info.get(CONF_ID, name))
+            gw_id = cv.slugify(info[CONF_ID])
 
             entries = [e.data for e in self._async_current_entries()]
 
@@ -83,7 +81,7 @@ class OpenThermGwConfigFlow(ConfigFlow, domain=DOMAIN):
             except ConnectionError, SerialException:
                 return self._show_form({"base": "cannot_connect"})
 
-            return self._create_entry(gw_id, name, device)
+            return self._create_entry(gw_id, device)
 
         return self._show_form()
 
@@ -99,20 +97,17 @@ class OpenThermGwConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id="init",
             data_schema=vol.Schema(
                 {
-                    # Name field is no longer allowed in config flow schemas
-                    # pylint: disable-next=home-assistant-config-flow-name-field
-                    vol.Required(CONF_NAME): str,
                     vol.Required(CONF_DEVICE): str,
-                    vol.Optional(CONF_ID): str,
+                    vol.Required(CONF_ID): str,
                 }
             ),
             errors=errors or {},
         )
 
-    def _create_entry(self, gw_id, name, device):
+    def _create_entry(self, gw_id, device):
         """Create entry for the OpenTherm Gateway device."""
         return self.async_create_entry(
-            title=name, data={CONF_ID: gw_id, CONF_DEVICE: device, CONF_NAME: name}
+            title="OpenTherm Gateway", data={CONF_ID: gw_id, CONF_DEVICE: device}
         )
 
 

homeassistant/components/opentherm_gw/strings.json

@@ -14,8 +14,7 @@
       "init": {
         "data": {
           "device": "Path or URL",
-          "id": "ID",
-          "name": "[%key:common::config_flow::data::name%]"
+          "id": "ID"
         }
       }
     }

homeassistant/components/opower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
   "quality_scale": "platinum",
-  "requirements": ["opower==0.18.2"]
+  "requirements": ["opower==0.18.3"]
 }

homeassistant/components/overkiz/__init__.py

@@ -4,18 +4,21 @@ from collections import defaultdict
 from dataclasses import dataclass
 
 from aiohttp import ClientError
-from pyoverkiz.client import OverkizClient
-from pyoverkiz.const import SUPPORTED_SERVERS
-from pyoverkiz.enums import APIType, OverkizState, UIClass, UIWidget
-from pyoverkiz.exceptions import (
-    BadCredentialsException,
-    MaintenanceException,
-    NotAuthenticatedException,
-    NotSuchTokenException,
-    TooManyRequestsException,
+from pyoverkiz.auth.credentials import (
+    LocalTokenCredentials,
+    UsernamePasswordCredentials,
 )
-from pyoverkiz.models import Device, OverkizServer, Scenario
-from pyoverkiz.utils import generate_local_server
+from pyoverkiz.client import OverkizClient
+from pyoverkiz.enums import APIType, OverkizState, Server, UIClass, UIWidget
+from pyoverkiz.exceptions import (
+    BadCredentialsError,
+    MaintenanceError,
+    NoSuchTokenError,
+    NotAuthenticatedError,
+    TooManyRequestsError,
+)
+from pyoverkiz.models import Device, PersistedActionGroup
+from pyoverkiz.utils import create_local_server_config
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -58,7 +61,7 @@ class HomeAssistantOverkizData:
 
     coordinator: OverkizDataUpdateCoordinator
     platforms: defaultdict[Platform, list[Device]]
-    scenarios: list[Scenario]
+    scenarios: list[PersistedActionGroup]
 
 
 type OverkizDataConfigEntry = ConfigEntry[HomeAssistantOverkizData]
@@ -90,7 +93,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: OverkizDataConfigEntry)
             hass,
             username=entry.data[CONF_USERNAME],
             password=entry.data[CONF_PASSWORD],
-            server=SUPPORTED_SERVERS[entry.data[CONF_HUB]],
+            server=entry.data[CONF_HUB],
         )
 
     try:
@@ -100,20 +103,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: OverkizDataConfigEntry)
         # Local API does expose scenarios, but they are not functional.
         # Tracked in https://github.com/Somfy-Developer/Somfy-TaHoma-Developer-Mode/issues/21
         if api_type == APIType.CLOUD:
-            scenarios = await client.get_scenarios()
+            scenarios = await client.get_action_groups()
         else:
             scenarios = []
     except (
-        BadCredentialsException,
-        NotSuchTokenException,
-        NotAuthenticatedException,
+        BadCredentialsError,
+        NoSuchTokenError,
+        NotAuthenticatedError,
     ) as exception:
         raise ConfigEntryAuthFailed("Invalid authentication") from exception
-    except TooManyRequestsException as exception:
+    except TooManyRequestsError as exception:
         raise ConfigEntryNotReady("Too many requests, try again later") from exception
     except (TimeoutError, ClientError) as exception:
         raise ConfigEntryNotReady("Failed to connect") from exception
-    except MaintenanceException as exception:
+    except MaintenanceError as exception:
         raise ConfigEntryNotReady("Server is down for maintenance") from exception
 
     coordinator = OverkizDataUpdateCoordinator(
@@ -173,13 +176,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: OverkizDataConfigEntry)
             identifiers={(DOMAIN, gateway.id)},
             model=gateway.type.beautify_name if gateway.type else None,
             model_id=str(gateway.type),
-            manufacturer=client.server.manufacturer,
+            manufacturer=client.server_config.manufacturer,
             name=gateway.type.beautify_name if gateway.type else gateway.id,
             sw_version=gateway.connectivity.protocol_version,
             hw_version=f"{gateway.type}:{gateway.sub_type}"
             if gateway.type and gateway.sub_type
             else None,
-            configuration_url=client.server.configuration_url,
+            configuration_url=client.server_config.configuration_url,
         )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -214,6 +217,9 @@ async def _async_migrate_strenum_unique_ids(
     """Migrate entities to the StrEnum-style unique IDs."""
     entity_registry = er.async_get(hass)
 
+    # Map enum members renamed in pyoverkiz 2.0 to their current names.
+    renamed_enum_members = {"TSKALARM_CONTROLLER": "TSK_ALARM_CONTROLLER"}
+
     @callback
     def update_unique_id(entry: er.RegistryEntry) -> dict[str, str] | None:
         # Python 3.11 treats (str, Enum) and StrEnum
@@ -229,6 +235,7 @@ async def _async_migrate_strenum_unique_ids(
             ("OverkizState", "UIWidget", "UIClass")
         ):
             state = key.split(".")[1]
+            state = renamed_enum_members.get(state, state)
             new_key = ""
 
             if key.startswith("UIClass"):
@@ -276,17 +283,15 @@ def create_local_client(
     session = async_create_clientsession(hass, verify_ssl=verify_ssl)
 
     return OverkizClient(
-        username="",
-        password="",
-        token=token,
+        server=create_local_server_config(host=host),
+        credentials=LocalTokenCredentials(token),
         session=session,
-        server=generate_local_server(host=host),
         verify_ssl=verify_ssl,
     )
 
 
 def create_cloud_client(
-    hass: HomeAssistant, username: str, password: str, server: OverkizServer
+    hass: HomeAssistant, username: str, password: str, server: Server
 ) -> OverkizClient:
     """Create Overkiz cloud client."""
     # To allow users with multiple accounts/hubs, we create a
@@ -294,5 +299,7 @@ def create_cloud_client(
     session = async_create_clientsession(hass)
 
     return OverkizClient(
-        username=username, password=password, session=session, server=server
+        server=server,
+        credentials=UsernamePasswordCredentials(username, password),
+        session=session,
     )

homeassistant/components/overkiz/alarm_control_panel.py

@@ -144,7 +144,7 @@ ALARM_DESCRIPTIONS: list[OverkizAlarmDescription] = [
     # Disabled by default since all Overkiz hubs have this
     # virtual device, but only a few users actually use this.
     OverkizAlarmDescription(
-        key=UIWidget.TSKALARM_CONTROLLER,
+        key=UIWidget.TSK_ALARM_CONTROLLER,
         entity_registry_enabled_default=False,
         supported_features=(
             AlarmControlPanelEntityFeature.ARM_AWAY

homeassistant/components/overkiz/binary_sensor.py

@@ -165,7 +165,7 @@ async def async_setup_entry(
                 description,
             )
             for state in device.definition.states
-            if (description := SUPPORTED_STATES.get(state.qualified_name))
+            if (description := SUPPORTED_STATES.get(state))
         )
 
     async_add_entities(entities)

homeassistant/components/overkiz/button.py

@@ -120,7 +120,7 @@ async def async_setup_entry(
                 description,
             )
             for command in device.definition.commands
-            if (description := SUPPORTED_COMMANDS.get(command.command_name))
+            if (description := SUPPORTED_COMMANDS.get(command))
         )
 
     async_add_entities(entities)

homeassistant/components/overkiz/climate/__init__.py

@@ -115,12 +115,13 @@ async def async_setup_entry(
     # Match devices based on the widget and protocol.
     # #ie Hitachi Air To Air Heat Pumps
     entities_based_on_widget_and_protocol: list[Entity] = [
-        WIDGET_AND_PROTOCOL_TO_CLIMATE_ENTITY[device.widget][device.protocol](
-            device.device_url, data.coordinator
-        )
+        WIDGET_AND_PROTOCOL_TO_CLIMATE_ENTITY[device.widget][
+            device.identifier.protocol
+        ](device.device_url, data.coordinator)
         for device in data.platforms[Platform.CLIMATE]
         if device.widget in WIDGET_AND_PROTOCOL_TO_CLIMATE_ENTITY
-        and device.protocol in WIDGET_AND_PROTOCOL_TO_CLIMATE_ENTITY[device.widget]
+        and device.identifier.protocol
+        in WIDGET_AND_PROTOCOL_TO_CLIMATE_ENTITY[device.widget]
     ]
 
     async_add_entities(

homeassistant/components/overkiz/climate/atlantic_electrical_heater_with_adjustable_temperature_setpoint.py

@@ -157,7 +157,7 @@ class AtlanticElectricalHeaterWithAdjustableTemperatureSetpoint(
     @property
     def target_temperature(self) -> float | None:
         """Return the temperature."""
-        if state := self.device.states[OverkizState.CORE_TARGET_TEMPERATURE]:
+        if state := self.device.states.get(OverkizState.CORE_TARGET_TEMPERATURE):
             return state.value_as_float
         return None
 
@@ -165,7 +165,9 @@ class AtlanticElectricalHeaterWithAdjustableTemperatureSetpoint(
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         if self.temperature_device is not None and (
-            temperature := self.temperature_device.states[OverkizState.CORE_TEMPERATURE]
+            temperature := self.temperature_device.states.get(
+                OverkizState.CORE_TEMPERATURE
+            )
         ):
             return temperature.value_as_float
         return None

homeassistant/components/overkiz/climate/atlantic_electrical_towel_dryer.py

@@ -104,7 +104,9 @@ class AtlanticElectricalTowelDryer(OverkizEntity, ClimateEntity):
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         if self.temperature_device is not None and (
-            temperature := self.temperature_device.states[OverkizState.CORE_TEMPERATURE]
+            temperature := self.temperature_device.states.get(
+                OverkizState.CORE_TEMPERATURE
+            )
         ):
             return cast(float, temperature.value)
 

homeassistant/components/overkiz/climate/atlantic_heat_recovery_ventilation.py

@@ -67,7 +67,9 @@ class AtlanticHeatRecoveryVentilation(OverkizEntity, ClimateEntity):
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         if self.temperature_device is not None and (
-            temperature := self.temperature_device.states[OverkizState.CORE_TEMPERATURE]
+            temperature := self.temperature_device.states.get(
+                OverkizState.CORE_TEMPERATURE
+            )
         ):
             return cast(float, temperature.value)
 

homeassistant/components/overkiz/climate/atlantic_pass_apc_heating_zone.py

@@ -106,7 +106,9 @@ class AtlanticPassAPCHeatingZone(OverkizEntity, ClimateEntity):
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         if self.temperature_device is not None and (
-            temperature := self.temperature_device.states[OverkizState.CORE_TEMPERATURE]
+            temperature := self.temperature_device.states.get(
+                OverkizState.CORE_TEMPERATURE
+            )
         ):
             return cast(float, temperature.value)
 

homeassistant/components/overkiz/climate/evo_home_controller.py

@@ -74,7 +74,7 @@ class EvoHomeController(OverkizEntity, ClimateEntity):
     def preset_mode(self) -> str | None:
         """Return the current preset mode, e.g., home, away, temp."""
         if (
-            state := self.device.states[OverkizState.RAMSES_RAMSES_OPERATING_MODE]
+            state := self.device.states.get(OverkizState.RAMSES_RAMSES_OPERATING_MODE)
         ) and state.value_as_str in OVERKIZ_TO_PRESET_MODES:
             return OVERKIZ_TO_PRESET_MODES[state.value_as_str]
 

homeassistant/components/overkiz/climate/hitachi_air_to_air_heat_pump_hlrrwifi.py

@@ -114,13 +114,13 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     def hvac_mode(self) -> HVACMode:
         """Return hvac operation ie. heat, cool mode."""
         if (
-            main_op_state := self.device.states[MAIN_OPERATION_STATE]
+            main_op_state := self.device.states.get(MAIN_OPERATION_STATE)
         ) and main_op_state.value_as_str:
             if main_op_state.value_as_str.lower() == OverkizCommandParam.OFF:
                 return HVACMode.OFF
 
         if (
-            mode_change_state := self.device.states[MODE_CHANGE_STATE]
+            mode_change_state := self.device.states.get(MODE_CHANGE_STATE)
         ) and mode_change_state.value_as_str:
             sanitized_value = mode_change_state.value_as_str.lower()
             return OVERKIZ_TO_HVAC_MODES[sanitized_value]
@@ -140,7 +140,7 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     @property
     def fan_mode(self) -> str | None:
         """Return the fan setting."""
-        if (state := self.device.states[FAN_SPEED_STATE]) and state.value_as_str:
+        if (state := self.device.states.get(FAN_SPEED_STATE)) and state.value_as_str:
             return OVERKIZ_TO_FAN_MODES[state.value_as_str]
 
         return None
@@ -157,7 +157,7 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     @property
     def swing_mode(self) -> str | None:
         """Return the swing setting."""
-        if (state := self.device.states[SWING_STATE]) and state.value_as_str:
+        if (state := self.device.states.get(SWING_STATE)) and state.value_as_str:
             return OVERKIZ_TO_SWING_MODES[state.value_as_str]
 
         return None
@@ -170,7 +170,7 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     def target_temperature(self) -> int | None:
         """Return the temperature."""
         if (
-            temperature := self.device.states[OverkizState.CORE_TARGET_TEMPERATURE]
+            temperature := self.device.states.get(OverkizState.CORE_TARGET_TEMPERATURE)
         ) and temperature.value_as_int:
             return temperature.value_as_int
 
@@ -179,7 +179,9 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     @property
     def current_temperature(self) -> int | None:
         """Return current temperature."""
-        if (state := self.device.states[ROOM_TEMPERATURE_STATE]) and state.value_as_int:
+        if (
+            state := self.device.states.get(ROOM_TEMPERATURE_STATE)
+        ) and state.value_as_int:
             return state.value_as_int
 
         return None
@@ -192,7 +194,7 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode, e.g., home, away, temp."""
-        if (state := self.device.states[LEAVE_HOME_STATE]) and state.value_as_str:
+        if (state := self.device.states.get(LEAVE_HOME_STATE)) and state.value_as_str:
             if state.value_as_str == OverkizCommandParam.ON:
                 return PRESET_HOLIDAY_MODE
 
@@ -222,7 +224,7 @@ class HitachiAirToAirHeatPumpHLRRWIFI(OverkizEntity, ClimateEntity):
         """
         if value:
             return value
-        state = self.device.states[state_name]
+        state = self.device.states.get(state_name)
         if state and state.value_as_str:
             return state.value_as_str
         return fallback_value

homeassistant/components/overkiz/climate/hitachi_air_to_air_heat_pump_ovp.py

@@ -118,13 +118,13 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def hvac_mode(self) -> HVACMode:
         """Return hvac operation ie. heat, cool mode."""
         if (
-            main_op_state := self.device.states[OverkizState.OVP_MAIN_OPERATION]
+            main_op_state := self.device.states.get(OverkizState.OVP_MAIN_OPERATION)
         ) and main_op_state.value_as_str:
             if main_op_state.value_as_str.lower() == OverkizCommandParam.OFF:
                 return HVACMode.OFF
 
         if (
-            mode_change_state := self.device.states[OverkizState.OVP_MODE_CHANGE]
+            mode_change_state := self.device.states.get(OverkizState.OVP_MODE_CHANGE)
         ) and mode_change_state.value_as_str:
             # The OVP protocol has 'auto cooling' and 'auto heating' values
             # that are equivalent to the HLRRWIFI protocol without spaces
@@ -147,7 +147,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def fan_mode(self) -> str | None:
         """Return the fan setting."""
         if (
-            state := self.device.states[OverkizState.OVP_FAN_SPEED]
+            state := self.device.states.get(OverkizState.OVP_FAN_SPEED)
         ) and state.value_as_str:
             return OVERKIZ_TO_FAN_MODES[state.value_as_str]
 
@@ -160,7 +160,9 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     @property
     def swing_mode(self) -> str | None:
         """Return the swing setting."""
-        if (state := self.device.states[OverkizState.OVP_SWING]) and state.value_as_str:
+        if (
+            state := self.device.states.get(OverkizState.OVP_SWING)
+        ) and state.value_as_str:
             return OVERKIZ_TO_SWING_MODES[state.value_as_str]
 
         return None
@@ -173,7 +175,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def target_temperature(self) -> int | None:
         """Return the target temperature."""
         if (
-            temperature := self.device.states[OverkizState.CORE_TARGET_TEMPERATURE]
+            temperature := self.device.states.get(OverkizState.CORE_TARGET_TEMPERATURE)
         ) and temperature.value_as_int:
             return temperature.value_as_int
 
@@ -183,7 +185,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def current_temperature(self) -> int | None:
         """Return current temperature."""
         if (
-            state := self.device.states[OverkizState.OVP_ROOM_TEMPERATURE]
+            state := self.device.states.get(OverkizState.OVP_ROOM_TEMPERATURE)
         ) and state.value_as_int:
             return state.value_as_int
 
@@ -197,7 +199,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def preset_mode(self) -> str | None:
         """Return the current preset mode, e.g., home, away, temp."""
         if (
-            state := self.device.states[OverkizState.CORE_HOLIDAYS_MODE]
+            state := self.device.states.get(OverkizState.CORE_HOLIDAYS_MODE)
         ) and state.value_as_str:
             if state.value_as_str == OverkizCommandParam.ON:
                 return PRESET_HOLIDAY_MODE
@@ -225,7 +227,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def auto_manu_mode(self) -> str | None:
         """Return auto/manu mode."""
         if (
-            state := self.device.states[OverkizState.CORE_AUTO_MANU_MODE]
+            state := self.device.states.get(OverkizState.CORE_AUTO_MANU_MODE)
         ) and state.value_as_str:
             return state.value_as_str
         return None
@@ -235,7 +237,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
     def temperature_change(self) -> int | None:
         """Return temperature change state."""
         if (
-            state := self.device.states[OverkizState.OVP_TEMPERATURE_CHANGE]
+            state := self.device.states.get(OverkizState.OVP_TEMPERATURE_CHANGE)
         ) and state.value_as_int:
             return state.value_as_int
 
@@ -266,7 +268,7 @@ class HitachiAirToAirHeatPumpOVP(OverkizEntity, ClimateEntity):
         """
         if value:
             return value
-        if (state := self.device.states[state_name]) is not None and (
+        if (state := self.device.states.get(state_name)) is not None and (
             value := state.value_as_str
         ) is not None:
             return value