2025.11.1 (#156076)

Co-authored-by: epenet <6771947+epenet@users.noreply.github.com>

.github/workflows/builder.yml

@@ -88,10 +88,6 @@ jobs:
       fail-fast: false
       matrix:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        exclude:
-          - arch: armv7
-          - arch: armhf
-          - arch: i386
     steps:
       - name: Checkout the repository
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -166,6 +162,18 @@ jobs:
             sed -i "s|home-assistant-intents==.*||" requirements_all.txt
           fi
 
+      - name: Adjustments for armhf
+        if: matrix.arch == 'armhf'
+        run: |
+          # Pandas has issues building on armhf, it is expected they
+          # will drop the platform in the near future (they consider it
+          # "flimsy" on 386). The following packages depend on pandas,
+          # so we comment them out.
+          sed -i "s|env-canada|# env-canada|g" requirements_all.txt
+          sed -i "s|noaa-coops|# noaa-coops|g" requirements_all.txt
+          sed -i "s|pyezviz|# pyezviz|g" requirements_all.txt
+          sed -i "s|pykrakenapi|# pykrakenapi|g" requirements_all.txt
+
       - name: Download translations
         uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
         with:
@@ -218,11 +226,19 @@ jobs:
           - odroid-c4
           - odroid-m1
           - odroid-n2
+          - odroid-xu
+          - qemuarm
           - qemuarm-64
+          - qemux86
           - qemux86-64
+          - raspberrypi
+          - raspberrypi2
+          - raspberrypi3
           - raspberrypi3-64
+          - raspberrypi4
           - raspberrypi4-64
           - raspberrypi5-64
+          - tinker
           - yellow
           - green
     steps:
@@ -281,7 +297,6 @@ jobs:
           key-description: "Home Assistant Core"
           version: ${{ needs.init.outputs.version }}
           channel: ${{ needs.init.outputs.channel }}
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
 
       - name: Update version file (stable -> beta)
         if: needs.init.outputs.channel == 'stable'
@@ -291,7 +306,6 @@ jobs:
           key-description: "Home Assistant Core"
           version: ${{ needs.init.outputs.version }}
           channel: beta
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
 
   publish_container:
     name: Publish meta container for ${{ matrix.registry }}
@@ -343,12 +357,27 @@ jobs:
 
             docker manifest create "${registry}/home-assistant:${tag_l}" \
               "${registry}/amd64-homeassistant:${tag_r}" \
+              "${registry}/i386-homeassistant:${tag_r}" \
+              "${registry}/armhf-homeassistant:${tag_r}" \
+              "${registry}/armv7-homeassistant:${tag_r}" \
               "${registry}/aarch64-homeassistant:${tag_r}"
 
             docker manifest annotate "${registry}/home-assistant:${tag_l}" \
               "${registry}/amd64-homeassistant:${tag_r}" \
               --os linux --arch amd64
 
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/i386-homeassistant:${tag_r}" \
+              --os linux --arch 386
+
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/armhf-homeassistant:${tag_r}" \
+              --os linux --arch arm --variant=v6
+
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/armv7-homeassistant:${tag_r}" \
+              --os linux --arch arm --variant=v7
+
             docker manifest annotate "${registry}/home-assistant:${tag_l}" \
               "${registry}/aarch64-homeassistant:${tag_r}" \
               --os linux --arch arm64 --variant=v8
@@ -376,14 +405,23 @@ jobs:
 
           # Pull images from github container registry and verify signature
           docker pull "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/i386-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/armhf-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/armv7-homeassistant:${{ needs.init.outputs.version }}"
           docker pull "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
 
           validate_image "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/i386-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/armhf-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/armv7-homeassistant:${{ needs.init.outputs.version }}"
           validate_image "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
 
           if [[ "${{ matrix.registry }}" ==  "docker.io/homeassistant" ]]; then
             # Upload images to dockerhub
             push_dockerhub "amd64-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "i386-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "armhf-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "armv7-homeassistant" "${{ needs.init.outputs.version }}"
             push_dockerhub "aarch64-homeassistant" "${{ needs.init.outputs.version }}"
           fi
 

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 1
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2025.12"
+  HA_SHORT_VERSION: "2025.11"
   DEFAULT_PYTHON: "3.13"
   ALL_PYTHON_VERSIONS: "['3.13', '3.14']"
   # 10.3 is the oldest supported version
@@ -502,6 +502,7 @@ jobs:
             libavfilter-dev \
             libavformat-dev \
             libavutil-dev \
+            libgammu-dev \
             libswresample-dev \
             libswscale-dev \
             libudev-dev
@@ -800,7 +801,8 @@ jobs:
             -o Dir::State::Lists=${{ env.APT_LIST_CACHE_DIR }} \
             bluez \
             ffmpeg \
-            libturbojpeg
+            libturbojpeg \
+            libgammu-dev
       - *checkout
       - *setup-python-default
       - *cache-restore-python-default
@@ -851,6 +853,7 @@ jobs:
             bluez \
             ffmpeg \
             libturbojpeg \
+            libgammu-dev \
             libxml2-utils
       - *checkout
       - *setup-python-matrix
@@ -1230,6 +1233,7 @@ jobs:
             bluez \
             ffmpeg \
             libturbojpeg \
+            libgammu-dev \
             libxml2-utils
       - *checkout
       - *setup-python-matrix

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@4e94bd11f71e507f7f87df81788dff88d1dacbfb # v4.31.0
         with:
           category: "/language:python"

.github/workflows/wheels.yml

@@ -228,7 +228,7 @@ jobs:
           arch: ${{ matrix.arch }}
           wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
-          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
+          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"

.strict-typing

@@ -107,7 +107,6 @@ homeassistant.components.automation.*
 homeassistant.components.awair.*
 homeassistant.components.axis.*
 homeassistant.components.azure_storage.*
-homeassistant.components.backblaze_b2.*
 homeassistant.components.backup.*
 homeassistant.components.baf.*
 homeassistant.components.bang_olufsen.*
@@ -396,6 +395,7 @@ homeassistant.components.otbr.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
 homeassistant.components.p1_monitor.*
+homeassistant.components.pandora.*
 homeassistant.components.panel_custom.*
 homeassistant.components.paperless_ngx.*
 homeassistant.components.peblar.*

CODEOWNERS

@@ -196,8 +196,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/azure_service_bus/ @hfurubotten
 /homeassistant/components/azure_storage/ @zweckj
 /tests/components/azure_storage/ @zweckj
-/homeassistant/components/backblaze_b2/ @hugo-vrijswijk @ElCruncharino
-/tests/components/backblaze_b2/ @hugo-vrijswijk @ElCruncharino
 /homeassistant/components/backup/ @home-assistant/core
 /tests/components/backup/ @home-assistant/core
 /homeassistant/components/baf/ @bdraco @jfroy
@@ -318,6 +316,8 @@ build.json @home-assistant/supervisor
 /tests/components/cpuspeed/ @fabaff
 /homeassistant/components/crownstone/ @Crownstone @RicArch97
 /tests/components/crownstone/ @Crownstone @RicArch97
+/homeassistant/components/cups/ @fabaff
+/tests/components/cups/ @fabaff
 /homeassistant/components/cync/ @Kinachi249
 /tests/components/cync/ @Kinachi249
 /homeassistant/components/daikin/ @fredrike
@@ -510,6 +510,8 @@ build.json @home-assistant/supervisor
 /tests/components/fjaraskupan/ @elupus
 /homeassistant/components/flexit_bacnet/ @lellky @piotrbulinski
 /tests/components/flexit_bacnet/ @lellky @piotrbulinski
+/homeassistant/components/flick_electric/ @ZephireNZ
+/tests/components/flick_electric/ @ZephireNZ
 /homeassistant/components/flipr/ @cnico
 /tests/components/flipr/ @cnico
 /homeassistant/components/flo/ @dmulcahey
@@ -1477,6 +1479,8 @@ build.json @home-assistant/supervisor
 /tests/components/smhi/ @gjohansson-ST
 /homeassistant/components/smlight/ @tl-sl
 /tests/components/smlight/ @tl-sl
+/homeassistant/components/sms/ @ocalvo
+/tests/components/sms/ @ocalvo
 /homeassistant/components/snapcast/ @luar123
 /tests/components/snapcast/ @luar123
 /homeassistant/components/snmp/ @nmaggioni
@@ -1717,8 +1721,8 @@ build.json @home-assistant/supervisor
 /tests/components/vallox/ @andre-richter @slovdahl @viiru- @yozik04
 /homeassistant/components/valve/ @home-assistant/core
 /tests/components/valve/ @home-assistant/core
-/homeassistant/components/vegehub/ @thulrus
-/tests/components/vegehub/ @thulrus
+/homeassistant/components/vegehub/ @ghowevege
+/tests/components/vegehub/ @ghowevege
 /homeassistant/components/velbus/ @Cereal2nd @brefra
 /tests/components/velbus/ @Cereal2nd @brefra
 /homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
@@ -1817,8 +1821,8 @@ build.json @home-assistant/supervisor
 /tests/components/ws66i/ @ssaenger
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
-/homeassistant/components/xbox/ @hunterjm @tr4nt0r
-/tests/components/xbox/ @hunterjm @tr4nt0r
+/homeassistant/components/xbox/ @hunterjm
+/tests/components/xbox/ @hunterjm
 /homeassistant/components/xiaomi_aqara/ @danielhiversen @syssi
 /tests/components/xiaomi_aqara/ @danielhiversen @syssi
 /homeassistant/components/xiaomi_ble/ @Jc2k @Ernst79

Dockerfile.dev

@@ -13,6 +13,7 @@ RUN \
         libavcodec-dev \
         libavdevice-dev \
         libavutil-dev \
+        libgammu-dev \
         libswscale-dev \
         libswresample-dev \
         libavfilter-dev \

homeassistant/auth/mfa_modules/notify.py

@@ -6,6 +6,7 @@ Sending HOTP through notify service
 from __future__ import annotations
 
 import asyncio
+from collections import OrderedDict
 import logging
 from typing import Any, cast
 
@@ -303,14 +304,13 @@ class NotifySetupFlow(SetupFlow[NotifyAuthModule]):
         if not self._available_notify_services:
             return self.async_abort(reason="no_available_service")
 
-        schema = vol.Schema(
-            {
-                vol.Required("notify_service"): vol.In(self._available_notify_services),
-                vol.Optional("target"): str,
-            }
-        )
+        schema: dict[str, Any] = OrderedDict()
+        schema["notify_service"] = vol.In(self._available_notify_services)
+        schema["target"] = vol.Optional(str)
 
-        return self.async_show_form(step_id="init", data_schema=schema, errors=errors)
+        return self.async_show_form(
+            step_id="init", data_schema=vol.Schema(schema), errors=errors
+        )
 
     async def async_step_setup(
         self, user_input: dict[str, str] | None = None

homeassistant/brands/yale.json

@@ -1,5 +1,11 @@
 {
   "domain": "yale",
-  "name": "Yale (non-US/Canada)",
-  "integrations": ["yale", "yalexs_ble", "yale_smart_alarm"]
+  "name": "Yale",
+  "integrations": [
+    "august",
+    "yale_smart_alarm",
+    "yalexs_ble",
+    "yale_home",
+    "yale"
+  ]
 }

homeassistant/brands/yale_august.json

@@ -1,5 +0,0 @@
-{
-  "domain": "yale_august",
-  "name": "Yale August (US/Canada)",
-  "integrations": ["august", "august_ble"]
-}

homeassistant/components/adax/config_flow.py

@@ -17,11 +17,6 @@ from homeassistant.const import (
     CONF_UNIQUE_ID,
 )
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import (
-    TextSelector,
-    TextSelectorConfig,
-    TextSelectorType,
-)
 
 from .const import (
     ACCOUNT_ID,
@@ -71,15 +66,7 @@ class AdaxConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the local step."""
         data_schema = vol.Schema(
-            {
-                vol.Required(WIFI_SSID): str,
-                vol.Required(WIFI_PSWD): TextSelector(
-                    TextSelectorConfig(
-                        type=TextSelectorType.PASSWORD,
-                        autocomplete="current-password",
-                    ),
-                ),
-            }
+            {vol.Required(WIFI_SSID): str, vol.Required(WIFI_PSWD): str}
         )
         if user_input is None:
             return self.async_show_form(

homeassistant/components/adax/sensor.py

@@ -2,16 +2,14 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import cast
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
-    SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfTemperature
+from homeassistant.const import UnitOfEnergy
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -22,74 +20,44 @@ from .const import CONNECTION_TYPE, DOMAIN, LOCAL
 from .coordinator import AdaxCloudCoordinator
 
 
-@dataclass(kw_only=True, frozen=True)
-class AdaxSensorDescription(SensorEntityDescription):
-    """Describes Adax sensor entity."""
-
-    data_key: str
-
-
-SENSORS: tuple[AdaxSensorDescription, ...] = (
-    AdaxSensorDescription(
-        key="temperature",
-        data_key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=1,
-    ),
-    AdaxSensorDescription(
-        key="energy",
-        data_key="energyWh",
-        device_class=SensorDeviceClass.ENERGY,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        suggested_display_precision=3,
-    ),
-)
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: AdaxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Adax sensors with config flow."""
+    """Set up the Adax energy sensors with config flow."""
     if entry.data.get(CONNECTION_TYPE) != LOCAL:
         cloud_coordinator = cast(AdaxCloudCoordinator, entry.runtime_data)
 
         # Create individual energy sensors for each device
         async_add_entities(
-            [
-                AdaxSensor(cloud_coordinator, entity_description, device_id)
-                for device_id in cloud_coordinator.data
-                for entity_description in SENSORS
-            ]
+            AdaxEnergySensor(cloud_coordinator, device_id)
+            for device_id in cloud_coordinator.data
         )
 
 
-class AdaxSensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
-    """Representation of an Adax sensor."""
+class AdaxEnergySensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
+    """Representation of an Adax energy sensor."""
 
-    entity_description: AdaxSensorDescription
     _attr_has_entity_name = True
+    _attr_translation_key = "energy"
+    _attr_device_class = SensorDeviceClass.ENERGY
+    _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
+    _attr_suggested_unit_of_measurement = UnitOfEnergy.KILO_WATT_HOUR
+    _attr_state_class = SensorStateClass.TOTAL_INCREASING
+    _attr_suggested_display_precision = 3
 
     def __init__(
         self,
         coordinator: AdaxCloudCoordinator,
-        entity_description: AdaxSensorDescription,
         device_id: str,
     ) -> None:
-        """Initialize the sensor."""
+        """Initialize the energy sensor."""
         super().__init__(coordinator)
-        self.entity_description = entity_description
         self._device_id = device_id
         room = coordinator.data[device_id]
 
-        self._attr_unique_id = (
-            f"{room['homeId']}_{device_id}_{self.entity_description.key}"
-        )
+        self._attr_unique_id = f"{room['homeId']}_{device_id}_energy"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, device_id)},
             name=room["name"],
@@ -100,14 +68,10 @@ class AdaxSensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
     def available(self) -> bool:
         """Return True if entity is available."""
         return (
-            super().available
-            and self.entity_description.data_key
-            in self.coordinator.data[self._device_id]
+            super().available and "energyWh" in self.coordinator.data[self._device_id]
         )
 
     @property
-    def native_value(self) -> int | float | None:
+    def native_value(self) -> int:
         """Return the native value of the sensor."""
-        return self.coordinator.data[self._device_id].get(
-            self.entity_description.data_key
-        )
+        return int(self.coordinator.data[self._device_id]["energyWh"])

homeassistant/components/ai_task/services.yaml

@@ -30,7 +30,6 @@ generate_data:
         media:
           accept:
             - "*"
-          multiple: true
 generate_image:
   fields:
     task_name:
@@ -58,4 +57,3 @@ generate_image:
         media:
           accept:
             - "*"
-          multiple: true

homeassistant/components/alexa/handlers.py

@@ -58,10 +58,7 @@ from homeassistant.const import (
 from homeassistant.helpers import network
 from homeassistant.util import color as color_util, dt as dt_util
 from homeassistant.util.decorator import Registry
-from homeassistant.util.unit_conversion import (
-    TemperatureConverter,
-    TemperatureDeltaConverter,
-)
+from homeassistant.util.unit_conversion import TemperatureConverter
 
 from .config import AbstractConfig
 from .const import (
@@ -847,7 +844,7 @@ def temperature_from_object(
         temp -= 273.15
 
     if interval:
-        return TemperatureDeltaConverter.convert(temp, from_unit, to_unit)
+        return TemperatureConverter.convert_interval(temp, from_unit, to_unit)
     return TemperatureConverter.convert(temp, from_unit, to_unit)
 
 

homeassistant/components/alexa_devices/diagnostics.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import asdict
 from typing import Any
 
 from aioamazondevices.structures import AmazonDevice
@@ -61,5 +60,5 @@ def build_device_data(device: AmazonDevice) -> dict[str, Any]:
         "online": device.online,
         "serial number": device.serial_number,
         "software version": device.software_version,
-        "sensors": {key: asdict(sensor) for key, sensor in device.sensors.items()},
+        "sensors": device.sensors,
     }

homeassistant/components/amberelectric/__init__.py

@@ -9,14 +9,14 @@ from homeassistant.helpers import config_validation as cv
 
 from .const import CONF_SITE_ID, DOMAIN, PLATFORMS
 from .coordinator import AmberConfigEntry, AmberUpdateCoordinator
-from .services import async_setup_services
+from .services import setup_services
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Amber component."""
-    async_setup_services(hass)
+    setup_services(hass)
     return True
 
 

homeassistant/components/amberelectric/services.py

@@ -10,7 +10,6 @@ from homeassistant.core import (
     ServiceCall,
     ServiceResponse,
     SupportsResponse,
-    callback,
 )
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.selector import ConfigEntrySelector
@@ -103,8 +102,7 @@ def get_forecasts(channel_type: str, data: dict) -> list[JsonValueType]:
     return results
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Amber integration."""
 
     async def handle_get_forecasts(call: ServiceCall) -> ServiceResponse:

homeassistant/components/androidtv/config_flow.py

@@ -39,11 +39,11 @@ from .const import (
     CONF_TURN_OFF_COMMAND,
     CONF_TURN_ON_COMMAND,
     DEFAULT_ADB_SERVER_PORT,
+    DEFAULT_DEVICE_CLASS,
     DEFAULT_EXCLUDE_UNNAMED_APPS,
     DEFAULT_GET_SOURCES,
     DEFAULT_PORT,
     DEFAULT_SCREENCAP_INTERVAL,
-    DEVICE_AUTO,
     DEVICE_CLASSES,
     DOMAIN,
     PROP_ETHMAC,
@@ -89,14 +89,8 @@ class AndroidTVFlowHandler(ConfigFlow, domain=DOMAIN):
         data_schema = vol.Schema(
             {
                 vol.Required(CONF_HOST, default=host): str,
-                vol.Required(CONF_DEVICE_CLASS, default=DEVICE_AUTO): SelectSelector(
-                    SelectSelectorConfig(
-                        options=[
-                            SelectOptionDict(value=k, label=v)
-                            for k, v in DEVICE_CLASSES.items()
-                        ],
-                        translation_key="device_class",
-                    )
+                vol.Required(CONF_DEVICE_CLASS, default=DEFAULT_DEVICE_CLASS): vol.In(
+                    DEVICE_CLASSES
                 ),
                 vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
             },

homeassistant/components/androidtv/const.py

@@ -15,19 +15,15 @@ CONF_TURN_OFF_COMMAND = "turn_off_command"
 CONF_TURN_ON_COMMAND = "turn_on_command"
 
 DEFAULT_ADB_SERVER_PORT = 5037
+DEFAULT_DEVICE_CLASS = "auto"
 DEFAULT_EXCLUDE_UNNAMED_APPS = False
 DEFAULT_GET_SOURCES = True
 DEFAULT_PORT = 5555
 DEFAULT_SCREENCAP_INTERVAL = 5
 
-DEVICE_AUTO = "auto"
 DEVICE_ANDROIDTV = "androidtv"
 DEVICE_FIRETV = "firetv"
-DEVICE_CLASSES = {
-    DEVICE_AUTO: "auto",
-    DEVICE_ANDROIDTV: "Android TV",
-    DEVICE_FIRETV: "Fire TV",
-}
+DEVICE_CLASSES = [DEFAULT_DEVICE_CLASS, DEVICE_ANDROIDTV, DEVICE_FIRETV]
 
 PROP_ETHMAC = "ethmac"
 PROP_SERIALNO = "serialno"

homeassistant/components/androidtv/strings.json

@@ -65,13 +65,6 @@
       }
     }
   },
-  "selector": {
-    "device_class": {
-      "options": {
-        "auto": "Auto-detect device type"
-      }
-    }
-  },
   "services": {
     "adb_command": {
       "description": "Sends an ADB command to an Android / Fire TV device.",

homeassistant/components/anthropic/config_flow.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from functools import partial
 import json
 import logging
-from typing import Any
+from typing import Any, cast
 
 import anthropic
 import voluptuous as vol
@@ -37,7 +38,6 @@ from homeassistant.helpers.selector import (
     SelectSelectorConfig,
     TemplateSelector,
 )
-from homeassistant.helpers.typing import VolDictType
 
 from .const import (
     CONF_CHAT_MODEL,
@@ -55,7 +55,6 @@ from .const import (
     CONF_WEB_SEARCH_USER_LOCATION,
     DEFAULT_CONVERSATION_NAME,
     DOMAIN,
-    NON_THINKING_MODELS,
     RECOMMENDED_CHAT_MODEL,
     RECOMMENDED_MAX_TOKENS,
     RECOMMENDED_TEMPERATURE,
@@ -153,218 +152,95 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
 class ConversationSubentryFlowHandler(ConfigSubentryFlow):
     """Flow for managing conversation subentries."""
 
-    options: dict[str, Any]
+    last_rendered_recommended = False
 
     @property
     def _is_new(self) -> bool:
         """Return if this is a new subentry."""
         return self.source == "user"
 
-    async def async_step_user(
+    async def async_step_set_options(
         self, user_input: dict[str, Any] | None = None
     ) -> SubentryFlowResult:
-        """Add a subentry."""
-        self.options = RECOMMENDED_OPTIONS.copy()
-        return await self.async_step_init()
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle reconfiguration of a subentry."""
-        self.options = self._get_reconfigure_subentry().data.copy()
-        return await self.async_step_init()
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Set initial options."""
+        """Set conversation options."""
         # abort if entry is not loaded
         if self._get_entry().state != ConfigEntryState.LOADED:
             return self.async_abort(reason="entry_not_loaded")
 
-        hass_apis: list[SelectOptionDict] = [
-            SelectOptionDict(
-                label=api.name,
-                value=api.id,
-            )
-            for api in llm.async_get_apis(self.hass)
-        ]
-        if (suggested_llm_apis := self.options.get(CONF_LLM_HASS_API)) and isinstance(
-            suggested_llm_apis, str
-        ):
-            self.options[CONF_LLM_HASS_API] = [suggested_llm_apis]
-
-        step_schema: VolDictType = {}
         errors: dict[str, str] = {}
 
-        if self._is_new:
-            step_schema[vol.Required(CONF_NAME, default=DEFAULT_CONVERSATION_NAME)] = (
-                str
+        if user_input is None:
+            if self._is_new:
+                options = RECOMMENDED_OPTIONS.copy()
+            else:
+                # If this is a reconfiguration, we need to copy the existing options
+                # so that we can show the current values in the form.
+                options = self._get_reconfigure_subentry().data.copy()
+
+            self.last_rendered_recommended = cast(
+                bool, options.get(CONF_RECOMMENDED, False)
             )
 
-        step_schema.update(
-            {
-                vol.Optional(CONF_PROMPT): TemplateSelector(),
-                vol.Optional(
-                    CONF_LLM_HASS_API,
-                ): SelectSelector(
-                    SelectSelectorConfig(options=hass_apis, multiple=True)
-                ),
-                vol.Required(
-                    CONF_RECOMMENDED, default=self.options.get(CONF_RECOMMENDED, False)
-                ): bool,
-            }
-        )
-
-        if user_input is not None:
+        elif user_input[CONF_RECOMMENDED] == self.last_rendered_recommended:
             if not user_input.get(CONF_LLM_HASS_API):
                 user_input.pop(CONF_LLM_HASS_API, None)
-
-            if user_input[CONF_RECOMMENDED]:
-                if not errors:
-                    if self._is_new:
-                        return self.async_create_entry(
-                            title=user_input.pop(CONF_NAME),
-                            data=user_input,
-                        )
-                    return self.async_update_and_abort(
-                        self._get_entry(),
-                        self._get_reconfigure_subentry(),
-                        data=user_input,
-                    )
-            else:
-                self.options.update(user_input)
-                if (
-                    CONF_LLM_HASS_API in self.options
-                    and CONF_LLM_HASS_API not in user_input
-                ):
-                    self.options.pop(CONF_LLM_HASS_API)
-                if not errors:
-                    return await self.async_step_advanced()
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=self.add_suggested_values_to_schema(
-                vol.Schema(step_schema), self.options
-            ),
-            errors=errors or None,
-        )
-
-    async def async_step_advanced(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Manage advanced options."""
-        errors: dict[str, str] = {}
-
-        step_schema: VolDictType = {
-            vol.Optional(
-                CONF_CHAT_MODEL,
-                default=RECOMMENDED_CHAT_MODEL,
-            ): str,
-            vol.Optional(
-                CONF_MAX_TOKENS,
-                default=RECOMMENDED_MAX_TOKENS,
-            ): int,
-            vol.Optional(
-                CONF_TEMPERATURE,
-                default=RECOMMENDED_TEMPERATURE,
-            ): NumberSelector(NumberSelectorConfig(min=0, max=1, step=0.05)),
-        }
-
-        if user_input is not None:
-            self.options.update(user_input)
-
-            if not errors:
-                return await self.async_step_model()
-
-        return self.async_show_form(
-            step_id="advanced",
-            data_schema=self.add_suggested_values_to_schema(
-                vol.Schema(step_schema), self.options
-            ),
-            errors=errors,
-        )
-
-    async def async_step_model(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Manage model-specific options."""
-        errors: dict[str, str] = {}
-
-        step_schema: VolDictType = {}
-
-        model = self.options[CONF_CHAT_MODEL]
-
-        if not model.startswith(tuple(NON_THINKING_MODELS)):
-            step_schema[
-                vol.Optional(CONF_THINKING_BUDGET, default=RECOMMENDED_THINKING_BUDGET)
-            ] = NumberSelector(
-                NumberSelectorConfig(
-                    min=0, max=self.options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS)
-                )
-            )
-        else:
-            self.options.pop(CONF_THINKING_BUDGET, None)
-
-        if not model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
-            step_schema.update(
-                {
-                    vol.Optional(
-                        CONF_WEB_SEARCH,
-                        default=RECOMMENDED_WEB_SEARCH,
-                    ): bool,
-                    vol.Optional(
-                        CONF_WEB_SEARCH_MAX_USES,
-                        default=RECOMMENDED_WEB_SEARCH_MAX_USES,
-                    ): int,
-                    vol.Optional(
-                        CONF_WEB_SEARCH_USER_LOCATION,
-                        default=RECOMMENDED_WEB_SEARCH_USER_LOCATION,
-                    ): bool,
-                }
-            )
-        else:
-            self.options.pop(CONF_WEB_SEARCH, None)
-            self.options.pop(CONF_WEB_SEARCH_MAX_USES, None)
-            self.options.pop(CONF_WEB_SEARCH_USER_LOCATION, None)
-
-        self.options.pop(CONF_WEB_SEARCH_CITY, None)
-        self.options.pop(CONF_WEB_SEARCH_REGION, None)
-        self.options.pop(CONF_WEB_SEARCH_COUNTRY, None)
-        self.options.pop(CONF_WEB_SEARCH_TIMEZONE, None)
-
-        if not step_schema:
-            user_input = {}
-
-        if user_input is not None:
-            if user_input.get(CONF_WEB_SEARCH, RECOMMENDED_WEB_SEARCH) and not errors:
-                if user_input.get(
+            if user_input.get(
+                CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
+            ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
+                errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
+            if user_input.get(CONF_WEB_SEARCH, RECOMMENDED_WEB_SEARCH):
+                model = user_input.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+                if model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
+                    errors[CONF_WEB_SEARCH] = "web_search_unsupported_model"
+                elif user_input.get(
                     CONF_WEB_SEARCH_USER_LOCATION, RECOMMENDED_WEB_SEARCH_USER_LOCATION
                 ):
                     user_input.update(await self._get_location_data())
 
-            self.options.update(user_input)
-
             if not errors:
                 if self._is_new:
                     return self.async_create_entry(
-                        title=self.options.pop(CONF_NAME),
-                        data=self.options,
+                        title=user_input.pop(CONF_NAME),
+                        data=user_input,
                     )
 
                 return self.async_update_and_abort(
                     self._get_entry(),
                     self._get_reconfigure_subentry(),
-                    data=self.options,
+                    data=user_input,
                 )
 
-        return self.async_show_form(
-            step_id="model",
-            data_schema=self.add_suggested_values_to_schema(
-                vol.Schema(step_schema), self.options
+            options = user_input
+            self.last_rendered_recommended = user_input[CONF_RECOMMENDED]
+        else:
+            # Re-render the options again, now with the recommended options shown/hidden
+            self.last_rendered_recommended = user_input[CONF_RECOMMENDED]
+
+            options = {
+                CONF_RECOMMENDED: user_input[CONF_RECOMMENDED],
+                CONF_PROMPT: user_input[CONF_PROMPT],
+                CONF_LLM_HASS_API: user_input.get(CONF_LLM_HASS_API),
+            }
+
+        suggested_values = options.copy()
+        if not suggested_values.get(CONF_PROMPT):
+            suggested_values[CONF_PROMPT] = llm.DEFAULT_INSTRUCTIONS_PROMPT
+        if (
+            suggested_llm_apis := suggested_values.get(CONF_LLM_HASS_API)
+        ) and isinstance(suggested_llm_apis, str):
+            suggested_values[CONF_LLM_HASS_API] = [suggested_llm_apis]
+
+        schema = self.add_suggested_values_to_schema(
+            vol.Schema(
+                anthropic_config_option_schema(self.hass, self._is_new, options)
             ),
+            suggested_values,
+        )
+
+        return self.async_show_form(
+            step_id="set_options",
+            data_schema=schema,
             errors=errors or None,
-            last_step=True,
         )
 
     async def _get_location_data(self) -> dict[str, str]:
@@ -428,3 +304,77 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         _LOGGER.debug("Location data: %s", location_data)
 
         return location_data
+
+    async_step_user = async_step_set_options
+    async_step_reconfigure = async_step_set_options
+
+
+def anthropic_config_option_schema(
+    hass: HomeAssistant,
+    is_new: bool,
+    options: Mapping[str, Any],
+) -> dict:
+    """Return a schema for Anthropic completion options."""
+    hass_apis: list[SelectOptionDict] = [
+        SelectOptionDict(
+            label=api.name,
+            value=api.id,
+        )
+        for api in llm.async_get_apis(hass)
+    ]
+
+    if is_new:
+        schema: dict[vol.Required | vol.Optional, Any] = {
+            vol.Required(CONF_NAME, default=DEFAULT_CONVERSATION_NAME): str,
+        }
+    else:
+        schema = {}
+
+    schema.update(
+        {
+            vol.Optional(CONF_PROMPT): TemplateSelector(),
+            vol.Optional(
+                CONF_LLM_HASS_API,
+            ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
+            vol.Required(
+                CONF_RECOMMENDED, default=options.get(CONF_RECOMMENDED, False)
+            ): bool,
+        }
+    )
+
+    if options.get(CONF_RECOMMENDED):
+        return schema
+
+    schema.update(
+        {
+            vol.Optional(
+                CONF_CHAT_MODEL,
+                default=RECOMMENDED_CHAT_MODEL,
+            ): str,
+            vol.Optional(
+                CONF_MAX_TOKENS,
+                default=RECOMMENDED_MAX_TOKENS,
+            ): int,
+            vol.Optional(
+                CONF_TEMPERATURE,
+                default=RECOMMENDED_TEMPERATURE,
+            ): NumberSelector(NumberSelectorConfig(min=0, max=1, step=0.05)),
+            vol.Optional(
+                CONF_THINKING_BUDGET,
+                default=RECOMMENDED_THINKING_BUDGET,
+            ): int,
+            vol.Optional(
+                CONF_WEB_SEARCH,
+                default=RECOMMENDED_WEB_SEARCH,
+            ): bool,
+            vol.Optional(
+                CONF_WEB_SEARCH_MAX_USES,
+                default=RECOMMENDED_WEB_SEARCH_MAX_USES,
+            ): int,
+            vol.Optional(
+                CONF_WEB_SEARCH_USER_LOCATION,
+                default=RECOMMENDED_WEB_SEARCH_USER_LOCATION,
+            ): bool,
+        }
+    )
+    return schema

homeassistant/components/anthropic/strings.json

@@ -24,44 +24,37 @@
         "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
       },
       "entry_type": "Conversation agent",
+
+      "error": {
+        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget.",
+        "web_search_unsupported_model": "Web search is not supported by the selected model. Please choose a compatible model or disable web search."
+      },
       "initiate_flow": {
         "reconfigure": "Reconfigure conversation agent",
         "user": "Add conversation agent"
       },
       "step": {
-        "advanced": {
+        "set_options": {
           "data": {
             "chat_model": "[%key:common::generic::model%]",
-            "max_tokens": "Maximum tokens to return in response",
-            "temperature": "Temperature"
-          },
-          "title": "Advanced settings"
-        },
-        "init": {
-          "data": {
             "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
+            "max_tokens": "Maximum tokens to return in response",
             "name": "[%key:common::config_flow::data::name%]",
             "prompt": "[%key:common::config_flow::data::prompt%]",
-            "recommended": "Recommended model settings"
-          },
-          "data_description": {
-            "prompt": "Instruct how the LLM should respond. This can be a template."
-          }
-        },
-        "model": {
-          "data": {
+            "recommended": "Recommended model settings",
+            "temperature": "Temperature",
             "thinking_budget": "Thinking budget",
             "user_location": "Include home location",
             "web_search": "Enable web search",
             "web_search_max_uses": "Maximum web searches"
           },
           "data_description": {
+            "prompt": "Instruct how the LLM should respond. This can be a template.",
             "thinking_budget": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking.",
             "user_location": "Localize search results based on home location",
             "web_search": "The web search tool gives Claude direct access to real-time web content, allowing it to answer questions with up-to-date information beyond its knowledge cutoff",
             "web_search_max_uses": "Limit the number of searches performed per response"
-          },
-          "title": "Model-specific options"
+          }
         }
       }
     }

homeassistant/components/august/__init__.py

@@ -14,11 +14,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr, issue_registry as ir
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
+from homeassistant.helpers import (
+    config_entry_oauth2_flow,
+    device_registry as dr,
+    issue_registry as ir,
 )
 
 from .const import DEFAULT_AUGUST_BRAND, DOMAIN, PLATFORMS
@@ -38,10 +37,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: AugustConfigEntry) -> bo
 
     session = async_create_august_clientsession(hass)
     try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
+        implementation = (
+            await config_entry_oauth2_flow.async_get_config_entry_implementation(
+                hass, entry
+            )
+        )
+    except ValueError as err:
         raise ConfigEntryNotReady("OAuth implementation not available") from err
-    oauth_session = OAuth2Session(hass, entry, implementation)
+    oauth_session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     august_gateway = AugustGateway(Path(hass.config.config_dir), session, oauth_session)
     try:
         await async_setup_august(hass, entry, august_gateway)

homeassistant/components/avea/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_polling",
   "loggers": ["avea"],
   "quality_scale": "legacy",
-  "requirements": ["avea==1.6.1"]
+  "requirements": ["avea==1.5.1"]
 }

homeassistant/components/backblaze_b2/__init__.py

@@ -1,116 +0,0 @@
-"""The Backblaze B2 integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-from typing import Any
-
-from b2sdk.v2 import B2Api, Bucket, InMemoryAccountInfo, exception
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.event import async_track_time_interval
-
-from .const import (
-    BACKBLAZE_REALM,
-    CONF_APPLICATION_KEY,
-    CONF_BUCKET,
-    CONF_KEY_ID,
-    DATA_BACKUP_AGENT_LISTENERS,
-    DOMAIN,
-)
-from .repairs import (
-    async_check_for_repair_issues,
-    create_bucket_access_restricted_issue,
-    create_bucket_not_found_issue,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-type BackblazeConfigEntry = ConfigEntry[Bucket]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: BackblazeConfigEntry) -> bool:
-    """Set up Backblaze B2 from a config entry."""
-
-    info = InMemoryAccountInfo()
-    b2_api = B2Api(info)
-
-    def _authorize_and_get_bucket_sync() -> Bucket:
-        """Synchronously authorize the Backblaze B2 account and retrieve the bucket.
-
-        This function runs in the event loop's executor as b2sdk operations are blocking.
-        """
-        b2_api.authorize_account(
-            BACKBLAZE_REALM,
-            entry.data[CONF_KEY_ID],
-            entry.data[CONF_APPLICATION_KEY],
-        )
-        return b2_api.get_bucket_by_name(entry.data[CONF_BUCKET])
-
-    try:
-        bucket = await hass.async_add_executor_job(_authorize_and_get_bucket_sync)
-    except exception.Unauthorized as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="invalid_credentials",
-        ) from err
-    except exception.RestrictedBucket as err:
-        create_bucket_access_restricted_issue(hass, entry, err.bucket_name)
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="restricted_bucket",
-            translation_placeholders={
-                "restricted_bucket_name": err.bucket_name,
-            },
-        ) from err
-    except exception.NonExistentBucket as err:
-        create_bucket_not_found_issue(hass, entry, entry.data[CONF_BUCKET])
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="invalid_bucket_name",
-        ) from err
-    except exception.ConnectionReset as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="cannot_connect",
-        ) from err
-    except exception.MissingAccountData as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="invalid_auth",
-        ) from err
-
-    entry.runtime_data = bucket
-
-    def _async_notify_backup_listeners() -> None:
-        """Notify any registered backup agent listeners."""
-        _LOGGER.debug("Notifying backup listeners for entry %s", entry.entry_id)
-        for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
-            listener()
-
-    entry.async_on_unload(entry.async_on_state_change(_async_notify_backup_listeners))
-
-    async def _periodic_issue_check(_now: Any) -> None:
-        """Periodically check for repair issues."""
-        await async_check_for_repair_issues(hass, entry)
-
-    entry.async_on_unload(
-        async_track_time_interval(hass, _periodic_issue_check, timedelta(minutes=30))
-    )
-
-    hass.async_create_task(async_check_for_repair_issues(hass, entry))
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: BackblazeConfigEntry) -> bool:
-    """Unload a Backblaze B2 config entry.
-
-    Any resources directly managed by this entry that need explicit shutdown
-    would be handled here. In this case, the `async_on_state_change` listener
-    handles the notification logic on unload.
-    """
-    return True

homeassistant/components/backblaze_b2/backup.py

@@ -1,615 +0,0 @@
-"""Backup platform for the Backblaze B2 integration."""
-
-import asyncio
-from collections.abc import AsyncIterator, Callable, Coroutine
-import functools
-import json
-import logging
-import mimetypes
-from time import time
-from typing import Any
-
-from b2sdk.v2 import FileVersion
-from b2sdk.v2.exception import B2Error
-
-from homeassistant.components.backup import (
-    AgentBackup,
-    BackupAgent,
-    BackupAgentError,
-    BackupNotFound,
-    suggested_filename,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.util.async_iterator import AsyncIteratorReader
-
-from . import BackblazeConfigEntry
-from .const import (
-    CONF_PREFIX,
-    DATA_BACKUP_AGENT_LISTENERS,
-    DOMAIN,
-    METADATA_FILE_SUFFIX,
-    METADATA_VERSION,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-# Cache TTL for backup list (in seconds)
-CACHE_TTL = 300
-
-
-def suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
-    """Return the suggested filenames for the backup and metadata files."""
-    base_name = suggested_filename(backup).rsplit(".", 1)[0]
-    return f"{base_name}.tar", f"{base_name}.metadata.json"
-
-
-def _parse_metadata(raw_content: str) -> dict[str, Any]:
-    """Parse metadata content from JSON."""
-    try:
-        data = json.loads(raw_content)
-    except json.JSONDecodeError as err:
-        raise ValueError(f"Invalid JSON format: {err}") from err
-    else:
-        if not isinstance(data, dict):
-            raise TypeError("JSON content is not a dictionary")
-        return data
-
-
-def _find_backup_file_for_metadata(
-    metadata_filename: str, all_files: dict[str, FileVersion], prefix: str
-) -> FileVersion | None:
-    """Find corresponding backup file for metadata file."""
-    base_name = metadata_filename[len(prefix) :].removesuffix(METADATA_FILE_SUFFIX)
-    return next(
-        (
-            file
-            for name, file in all_files.items()
-            if name.startswith(prefix + base_name)
-            and name.endswith(".tar")
-            and name != metadata_filename
-        ),
-        None,
-    )
-
-
-def _create_backup_from_metadata(
-    metadata_content: dict[str, Any], backup_file: FileVersion
-) -> AgentBackup:
-    """Construct an AgentBackup from parsed metadata content and the associated backup file."""
-    metadata = metadata_content["backup_metadata"]
-    metadata["size"] = backup_file.size
-    return AgentBackup.from_dict(metadata)
-
-
-def handle_b2_errors[T](
-    func: Callable[..., Coroutine[Any, Any, T]],
-) -> Callable[..., Coroutine[Any, Any, T]]:
-    """Handle B2Errors by converting them to BackupAgentError."""
-
-    @functools.wraps(func)
-    async def wrapper(*args: Any, **kwargs: Any) -> T:
-        """Catch B2Error and raise BackupAgentError."""
-        try:
-            return await func(*args, **kwargs)
-        except B2Error as err:
-            error_msg = f"Failed during {func.__name__}"
-            raise BackupAgentError(error_msg) from err
-
-    return wrapper
-
-
-async def async_get_backup_agents(
-    hass: HomeAssistant,
-) -> list[BackupAgent]:
-    """Return a list of backup agents for all configured Backblaze B2 entries."""
-    entries: list[BackblazeConfigEntry] = hass.config_entries.async_loaded_entries(
-        DOMAIN
-    )
-    return [BackblazeBackupAgent(hass, entry) for entry in entries]
-
-
-@callback
-def async_register_backup_agents_listener(
-    hass: HomeAssistant,
-    *,
-    listener: Callable[[], None],
-    **kwargs: Any,
-) -> Callable[[], None]:
-    """Register a listener to be called when backup agents are added or removed.
-
-    :return: A function to unregister the listener.
-    """
-    hass.data.setdefault(DATA_BACKUP_AGENT_LISTENERS, []).append(listener)
-
-    @callback
-    def remove_listener() -> None:
-        """Remove the listener."""
-        hass.data[DATA_BACKUP_AGENT_LISTENERS].remove(listener)
-        if not hass.data[DATA_BACKUP_AGENT_LISTENERS]:
-            hass.data.pop(DATA_BACKUP_AGENT_LISTENERS, None)
-
-    return remove_listener
-
-
-class BackblazeBackupAgent(BackupAgent):
-    """Backup agent for Backblaze B2 cloud storage."""
-
-    domain = DOMAIN
-
-    def __init__(self, hass: HomeAssistant, entry: BackblazeConfigEntry) -> None:
-        """Initialize the Backblaze B2 agent."""
-        super().__init__()
-        self._hass = hass
-        self._bucket = entry.runtime_data
-        self._prefix = entry.data[CONF_PREFIX]
-
-        self.name = entry.title
-        self.unique_id = entry.entry_id
-
-        self._all_files_cache: dict[str, FileVersion] = {}
-        self._all_files_cache_expiration: float = 0.0
-        self._backup_list_cache: dict[str, AgentBackup] = {}
-        self._backup_list_cache_expiration: float = 0.0
-
-        self._all_files_cache_lock = asyncio.Lock()
-        self._backup_list_cache_lock = asyncio.Lock()
-
-    def _is_cache_valid(self, expiration_time: float) -> bool:
-        """Check if cache is still valid based on expiration time."""
-        return time() <= expiration_time
-
-    async def _cleanup_failed_upload(self, filename: str) -> None:
-        """Clean up a partially uploaded file after upload failure."""
-        _LOGGER.warning(
-            "Attempting to delete partially uploaded main backup file %s "
-            "due to metadata upload failure",
-            filename,
-        )
-        try:
-            uploaded_main_file_info = await self._hass.async_add_executor_job(
-                self._bucket.get_file_info_by_name, filename
-            )
-            await self._hass.async_add_executor_job(uploaded_main_file_info.delete)
-        except B2Error:
-            _LOGGER.debug(
-                "Failed to clean up partially uploaded main backup file %s. "
-                "Manual intervention may be required to delete it from Backblaze B2",
-                filename,
-                exc_info=True,
-            )
-        else:
-            _LOGGER.debug(
-                "Successfully deleted partially uploaded main backup file %s", filename
-            )
-
-    async def _get_file_for_download(self, backup_id: str) -> FileVersion:
-        """Get backup file for download, raising if not found."""
-        file, _ = await self._find_file_and_metadata_version_by_id(backup_id)
-        if not file:
-            raise BackupNotFound(f"Backup {backup_id} not found")
-        return file
-
-    @handle_b2_errors
-    async def async_download_backup(
-        self, backup_id: str, **kwargs: Any
-    ) -> AsyncIterator[bytes]:
-        """Download a backup from Backblaze B2."""
-        file = await self._get_file_for_download(backup_id)
-        _LOGGER.debug("Downloading %s", file.file_name)
-
-        downloaded_file = await self._hass.async_add_executor_job(file.download)
-        response = downloaded_file.response
-
-        async def stream_response() -> AsyncIterator[bytes]:
-            """Stream the response into an AsyncIterator."""
-            try:
-                iterator = response.iter_content(chunk_size=1024 * 1024)
-                while True:
-                    chunk = await self._hass.async_add_executor_job(
-                        next, iterator, None
-                    )
-                    if chunk is None:
-                        break
-                    yield chunk
-            finally:
-                _LOGGER.debug("Finished streaming download for %s", file.file_name)
-
-        return stream_response()
-
-    @handle_b2_errors
-    async def async_upload_backup(
-        self,
-        *,
-        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
-        backup: AgentBackup,
-        **kwargs: Any,
-    ) -> None:
-        """Upload a backup to Backblaze B2.
-
-        This involves uploading the main backup archive and a separate metadata JSON file.
-        """
-        tar_filename, metadata_filename = suggested_filenames(backup)
-        prefixed_tar_filename = self._prefix + tar_filename
-        prefixed_metadata_filename = self._prefix + metadata_filename
-
-        metadata_content_bytes = json.dumps(
-            {
-                "metadata_version": METADATA_VERSION,
-                "backup_id": backup.backup_id,
-                "backup_metadata": backup.as_dict(),
-            }
-        ).encode("utf-8")
-
-        _LOGGER.debug(
-            "Uploading backup: %s, and metadata: %s",
-            prefixed_tar_filename,
-            prefixed_metadata_filename,
-        )
-
-        upload_successful = False
-        try:
-            await self._upload_backup_file(prefixed_tar_filename, open_stream, {})
-            _LOGGER.debug(
-                "Main backup file upload finished for %s", prefixed_tar_filename
-            )
-
-            _LOGGER.debug("Uploading metadata file: %s", prefixed_metadata_filename)
-            await self._upload_metadata_file(
-                metadata_content_bytes, prefixed_metadata_filename
-            )
-            _LOGGER.debug(
-                "Metadata file upload finished for %s", prefixed_metadata_filename
-            )
-            upload_successful = True
-        finally:
-            if upload_successful:
-                _LOGGER.debug("Backup upload complete: %s", prefixed_tar_filename)
-                self._invalidate_caches(
-                    backup.backup_id, prefixed_tar_filename, prefixed_metadata_filename
-                )
-            else:
-                await self._cleanup_failed_upload(prefixed_tar_filename)
-
-    def _upload_metadata_file_sync(
-        self, metadata_content: bytes, filename: str
-    ) -> None:
-        """Synchronously upload metadata file to B2."""
-        self._bucket.upload_bytes(
-            metadata_content,
-            filename,
-            content_type="application/json",
-            file_info={"metadata_only": "true"},
-        )
-
-    async def _upload_metadata_file(
-        self, metadata_content: bytes, filename: str
-    ) -> None:
-        """Upload metadata file to B2."""
-        await self._hass.async_add_executor_job(
-            self._upload_metadata_file_sync,
-            metadata_content,
-            filename,
-        )
-
-    def _upload_unbound_stream_sync(
-        self,
-        reader: AsyncIteratorReader,
-        filename: str,
-        content_type: str,
-        file_info: dict[str, Any],
-    ) -> FileVersion:
-        """Synchronously upload unbound stream to B2."""
-        return self._bucket.upload_unbound_stream(
-            reader,
-            filename,
-            content_type=content_type,
-            file_info=file_info,
-        )
-
-    def _download_and_parse_metadata_sync(
-        self, metadata_file_version: FileVersion
-    ) -> dict[str, Any]:
-        """Synchronously download and parse metadata file."""
-        return _parse_metadata(
-            metadata_file_version.download().response.content.decode("utf-8")
-        )
-
-    async def _upload_backup_file(
-        self,
-        filename: str,
-        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
-        file_info: dict[str, Any],
-    ) -> None:
-        """Upload backup file to B2 using streaming."""
-        _LOGGER.debug("Starting streaming upload for %s", filename)
-
-        stream = await open_stream()
-        reader = AsyncIteratorReader(self._hass.loop, stream)
-
-        _LOGGER.debug("Uploading backup file %s with streaming", filename)
-        try:
-            content_type, _ = mimetypes.guess_type(filename)
-            file_version = await self._hass.async_add_executor_job(
-                self._upload_unbound_stream_sync,
-                reader,
-                filename,
-                content_type or "application/x-tar",
-                file_info,
-            )
-        finally:
-            reader.close()
-
-        _LOGGER.debug("Successfully uploaded %s (ID: %s)", filename, file_version.id_)
-
-    @handle_b2_errors
-    async def async_delete_backup(self, backup_id: str, **kwargs: Any) -> None:
-        """Delete a backup and its associated metadata file from Backblaze B2."""
-        file, metadata_file = await self._find_file_and_metadata_version_by_id(
-            backup_id
-        )
-        if not file:
-            raise BackupNotFound(f"Backup {backup_id} not found")
-
-        # Invariant: when file is not None, metadata_file is also not None
-        assert metadata_file is not None
-
-        _LOGGER.debug(
-            "Deleting backup file: %s and metadata file: %s",
-            file.file_name,
-            metadata_file.file_name,
-        )
-
-        await self._hass.async_add_executor_job(file.delete)
-        await self._hass.async_add_executor_job(metadata_file.delete)
-
-        self._invalidate_caches(
-            backup_id,
-            file.file_name,
-            metadata_file.file_name,
-            remove_files=True,
-        )
-
-    @handle_b2_errors
-    async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
-        """List all backups by finding their associated metadata files in Backblaze B2."""
-        async with self._backup_list_cache_lock:
-            if self._backup_list_cache and self._is_cache_valid(
-                self._backup_list_cache_expiration
-            ):
-                _LOGGER.debug("Returning backups from cache")
-                return list(self._backup_list_cache.values())
-
-            _LOGGER.debug(
-                "Cache expired or empty, fetching all files from B2 to build backup list"
-            )
-            all_files_in_prefix = await self._get_all_files_in_prefix()
-
-            _LOGGER.debug(
-                "Files found in prefix '%s': %s",
-                self._prefix,
-                list(all_files_in_prefix.keys()),
-            )
-
-            # Process metadata files sequentially to avoid exhausting executor pool
-            backups = {}
-            for file_name, file_version in all_files_in_prefix.items():
-                if file_name.endswith(METADATA_FILE_SUFFIX):
-                    backup = await self._hass.async_add_executor_job(
-                        self._process_metadata_file_sync,
-                        file_name,
-                        file_version,
-                        all_files_in_prefix,
-                    )
-                    if backup:
-                        backups[backup.backup_id] = backup
-            self._backup_list_cache = backups
-            self._backup_list_cache_expiration = time() + CACHE_TTL
-
-            return list(backups.values())
-
-    @handle_b2_errors
-    async def async_get_backup(self, backup_id: str, **kwargs: Any) -> AgentBackup:
-        """Get a specific backup by its ID from Backblaze B2."""
-        if self._backup_list_cache and self._is_cache_valid(
-            self._backup_list_cache_expiration
-        ):
-            if backup := self._backup_list_cache.get(backup_id):
-                _LOGGER.debug("Returning backup %s from cache", backup_id)
-                return backup
-
-        file, metadata_file_version = await self._find_file_and_metadata_version_by_id(
-            backup_id
-        )
-        if not file or not metadata_file_version:
-            raise BackupNotFound(f"Backup {backup_id} not found")
-
-        metadata_content = await self._hass.async_add_executor_job(
-            self._download_and_parse_metadata_sync,
-            metadata_file_version,
-        )
-
-        _LOGGER.debug(
-            "Successfully retrieved metadata for backup ID %s from file %s",
-            backup_id,
-            metadata_file_version.file_name,
-        )
-        backup = _create_backup_from_metadata(metadata_content, file)
-
-        if self._is_cache_valid(self._backup_list_cache_expiration):
-            self._backup_list_cache[backup.backup_id] = backup
-
-        return backup
-
-    async def _find_file_and_metadata_version_by_id(
-        self, backup_id: str
-    ) -> tuple[FileVersion | None, FileVersion | None]:
-        """Find the main backup file and its associated metadata file version by backup ID."""
-        all_files_in_prefix = await self._get_all_files_in_prefix()
-
-        # Process metadata files sequentially to avoid exhausting executor pool
-        for file_name, file_version in all_files_in_prefix.items():
-            if file_name.endswith(METADATA_FILE_SUFFIX):
-                (
-                    result_backup_file,
-                    result_metadata_file_version,
-                ) = await self._hass.async_add_executor_job(
-                    self._process_metadata_file_for_id_sync,
-                    file_name,
-                    file_version,
-                    backup_id,
-                    all_files_in_prefix,
-                )
-                if result_backup_file and result_metadata_file_version:
-                    return result_backup_file, result_metadata_file_version
-
-        _LOGGER.debug("Backup %s not found", backup_id)
-        return None, None
-
-    def _process_metadata_file_for_id_sync(
-        self,
-        file_name: str,
-        file_version: FileVersion,
-        target_backup_id: str,
-        all_files_in_prefix: dict[str, FileVersion],
-    ) -> tuple[FileVersion | None, FileVersion | None]:
-        """Synchronously process a single metadata file for a specific backup ID.
-
-        Called within a thread pool executor.
-        """
-        try:
-            download_response = file_version.download().response
-        except B2Error as err:
-            _LOGGER.warning(
-                "Failed to download metadata file %s during ID search: %s",
-                file_name,
-                err,
-            )
-            return None, None
-
-        try:
-            metadata_content = _parse_metadata(
-                download_response.content.decode("utf-8")
-            )
-        except ValueError:
-            return None, None
-
-        if metadata_content["backup_id"] != target_backup_id:
-            _LOGGER.debug(
-                "Metadata file %s does not match target backup ID %s",
-                file_name,
-                target_backup_id,
-            )
-            return None, None
-
-        found_backup_file = _find_backup_file_for_metadata(
-            file_name, all_files_in_prefix, self._prefix
-        )
-        if not found_backup_file:
-            _LOGGER.warning(
-                "Found metadata file %s for backup ID %s, but no corresponding backup file",
-                file_name,
-                target_backup_id,
-            )
-            return None, None
-
-        _LOGGER.debug(
-            "Found backup file %s and metadata file %s for ID %s",
-            found_backup_file.file_name,
-            file_name,
-            target_backup_id,
-        )
-        return found_backup_file, file_version
-
-    async def _get_all_files_in_prefix(self) -> dict[str, FileVersion]:
-        """Get all file versions in the configured prefix from Backblaze B2.
-
-        Uses a cache to minimize API calls.
-
-        This fetches a flat list of all files, including main backups and metadata files.
-        """
-        async with self._all_files_cache_lock:
-            if self._is_cache_valid(self._all_files_cache_expiration):
-                _LOGGER.debug("Returning all files from cache")
-                return self._all_files_cache
-
-            _LOGGER.debug("Cache for all files expired or empty, fetching from B2")
-            all_files_in_prefix = await self._hass.async_add_executor_job(
-                self._fetch_all_files_in_prefix
-            )
-            self._all_files_cache = all_files_in_prefix
-            self._all_files_cache_expiration = time() + CACHE_TTL
-            return all_files_in_prefix
-
-    def _fetch_all_files_in_prefix(self) -> dict[str, FileVersion]:
-        """Fetch all files in the configured prefix from B2."""
-        all_files: dict[str, FileVersion] = {}
-        for file, _ in self._bucket.ls(self._prefix):
-            all_files[file.file_name] = file
-        return all_files
-
-    def _process_metadata_file_sync(
-        self,
-        file_name: str,
-        file_version: FileVersion,
-        all_files_in_prefix: dict[str, FileVersion],
-    ) -> AgentBackup | None:
-        """Synchronously process a single metadata file and return an AgentBackup if valid."""
-        try:
-            download_response = file_version.download().response
-        except B2Error as err:
-            _LOGGER.warning("Failed to download metadata file %s: %s", file_name, err)
-            return None
-
-        try:
-            metadata_content = _parse_metadata(
-                download_response.content.decode("utf-8")
-            )
-        except ValueError:
-            return None
-
-        found_backup_file = _find_backup_file_for_metadata(
-            file_name, all_files_in_prefix, self._prefix
-        )
-        if not found_backup_file:
-            _LOGGER.warning(
-                "Found metadata file %s but no corresponding backup file",
-                file_name,
-            )
-            return None
-
-        _LOGGER.debug(
-            "Successfully processed metadata file %s for backup ID %s",
-            file_name,
-            metadata_content["backup_id"],
-        )
-        return _create_backup_from_metadata(metadata_content, found_backup_file)
-
-    def _invalidate_caches(
-        self,
-        backup_id: str,
-        tar_filename: str,
-        metadata_filename: str | None,
-        *,
-        remove_files: bool = False,
-    ) -> None:
-        """Invalidate caches after upload/deletion operations.
-
-        Args:
-            backup_id: The backup ID to remove from backup cache
-            tar_filename: The tar filename to remove from files cache
-            metadata_filename: The metadata filename to remove from files cache
-            remove_files: If True, remove specific files from cache; if False, expire entire cache
-        """
-        if remove_files:
-            if self._is_cache_valid(self._all_files_cache_expiration):
-                self._all_files_cache.pop(tar_filename, None)
-                if metadata_filename:
-                    self._all_files_cache.pop(metadata_filename, None)
-
-            if self._is_cache_valid(self._backup_list_cache_expiration):
-                self._backup_list_cache.pop(backup_id, None)
-        else:
-            # For uploads, we can't easily add new FileVersion objects without API calls,
-            # so we expire the entire cache for simplicity
-            self._all_files_cache_expiration = 0.0
-            self._backup_list_cache_expiration = 0.0

homeassistant/components/backblaze_b2/config_flow.py

@@ -1,288 +0,0 @@
-"""Config flow for the Backblaze B2 integration."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-import logging
-from typing import Any
-
-from b2sdk.v2 import B2Api, InMemoryAccountInfo, exception
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.selector import (
-    TextSelector,
-    TextSelectorConfig,
-    TextSelectorType,
-)
-
-from .const import (
-    BACKBLAZE_REALM,
-    CONF_APPLICATION_KEY,
-    CONF_BUCKET,
-    CONF_KEY_ID,
-    CONF_PREFIX,
-    DOMAIN,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-# Constants
-REQUIRED_CAPABILITIES = {"writeFiles", "listFiles", "deleteFiles", "readFiles"}
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_KEY_ID): cv.string,
-        vol.Required(CONF_APPLICATION_KEY): TextSelector(
-            config=TextSelectorConfig(type=TextSelectorType.PASSWORD)
-        ),
-        vol.Required(CONF_BUCKET): cv.string,
-        vol.Optional(CONF_PREFIX, default=""): cv.string,
-    }
-)
-
-
-class BackblazeConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Backblaze B2."""
-
-    VERSION = 1
-
-    reauth_entry: ConfigEntry[Any] | None
-
-    def _abort_if_duplicate_credentials(self, user_input: dict[str, Any]) -> None:
-        """Abort if credentials already exist in another entry."""
-        self._async_abort_entries_match(
-            {
-                CONF_KEY_ID: user_input[CONF_KEY_ID],
-                CONF_APPLICATION_KEY: user_input[CONF_APPLICATION_KEY],
-            }
-        )
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle a flow initiated by the user."""
-        errors: dict[str, str] = {}
-        placeholders: dict[str, str] = {}
-
-        if user_input is not None:
-            self._abort_if_duplicate_credentials(user_input)
-
-            errors, placeholders = await self._async_validate_backblaze_connection(
-                user_input
-            )
-
-            if not errors:
-                if user_input[CONF_PREFIX] and not user_input[CONF_PREFIX].endswith(
-                    "/"
-                ):
-                    user_input[CONF_PREFIX] += "/"
-
-                return self.async_create_entry(
-                    title=user_input[CONF_BUCKET], data=user_input
-                )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, user_input
-            ),
-            errors=errors,
-            description_placeholders={"brand_name": "Backblaze B2", **placeholders},
-        )
-
-    async def _async_validate_backblaze_connection(
-        self, user_input: dict[str, Any]
-    ) -> tuple[dict[str, str], dict[str, str]]:
-        """Validate Backblaze B2 credentials, bucket, capabilities, and prefix.
-
-        Returns a tuple of (errors_dict, placeholders_dict).
-        """
-        errors: dict[str, str] = {}
-        placeholders: dict[str, str] = {}
-
-        info = InMemoryAccountInfo()
-        b2_api = B2Api(info)
-
-        def _authorize_and_get_bucket_sync() -> None:
-            """Synchronously authorize the account and get the bucket by name.
-
-            This function is run in the executor because b2sdk operations are blocking.
-            """
-            b2_api.authorize_account(
-                BACKBLAZE_REALM,  # Use the defined realm constant
-                user_input[CONF_KEY_ID],
-                user_input[CONF_APPLICATION_KEY],
-            )
-            b2_api.get_bucket_by_name(user_input[CONF_BUCKET])
-
-        try:
-            await self.hass.async_add_executor_job(_authorize_and_get_bucket_sync)
-
-            allowed = b2_api.account_info.get_allowed()
-
-            # Check if allowed info is available
-            if allowed is None or not allowed.get("capabilities"):
-                errors["base"] = "invalid_capability"
-                placeholders["missing_capabilities"] = ", ".join(
-                    sorted(REQUIRED_CAPABILITIES)
-                )
-            else:
-                # Check if all required capabilities are present
-                current_caps = set(allowed["capabilities"])
-                if not REQUIRED_CAPABILITIES.issubset(current_caps):
-                    missing_caps = REQUIRED_CAPABILITIES - current_caps
-                    _LOGGER.warning(
-                        "Missing required Backblaze B2 capabilities for Key ID '%s': %s",
-                        user_input[CONF_KEY_ID],
-                        ", ".join(sorted(missing_caps)),
-                    )
-                    errors["base"] = "invalid_capability"
-                    placeholders["missing_capabilities"] = ", ".join(
-                        sorted(missing_caps)
-                    )
-                else:
-                    # Only check prefix if capabilities are valid
-                    configured_prefix: str = user_input[CONF_PREFIX]
-                    allowed_prefix = allowed.get("namePrefix") or ""
-                    # Ensure configured prefix starts with Backblaze B2's allowed prefix
-                    if allowed_prefix and not configured_prefix.startswith(
-                        allowed_prefix
-                    ):
-                        errors[CONF_PREFIX] = "invalid_prefix"
-                        placeholders["allowed_prefix"] = allowed_prefix
-
-        except exception.Unauthorized:
-            _LOGGER.debug(
-                "Backblaze B2 authentication failed for Key ID '%s'",
-                user_input[CONF_KEY_ID],
-            )
-            errors["base"] = "invalid_credentials"
-        except exception.RestrictedBucket as err:
-            _LOGGER.debug(
-                "Access to Backblaze B2 bucket '%s' is restricted: %s",
-                user_input[CONF_BUCKET],
-                err,
-            )
-            placeholders["restricted_bucket_name"] = err.bucket_name
-            errors[CONF_BUCKET] = "restricted_bucket"
-        except exception.NonExistentBucket:
-            _LOGGER.debug(
-                "Backblaze B2 bucket '%s' does not exist", user_input[CONF_BUCKET]
-            )
-            errors[CONF_BUCKET] = "invalid_bucket_name"
-        except exception.ConnectionReset:
-            _LOGGER.error("Failed to connect to Backblaze B2. Connection reset")
-            errors["base"] = "cannot_connect"
-        except exception.MissingAccountData:
-            # This generally indicates an issue with how InMemoryAccountInfo is used
-            _LOGGER.error(
-                "Missing account data during Backblaze B2 authorization for Key ID '%s'",
-                user_input[CONF_KEY_ID],
-            )
-            errors["base"] = "invalid_credentials"
-        except Exception:
-            _LOGGER.exception(
-                "An unexpected error occurred during Backblaze B2 configuration for Key ID '%s'",
-                user_input[CONF_KEY_ID],
-            )
-            errors["base"] = "unknown"
-
-        return errors, placeholders
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauthentication flow."""
-        self.reauth_entry = self.hass.config_entries.async_get_entry(
-            self.context["entry_id"]
-        )
-        assert self.reauth_entry is not None
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm reauthentication."""
-        assert self.reauth_entry is not None
-        errors: dict[str, str] = {}
-        placeholders: dict[str, str] = {}
-
-        if user_input is not None:
-            self._abort_if_duplicate_credentials(user_input)
-
-            validation_input = {
-                CONF_KEY_ID: user_input[CONF_KEY_ID],
-                CONF_APPLICATION_KEY: user_input[CONF_APPLICATION_KEY],
-                CONF_BUCKET: self.reauth_entry.data[CONF_BUCKET],
-                CONF_PREFIX: self.reauth_entry.data[CONF_PREFIX],
-            }
-
-            errors, placeholders = await self._async_validate_backblaze_connection(
-                validation_input
-            )
-
-            if not errors:
-                return self.async_update_reload_and_abort(
-                    self.reauth_entry,
-                    data_updates={
-                        CONF_KEY_ID: user_input[CONF_KEY_ID],
-                        CONF_APPLICATION_KEY: user_input[CONF_APPLICATION_KEY],
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_KEY_ID): cv.string,
-                    vol.Required(CONF_APPLICATION_KEY): TextSelector(
-                        config=TextSelectorConfig(type=TextSelectorType.PASSWORD)
-                    ),
-                }
-            ),
-            errors=errors,
-            description_placeholders={
-                "brand_name": "Backblaze B2",
-                "bucket": self.reauth_entry.data[CONF_BUCKET],
-                **placeholders,
-            },
-        )
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration flow."""
-        entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
-        assert entry is not None
-
-        if user_input is not None:
-            self._abort_if_duplicate_credentials(user_input)
-
-            errors, placeholders = await self._async_validate_backblaze_connection(
-                user_input
-            )
-
-            if not errors:
-                if user_input[CONF_PREFIX] and not user_input[CONF_PREFIX].endswith(
-                    "/"
-                ):
-                    user_input[CONF_PREFIX] += "/"
-
-                return self.async_update_reload_and_abort(
-                    entry,
-                    data_updates=user_input,
-                )
-        else:
-            errors = {}
-            placeholders = {}
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, user_input or entry.data
-            ),
-            errors=errors,
-            description_placeholders={"brand_name": "Backblaze B2", **placeholders},
-        )

homeassistant/components/backblaze_b2/const.py

@@ -1,22 +0,0 @@
-"""Constants for the Backblaze B2 integration."""
-
-from collections.abc import Callable
-from typing import Final
-
-from homeassistant.util.hass_dict import HassKey
-
-DOMAIN: Final = "backblaze_b2"
-
-CONF_KEY_ID = "key_id"
-CONF_APPLICATION_KEY = "application_key"
-CONF_BUCKET = "bucket"
-CONF_PREFIX = "prefix"
-
-DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
-    f"{DOMAIN}.backup_agent_listeners"
-)
-
-METADATA_FILE_SUFFIX = ".metadata.json"
-METADATA_VERSION = "1"
-
-BACKBLAZE_REALM = "production"

homeassistant/components/backblaze_b2/diagnostics.py

@@ -1,56 +0,0 @@
-"""Diagnostics support for Backblaze B2."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from . import BackblazeConfigEntry
-from .const import CONF_APPLICATION_KEY, CONF_KEY_ID
-
-TO_REDACT_ENTRY_DATA = {CONF_APPLICATION_KEY, CONF_KEY_ID}
-TO_REDACT_ACCOUNT_DATA_ALLOWED = {"bucketId", "bucketName", "namePrefix"}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: BackblazeConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    bucket = entry.runtime_data
-
-    try:
-        bucket_info = {
-            "name": bucket.name,
-            "id": bucket.id_,
-            "type": bucket.type_,
-            "cors_rules": bucket.cors_rules,
-            "lifecycle_rules": bucket.lifecycle_rules,
-            "revision": bucket.revision,
-        }
-
-        account_info = bucket.api.account_info
-        account_data: dict[str, Any] = {
-            "account_id": account_info.get_account_id(),
-            "api_url": account_info.get_api_url(),
-            "download_url": account_info.get_download_url(),
-            "minimum_part_size": account_info.get_minimum_part_size(),
-            "allowed": account_info.get_allowed(),
-        }
-
-        if isinstance(account_data["allowed"], dict):
-            account_data["allowed"] = async_redact_data(
-                account_data["allowed"], TO_REDACT_ACCOUNT_DATA_ALLOWED
-            )
-
-    except (AttributeError, TypeError, ValueError, KeyError):
-        bucket_info = {"name": "unknown", "id": "unknown"}
-        account_data = {"error": "Failed to retrieve detailed account information"}
-
-    return {
-        "entry_data": async_redact_data(entry.data, TO_REDACT_ENTRY_DATA),
-        "entry_options": entry.options,
-        "bucket_info": bucket_info,
-        "account_info": account_data,
-    }

homeassistant/components/backblaze_b2/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "backblaze_b2",
-  "name": "Backblaze B2",
-  "codeowners": ["@hugo-vrijswijk", "@ElCruncharino"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/backblaze_b2",
-  "integration_type": "service",
-  "iot_class": "cloud_push",
-  "loggers": ["b2sdk"],
-  "quality_scale": "bronze",
-  "requirements": ["b2sdk==2.8.1"]
-}

homeassistant/components/backblaze_b2/quality_scale.yaml

@@ -1,124 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions.
-  appropriate-polling:
-    status: exempt
-    comment: Integration does not poll.
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: This integration does not have any custom actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Entities of this integration do not explicitly subscribe to events.
-  entity-unique-id:
-    status: exempt
-    comment: |
-      This integration does not have entities.
-  has-entity-name:
-    status: exempt
-    comment: |
-      This integration does not have entities.
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: This integration does not have an options flow.
-  docs-installation-parameters: done
-  entity-unavailable:
-    status: exempt
-    comment: This integration does not have entities.
-  integration-owner: done
-  log-when-unavailable:
-    status: exempt
-    comment: This integration does not have entities.
-  parallel-updates:
-    status: exempt
-    comment: This integration does not poll.
-  reauthentication-flow: done
-  test-coverage: done
-
-  # Gold
-  devices:
-    status: exempt
-    comment: This integration does not have entities.
-  diagnostics: done
-  discovery-update-info:
-    status: exempt
-    comment: Backblaze B2 is a cloud service that is not discovered on the network.
-  discovery:
-    status: exempt
-    comment: Backblaze B2 is a cloud service that is not discovered on the network.
-  docs-data-update:
-    status: exempt
-    comment: This integration does not poll.
-  docs-examples:
-    status: exempt
-    comment: The integration extends core functionality and does not require examples.
-  docs-known-limitations: done
-  docs-supported-devices:
-    status: exempt
-    comment: This integration does not support physical devices.
-  docs-supported-functions:
-    status: exempt
-    comment: This integration does not have entities.
-  docs-troubleshooting: todo
-  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: This integration does not have devices.
-  entity-category:
-    status: exempt
-    comment: This integration does not have entities.
-  entity-device-class:
-    status: exempt
-    comment: This integration does not have entities.
-  entity-disabled-by-default:
-    status: exempt
-    comment: This integration does not have entities.
-  entity-translations:
-    status: exempt
-    comment: This integration does not have entities.
-  exception-translations: done
-  icon-translations:
-    status: exempt
-    comment: This integration does not use icons.
-  reconfiguration-flow: done
-  repair-issues: done
-  stale-devices:
-    status: exempt
-    comment: This integration does not have devices.
-
-  # Platinum
-  async-dependency:
-    status: exempt
-    comment: |
-      The b2sdk library is synchronous by design. All sync operations are properly
-      wrapped with async_add_executor_job to prevent blocking the event loop.
-  inject-websession:
-    status: exempt
-    comment: |
-      The b2sdk library does not support custom HTTP session injection.
-      It manages HTTP connections internally through its own session management.
-  strict-typing:
-    status: exempt
-    comment: |
-      The b2sdk dependency does not include a py.typed file and is not PEP 561 compliant.
-      This is outside the integration's control as it's a third-party library requirement.

homeassistant/components/backblaze_b2/repairs.py

@@ -1,93 +0,0 @@
-"""Repair issues for the Backblaze B2 integration."""
-
-from __future__ import annotations
-
-import logging
-
-from b2sdk.v2.exception import (
-    B2Error,
-    NonExistentBucket,
-    RestrictedBucket,
-    Unauthorized,
-)
-
-from homeassistant.components.repairs import ConfirmRepairFlow
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import issue_registry as ir
-
-from .const import CONF_BUCKET, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-ISSUE_BUCKET_ACCESS_RESTRICTED = "bucket_access_restricted"
-ISSUE_BUCKET_NOT_FOUND = "bucket_not_found"
-
-
-def _create_issue(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    issue_type: str,
-    bucket_name: str,
-) -> None:
-    """Create a repair issue with standard parameters."""
-    ir.async_create_issue(
-        hass,
-        DOMAIN,
-        f"{issue_type}_{entry.entry_id}",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.ERROR,
-        translation_key=issue_type,
-        translation_placeholders={
-            "brand_name": "Backblaze B2",
-            "title": entry.title,
-            "bucket_name": bucket_name,
-            "entry_id": entry.entry_id,
-        },
-    )
-
-
-def create_bucket_access_restricted_issue(
-    hass: HomeAssistant, entry: ConfigEntry, bucket_name: str
-) -> None:
-    """Create a repair issue for restricted bucket access."""
-    _create_issue(hass, entry, ISSUE_BUCKET_ACCESS_RESTRICTED, bucket_name)
-
-
-def create_bucket_not_found_issue(
-    hass: HomeAssistant, entry: ConfigEntry, bucket_name: str
-) -> None:
-    """Create a repair issue for non-existent bucket."""
-    _create_issue(hass, entry, ISSUE_BUCKET_NOT_FOUND, bucket_name)
-
-
-async def async_check_for_repair_issues(
-    hass: HomeAssistant, entry: ConfigEntry
-) -> None:
-    """Check for common issues that require user action."""
-    bucket = entry.runtime_data
-    restricted_issue_id = f"{ISSUE_BUCKET_ACCESS_RESTRICTED}_{entry.entry_id}"
-    not_found_issue_id = f"{ISSUE_BUCKET_NOT_FOUND}_{entry.entry_id}"
-
-    try:
-        await hass.async_add_executor_job(bucket.api.account_info.get_allowed)
-        ir.async_delete_issue(hass, DOMAIN, restricted_issue_id)
-        ir.async_delete_issue(hass, DOMAIN, not_found_issue_id)
-    except Unauthorized:
-        entry.async_start_reauth(hass)
-    except RestrictedBucket as err:
-        _create_issue(hass, entry, ISSUE_BUCKET_ACCESS_RESTRICTED, err.bucket_name)
-    except NonExistentBucket:
-        _create_issue(hass, entry, ISSUE_BUCKET_NOT_FOUND, entry.data[CONF_BUCKET])
-    except B2Error as err:
-        _LOGGER.debug("B2 connectivity test failed: %s", err)
-
-
-async def async_create_fix_flow(
-    hass: HomeAssistant,
-    issue_id: str,
-    data: dict[str, str | int | float | None] | None,
-) -> ConfirmRepairFlow:
-    """Create a fix flow for Backblaze B2 issues."""
-    return ConfirmRepairFlow()

homeassistant/components/backblaze_b2/strings.json

@@ -1,92 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_bucket_name": "[%key:component::backblaze_b2::exceptions::invalid_bucket_name::message%]",
-      "invalid_capability": "[%key:component::backblaze_b2::exceptions::invalid_capability::message%]",
-      "invalid_credentials": "[%key:component::backblaze_b2::exceptions::invalid_credentials::message%]",
-      "invalid_prefix": "[%key:component::backblaze_b2::exceptions::invalid_prefix::message%]",
-      "restricted_bucket": "[%key:component::backblaze_b2::exceptions::restricted_bucket::message%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "reauth_confirm": {
-        "data": {
-          "application_key": "Application key",
-          "key_id": "Key ID"
-        },
-        "data_description": {
-          "application_key": "Application key to connect to {brand_name}",
-          "key_id": "Key ID to connect to {brand_name}"
-        },
-        "description": "Update your {brand_name} credentials for bucket {bucket}.",
-        "title": "Reauthenticate {brand_name}"
-      },
-      "reconfigure": {
-        "data": {
-          "application_key": "Application key",
-          "bucket": "Bucket name",
-          "key_id": "Key ID",
-          "prefix": "Folder prefix (optional)"
-        },
-        "data_description": {
-          "application_key": "Application key to connect to {brand_name}",
-          "bucket": "Bucket must already exist and be writable by the provided credentials.",
-          "key_id": "Key ID to connect to {brand_name}",
-          "prefix": "Directory path to store backup files in. Leave empty to store in the root."
-        },
-        "title": "Reconfigure {brand_name}"
-      },
-      "user": {
-        "data": {
-          "application_key": "Application key",
-          "bucket": "Bucket name",
-          "key_id": "Key ID",
-          "prefix": "Folder prefix (optional)"
-        },
-        "data_description": {
-          "application_key": "Application key to connect to {brand_name}",
-          "bucket": "Bucket must already exist and be writable by the provided credentials.",
-          "key_id": "Key ID to connect to {brand_name}",
-          "prefix": "Directory path to store backup files in. Leave empty to store in the root."
-        },
-        "title": "Add {brand_name} backup"
-      }
-    }
-  },
-  "exceptions": {
-    "cannot_connect": {
-      "message": "Cannot connect to endpoint"
-    },
-    "invalid_bucket_name": {
-      "message": "Bucket does not exist or is not writable by the provided credentials."
-    },
-    "invalid_capability": {
-      "message": "Application key does not have the required read/write capabilities."
-    },
-    "invalid_credentials": {
-      "message": "Bucket cannot be accessed using provided of key ID and application key."
-    },
-    "invalid_prefix": {
-      "message": "Prefix is not allowed for provided key. Must start with {allowed_prefix}."
-    },
-    "restricted_bucket": {
-      "message": "Application key is restricted to bucket {restricted_bucket_name}."
-    }
-  },
-  "issues": {
-    "bucket_access_restricted": {
-      "description": "Access to your {brand_name} bucket {bucket_name} is restricted for the current credentials. This means your application key may only have access to specific buckets, but not this one. To fix this issue:\n\n1. Log in to your {brand_name} account\n2. Check your application key restrictions\n3. Either use a different bucket that your key can access, or create a new application key with access to {bucket_name}\n4. Go to Settings > Devices & Services > {brand_name} and reconfigure the integration settings\n\nOnce you update the integration settings, this issue will be automatically resolved.",
-      "title": "{brand_name} bucket access restricted"
-    },
-    "bucket_not_found": {
-      "description": "The {brand_name} bucket {bucket_name} cannot be found or accessed. This could mean:\n\n1. The bucket was deleted\n2. The bucket name was changed\n3. Your credentials no longer have access to this bucket\n\nTo fix this issue:\n\n1. Log in to your {brand_name} account\n2. Verify the bucket still exists and check its name\n3. Ensure your application key has access to this bucket\n4. Go to Settings > Devices & Services > {brand_name} and reconfigure the integration settings\n\nOnce you update the integration settings, this issue will be automatically resolved.",
-      "title": "{brand_name} bucket not found"
-    }
-  }
-}

homeassistant/components/backup/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "service",
   "iot_class": "calculated",
   "quality_scale": "internal",
-  "requirements": ["cronsim==2.7", "securetar==2025.2.1"],
+  "requirements": ["cronsim==2.6", "securetar==2025.2.1"],
   "single_config_entry": true
 }

homeassistant/components/bang_olufsen/manifest.json

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

homeassistant/components/blue_current/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/blue_current",
   "iot_class": "cloud_push",
   "loggers": ["bluecurrent_api"],
-  "requirements": ["bluecurrent-api==1.3.2"]
+  "requirements": ["bluecurrent-api==1.3.1"]
 }

homeassistant/components/bluemaestro/config_flow.py

@@ -72,7 +72,7 @@ class BlueMaestroConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=self._discovered_devices[address], data={}
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if address in current_addresses or address in self._discovered_devices:

homeassistant/components/bluetooth/manifest.json

@@ -20,7 +20,7 @@
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.28.4",
-    "dbus-fast==2.45.0",
+    "dbus-fast==2.44.5",
     "habluetooth==5.7.0"
   ]
 }

homeassistant/components/bluetooth/passive_update_processor.py

@@ -99,12 +99,6 @@ def deserialize_entity_description(
         descriptions_class = descriptions_class._dataclass  # noqa: SLF001
     for field in cached_fields(descriptions_class):
         field_name = field.name
-        # Only set fields that are in the data
-        # otherwise we would override default values with None
-        # causing side effects
-        if field_name not in data:
-            continue
-
         # It would be nice if field.type returned the actual
         # type instead of a str so we could avoid writing this
         # out, but it doesn't. If we end up using this in more

homeassistant/components/brother/__init__.py

@@ -9,7 +9,7 @@ from brother import Brother, SnmpError
 from homeassistant.components.snmp import async_get_snmp_engine
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_TYPE, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady
 
 from .const import (
     CONF_COMMUNITY,
@@ -50,15 +50,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: BrotherConfigEntry) -> b
     coordinator = BrotherDataUpdateCoordinator(hass, entry, brother)
     await coordinator.async_config_entry_first_refresh()
 
-    if brother.serial.lower() != entry.unique_id:
-        raise ConfigEntryError(
-            translation_domain=DOMAIN,
-            translation_key="serial_mismatch",
-            translation_placeholders={
-                "device": entry.title,
-            },
-        )
-
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/brother/config_flow.py

@@ -13,7 +13,6 @@ from homeassistant.const import CONF_HOST, CONF_PORT, CONF_TYPE
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import section
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from homeassistant.util.network import is_host_valid
 
@@ -22,7 +21,6 @@ from .const import (
     DEFAULT_COMMUNITY,
     DEFAULT_PORT,
     DOMAIN,
-    PRINTER_TYPE_LASER,
     PRINTER_TYPES,
     SECTION_ADVANCED_SETTINGS,
 )
@@ -30,12 +28,7 @@ from .const import (
 DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST): str,
-        vol.Required(CONF_TYPE, default=PRINTER_TYPE_LASER): SelectSelector(
-            SelectSelectorConfig(
-                options=PRINTER_TYPES,
-                translation_key="printer_type",
-            )
-        ),
+        vol.Optional(CONF_TYPE, default="laser"): vol.In(PRINTER_TYPES),
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
                 {
@@ -49,12 +42,7 @@ DATA_SCHEMA = vol.Schema(
 )
 ZEROCONF_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_TYPE, default=PRINTER_TYPE_LASER): SelectSelector(
-            SelectSelectorConfig(
-                options=PRINTER_TYPES,
-                translation_key="printer_type",
-            )
-        ),
+        vol.Optional(CONF_TYPE, default="laser"): vol.In(PRINTER_TYPES),
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
                 {

homeassistant/components/brother/const.py

@@ -7,10 +7,7 @@ from typing import Final
 
 DOMAIN: Final = "brother"
 
-PRINTER_TYPE_LASER = "laser"
-PRINTER_TYPE_INK = "ink"
-
-PRINTER_TYPES: Final = [PRINTER_TYPE_LASER, PRINTER_TYPE_INK]
+PRINTER_TYPES: Final = ["laser", "ink"]
 
 UPDATE_INTERVAL = timedelta(seconds=30)
 

homeassistant/components/brother/entity.py

@@ -1,30 +0,0 @@
-"""Define the Brother entity."""
-
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import BrotherDataUpdateCoordinator
-
-
-class BrotherPrinterEntity(CoordinatorEntity[BrotherDataUpdateCoordinator]):
-    """Define a Brother Printer entity."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: BrotherDataUpdateCoordinator,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            configuration_url=f"http://{coordinator.brother.host}/",
-            identifiers={(DOMAIN, coordinator.brother.serial)},
-            connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
-            serial_number=coordinator.brother.serial,
-            manufacturer="Brother",
-            model=coordinator.brother.model,
-            name=coordinator.brother.model,
-            sw_version=coordinator.brother.firmware,
-        )

homeassistant/components/brother/sensor.py

@@ -19,15 +19,13 @@ from homeassistant.components.sensor import (
 from homeassistant.const import PERCENTAGE, EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import BrotherConfigEntry, BrotherDataUpdateCoordinator
-from .entity import BrotherPrinterEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
 
 ATTR_COUNTER = "counter"
 ATTR_REMAINING_PAGES = "remaining_pages"
@@ -332,9 +330,12 @@ async def async_setup_entry(
     )
 
 
-class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
-    """Define a Brother Printer sensor."""
+class BrotherPrinterSensor(
+    CoordinatorEntity[BrotherDataUpdateCoordinator], SensorEntity
+):
+    """Define an Brother Printer sensor."""
 
+    _attr_has_entity_name = True
     entity_description: BrotherSensorEntityDescription
 
     def __init__(
@@ -344,7 +345,16 @@ class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
     ) -> None:
         """Initialize."""
         super().__init__(coordinator)
-
+        self._attr_device_info = DeviceInfo(
+            configuration_url=f"http://{coordinator.brother.host}/",
+            identifiers={(DOMAIN, coordinator.brother.serial)},
+            connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
+            serial_number=coordinator.brother.serial,
+            manufacturer="Brother",
+            model=coordinator.brother.model,
+            name=coordinator.brother.model,
+            sw_version=coordinator.brother.firmware,
+        )
         self._attr_native_value = description.value(coordinator.data)
         self._attr_unique_id = f"{coordinator.brother.serial.lower()}_{description.key}"
         self.entity_description = description

homeassistant/components/brother/strings.json

@@ -38,11 +38,11 @@
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
-          "type": "Printer type"
+          "type": "Type of the printer"
         },
         "data_description": {
           "host": "The hostname or IP address of the Brother printer to control.",
-          "type": "The type of the Brother printer."
+          "type": "Brother printer type: ink or laser."
         },
         "sections": {
           "advanced_settings": {
@@ -207,19 +207,8 @@
     "cannot_connect": {
       "message": "An error occurred while connecting to the {device} printer: {error}"
     },
-    "serial_mismatch": {
-      "message": "The serial number for {device} doesn't match the one in the configuration. It's possible that the two Brother printers have swapped IP addresses. Restore the previous IP address configuration or reconfigure the devices with Home Assistant."
-    },
     "update_error": {
       "message": "An error occurred while retrieving data from the {device} printer: {error}"
     }
-  },
-  "selector": {
-    "printer_type": {
-      "options": {
-        "ink": "ink",
-        "laser": "laser"
-      }
-    }
   }
 }

homeassistant/components/bthome/binary_sensor.py

@@ -63,7 +63,6 @@ BINARY_SENSOR_DESCRIPTIONS = {
     ),
     BTHomeBinarySensorDeviceClass.GENERIC: BinarySensorEntityDescription(
         key=BTHomeBinarySensorDeviceClass.GENERIC,
-        translation_key="generic",
     ),
     BTHomeBinarySensorDeviceClass.LIGHT: BinarySensorEntityDescription(
         key=BTHomeBinarySensorDeviceClass.LIGHT,
@@ -160,7 +159,10 @@ def sensor_update_to_bluetooth_data_update(
             device_key_to_bluetooth_entity_key(device_key): sensor_values.native_value
             for device_key, sensor_values in sensor_update.binary_entity_values.items()
         },
-        entity_names={},
+        entity_names={
+            device_key_to_bluetooth_entity_key(device_key): sensor_values.name
+            for device_key, sensor_values in sensor_update.binary_entity_values.items()
+        },
     )
 
 

homeassistant/components/bthome/sensor.py

@@ -59,7 +59,6 @@ SENSOR_DESCRIPTIONS = {
         key=f"{BTHomeSensorDeviceClass.ACCELERATION}_{Units.ACCELERATION_METERS_PER_SQUARE_SECOND}",
         native_unit_of_measurement=Units.ACCELERATION_METERS_PER_SQUARE_SECOND,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="acceleration",
     ),
     # Battery (percent)
     (BTHomeSensorDeviceClass.BATTERY, Units.PERCENTAGE): SensorEntityDescription(
@@ -73,7 +72,6 @@ SENSOR_DESCRIPTIONS = {
     (BTHomeExtendedSensorDeviceClass.CHANNEL, None): SensorEntityDescription(
         key=str(BTHomeExtendedSensorDeviceClass.CHANNEL),
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="channel",
     ),
     # Conductivity (μS/cm)
     (
@@ -89,7 +87,6 @@ SENSOR_DESCRIPTIONS = {
     (BTHomeSensorDeviceClass.COUNT, None): SensorEntityDescription(
         key=str(BTHomeSensorDeviceClass.COUNT),
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="count",
     ),
     # CO2 (parts per million)
     (
@@ -117,14 +114,12 @@ SENSOR_DESCRIPTIONS = {
         device_class=SensorDeviceClass.TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="dew_point",
     ),
     # Directions (°)
     (BTHomeExtendedSensorDeviceClass.DIRECTION, Units.DEGREE): SensorEntityDescription(
         key=f"{BTHomeExtendedSensorDeviceClass.DIRECTION}_{Units.DEGREE}",
         native_unit_of_measurement=DEGREE,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="direction",
     ),
     # Distance (mm)
     (
@@ -178,7 +173,6 @@ SENSOR_DESCRIPTIONS = {
         key=f"{BTHomeSensorDeviceClass.GYROSCOPE}_{Units.GYROSCOPE_DEGREES_PER_SECOND}",
         native_unit_of_measurement=Units.GYROSCOPE_DEGREES_PER_SECOND,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="gyroscope",
     ),
     # Humidity in (percent)
     (BTHomeSensorDeviceClass.HUMIDITY, Units.PERCENTAGE): SensorEntityDescription(
@@ -221,7 +215,6 @@ SENSOR_DESCRIPTIONS = {
         state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
-        translation_key="packet_id",
     ),
     # PM10 (μg/m3)
     (
@@ -270,14 +263,12 @@ SENSOR_DESCRIPTIONS = {
     # Raw (-)
     (BTHomeExtendedSensorDeviceClass.RAW, None): SensorEntityDescription(
         key=str(BTHomeExtendedSensorDeviceClass.RAW),
-        translation_key="raw",
     ),
     # Rotation (°)
     (BTHomeSensorDeviceClass.ROTATION, Units.DEGREE): SensorEntityDescription(
         key=f"{BTHomeSensorDeviceClass.ROTATION}_{Units.DEGREE}",
         native_unit_of_measurement=DEGREE,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="rotation",
     ),
     # Rotational speed (rpm)
     (
@@ -287,7 +278,6 @@ SENSOR_DESCRIPTIONS = {
         key=f"{BTHomeExtendedSensorDeviceClass.ROTATIONAL_SPEED}_{Units.REVOLUTIONS_PER_MINUTE}",
         native_unit_of_measurement=REVOLUTIONS_PER_MINUTE,
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="rotational_speed",
     ),
     # Signal Strength (RSSI) (dB)
     (
@@ -321,7 +311,6 @@ SENSOR_DESCRIPTIONS = {
     # Text (-)
     (BTHomeExtendedSensorDeviceClass.TEXT, None): SensorEntityDescription(
         key=str(BTHomeExtendedSensorDeviceClass.TEXT),
-        translation_key="text",
     ),
     # Timestamp (datetime object)
     (
@@ -338,7 +327,6 @@ SENSOR_DESCRIPTIONS = {
     ): SensorEntityDescription(
         key=str(BTHomeSensorDeviceClass.UV_INDEX),
         state_class=SensorStateClass.MEASUREMENT,
-        translation_key="uv_index",
     ),
     # Volatile organic Compounds (VOC) (μg/m3)
     (
@@ -435,7 +423,10 @@ def sensor_update_to_bluetooth_data_update(
             )
             for device_key, sensor_values in sensor_update.entity_values.items()
         },
-        entity_names={},
+        entity_names={
+            device_key_to_bluetooth_entity_key(device_key): sensor_values.name
+            for device_key, sensor_values in sensor_update.entity_values.items()
+        },
     )
 
 

homeassistant/components/bthome/strings.json

@@ -47,11 +47,6 @@
     }
   },
   "entity": {
-    "binary_sensor": {
-      "generic": {
-        "name": "Generic"
-      }
-    },
     "event": {
       "button": {
         "state_attributes": {
@@ -78,44 +73,6 @@
           }
         }
       }
-    },
-    "sensor": {
-      "acceleration": {
-        "name": "Acceleration"
-      },
-      "channel": {
-        "name": "Channel"
-      },
-      "count": {
-        "name": "Count"
-      },
-      "dew_point": {
-        "name": "Dew point"
-      },
-      "direction": {
-        "name": "Direction"
-      },
-      "gyroscope": {
-        "name": "Gyroscope"
-      },
-      "packet_id": {
-        "name": "Packet ID"
-      },
-      "raw": {
-        "name": "Raw"
-      },
-      "rotation": {
-        "name": "Rotation"
-      },
-      "rotational_speed": {
-        "name": "Rotational speed"
-      },
-      "text": {
-        "name": "Text"
-      },
-      "uv_index": {
-        "name": "UV Index"
-      }
     }
   }
 }

homeassistant/components/caldav/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/caldav",
   "iot_class": "cloud_polling",
   "loggers": ["caldav", "vobject"],
-  "requirements": ["caldav==2.1.0", "icalendar==6.3.1", "vobject==0.9.9"]
+  "requirements": ["caldav==1.6.0", "icalendar==6.3.1"]
 }

homeassistant/components/climate/reproduce_state.py

@@ -57,9 +57,9 @@ async def _async_reproduce_states(
         await call_service(SERVICE_SET_HVAC_MODE, [], {ATTR_HVAC_MODE: state.state})
 
     if (
-        (state.attributes.get(ATTR_TEMPERATURE) is not None)
-        or (state.attributes.get(ATTR_TARGET_TEMP_HIGH) is not None)
-        or (state.attributes.get(ATTR_TARGET_TEMP_LOW) is not None)
+        (ATTR_TEMPERATURE in state.attributes)
+        or (ATTR_TARGET_TEMP_HIGH in state.attributes)
+        or (ATTR_TARGET_TEMP_LOW in state.attributes)
     ):
         await call_service(
             SERVICE_SET_TEMPERATURE,

homeassistant/components/cloud/account_link.py

@@ -71,11 +71,8 @@ async def _get_services(hass: HomeAssistant) -> list[dict[str, Any]]:
         services = await account_link.async_fetch_available_services(
             hass.data[DATA_CLOUD]
         )
-    except (aiohttp.ClientError, TimeoutError) as err:
-        raise config_entry_oauth2_flow.ImplementationUnavailableError(
-            "Cannot provide OAuth2 implementation for cloud services. "
-            "Failed to fetch from account link server."
-        ) from err
+    except (aiohttp.ClientError, TimeoutError):
+        return []
 
     hass.data[DATA_SERVICES] = services
 

homeassistant/components/comelit/binary_sensor.py

@@ -14,9 +14,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import ObjectClassType
 from .coordinator import ComelitConfigEntry, ComelitVedoSystem
-from .utils import new_device_listener
+from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -31,7 +30,7 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)

homeassistant/components/comelit/const.py

@@ -2,20 +2,10 @@
 
 import logging
 
-from aiocomelit.api import (
-    ComelitSerialBridgeObject,
-    ComelitVedoAreaObject,
-    ComelitVedoZoneObject,
-)
 from aiocomelit.const import BRIDGE, VEDO
 
 _LOGGER = logging.getLogger(__package__)
 
-ObjectClassType = (
-    ComelitSerialBridgeObject | ComelitVedoAreaObject | ComelitVedoZoneObject
-)
-
-
 DOMAIN = "comelit"
 DEFAULT_PORT = 80
 DEVICE_TYPE_LIST = [BRIDGE, VEDO]

homeassistant/components/comelit/coordinator.py

@@ -10,6 +10,8 @@ from aiocomelit.api import (
     ComeliteSerialBridgeApi,
     ComelitSerialBridgeObject,
     ComelitVedoApi,
+    ComelitVedoAreaObject,
+    ComelitVedoZoneObject,
 )
 from aiocomelit.const import (
     BRIDGE,
@@ -30,7 +32,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import _LOGGER, DOMAIN, SCAN_INTERVAL, ObjectClassType
+from .const import _LOGGER, DOMAIN, SCAN_INTERVAL
 
 type ComelitConfigEntry = ConfigEntry[ComelitBaseCoordinator]
 
@@ -75,7 +77,9 @@ class ComelitBaseCoordinator(DataUpdateCoordinator[T]):
 
     def platform_device_info(
         self,
-        object_class: ObjectClassType,
+        object_class: ComelitVedoZoneObject
+        | ComelitVedoAreaObject
+        | ComelitSerialBridgeObject,
         object_type: str,
     ) -> dr.DeviceInfo:
         """Set platform device info."""

homeassistant/components/comelit/cover.py

@@ -12,10 +12,9 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
 
-from .const import ObjectClassType
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call, new_device_listener
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -30,7 +29,7 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitCoverEntity(coordinator, device, config_entry.entry_id)

homeassistant/components/comelit/light.py

@@ -10,10 +10,9 @@ from homeassistant.components.light import ColorMode, LightEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import ObjectClassType
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call, new_device_listener
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -28,7 +27,7 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitLightEntity(coordinator, device, config_entry.entry_id)

homeassistant/components/comelit/sensor.py

@@ -18,10 +18,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import ObjectClassType
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
 from .entity import ComelitBridgeBaseEntity
-from .utils import new_device_listener
+from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -67,7 +66,7 @@ async def async_setup_bridge_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitBridgeSensorEntity(
@@ -94,7 +93,7 @@ async def async_setup_vedo_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitVedoSensorEntity(

homeassistant/components/comelit/switch.py

@@ -11,10 +11,9 @@ from homeassistant.components.switch import SwitchDeviceClass, SwitchEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import ObjectClassType
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call, new_device_listener
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -29,7 +28,7 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitSwitchEntity(coordinator, device, config_entry.entry_id)

homeassistant/components/comelit/utils.py

@@ -2,9 +2,13 @@
 
 from collections.abc import Awaitable, Callable, Coroutine
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Concatenate
+from typing import Any, Concatenate
 
-from aiocomelit.api import ComelitSerialBridgeObject
+from aiocomelit.api import (
+    ComelitSerialBridgeObject,
+    ComelitVedoAreaObject,
+    ComelitVedoZoneObject,
+)
 from aiocomelit.exceptions import CannotAuthenticate, CannotConnect, CannotRetrieveData
 from aiohttp import ClientSession, CookieJar
 
@@ -18,10 +22,12 @@ from homeassistant.helpers import (
     entity_registry as er,
 )
 
-from .const import _LOGGER, DOMAIN, ObjectClassType
+from .const import _LOGGER, DOMAIN
 from .coordinator import ComelitBaseCoordinator
 from .entity import ComelitBridgeBaseEntity
 
+DeviceType = ComelitSerialBridgeObject | ComelitVedoAreaObject | ComelitVedoZoneObject
+
 
 async def async_client_session(hass: HomeAssistant) -> ClientSession:
     """Return a new aiohttp session."""
@@ -120,7 +126,11 @@ def new_device_listener(
     coordinator: ComelitBaseCoordinator,
     new_devices_callback: Callable[
         [
-            list[ObjectClassType],
+            list[
+                ComelitSerialBridgeObject
+                | ComelitVedoAreaObject
+                | ComelitVedoZoneObject
+            ],
             str,
         ],
         None,
@@ -132,10 +142,10 @@ def new_device_listener(
 
     def _check_devices() -> None:
         """Check for new devices and call callback with any new monitors."""
-        if TYPE_CHECKING:
-            assert coordinator.data
+        if not coordinator.data:
+            return
 
-        new_devices: list[ObjectClassType] = []
+        new_devices: list[DeviceType] = []
         for _id in coordinator.data[data_type]:
             if _id not in (id_list := known_devices.get(data_type, [])):
                 known_devices.update({data_type: [*id_list, _id]})

homeassistant/components/coolmaster/const.py

@@ -6,5 +6,3 @@ DEFAULT_PORT = 10102
 
 CONF_SUPPORTED_MODES = "supported_modes"
 CONF_SWING_SUPPORT = "swing_support"
-MAX_RETRIES = 3
-BACKOFF_BASE_DELAY = 2

homeassistant/components/coolmaster/coordinator.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from pycoolmasternet_async import CoolMasterNet
@@ -13,7 +12,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import BACKOFF_BASE_DELAY, DOMAIN, MAX_RETRIES
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -47,34 +46,7 @@ class CoolmasterDataUpdateCoordinator(
 
     async def _async_update_data(self) -> dict[str, CoolMasterNetUnit]:
         """Fetch data from Coolmaster."""
-        retries_left = MAX_RETRIES
-        status: dict[str, CoolMasterNetUnit] = {}
-        while retries_left > 0 and not status:
-            retries_left -= 1
-            try:
-                status = await self._coolmaster.status()
-            except OSError as error:
-                if retries_left == 0:
-                    raise UpdateFailed(
-                        f"Error communicating with Coolmaster (aborting after {MAX_RETRIES} retries): {error}"
-                    ) from error
-                _LOGGER.debug(
-                    "Error communicating with coolmaster (%d retries left): %s",
-                    retries_left,
-                    str(error),
-                )
-            else:
-                if status:
-                    return status
-
-                _LOGGER.debug(
-                    "Error communicating with coolmaster: empty status received (%d retries left)",
-                    retries_left,
-                )
-
-            backoff = BACKOFF_BASE_DELAY ** (MAX_RETRIES - retries_left)
-            await asyncio.sleep(backoff)
-
-        raise UpdateFailed(
-            f"Error communicating with Coolmaster (aborting after {MAX_RETRIES} retries): empty status received"
-        )
+        try:
+            return await self._coolmaster.status()
+        except OSError as error:
+            raise UpdateFailed from error

homeassistant/components/cups/__init__.py

@@ -0,0 +1,4 @@
+"""The cups component."""
+
+DOMAIN = "cups"
+CONF_PRINTERS = "printers"

homeassistant/components/cups/manifest.json

@@ -0,0 +1,9 @@
+{
+  "domain": "cups",
+  "name": "CUPS",
+  "codeowners": ["@fabaff"],
+  "documentation": "https://www.home-assistant.io/integrations/cups",
+  "iot_class": "local_polling",
+  "quality_scale": "legacy",
+  "requirements": ["pycups==2.0.4"]
+}

homeassistant/components/cups/sensor.py

@@ -0,0 +1,349 @@
+"""Details about printers which are connected to CUPS."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import importlib
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components.sensor import (
+    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
+    SensorEntity,
+)
+from homeassistant.const import CONF_HOST, CONF_PORT, PERCENTAGE
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.exceptions import PlatformNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from . import CONF_PRINTERS, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_MARKER_TYPE = "marker_type"
+ATTR_MARKER_LOW_LEVEL = "marker_low_level"
+ATTR_MARKER_HIGH_LEVEL = "marker_high_level"
+ATTR_PRINTER_NAME = "printer_name"
+ATTR_DEVICE_URI = "device_uri"
+ATTR_PRINTER_INFO = "printer_info"
+ATTR_PRINTER_IS_SHARED = "printer_is_shared"
+ATTR_PRINTER_LOCATION = "printer_location"
+ATTR_PRINTER_MODEL = "printer_model"
+ATTR_PRINTER_STATE_MESSAGE = "printer_state_message"
+ATTR_PRINTER_STATE_REASON = "printer_state_reason"
+ATTR_PRINTER_TYPE = "printer_type"
+ATTR_PRINTER_URI_SUPPORTED = "printer_uri_supported"
+
+CONF_IS_CUPS_SERVER = "is_cups_server"
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 631
+DEFAULT_IS_CUPS_SERVER = True
+
+ICON_PRINTER = "mdi:printer"
+ICON_MARKER = "mdi:water"
+
+SCAN_INTERVAL = timedelta(minutes=1)
+
+PRINTER_STATES = {3: "idle", 4: "printing", 5: "stopped"}
+
+PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
+    {
+        vol.Required(CONF_PRINTERS): vol.All(cv.ensure_list, [cv.string]),
+        vol.Optional(CONF_IS_CUPS_SERVER, default=DEFAULT_IS_CUPS_SERVER): cv.boolean,
+        vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    }
+)
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the CUPS sensor."""
+    host: str = config[CONF_HOST]
+    port: int = config[CONF_PORT]
+    printers: list[str] = config[CONF_PRINTERS]
+    is_cups: bool = config[CONF_IS_CUPS_SERVER]
+
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "CUPS",
+        },
+    )
+
+    if is_cups:
+        data = CupsData(host, port, None)
+        data.update()
+        if data.available is False:
+            _LOGGER.error("Unable to connect to CUPS server: %s:%s", host, port)
+            raise PlatformNotReady
+        assert data.printers is not None
+
+        dev: list[SensorEntity] = []
+        for printer in printers:
+            if printer not in data.printers:
+                _LOGGER.error("Printer is not present: %s", printer)
+                continue
+            dev.append(CupsSensor(data, printer))
+
+            if "marker-names" in data.attributes[printer]:
+                dev.extend(
+                    MarkerSensor(data, printer, marker, True)
+                    for marker in data.attributes[printer]["marker-names"]
+                )
+
+        add_entities(dev, True)
+        return
+
+    data = CupsData(host, port, printers)
+    data.update()
+    if data.available is False:
+        _LOGGER.error("Unable to connect to IPP printer: %s:%s", host, port)
+        raise PlatformNotReady
+
+    dev = []
+    for printer in printers:
+        dev.append(IPPSensor(data, printer))
+
+        if "marker-names" in data.attributes[printer]:
+            for marker in data.attributes[printer]["marker-names"]:
+                dev.append(MarkerSensor(data, printer, marker, False))
+
+    add_entities(dev, True)
+
+
+class CupsSensor(SensorEntity):
+    """Representation of a CUPS sensor."""
+
+    _attr_icon = ICON_PRINTER
+
+    def __init__(self, data: CupsData, printer_name: str) -> None:
+        """Initialize the CUPS sensor."""
+        self.data = data
+        self._name = printer_name
+        self._printer: dict[str, Any] | None = None
+        self._attr_available = False
+
+    @property
+    def name(self) -> str:
+        """Return the name of the entity."""
+        return self._name
+
+    @property
+    def native_value(self):
+        """Return the state of the sensor."""
+        if self._printer is None:
+            return None
+
+        key = self._printer["printer-state"]
+        return PRINTER_STATES.get(key, key)
+
+    @property
+    def extra_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        if self._printer is None:
+            return None
+
+        return {
+            ATTR_DEVICE_URI: self._printer["device-uri"],
+            ATTR_PRINTER_INFO: self._printer["printer-info"],
+            ATTR_PRINTER_IS_SHARED: self._printer["printer-is-shared"],
+            ATTR_PRINTER_LOCATION: self._printer["printer-location"],
+            ATTR_PRINTER_MODEL: self._printer["printer-make-and-model"],
+            ATTR_PRINTER_STATE_MESSAGE: self._printer["printer-state-message"],
+            ATTR_PRINTER_STATE_REASON: self._printer["printer-state-reasons"],
+            ATTR_PRINTER_TYPE: self._printer["printer-type"],
+            ATTR_PRINTER_URI_SUPPORTED: self._printer["printer-uri-supported"],
+        }
+
+    def update(self) -> None:
+        """Get the latest data and updates the states."""
+        self.data.update()
+        assert self.data.printers is not None
+        self._printer = self.data.printers.get(self.name)
+        self._attr_available = self.data.available
+
+
+class IPPSensor(SensorEntity):
+    """Implementation of the IPPSensor.
+
+    This sensor represents the status of the printer.
+    """
+
+    _attr_icon = ICON_PRINTER
+
+    def __init__(self, data: CupsData, printer_name: str) -> None:
+        """Initialize the sensor."""
+        self.data = data
+        self._printer_name = printer_name
+        self._attributes = None
+        self._attr_available = False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._attributes["printer-make-and-model"]
+
+    @property
+    def native_value(self):
+        """Return the state of the sensor."""
+        if self._attributes is None:
+            return None
+
+        key = self._attributes["printer-state"]
+        return PRINTER_STATES.get(key, key)
+
+    @property
+    def extra_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        if self._attributes is None:
+            return None
+
+        state_attributes = {}
+
+        if "printer-info" in self._attributes:
+            state_attributes[ATTR_PRINTER_INFO] = self._attributes["printer-info"]
+
+        if "printer-location" in self._attributes:
+            state_attributes[ATTR_PRINTER_LOCATION] = self._attributes[
+                "printer-location"
+            ]
+
+        if "printer-state-message" in self._attributes:
+            state_attributes[ATTR_PRINTER_STATE_MESSAGE] = self._attributes[
+                "printer-state-message"
+            ]
+
+        if "printer-state-reasons" in self._attributes:
+            state_attributes[ATTR_PRINTER_STATE_REASON] = self._attributes[
+                "printer-state-reasons"
+            ]
+
+        if "printer-uri-supported" in self._attributes:
+            state_attributes[ATTR_PRINTER_URI_SUPPORTED] = self._attributes[
+                "printer-uri-supported"
+            ]
+
+        return state_attributes
+
+    def update(self) -> None:
+        """Fetch new state data for the sensor."""
+        self.data.update()
+        self._attributes = self.data.attributes.get(self._printer_name)
+        self._attr_available = self.data.available
+
+
+class MarkerSensor(SensorEntity):
+    """Implementation of the MarkerSensor.
+
+    This sensor represents the percentage of ink or toner.
+    """
+
+    _attr_icon = ICON_MARKER
+    _attr_native_unit_of_measurement = PERCENTAGE
+
+    def __init__(self, data: CupsData, printer: str, name: str, is_cups: bool) -> None:
+        """Initialize the sensor."""
+        self.data = data
+        self._attr_name = name
+        self._printer = printer
+        self._index = data.attributes[printer]["marker-names"].index(name)
+        self._is_cups = is_cups
+        self._attributes: dict[str, Any] | None = None
+
+    @property
+    def native_value(self):
+        """Return the state of the sensor."""
+        if self._attributes is None:
+            return None
+
+        return self._attributes[self._printer]["marker-levels"][self._index]
+
+    @property
+    def extra_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        if self._attributes is None:
+            return None
+
+        high_level = self._attributes[self._printer].get("marker-high-levels")
+        if isinstance(high_level, list):
+            high_level = high_level[self._index]
+
+        low_level = self._attributes[self._printer].get("marker-low-levels")
+        if isinstance(low_level, list):
+            low_level = low_level[self._index]
+
+        marker_types = self._attributes[self._printer]["marker-types"]
+        if isinstance(marker_types, list):
+            marker_types = marker_types[self._index]
+
+        if self._is_cups:
+            printer_name = self._printer
+        else:
+            printer_name = self._attributes[self._printer]["printer-make-and-model"]
+
+        return {
+            ATTR_MARKER_HIGH_LEVEL: high_level,
+            ATTR_MARKER_LOW_LEVEL: low_level,
+            ATTR_MARKER_TYPE: marker_types,
+            ATTR_PRINTER_NAME: printer_name,
+        }
+
+    def update(self) -> None:
+        """Update the state of the sensor."""
+        # Data fetching is done by CupsSensor/IPPSensor
+        self._attributes = self.data.attributes
+
+
+class CupsData:
+    """Get the latest data from CUPS and update the state."""
+
+    def __init__(self, host: str, port: int, ipp_printers: list[str] | None) -> None:
+        """Initialize the data object."""
+        self._host = host
+        self._port = port
+        self._ipp_printers = ipp_printers
+        self.is_cups = ipp_printers is None
+        self.printers: dict[str, dict[str, Any]] | None = None
+        self.attributes: dict[str, Any] = {}
+        self.available = False
+
+    def update(self) -> None:
+        """Get the latest data from CUPS."""
+        cups = importlib.import_module("cups")
+
+        try:
+            conn = cups.Connection(host=self._host, port=self._port)
+            if self.is_cups:
+                self.printers = conn.getPrinters()
+                assert self.printers is not None
+                for printer in self.printers:
+                    self.attributes[printer] = conn.getPrinterAttributes(name=printer)
+            else:
+                assert self._ipp_printers is not None
+                for ipp_printer in self._ipp_printers:
+                    self.attributes[ipp_printer] = conn.getPrinterAttributes(
+                        uri=f"ipp://{self._host}:{self._port}/{ipp_printer}"
+                    )
+
+            self.available = True
+        except RuntimeError:
+            self.available = False

homeassistant/components/decora/__init__.py

@@ -0,0 +1,3 @@
+"""The decora component."""
+
+DOMAIN = "decora"

homeassistant/components/decora/light.py

@@ -0,0 +1,166 @@
+"""Support for Decora dimmers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import copy
+from functools import wraps
+import logging
+import time
+from typing import TYPE_CHECKING, Any, Concatenate
+
+from bluepy.btle import BTLEException
+import decora
+import voluptuous as vol
+
+from homeassistant import util
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    PLATFORM_SCHEMA as LIGHT_PLATFORM_SCHEMA,
+    ColorMode,
+    LightEntity,
+)
+from homeassistant.const import CONF_API_KEY, CONF_DEVICES, CONF_NAME
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+
+from . import DOMAIN
+
+if TYPE_CHECKING:
+    from homeassistant.core import HomeAssistant
+    from homeassistant.helpers.entity_platform import AddEntitiesCallback
+    from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _name_validator(config):
+    """Validate the name."""
+    config = copy.deepcopy(config)
+    for address, device_config in config[CONF_DEVICES].items():
+        if CONF_NAME not in device_config:
+            device_config[CONF_NAME] = util.slugify(address)
+
+    return config
+
+
+DEVICE_SCHEMA = vol.Schema(
+    {vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_API_KEY): cv.string}
+)
+
+PLATFORM_SCHEMA = vol.Schema(
+    vol.All(
+        LIGHT_PLATFORM_SCHEMA.extend(
+            {vol.Optional(CONF_DEVICES, default={}): {cv.string: DEVICE_SCHEMA}}
+        ),
+        _name_validator,
+    )
+)
+
+
+def retry[_DecoraLightT: DecoraLight, **_P, _R](
+    method: Callable[Concatenate[_DecoraLightT, _P], _R],
+) -> Callable[Concatenate[_DecoraLightT, _P], _R | None]:
+    """Retry bluetooth commands."""
+
+    @wraps(method)
+    def wrapper_retry(
+        device: _DecoraLightT, *args: _P.args, **kwargs: _P.kwargs
+    ) -> _R | None:
+        """Try send command and retry on error."""
+
+        initial = time.monotonic()
+        while True:
+            if time.monotonic() - initial >= 10:
+                return None
+            try:
+                return method(device, *args, **kwargs)
+            except (decora.decoraException, AttributeError, BTLEException):
+                _LOGGER.warning(
+                    "Decora connect error for device %s. Reconnecting",
+                    device.name,
+                )
+                device._switch.connect()  # noqa: SLF001
+
+    return wrapper_retry
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up an Decora switch."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Leviton Decora",
+        },
+    )
+
+    lights = []
+    for address, device_config in config[CONF_DEVICES].items():
+        device = {}
+        device["name"] = device_config[CONF_NAME]
+        device["key"] = device_config[CONF_API_KEY]
+        device["address"] = address
+        light = DecoraLight(device)
+        lights.append(light)
+
+    add_entities(lights)
+
+
+class DecoraLight(LightEntity):
+    """Representation of an Decora light."""
+
+    _attr_color_mode = ColorMode.BRIGHTNESS
+    _attr_supported_color_modes = {ColorMode.BRIGHTNESS}
+
+    def __init__(self, device: dict[str, Any]) -> None:
+        """Initialize the light."""
+
+        self._attr_name = device["name"]
+        self._attr_unique_id = device["address"]
+        self._key = device["key"]
+        self._switch = decora.decora(device["address"], self._key)
+        self._attr_brightness = 0
+        self._attr_is_on = False
+
+    @retry
+    def set_state(self, brightness: int) -> None:
+        """Set the state of this lamp to the provided brightness."""
+        self._switch.set_brightness(int(brightness / 2.55))
+        self._attr_brightness = brightness
+
+    @retry
+    def turn_on(self, **kwargs: Any) -> None:
+        """Turn the specified or all lights on."""
+        brightness = kwargs.get(ATTR_BRIGHTNESS)
+        self._switch.on()
+        self._attr_is_on = True
+
+        if brightness is not None:
+            self.set_state(brightness)
+
+    @retry
+    def turn_off(self, **kwargs: Any) -> None:
+        """Turn the specified or all lights off."""
+        self._switch.off()
+        self._attr_is_on = False
+
+    @retry
+    def update(self) -> None:
+        """Synchronise internal state with the actual light state."""
+        self._attr_brightness = self._switch.get_brightness() * 2.55
+        self._attr_is_on = self._switch.get_on()

homeassistant/components/decora/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "decora",
+  "name": "Leviton Decora",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/decora",
+  "iot_class": "local_polling",
+  "loggers": ["bluepy", "decora"],
+  "quality_scale": "legacy",
+  "requirements": ["bluepy==1.3.0", "decora==0.6"]
+}

homeassistant/components/devolo_home_control/__init__.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Mapping
 from functools import partial
-import logging
 from typing import Any
 
 from devolo_home_control_api.exceptions.gateway import GatewayOfflineError
@@ -23,8 +22,6 @@ from .const import DOMAIN, PLATFORMS
 
 type DevoloHomeControlConfigEntry = ConfigEntry[list[HomeControl]]
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: DevoloHomeControlConfigEntry
@@ -47,29 +44,26 @@ async def async_setup_entry(
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, shutdown)
     )
 
-    zeroconf_instance = await zeroconf.async_get_instance(hass)
-    entry.runtime_data = []
-    offline_gateways = 0
-    for gateway_id in gateway_ids:
-        try:
+    try:
+        zeroconf_instance = await zeroconf.async_get_instance(hass)
+        entry.runtime_data = []
+        for gateway_id in gateway_ids:
             entry.runtime_data.append(
                 await hass.async_add_executor_job(
                     partial(
                         HomeControl,
-                        gateway_id=gateway_id,
+                        gateway_id=str(gateway_id),
                         mydevolo_instance=mydevolo,
                         zeroconf_instance=zeroconf_instance,
                     )
                 )
             )
-        except GatewayOfflineError:
-            offline_gateways += 1
-            _LOGGER.info("Central unit %s cannot be reached locally", gateway_id)
-    if len(gateway_ids) == offline_gateways:
+    except GatewayOfflineError as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
             translation_key="connection_failed",
-        )
+            translation_placeholders={"gateway_id": gateway_id},
+        ) from err
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 

homeassistant/components/devolo_home_control/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/devolo_home_control",
   "integration_type": "hub",
   "iot_class": "local_push",
-  "loggers": ["HomeControl", "Mydevolo", "MprmRest", "MprmWebsocket", "Mprm"],
+  "loggers": ["devolo_home_control_api"],
   "requirements": ["devolo-home-control-api==0.19.0"],
   "zeroconf": ["_dvl-deviceapi._tcp.local."]
 }

homeassistant/components/devolo_home_control/strings.json

@@ -58,7 +58,7 @@
   },
   "exceptions": {
     "connection_failed": {
-      "message": "Failed to connect to any devolo Home Control central unit."
+      "message": "Failed to connect to devolo Home Control central unit {gateway_id}."
     },
     "invalid_auth": {
       "message": "Authentication failed. Please re-authenticate with your mydevolo account."

homeassistant/components/dlib_face_detect/__init__.py

@@ -0,0 +1,3 @@
+"""The dlib_face_detect component."""
+
+DOMAIN = "dlib_face_detect"

homeassistant/components/dlib_face_detect/image_processing.py

@@ -0,0 +1,82 @@
+"""Component that will help set the Dlib face detect processing."""
+
+from __future__ import annotations
+
+import io
+
+import face_recognition
+
+from homeassistant.components.image_processing import (
+    PLATFORM_SCHEMA as IMAGE_PROCESSING_PLATFORM_SCHEMA,
+    ImageProcessingFaceEntity,
+)
+from homeassistant.const import ATTR_LOCATION, CONF_ENTITY_ID, CONF_NAME, CONF_SOURCE
+from homeassistant.core import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
+    HomeAssistant,
+    split_entity_id,
+)
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from . import DOMAIN
+
+PLATFORM_SCHEMA = IMAGE_PROCESSING_PLATFORM_SCHEMA
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the Dlib Face detection platform."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Dlib Face Detect",
+        },
+    )
+    source: list[dict[str, str]] = config[CONF_SOURCE]
+    add_entities(
+        DlibFaceDetectEntity(camera[CONF_ENTITY_ID], camera.get(CONF_NAME))
+        for camera in source
+    )
+
+
+class DlibFaceDetectEntity(ImageProcessingFaceEntity):
+    """Dlib Face API entity for identify."""
+
+    def __init__(self, camera_entity: str, name: str | None) -> None:
+        """Initialize Dlib face entity."""
+        super().__init__()
+
+        self._attr_camera_entity = camera_entity
+
+        if name:
+            self._attr_name = name
+        else:
+            self._attr_name = f"Dlib Face {split_entity_id(camera_entity)[1]}"
+
+    def process_image(self, image: bytes) -> None:
+        """Process image."""
+
+        fak_file = io.BytesIO(image)
+        fak_file.name = "snapshot.jpg"
+        fak_file.seek(0)
+
+        image = face_recognition.load_image_file(fak_file)
+        face_locations = face_recognition.face_locations(image)
+
+        face_locations = [{ATTR_LOCATION: location} for location in face_locations]
+
+        self.process_faces(face_locations, len(face_locations))

homeassistant/components/dlib_face_detect/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "dlib_face_detect",
+  "name": "Dlib Face Detect",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/dlib_face_detect",
+  "iot_class": "local_push",
+  "loggers": ["face_recognition"],
+  "quality_scale": "legacy",
+  "requirements": ["face-recognition==1.2.3"]
+}

homeassistant/components/dlib_face_identify/__init__.py

@@ -0,0 +1,4 @@
+"""The dlib_face_identify component."""
+
+CONF_FACES = "faces"
+DOMAIN = "dlib_face_identify"

homeassistant/components/dlib_face_identify/image_processing.py

@@ -0,0 +1,127 @@
+"""Component that will help set the Dlib face detect processing."""
+
+from __future__ import annotations
+
+import io
+import logging
+
+import face_recognition
+import voluptuous as vol
+
+from homeassistant.components.image_processing import (
+    CONF_CONFIDENCE,
+    PLATFORM_SCHEMA as IMAGE_PROCESSING_PLATFORM_SCHEMA,
+    FaceInformation,
+    ImageProcessingFaceEntity,
+)
+from homeassistant.const import ATTR_NAME, CONF_ENTITY_ID, CONF_NAME, CONF_SOURCE
+from homeassistant.core import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
+    HomeAssistant,
+    split_entity_id,
+)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from . import CONF_FACES, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+PLATFORM_SCHEMA = IMAGE_PROCESSING_PLATFORM_SCHEMA.extend(
+    {
+        vol.Required(CONF_FACES): {cv.string: cv.isfile},
+        vol.Optional(CONF_CONFIDENCE, default=0.6): vol.Coerce(float),
+    }
+)
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the Dlib Face detection platform."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Dlib Face Identify",
+        },
+    )
+
+    confidence: float = config[CONF_CONFIDENCE]
+    faces: dict[str, str] = config[CONF_FACES]
+    source: list[dict[str, str]] = config[CONF_SOURCE]
+    add_entities(
+        DlibFaceIdentifyEntity(
+            camera[CONF_ENTITY_ID],
+            faces,
+            camera.get(CONF_NAME),
+            confidence,
+        )
+        for camera in source
+    )
+
+
+class DlibFaceIdentifyEntity(ImageProcessingFaceEntity):
+    """Dlib Face API entity for identify."""
+
+    def __init__(
+        self,
+        camera_entity: str,
+        faces: dict[str, str],
+        name: str | None,
+        tolerance: float,
+    ) -> None:
+        """Initialize Dlib face identify entry."""
+
+        super().__init__()
+
+        self._attr_camera_entity = camera_entity
+
+        if name:
+            self._attr_name = name
+        else:
+            self._attr_name = f"Dlib Face {split_entity_id(camera_entity)[1]}"
+
+        self._faces = {}
+        for face_name, face_file in faces.items():
+            try:
+                image = face_recognition.load_image_file(face_file)
+                self._faces[face_name] = face_recognition.face_encodings(image)[0]
+            except IndexError as err:
+                _LOGGER.error("Failed to parse %s. Error: %s", face_file, err)
+
+        self._tolerance = tolerance
+
+    def process_image(self, image: bytes) -> None:
+        """Process image."""
+
+        fak_file = io.BytesIO(image)
+        fak_file.name = "snapshot.jpg"
+        fak_file.seek(0)
+
+        image = face_recognition.load_image_file(fak_file)
+        unknowns = face_recognition.face_encodings(image)
+
+        found: list[FaceInformation] = []
+        for unknown_face in unknowns:
+            for name, face in self._faces.items():
+                result = face_recognition.compare_faces(
+                    [face], unknown_face, tolerance=self._tolerance
+                )
+                if result[0]:
+                    found.append({ATTR_NAME: name})
+
+        self.process_faces(found, len(unknowns))

homeassistant/components/dlib_face_identify/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "dlib_face_identify",
+  "name": "Dlib Face Identify",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/dlib_face_identify",
+  "iot_class": "local_push",
+  "loggers": ["face_recognition"],
+  "quality_scale": "legacy",
+  "requirements": ["face-recognition==1.2.3"]
+}

homeassistant/components/ecovacs/icons.json

@@ -81,9 +81,6 @@
       "active_map": {
         "default": "mdi:floor-plan"
       },
-      "auto_empty": {
-        "default": "mdi:delete-empty"
-      },
       "water_amount": {
         "default": "mdi:water"
       },
@@ -163,9 +160,6 @@
       "advanced_mode": {
         "default": "mdi:tune"
       },
-      "border_spin": {
-        "default": "mdi:rotate-right"
-      },
       "border_switch": {
         "default": "mdi:land-fields"
       },

homeassistant/components/ecovacs/select.py

@@ -5,9 +5,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import CapabilityMap, CapabilitySet, CapabilitySetTypes
-from deebot_client.command import CommandWithMessageHandling
 from deebot_client.device import Device
-from deebot_client.events import WorkModeEvent, auto_empty
+from deebot_client.events import WorkModeEvent
 from deebot_client.events.base import Event
 from deebot_client.events.map import CachedMapInfoEvent, MajorMapEvent
 from deebot_client.events.water_info import WaterAmountEvent
@@ -35,9 +34,6 @@ class EcovacsSelectEntityDescription[EventT: Event](
 
     current_option_fn: Callable[[EventT], str | None]
     options_fn: Callable[[CapabilitySetTypes], list[str]]
-    set_option_fn: Callable[[CapabilitySetTypes, str], CommandWithMessageHandling] = (
-        lambda cap, option: cap.set(option)
-    )
 
 
 ENTITY_DESCRIPTIONS: tuple[EcovacsSelectEntityDescription, ...] = (
@@ -62,14 +58,6 @@ ENTITY_DESCRIPTIONS: tuple[EcovacsSelectEntityDescription, ...] = (
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.CONFIG,
     ),
-    EcovacsSelectEntityDescription[auto_empty.AutoEmptyEvent](
-        capability_fn=lambda caps: caps.station.auto_empty if caps.station else None,
-        current_option_fn=lambda e: get_name_key(e.frequency) if e.frequency else None,
-        options_fn=lambda cap: [get_name_key(freq) for freq in cap.types],
-        set_option_fn=lambda cap, option: cap.set(None, option),
-        key="auto_empty",
-        translation_key="auto_empty",
-    ),
 )
 
 
@@ -118,17 +106,14 @@ class EcovacsSelectEntity[EventT: Event](
         await super().async_added_to_hass()
 
         async def on_event(event: EventT) -> None:
-            if (option := self.entity_description.current_option_fn(event)) is not None:
-                self._attr_current_option = option
-                self.async_write_ha_state()
+            self._attr_current_option = self.entity_description.current_option_fn(event)
+            self.async_write_ha_state()
 
         self._subscribe(self._capability.event, on_event)
 
     async def async_select_option(self, option: str) -> None:
         """Change the selected option."""
-        await self._device.execute_command(
-            self.entity_description.set_option_fn(self._capability, option)
-        )
+        await self._device.execute_command(self._capability.set(option))
 
 
 class EcovacsActiveMapSelectEntity(

homeassistant/components/ecovacs/strings.json

@@ -129,16 +129,6 @@
       "active_map": {
         "name": "Active map"
       },
-      "auto_empty": {
-        "name": "Auto-empty frequency",
-        "state": {
-          "auto": "Auto",
-          "min_10": "10 minutes",
-          "min_15": "15 minutes",
-          "min_25": "25 minutes",
-          "smart": "Smart"
-        }
-      },
       "water_amount": {
         "name": "[%key:component::ecovacs::entity::number::water_amount::name%]",
         "state": {
@@ -241,9 +231,6 @@
       "advanced_mode": {
         "name": "Advanced mode"
       },
-      "border_spin": {
-        "name": "Border spin"
-      },
       "border_switch": {
         "name": "Border switch"
       },

homeassistant/components/ecovacs/switch.py

@@ -99,13 +99,6 @@ ENTITY_DESCRIPTIONS: tuple[EcovacsSwitchEntityDescription, ...] = (
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.CONFIG,
     ),
-    EcovacsSwitchEntityDescription(
-        capability_fn=lambda c: c.settings.border_spin,
-        key="border_spin",
-        translation_key="border_spin",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.CONFIG,
-    ),
 )
 
 

homeassistant/components/ecowitt/sensor.py

@@ -151,12 +151,14 @@ ECOWITT_SENSORS_MAPPING: Final = {
         key="RAIN_COUNT_MM",
         native_unit_of_measurement=UnitOfPrecipitationDepth.MILLIMETERS,
         device_class=SensorDeviceClass.PRECIPITATION,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=1,
     ),
     EcoWittSensorTypes.RAIN_COUNT_INCHES: SensorEntityDescription(
         key="RAIN_COUNT_INCHES",
         native_unit_of_measurement=UnitOfPrecipitationDepth.INCHES,
         device_class=SensorDeviceClass.PRECIPITATION,
+        state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
     ),
     EcoWittSensorTypes.RAIN_RATE_MM: SensorEntityDescription(

homeassistant/components/eddystone_temperature/__init__.py

@@ -0,0 +1,6 @@
+"""The eddystone_temperature component."""
+
+DOMAIN = "eddystone_temperature"
+CONF_BEACONS = "beacons"
+CONF_INSTANCE = "instance"
+CONF_NAMESPACE = "namespace"

homeassistant/components/eddystone_temperature/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "eddystone_temperature",
+  "name": "Eddystone",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/eddystone_temperature",
+  "iot_class": "local_polling",
+  "loggers": ["beacontools"],
+  "quality_scale": "legacy",
+  "requirements": ["beacontools[scan]==2.1.0"]
+}

homeassistant/components/eddystone_temperature/sensor.py

@@ -0,0 +1,211 @@
+"""Read temperature information from Eddystone beacons.
+
+Your beacons must be configured to transmit UID (for identification) and TLM
+(for temperature) frames.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from beacontools import BeaconScanner, EddystoneFilter, EddystoneTLMFrame
+import voluptuous as vol
+
+from homeassistant.components.sensor import (
+    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
+    SensorDeviceClass,
+    SensorEntity,
+)
+from homeassistant.const import (
+    CONF_NAME,
+    EVENT_HOMEASSISTANT_START,
+    EVENT_HOMEASSISTANT_STOP,
+    STATE_UNKNOWN,
+    UnitOfTemperature,
+)
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, Event, HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from . import CONF_BEACONS, CONF_INSTANCE, CONF_NAMESPACE, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_BT_DEVICE_ID = "bt_device_id"
+
+
+BEACON_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_NAMESPACE): cv.string,
+        vol.Required(CONF_INSTANCE): cv.string,
+        vol.Optional(CONF_NAME): cv.string,
+    }
+)
+
+PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
+    {
+        vol.Optional(CONF_BT_DEVICE_ID, default=0): cv.positive_int,
+        vol.Required(CONF_BEACONS): vol.Schema({cv.string: BEACON_SCHEMA}),
+    }
+)
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Validate configuration, create devices and start monitoring thread."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Eddystone",
+        },
+    )
+
+    bt_device_id: int = config[CONF_BT_DEVICE_ID]
+
+    beacons: dict[str, dict[str, str]] = config[CONF_BEACONS]
+    devices: list[EddystoneTemp] = []
+
+    for dev_name, properties in beacons.items():
+        namespace = get_from_conf(properties, CONF_NAMESPACE, 20)
+        instance = get_from_conf(properties, CONF_INSTANCE, 12)
+        name = properties.get(CONF_NAME, dev_name)
+
+        if instance is None or namespace is None:
+            _LOGGER.error("Skipping %s", dev_name)
+            continue
+
+        devices.append(EddystoneTemp(name, namespace, instance))
+
+    if devices:
+        mon = Monitor(hass, devices, bt_device_id)
+
+        def monitor_stop(event: Event) -> None:
+            """Stop the monitor thread."""
+            _LOGGER.debug("Stopping scanner for Eddystone beacons")
+            mon.stop()
+
+        def monitor_start(event: Event) -> None:
+            """Start the monitor thread."""
+            _LOGGER.debug("Starting scanner for Eddystone beacons")
+            mon.start()
+
+        add_entities(devices)
+        mon.start()
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, monitor_stop)
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_START, monitor_start)
+    else:
+        _LOGGER.warning("No devices were added")
+
+
+def get_from_conf(config: dict[str, str], config_key: str, length: int) -> str | None:
+    """Retrieve value from config and validate length."""
+    string = config[config_key]
+    if len(string) != length:
+        _LOGGER.error(
+            (
+                "Error in configuration parameter %s: Must be exactly %d "
+                "bytes. Device will not be added"
+            ),
+            config_key,
+            length / 2,
+        )
+        return None
+    return string
+
+
+class EddystoneTemp(SensorEntity):
+    """Representation of a temperature sensor."""
+
+    _attr_device_class = SensorDeviceClass.TEMPERATURE
+    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
+    _attr_should_poll = False
+
+    def __init__(self, name: str, namespace: str, instance: str) -> None:
+        """Initialize a sensor."""
+        self._attr_name = name
+        self.namespace = namespace
+        self.instance = instance
+        self.bt_addr = None
+        self.temperature = STATE_UNKNOWN
+
+    @property
+    def native_value(self):
+        """Return the state of the device."""
+        return self.temperature
+
+
+class Monitor:
+    """Continuously scan for BLE advertisements."""
+
+    def __init__(
+        self, hass: HomeAssistant, devices: list[EddystoneTemp], bt_device_id: int
+    ) -> None:
+        """Construct interface object."""
+        self.hass = hass
+
+        # List of beacons to monitor
+        self.devices = devices
+        # Number of the bt device (hciX)
+        self.bt_device_id = bt_device_id
+
+        def callback(bt_addr, _, packet, additional_info):
+            """Handle new packets."""
+            self.process_packet(
+                additional_info["namespace"],
+                additional_info["instance"],
+                packet.temperature,
+            )
+
+        device_filters = [EddystoneFilter(d.namespace, d.instance) for d in devices]
+
+        self.scanner = BeaconScanner(
+            callback, bt_device_id, device_filters, EddystoneTLMFrame
+        )
+        self.scanning = False
+
+    def start(self) -> None:
+        """Continuously scan for BLE advertisements."""
+        if not self.scanning:
+            self.scanner.start()
+            self.scanning = True
+        else:
+            _LOGGER.debug("start() called, but scanner is already running")
+
+    def process_packet(self, namespace, instance, temperature) -> None:
+        """Assign temperature to device."""
+        _LOGGER.debug(
+            "Received temperature for <%s,%s>: %d", namespace, instance, temperature
+        )
+
+        for dev in self.devices:
+            if (
+                dev.namespace == namespace
+                and dev.instance == instance
+                and dev.temperature != temperature
+            ):
+                dev.temperature = temperature
+                dev.schedule_update_ha_state()
+
+    def stop(self) -> None:
+        """Signal runner to stop and join thread."""
+        if self.scanning:
+            _LOGGER.debug("Stopping")
+            self.scanner.stop()
+            _LOGGER.debug("Stopped")
+            self.scanning = False
+        else:
+            _LOGGER.debug("stop() called but scanner was not running")

homeassistant/components/elkm1/config_flow.py

@@ -296,7 +296,7 @@ class Elkm1ConfigFlow(ConfigFlow, domain=DOMAIN):
                 return await self.async_step_discovered_connection()
             return await self.async_step_manual_connection()
 
-        current_unique_ids = self._async_current_ids(include_ignore=False)
+        current_unique_ids = self._async_current_ids()
         current_hosts = {
             hostname_from_url(entry.data[CONF_HOST])
             for entry in self._async_current_entries(include_ignore=False)

homeassistant/components/elkm1/manifest.json

@@ -15,5 +15,5 @@
   "documentation": "https://www.home-assistant.io/integrations/elkm1",
   "iot_class": "local_push",
   "loggers": ["elkm1_lib"],
-  "requirements": ["elkm1-lib==2.2.12"]
+  "requirements": ["elkm1-lib==2.2.11"]
 }

homeassistant/components/elkm1/sensor.py

@@ -189,7 +189,9 @@ class ElkPanel(ElkSensor):
 
     def _element_changed(self, element: Element, changeset: dict[str, Any]) -> None:
         if self._elk.is_connected():
-            self._attr_native_value = "Paused" if self._elk.is_paused() else "Connected"
+            self._attr_native_value = (
+                "Paused" if self._element.remote_programming_status else "Connected"
+            )
         else:
             self._attr_native_value = "Disconnected"
 

homeassistant/components/esphome/__init__.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import logging
-
-from aioesphomeapi import APIClient, APIConnectionError
+from aioesphomeapi import APIClient
 
 from homeassistant.components import zeroconf
 from homeassistant.components.bluetooth import async_remove_scanner
@@ -22,12 +20,9 @@ from homeassistant.helpers.typing import ConfigType
 from . import assist_satellite, dashboard, ffmpeg_proxy
 from .const import CONF_BLUETOOTH_MAC_ADDRESS, CONF_NOISE_PSK, DOMAIN
 from .domain_data import DomainData
-from .encryption_key_storage import async_get_encryption_key_storage
 from .entry_data import ESPHomeConfigEntry, RuntimeEntryData
 from .manager import DEVICE_CONFLICT_ISSUE_FORMAT, ESPHomeManager, cleanup_instance
 
-_LOGGER = logging.getLogger(__name__)
-
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 CLIENT_INFO = f"Home Assistant {ha_version}"
@@ -96,57 +91,3 @@ async def async_remove_entry(hass: HomeAssistant, entry: ESPHomeConfigEntry) ->
         hass, DOMAIN, DEVICE_CONFLICT_ISSUE_FORMAT.format(entry.entry_id)
     )
     await DomainData.get(hass).get_or_create_store(hass, entry).async_remove()
-
-    await _async_clear_dynamic_encryption_key(hass, entry)
-
-
-async def _async_clear_dynamic_encryption_key(
-    hass: HomeAssistant, entry: ESPHomeConfigEntry
-) -> None:
-    """Clear the dynamic encryption key on the device and from storage."""
-    if entry.unique_id is None or entry.data.get(CONF_NOISE_PSK) is None:
-        return
-
-    # Only clear the key if it's stored in our storage, meaning it was
-    # dynamically generated by us and not user-provided
-    storage = await async_get_encryption_key_storage(hass)
-    if await storage.async_get_key(entry.unique_id) is None:
-        return
-
-    host: str = entry.data[CONF_HOST]
-    port: int = entry.data[CONF_PORT]
-    password: str | None = entry.data[CONF_PASSWORD]
-    noise_psk: str | None = entry.data.get(CONF_NOISE_PSK)
-
-    zeroconf_instance = await zeroconf.async_get_instance(hass)
-
-    cli = APIClient(
-        host,
-        port,
-        password,
-        client_info=CLIENT_INFO,
-        zeroconf_instance=zeroconf_instance,
-        noise_psk=noise_psk,
-        timezone=hass.config.time_zone,
-    )
-
-    try:
-        await cli.connect()
-        # Clear the encryption key on the device by passing an empty key
-        if not await cli.noise_encryption_set_key(b""):
-            _LOGGER.debug(
-                "Could not clear dynamic encryption key for ESPHome device %s: Device rejected key removal",
-                entry.unique_id,
-            )
-            return
-    except APIConnectionError as exc:
-        _LOGGER.debug(
-            "Could not connect to ESPHome device %s to clear dynamic encryption key: %s",
-            entry.unique_id,
-            exc,
-        )
-        return
-    finally:
-        await cli.disconnect()
-
-    await storage.async_remove_key(entry.unique_id)

homeassistant/components/esphome/config_flow.py

@@ -31,7 +31,7 @@ from homeassistant.config_entries import (
     ConfigFlow,
     ConfigFlowResult,
     FlowType,
-    OptionsFlowWithReload,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT
 from homeassistant.core import callback
@@ -918,7 +918,7 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
         return OptionsFlowHandler()
 
 
-class OptionsFlowHandler(OptionsFlowWithReload):
+class OptionsFlowHandler(OptionsFlow):
     """Handle a option flow for esphome."""
 
     async def async_step_init(

homeassistant/components/esphome/entry_data.py

@@ -442,6 +442,14 @@ class RuntimeEntryData:
             # save delay has passed.
             await self.store.async_save(self._pending_storage())
 
+    async def async_update_listener(
+        self, hass: HomeAssistant, entry: ESPHomeConfigEntry
+    ) -> None:
+        """Handle options update."""
+        if self.original_options == entry.options:
+            return
+        hass.async_create_task(hass.config_entries.async_reload(entry.entry_id))
+
     @callback
     def async_on_disconnect(self) -> None:
         """Call when the entry has been disconnected.

homeassistant/components/esphome/manager.py

@@ -983,6 +983,10 @@ class ESPHomeManager:
 
         await reconnect_logic.start()
 
+        entry.async_on_unload(
+            entry.add_update_listener(entry_data.async_update_listener)
+        )
+
 
 @callback
 def _async_setup_device_registry(

homeassistant/components/esphome/manifest.json

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

homeassistant/components/eufylife_ble/config_flow.py

@@ -77,7 +77,7 @@ class EufyLifeConfigFlow(ConfigFlow, domain=DOMAIN):
                 data={CONF_MODEL: model},
             )
 
-        current_addresses = self._async_current_ids(include_ignore=False)
+        current_addresses = self._async_current_ids()
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address
             if (

homeassistant/components/file/__init__.py

@@ -11,7 +11,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
-from .services import async_setup_services
+from .services import async_register_services
 
 PLATFORMS = [Platform.NOTIFY, Platform.SENSOR]
 
@@ -20,7 +20,7 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the file component."""
-    async_setup_services(hass)
+    async_register_services(hass)
     return True
 
 

homeassistant/components/file/services.py

@@ -6,29 +6,29 @@ import json
 import voluptuous as vol
 import yaml
 
-from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 
 from .const import ATTR_FILE_ENCODING, ATTR_FILE_NAME, DOMAIN, SERVICE_READ_FILE
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def async_register_services(hass: HomeAssistant) -> None:
     """Register services for File integration."""
 
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_READ_FILE,
-        read_file,
-        schema=vol.Schema(
-            {
-                vol.Required(ATTR_FILE_NAME): cv.string,
-                vol.Required(ATTR_FILE_ENCODING): cv.string,
-            }
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
+    if not hass.services.has_service(DOMAIN, SERVICE_READ_FILE):
+        hass.services.async_register(
+            DOMAIN,
+            SERVICE_READ_FILE,
+            read_file,
+            schema=vol.Schema(
+                {
+                    vol.Required(ATTR_FILE_NAME): cv.string,
+                    vol.Required(ATTR_FILE_ENCODING): cv.string,
+                }
+            ),
+            supports_response=SupportsResponse.ONLY,
+        )
 
 
 ENCODING_LOADERS: dict[str, tuple[Callable, type[Exception]]] = {

homeassistant/components/firefly_iii/config_flow.py

@@ -129,51 +129,6 @@ class FireflyConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of the integration."""
-        errors: dict[str, str] = {}
-        reconf_entry = self._get_reconfigure_entry()
-
-        if user_input:
-            try:
-                await _validate_input(
-                    self.hass,
-                    data={
-                        **reconf_entry.data,
-                        **user_input,
-                    },
-                )
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except FireflyClientTimeout:
-                errors["base"] = "timeout_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                self._async_abort_entries_match({CONF_URL: user_input[CONF_URL]})
-                return self.async_update_reload_and_abort(
-                    reconf_entry,
-                    data_updates={
-                        CONF_URL: user_input[CONF_URL],
-                        CONF_API_KEY: user_input[CONF_API_KEY],
-                        CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                data_schema=STEP_USER_DATA_SCHEMA,
-                suggested_values=user_input or reconf_entry.data.copy(),
-            ),
-            errors=errors,
-        )
-
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/firefly_iii/strings.json

@@ -2,8 +2,7 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -21,20 +20,6 @@
         },
         "description": "The access token for your Firefly III instance is invalid and needs to be updated. Go to **Options > Profile** and select the **OAuth** tab. Create a new personal access token and copy it (it will only display once)."
       },
-      "reconfigure": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "url": "[%key:common::config_flow::data::url%]",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-        },
-        "data_description": {
-          "api_key": "[%key:component::firefly_iii::config::step::user::data_description::api_key%]",
-          "url": "[%key:common::config_flow::data::url%]",
-          "verify_ssl": "[%key:component::firefly_iii::config::step::user::data_description::verify_ssl%]"
-        },
-        "description": "Use the following form to reconfigure your Firefly III instance.",
-        "title": "Reconfigure Firefly III Integration"
-      },
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",

homeassistant/components/flick_electric/__init__.py

@@ -0,0 +1,152 @@
+"""The Flick Electric integration."""
+
+from datetime import datetime as dt
+import logging
+from typing import Any
+
+import jwt
+from pyflick import FlickAPI
+from pyflick.authentication import SimpleFlickAuth
+from pyflick.const import DEFAULT_CLIENT_ID, DEFAULT_CLIENT_SECRET
+
+from homeassistant.const import (
+    CONF_ACCESS_TOKEN,
+    CONF_CLIENT_ID,
+    CONF_CLIENT_SECRET,
+    CONF_PASSWORD,
+    CONF_USERNAME,
+    Platform,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import aiohttp_client
+
+from .const import CONF_ACCOUNT_ID, CONF_SUPPLY_NODE_REF, CONF_TOKEN_EXPIRY
+from .coordinator import FlickConfigEntry, FlickElectricDataCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ID_TOKEN = "id_token"
+
+PLATFORMS = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: FlickConfigEntry) -> bool:
+    """Set up Flick Electric from a config entry."""
+    auth = HassFlickAuth(hass, entry)
+
+    coordinator = FlickElectricDataCoordinator(hass, entry, FlickAPI(auth))
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: FlickConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: FlickConfigEntry
+) -> bool:
+    """Migrate old entry."""
+    _LOGGER.debug(
+        "Migrating configuration from version %s.%s",
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    if config_entry.version > 2:
+        return False
+
+    if config_entry.version == 1:
+        api = FlickAPI(HassFlickAuth(hass, config_entry))
+
+        accounts = await api.getCustomerAccounts()
+        active_accounts = [
+            account for account in accounts if account["status"] == "active"
+        ]
+
+        # A single active account can be auto-migrated
+        if (len(active_accounts)) == 1:
+            account = active_accounts[0]
+
+            new_data = {**config_entry.data}
+            new_data[CONF_ACCOUNT_ID] = account["id"]
+            new_data[CONF_SUPPLY_NODE_REF] = account["main_consumer"]["supply_node_ref"]
+            hass.config_entries.async_update_entry(
+                config_entry,
+                title=account["address"],
+                unique_id=account["id"],
+                data=new_data,
+                version=2,
+            )
+            return True
+
+        config_entry.async_start_reauth(hass, data={**config_entry.data})
+        return False
+
+    return True
+
+
+class HassFlickAuth(SimpleFlickAuth):
+    """Implementation of AbstractFlickAuth based on a Home Assistant entity config."""
+
+    def __init__(self, hass: HomeAssistant, entry: FlickConfigEntry) -> None:
+        """Flick authentication based on a Home Assistant entity config."""
+        super().__init__(
+            username=entry.data[CONF_USERNAME],
+            password=entry.data[CONF_PASSWORD],
+            client_id=entry.data.get(CONF_CLIENT_ID, DEFAULT_CLIENT_ID),
+            client_secret=entry.data.get(CONF_CLIENT_SECRET, DEFAULT_CLIENT_SECRET),
+            websession=aiohttp_client.async_get_clientsession(hass),
+        )
+        self._entry = entry
+        self._hass = hass
+
+    async def _get_entry_token(self) -> dict[str, Any]:
+        # No token saved, generate one
+        if (
+            CONF_TOKEN_EXPIRY not in self._entry.data
+            or CONF_ACCESS_TOKEN not in self._entry.data
+        ):
+            await self._update_token()
+
+        # Token is expired, generate a new one
+        if self._entry.data[CONF_TOKEN_EXPIRY] <= dt.now().timestamp():
+            await self._update_token()
+
+        return self._entry.data[CONF_ACCESS_TOKEN]
+
+    async def _update_token(self):
+        _LOGGER.debug("Fetching new access token")
+
+        token = await super().get_new_token(
+            self._username, self._password, self._client_id, self._client_secret
+        )
+
+        _LOGGER.debug("New token: %s", token)
+
+        # Flick will send the same token, but expiry is relative - so grab it from the token
+        token_decoded = jwt.decode(
+            token[CONF_ID_TOKEN], options={"verify_signature": False}
+        )
+
+        self._hass.config_entries.async_update_entry(
+            self._entry,
+            data={
+                **self._entry.data,
+                CONF_ACCESS_TOKEN: token,
+                CONF_TOKEN_EXPIRY: token_decoded["exp"],
+            },
+        )
+
+    async def async_get_access_token(self):
+        """Get Access Token from HASS Storage."""
+        token = await self._get_entry_token()
+
+        return token[CONF_ID_TOKEN]

homeassistant/components/flick_electric/config_flow.py

@@ -0,0 +1,210 @@
+"""Config Flow for Flick Electric integration."""
+
+import asyncio
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+from aiohttp import ClientResponseError
+from pyflick import FlickAPI
+from pyflick.authentication import AbstractFlickAuth, SimpleFlickAuth
+from pyflick.const import DEFAULT_CLIENT_ID, DEFAULT_CLIENT_SECRET
+from pyflick.types import APIException, AuthException, CustomerAccount
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.const import (
+    CONF_CLIENT_ID,
+    CONF_CLIENT_SECRET,
+    CONF_PASSWORD,
+    CONF_USERNAME,
+)
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import aiohttp_client
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
+
+from .const import CONF_ACCOUNT_ID, CONF_SUPPLY_NODE_REF, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+LOGIN_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_USERNAME): str,
+        vol.Required(CONF_PASSWORD): str,
+        vol.Optional(CONF_CLIENT_ID): str,
+        vol.Optional(CONF_CLIENT_SECRET): str,
+    }
+)
+
+
+class FlickConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Flick config flow."""
+
+    VERSION = 2
+    auth: AbstractFlickAuth
+    accounts: list[CustomerAccount]
+    data: dict[str, Any]
+
+    async def _validate_auth(self, user_input: Mapping[str, Any]) -> bool:
+        self.auth = SimpleFlickAuth(
+            username=user_input[CONF_USERNAME],
+            password=user_input[CONF_PASSWORD],
+            websession=aiohttp_client.async_get_clientsession(self.hass),
+            client_id=user_input.get(CONF_CLIENT_ID, DEFAULT_CLIENT_ID),
+            client_secret=user_input.get(CONF_CLIENT_SECRET, DEFAULT_CLIENT_SECRET),
+        )
+
+        try:
+            async with asyncio.timeout(60):
+                token = await self.auth.async_get_access_token()
+        except (TimeoutError, ClientResponseError) as err:
+            raise CannotConnect from err
+        except AuthException as err:
+            raise InvalidAuth from err
+
+        return token is not None
+
+    async def async_step_select_account(
+        self, user_input: Mapping[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Ask user to select account."""
+
+        errors = {}
+        if user_input is not None and CONF_ACCOUNT_ID in user_input:
+            self.data[CONF_ACCOUNT_ID] = user_input[CONF_ACCOUNT_ID]
+            self.data[CONF_SUPPLY_NODE_REF] = self._get_supply_node_ref(
+                user_input[CONF_ACCOUNT_ID]
+            )
+            try:
+                # Ensure supply node is active
+                await FlickAPI(self.auth).getPricing(self.data[CONF_SUPPLY_NODE_REF])
+            except (APIException, ClientResponseError):
+                errors["base"] = "cannot_connect"
+            except AuthException:
+                # We should never get here as we have a valid token
+                return self.async_abort(reason="no_permissions")
+            else:
+                # Supply node is active
+                return await self._async_create_entry()
+
+        try:
+            self.accounts = await FlickAPI(self.auth).getCustomerAccounts()
+        except (APIException, ClientResponseError):
+            errors["base"] = "cannot_connect"
+
+        active_accounts = [a for a in self.accounts if a["status"] == "active"]
+
+        if len(active_accounts) == 0:
+            return self.async_abort(reason="no_accounts")
+
+        if len(active_accounts) == 1:
+            self.data[CONF_ACCOUNT_ID] = active_accounts[0]["id"]
+            self.data[CONF_SUPPLY_NODE_REF] = self._get_supply_node_ref(
+                active_accounts[0]["id"]
+            )
+
+            return await self._async_create_entry()
+
+        return self.async_show_form(
+            step_id="select_account",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ACCOUNT_ID): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                SelectOptionDict(
+                                    value=account["id"], label=account["address"]
+                                )
+                                for account in active_accounts
+                            ],
+                            mode=SelectSelectorMode.LIST,
+                        )
+                    )
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_user(
+        self, user_input: Mapping[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle gathering login info."""
+        errors = {}
+        if user_input is not None:
+            try:
+                await self._validate_auth(user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                self.data = dict(user_input)
+                return await self.async_step_select_account(user_input)
+
+        return self.async_show_form(
+            step_id="user", data_schema=LOGIN_SCHEMA, errors=errors
+        )
+
+    async def async_step_reauth(
+        self, user_input: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle re-authentication."""
+
+        self.data = {**user_input}
+
+        return await self.async_step_user(user_input)
+
+    async def _async_create_entry(self) -> ConfigFlowResult:
+        """Create an entry for the flow."""
+
+        await self.async_set_unique_id(self.data[CONF_ACCOUNT_ID])
+
+        account = self._get_account(self.data[CONF_ACCOUNT_ID])
+
+        if self.source == SOURCE_REAUTH:
+            # Migration completed
+            if self._get_reauth_entry().version == 1:
+                self.hass.config_entries.async_update_entry(
+                    self._get_reauth_entry(),
+                    unique_id=self.unique_id,
+                    data=self.data,
+                    version=self.VERSION,
+                )
+
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(),
+                unique_id=self.unique_id,
+                title=account["address"],
+                data=self.data,
+            )
+
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(
+            title=account["address"],
+            data=self.data,
+        )
+
+    def _get_account(self, account_id: str) -> CustomerAccount:
+        """Get the account for the account ID."""
+        return next(a for a in self.accounts if a["id"] == account_id)
+
+    def _get_supply_node_ref(self, account_id: str) -> str:
+        """Get the supply node ref for the account."""
+        return self._get_account(account_id)["main_consumer"][CONF_SUPPLY_NODE_REF]
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(HomeAssistantError):
+    """Error to indicate there is invalid auth."""

homeassistant/components/flick_electric/const.py

@@ -0,0 +1,12 @@
+"""Constants for the Flick Electric integration."""
+
+DOMAIN = "flick_electric"
+
+CONF_TOKEN_EXPIRY = "expires"
+CONF_ACCOUNT_ID = "account_id"
+CONF_SUPPLY_NODE_REF = "supply_node_ref"
+
+ATTR_START_AT = "start_at"
+ATTR_END_AT = "end_at"
+
+ATTR_COMPONENTS = ["retailer", "ea", "metering", "generation", "admin", "network"]