Bump bluetooth-data-tools to 1.28.4

changelog: https://github.com/Bluetooth-Devices/bluetooth-data-tools/compare/v1.28.3...v1.28.4

.github/workflows/builder.yml

@@ -162,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:
@@ -214,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:
@@ -277,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'
@@ -287,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 }}
@@ -339,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
@@ -372,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
@@ -364,13 +364,13 @@ jobs:
       - name: Run check-json
         run: |
           . venv/bin/activate
-          pre-commit run --hook-stage manual check-json --all-files --show-diff-on-failure
+          pre-commit run --hook-stage manual check-json --all-files
 
       - name: Run prettier (fully)
         if: needs.info.outputs.test_full_suite == 'true'
         run: |
           . venv/bin/activate
-          pre-commit run --hook-stage manual prettier --all-files --show-diff-on-failure
+          pre-commit run --hook-stage manual prettier --all-files
 
       - name: Run prettier (partially)
         if: needs.info.outputs.test_full_suite == 'false'
@@ -378,7 +378,7 @@ jobs:
         run: |
           . venv/bin/activate
           shopt -s globstar
-          pre-commit run --hook-stage manual prettier --show-diff-on-failure --files {homeassistant,tests}/components/${{ needs.info.outputs.integrations_glob }}/{*,**/*}
+          pre-commit run --hook-stage manual prettier --files {homeassistant,tests}/components/${{ needs.info.outputs.integrations_glob }}/{*,**/*}
 
       - name: Register check executables problem matcher
         run: |
@@ -386,7 +386,7 @@ jobs:
       - name: Run executables check
         run: |
           . venv/bin/activate
-          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files --show-diff-on-failure
+          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files
 
       - name: Register codespell problem matcher
         run: |
@@ -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/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.*
@@ -362,6 +361,7 @@ homeassistant.components.myuplink.*
 homeassistant.components.nam.*
 homeassistant.components.nanoleaf.*
 homeassistant.components.nasweb.*
+homeassistant.components.neato.*
 homeassistant.components.nest.*
 homeassistant.components.netatmo.*
 homeassistant.components.network.*
@@ -395,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

Dockerfile

@@ -31,7 +31,7 @@ RUN \
     && go2rtc --version
 
 # Install uv
-RUN pip3 install uv==0.9.6
+RUN pip3 install uv==0.9.5
 
 WORKDIR /usr/src
 

Dockerfile.dev

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

build.yaml

@@ -1,7 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
   aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
   amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/components/airthings_ble/manifest.json

@@ -28,5 +28,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/airthings_ble",
   "iot_class": "local_polling",
-  "requirements": ["airthings-ble==1.2.0"]
+  "requirements": ["airthings-ble==1.1.1"]
 }

homeassistant/components/alexa_devices/const.py

@@ -26,6 +26,3 @@ COUNTRY_DOMAINS = {
     "us": DEFAULT_DOMAIN,
     "za": "co.za",
 }
-
-CATEGORY_SENSORS = "sensors"
-CATEGORY_NOTIFICATIONS = "notifications"

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==6.5.5"]
+  "requirements": ["aioamazondevices==6.4.6"]
 }

homeassistant/components/alexa_devices/sensor.py

@@ -4,15 +4,9 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from datetime import datetime
 from typing import Final
 
 from aioamazondevices.api import AmazonDevice
-from aioamazondevices.const import (
-    NOTIFICATION_ALARM,
-    NOTIFICATION_REMINDER,
-    NOTIFICATION_TIMER,
-)
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -25,7 +19,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
-from .const import CATEGORY_NOTIFICATIONS, CATEGORY_SENSORS
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
 
@@ -43,20 +36,6 @@ class AmazonSensorEntityDescription(SensorEntityDescription):
         and (sensor := device.sensors.get(key)) is not None
         and sensor.error is False
     )
-    category: str = CATEGORY_SENSORS
-
-
-@dataclass(frozen=True, kw_only=True)
-class AmazonNotificationEntityDescription(SensorEntityDescription):
-    """Amazon Devices notification entity description."""
-
-    native_unit_of_measurement_fn: Callable[[AmazonDevice, str], str] | None = None
-    is_available_fn: Callable[[AmazonDevice, str], bool] = lambda device, key: (
-        device.online
-        and (notification := device.notifications.get(key)) is not None
-        and notification.next_occurrence is not None
-    )
-    category: str = CATEGORY_NOTIFICATIONS
 
 
 SENSORS: Final = (
@@ -77,23 +56,6 @@ SENSORS: Final = (
         state_class=SensorStateClass.MEASUREMENT,
     ),
 )
-NOTIFICATIONS: Final = (
-    AmazonNotificationEntityDescription(
-        key=NOTIFICATION_ALARM,
-        translation_key="alarm",
-        device_class=SensorDeviceClass.TIMESTAMP,
-    ),
-    AmazonNotificationEntityDescription(
-        key=NOTIFICATION_REMINDER,
-        translation_key="reminder",
-        device_class=SensorDeviceClass.TIMESTAMP,
-    ),
-    AmazonNotificationEntityDescription(
-        key=NOTIFICATION_TIMER,
-        translation_key="timer",
-        device_class=SensorDeviceClass.TIMESTAMP,
-    ),
-)
 
 
 async def async_setup_entry(
@@ -112,18 +74,12 @@ async def async_setup_entry(
         new_devices = current_devices - known_devices
         if new_devices:
             known_devices.update(new_devices)
-            sensors_list = [
+            async_add_entities(
                 AmazonSensorEntity(coordinator, serial_num, sensor_desc)
                 for sensor_desc in SENSORS
                 for serial_num in new_devices
                 if coordinator.data[serial_num].sensors.get(sensor_desc.key) is not None
-            ]
-            notifications_list = [
-                AmazonSensorEntity(coordinator, serial_num, notification_desc)
-                for notification_desc in NOTIFICATIONS
-                for serial_num in new_devices
-            ]
-            async_add_entities(sensors_list + notifications_list)
+            )
 
     _check_device()
     entry.async_on_unload(coordinator.async_add_listener(_check_device))
@@ -132,9 +88,7 @@ async def async_setup_entry(
 class AmazonSensorEntity(AmazonEntity, SensorEntity):
     """Sensor device."""
 
-    entity_description: (
-        AmazonSensorEntityDescription | AmazonNotificationEntityDescription
-    )
+    entity_description: AmazonSensorEntityDescription
 
     @property
     def native_unit_of_measurement(self) -> str | None:
@@ -147,13 +101,9 @@ class AmazonSensorEntity(AmazonEntity, SensorEntity):
         return super().native_unit_of_measurement
 
     @property
-    def native_value(self) -> StateType | datetime:
+    def native_value(self) -> StateType:
         """Return the state of the sensor."""
-        # Sensors
-        if self.entity_description.category == CATEGORY_SENSORS:
-            return self.device.sensors[self.entity_description.key].value
-        # Notifications
-        return self.device.notifications[self.entity_description.key].next_occurrence
+        return self.device.sensors[self.entity_description.key].value
 
     @property
     def available(self) -> bool:

homeassistant/components/alexa_devices/strings.json

@@ -66,17 +66,6 @@
         "name": "Speak"
       }
     },
-    "sensor": {
-      "alarm": {
-        "name": "Next alarm"
-      },
-      "reminder": {
-        "name": "Next reminder"
-      },
-      "timer": {
-        "name": "Next timer"
-      }
-    },
     "switch": {
       "do_not_disturb": {
         "name": "Do not disturb"

homeassistant/components/assist_satellite/manifest.json

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

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/blink/__init__.py

@@ -4,6 +4,7 @@ from copy import deepcopy
 import logging
 from typing import Any
 
+from aiohttp import ClientError
 from blinkpy.auth import Auth
 from blinkpy.blinkpy import Blink
 import voluptuous as vol
@@ -17,6 +18,7 @@ from homeassistant.const import (
     CONF_SCAN_INTERVAL,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
@@ -81,15 +83,22 @@ async def async_setup_entry(hass: HomeAssistant, entry: BlinkConfigEntry) -> boo
     session = async_get_clientsession(hass)
     blink = Blink(session=session)
     auth_data = deepcopy(dict(entry.data))
-    blink.auth = Auth(
-        auth_data,
-        no_prompt=True,
-        session=session,
-        callback=lambda: _async_update_entry_data(hass, entry, blink),
-    )
+    blink.auth = Auth(auth_data, no_prompt=True, session=session)
     blink.refresh_rate = entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
     coordinator = BlinkUpdateCoordinator(hass, entry, blink)
 
+    try:
+        await blink.start()
+    except (ClientError, TimeoutError) as ex:
+        raise ConfigEntryNotReady("Can not connect to host") from ex
+
+    if blink.auth.check_key_required():
+        _LOGGER.debug("Attempting a reauth flow")
+        raise ConfigEntryAuthFailed("Need 2FA for Blink")
+
+    if not blink.available:
+        raise ConfigEntryNotReady
+
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator
@@ -99,14 +108,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: BlinkConfigEntry) -> boo
     return True
 
 
-@callback
-def _async_update_entry_data(
-    hass: HomeAssistant, entry: BlinkConfigEntry, blink: Blink
-) -> None:
-    """Update the config entry data after token refresh."""
-    hass.config_entries.async_update_entry(entry, data=blink.auth.login_attributes)
-
-
 @callback
 def _async_import_options_from_data_if_missing(
     hass: HomeAssistant, entry: BlinkConfigEntry

homeassistant/components/blink/alarm_control_panel.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from blinkpy.auth import UnauthorizedError
 from blinkpy.blinkpy import Blink, BlinkSyncModule
 
 from homeassistant.components.alarm_control_panel import (
@@ -14,7 +13,7 @@ from homeassistant.components.alarm_control_panel import (
 )
 from homeassistant.const import ATTR_ATTRIBUTION
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -92,9 +91,6 @@ class BlinkSyncModuleHA(
 
         except TimeoutError as er:
             raise HomeAssistantError("Blink failed to disarm camera") from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         await self.coordinator.async_refresh()
 
@@ -105,8 +101,5 @@ class BlinkSyncModuleHA(
 
         except TimeoutError as er:
             raise HomeAssistantError("Blink failed to arm camera away") from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         await self.coordinator.async_refresh()

homeassistant/components/blink/camera.py

@@ -6,19 +6,13 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from blinkpy.auth import UnauthorizedError
-from blinkpy.camera import BlinkCamera as BlinkCameraAPI
 from requests.exceptions import ChunkedEncodingError
 import voluptuous as vol
 
 from homeassistant.components.camera import Camera
 from homeassistant.const import CONF_FILE_PATH, CONF_FILENAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    HomeAssistantError,
-    ServiceValidationError,
-)
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -77,9 +71,7 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
     _attr_has_entity_name = True
     _attr_name = None
 
-    def __init__(
-        self, coordinator: BlinkUpdateCoordinator, name, camera: BlinkCameraAPI
-    ) -> None:
+    def __init__(self, coordinator: BlinkUpdateCoordinator, name, camera) -> None:
         """Initialize a camera."""
         super().__init__(coordinator)
         Camera.__init__(self)
@@ -109,9 +101,6 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="failed_arm",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         self._camera.motion_enabled = True
         await self.coordinator.async_refresh()
@@ -125,9 +114,6 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="failed_disarm",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         self._camera.motion_enabled = False
         await self.coordinator.async_refresh()
@@ -151,9 +137,6 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="failed_clip",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         self.async_write_ha_state()
 
@@ -166,9 +149,6 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="failed_snap",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         self.async_write_ha_state()
 
@@ -202,9 +182,6 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="cant_write",
             ) from err
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
     async def save_video(self, filename) -> None:
         """Handle save video service calls."""
@@ -223,6 +200,3 @@ class BlinkCamera(CoordinatorEntity[BlinkUpdateCoordinator], Camera):
                 translation_domain=DOMAIN,
                 translation_key="cant_write",
             ) from err
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er

homeassistant/components/blink/config_flow.py

@@ -6,18 +6,13 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from blinkpy.auth import Auth, BlinkTwoFARequiredError, LoginError, TokenRefreshFailed
+from blinkpy.auth import Auth, LoginError, TokenRefreshFailed
 from blinkpy.blinkpy import Blink, BlinkSetupError
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
-    ConfigFlow,
-    ConfigFlowResult,
-)
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_PIN, CONF_USERNAME
-from homeassistant.core import callback
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -26,18 +21,23 @@ from .const import DEVICE_ID, DOMAIN
 _LOGGER = logging.getLogger(__name__)
 
 
-async def validate_input(blink: Blink) -> None:
+async def validate_input(auth: Auth) -> None:
     """Validate the user input allows us to connect."""
     try:
-        await blink.start()
+        await auth.startup()
     except (LoginError, TokenRefreshFailed) as err:
         raise InvalidAuth from err
+    if auth.check_key_required():
+        raise Require2FA
 
 
-async def _send_blink_2fa_pin(blink: Blink, pin: str | None) -> bool:
+async def _send_blink_2fa_pin(hass: HomeAssistant, auth: Auth, pin: str | None) -> bool:
     """Send 2FA pin to blink servers."""
-    await blink.send_2fa_code(pin)
-    return True
+    blink = Blink(session=async_get_clientsession(hass))
+    blink.auth = auth
+    blink.setup_login_ids()
+    blink.setup_urls()
+    return await auth.send_auth_key(blink, pin)
 
 
 class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
@@ -48,23 +48,6 @@ class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
     def __init__(self) -> None:
         """Initialize the blink flow."""
         self.auth: Auth | None = None
-        self.blink: Blink | None = None
-
-    async def _handle_user_input(self, user_input: dict[str, Any]):
-        """Handle user input."""
-        self.auth = Auth(
-            {**user_input, "device_id": DEVICE_ID},
-            no_prompt=True,
-            session=async_get_clientsession(self.hass),
-        )
-        self.blink = Blink(session=async_get_clientsession(self.hass))
-        self.blink.auth = self.auth
-        await self.async_set_unique_id(user_input[CONF_USERNAME])
-        if self.source not in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
-            self._abort_if_unique_id_configured()
-
-        await validate_input(self.blink)
-        return self._async_finish_flow()
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -72,9 +55,19 @@ class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle a flow initiated by the user."""
         errors = {}
         if user_input is not None:
+            self.auth = Auth(
+                {**user_input, "device_id": DEVICE_ID},
+                no_prompt=True,
+                session=async_get_clientsession(self.hass),
+            )
+            await self.async_set_unique_id(user_input[CONF_USERNAME])
+            if self.source != SOURCE_REAUTH:
+                self._abort_if_unique_id_configured()
+
             try:
-                return await self._handle_user_input(user_input)
-            except BlinkTwoFARequiredError:
+                await validate_input(self.auth)
+                return self._async_finish_flow()
+            except Require2FA:
                 return await self.async_step_2fa()
             except InvalidAuth:
                 errors["base"] = "invalid_auth"
@@ -100,16 +93,19 @@ class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
         errors = {}
         if user_input is not None:
             try:
-                await _send_blink_2fa_pin(self.blink, user_input.get(CONF_PIN))
+                valid_token = await _send_blink_2fa_pin(
+                    self.hass, self.auth, user_input.get(CONF_PIN)
+                )
             except BlinkSetupError:
                 errors["base"] = "cannot_connect"
-            except TokenRefreshFailed:
-                errors["base"] = "invalid_access_token"
             except Exception:
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
+
             else:
-                return self._async_finish_flow()
+                if valid_token:
+                    return self._async_finish_flow()
+                errors["base"] = "invalid_access_token"
 
         return self.async_show_form(
             step_id="2fa",
@@ -122,89 +118,19 @@ class BlinkConfigFlow(ConfigFlow, domain=DOMAIN):
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
-        """Perform reauth after an authentication error."""
-        return await self.async_step_reauth_confirm(None)
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauth confirmation."""
-        errors = {}
-        if user_input is not None:
-            try:
-                return await self._handle_user_input(user_input)
-            except BlinkTwoFARequiredError:
-                return await self.async_step_2fa()
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-
-        config_entry = self._get_reauth_entry()
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_USERNAME, default=config_entry.data[CONF_USERNAME]
-                    ): str,
-                    vol.Required(
-                        CONF_PASSWORD, default=config_entry.data[CONF_PASSWORD]
-                    ): str,
-                }
-            ),
-            errors=errors,
-            description_placeholders={"username": config_entry.data[CONF_USERNAME]},
-        )
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration initiated by the user."""
-        errors = {}
-        if user_input is not None:
-            try:
-                return await self._handle_user_input(user_input)
-            except BlinkTwoFARequiredError:
-                return await self.async_step_2fa()
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-
-        config_entry = self._get_reconfigure_entry()
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_USERNAME, default=config_entry.data[CONF_USERNAME]
-                    ): str,
-                    vol.Required(
-                        CONF_PASSWORD, default=config_entry.data[CONF_PASSWORD]
-                    ): str,
-                }
-            ),
-            errors=errors,
-        )
+        """Perform reauth upon migration of old entries."""
+        return await self.async_step_user(dict(entry_data))
 
     @callback
     def _async_finish_flow(self) -> ConfigFlowResult:
         """Finish with setup."""
         assert self.auth
-
-        if self.source in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry()
-                if self.source == SOURCE_REAUTH
-                else self._get_reconfigure_entry(),
-                data_updates=self.auth.login_attributes,
-            )
-
         return self.async_create_entry(title=DOMAIN, data=self.auth.login_attributes)
 
 
+class Require2FA(HomeAssistantError):
+    """Error to indicate we require 2FA."""
+
+
 class InvalidAuth(HomeAssistantError):
     """Error to indicate there is invalid auth."""

homeassistant/components/blink/coordinator.py

@@ -6,17 +6,10 @@ from datetime import timedelta
 import logging
 from typing import Any
 
-from aiohttp import ClientError
-from blinkpy.auth import BlinkTwoFARequiredError, UnauthorizedError
 from blinkpy.blinkpy import Blink
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryError,
-    ConfigEntryNotReady,
-)
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN
@@ -45,23 +38,6 @@ class BlinkUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             update_interval=timedelta(seconds=SCAN_INTERVAL),
         )
 
-    async def _async_setup(self):
-        """Set up the coordinator."""
-        try:
-            await self.api.start()
-        except (ClientError, TimeoutError) as ex:
-            raise ConfigEntryNotReady("Can not connect to host") from ex
-        except (BlinkTwoFARequiredError, UnauthorizedError) as ex:
-            raise ConfigEntryAuthFailed("Required Blink re-authentication") from ex
-        except Exception as ex:
-            raise ConfigEntryError("Unknown error connecting to Blink") from ex
-
-        if not self.api.available:
-            raise ConfigEntryNotReady
-
     async def _async_update_data(self) -> dict[str, Any]:
         """Async update wrapper."""
-        try:
-            return await self.api.refresh(force=True)
-        except UnauthorizedError as ex:
-            raise ConfigEntryAuthFailed("Blink API authorization failed") from ex
+        return await self.api.refresh(force=True)

homeassistant/components/blink/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/blink",
   "iot_class": "cloud_polling",
   "loggers": ["blinkpy"],
-  "requirements": ["blinkpy==0.24.1"]
+  "requirements": ["blinkpy==0.23.0"]
 }

homeassistant/components/blink/services.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 
 import voluptuous as vol
 
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_CONFIG_ENTRY_ID, CONF_PIN
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, issue_registry as ir
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.helpers import config_validation as cv
 
 from .const import DOMAIN, SERVICE_SEND_PIN
+from .coordinator import BlinkConfigEntry
 
 SERVICE_SEND_PIN_SCHEMA = vol.Schema(
     {
@@ -21,25 +23,25 @@ SERVICE_SEND_PIN_SCHEMA = vol.Schema(
 
 async def _send_pin(call: ServiceCall) -> None:
     """Call blink to send new pin."""
-    # Create repair issue to inform user about service removal
-    ir.async_create_issue(
-        call.hass,
-        DOMAIN,
-        "service_send_pin_deprecation",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.ERROR,
-        breaks_in_ha_version="2026.5.0",
-        translation_key="service_send_pin_deprecation",
-        translation_placeholders={"service_name": f"{DOMAIN}.{SERVICE_SEND_PIN}"},
-    )
-
-    # Service has been removed - raise exception
-    raise HomeAssistantError(
-        translation_domain=DOMAIN,
-        translation_key="service_removed",
-        translation_placeholders={"service_name": f"{DOMAIN}.{SERVICE_SEND_PIN}"},
-    )
+    config_entry: BlinkConfigEntry | None
+    for entry_id in call.data[ATTR_CONFIG_ENTRY_ID]:
+        if not (config_entry := call.hass.config_entries.async_get_entry(entry_id)):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="integration_not_found",
+                translation_placeholders={"target": DOMAIN},
+            )
+        if config_entry.state != ConfigEntryState.LOADED:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="not_loaded",
+                translation_placeholders={"target": config_entry.title},
+            )
+        coordinator = config_entry.runtime_data
+        await coordinator.api.auth.send_auth_key(
+            coordinator.api,
+            call.data[CONF_PIN],
+        )
 
 
 @callback

homeassistant/components/blink/strings.json

@@ -1,8 +1,7 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -18,14 +17,6 @@
         "description": "Enter the PIN sent via email or SMS",
         "title": "Two-factor authentication"
       },
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "description": "The credentials for {username} need to be updated",
-        "title": "Re-authenticate Blink"
-      },
       "user": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",
@@ -82,9 +73,6 @@
     },
     "not_loaded": {
       "message": "{target} is not loaded."
-    },
-    "service_removed": {
-      "message": "The service {service_name} has been removed and is no longer needed. Home Assistant will automatically prompt for reauthentication when required."
     }
   },
   "issues": {
@@ -98,10 +86,6 @@
         }
       },
       "title": "Blink update service is being removed"
-    },
-    "service_send_pin_deprecation": {
-      "description": "The service {service_name} has been removed and is no longer needed. When a new two-factor authentication code is required, Home Assistant will automatically prompt you to reauthenticate through the integration configuration. Please remove any automations or scripts that call this service.",
-      "title": "Blink send PIN service has been removed"
     }
   },
   "options": {

homeassistant/components/blink/switch.py

@@ -4,15 +4,13 @@ from __future__ import annotations
 
 from typing import Any
 
-from blinkpy.auth import UnauthorizedError
-
 from homeassistant.components.switch import (
     SwitchDeviceClass,
     SwitchEntity,
     SwitchEntityDescription,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -79,9 +77,6 @@ class BlinkSwitch(CoordinatorEntity[BlinkUpdateCoordinator], SwitchEntity):
                 translation_domain=DOMAIN,
                 translation_key="failed_arm_motion",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         await self.coordinator.async_refresh()
 
@@ -95,9 +90,6 @@ class BlinkSwitch(CoordinatorEntity[BlinkUpdateCoordinator], SwitchEntity):
                 translation_domain=DOMAIN,
                 translation_key="failed_disarm_motion",
             ) from er
-        except UnauthorizedError as er:
-            self.coordinator.config_entry.async_start_reauth(self.hass)
-            raise ConfigEntryAuthFailed("Blink authorization failed") from er
 
         await self.coordinator.async_refresh()
 

homeassistant/components/blueprint/__init__.py

@@ -1,9 +1,7 @@
 """The blueprint integration."""
 
-from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.typing import ConfigType
 
 from . import websocket_api
@@ -30,7 +28,4 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the blueprint integration."""
     websocket_api.async_setup(hass)
-    hass.async_create_task(
-        async_load_platform(hass, Platform.UPDATE, DOMAIN, None, config)
-    )
     return True

homeassistant/components/blueprint/models.py

@@ -204,8 +204,8 @@ class DomainBlueprints:
         self.hass = hass
         self.domain = domain
         self.logger = logger
-        self.blueprint_in_use = blueprint_in_use
-        self.reload_blueprint_consumers = reload_blueprint_consumers
+        self._blueprint_in_use = blueprint_in_use
+        self._reload_blueprint_consumers = reload_blueprint_consumers
         self._blueprints: dict[str, Blueprint | None] = {}
         self._load_lock = asyncio.Lock()
         self._blueprint_schema = blueprint_schema
@@ -325,7 +325,7 @@ class DomainBlueprints:
 
     async def async_remove_blueprint(self, blueprint_path: str) -> None:
         """Remove a blueprint file."""
-        if self.blueprint_in_use(self.hass, blueprint_path):
+        if self._blueprint_in_use(self.hass, blueprint_path):
             raise BlueprintInUse(self.domain, blueprint_path)
         path = self.blueprint_folder / blueprint_path
         await self.hass.async_add_executor_job(path.unlink)
@@ -362,7 +362,7 @@ class DomainBlueprints:
         self._blueprints[blueprint_path] = blueprint
 
         if overrides_existing:
-            await self.reload_blueprint_consumers(self.hass, blueprint_path)
+            await self._reload_blueprint_consumers(self.hass, blueprint_path)
 
         return overrides_existing
 

homeassistant/components/blueprint/update.py

@@ -1,293 +0,0 @@
-"""Update entities for blueprints."""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-import logging
-from datetime import timedelta
-from typing import Any, Final
-
-from homeassistant.components import automation, script
-from . import importer, models
-from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
-from homeassistant.const import CONF_SOURCE_URL
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import event as event_helper
-from homeassistant.helpers.entity import EntityCategory
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-from .const import DOMAIN as BLUEPRINT_DOMAIN
-from .errors import BlueprintException
-
-_LOGGER = logging.getLogger(__name__)
-
-_LATEST_VERSION_PLACEHOLDER: Final = "remote"
-DATA_UPDATE_MANAGER: Final = "update_manager"
-REFRESH_INTERVAL: Final = timedelta(days=1)
-
-
-@dataclass(slots=True)
-class BlueprintUsage:
-    """Details about a blueprint currently in use."""
-
-    domain: str
-    path: str
-    domain_blueprints: models.DomainBlueprints
-    blueprint: models.Blueprint
-    entities: list[str]
-
-
-async def async_setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the blueprint update platform."""
-    data = hass.data.setdefault(BLUEPRINT_DOMAIN, {})
-
-    if (manager := data.get(DATA_UPDATE_MANAGER)) is None:
-        manager = BlueprintUpdateManager(hass, async_add_entities)
-        data[DATA_UPDATE_MANAGER] = manager
-        await manager.async_start()
-        return
-
-    manager.replace_add_entities(async_add_entities)
-    await manager.async_recreate_entities()
-
-
-class BlueprintUpdateManager:
-    """Manage blueprint update entities based on blueprint usage."""
-
-    def __init__(
-        self, hass: HomeAssistant, async_add_entities: AddEntitiesCallback
-    ) -> None:
-        """Initialize the manager."""
-        self.hass = hass
-        self._async_add_entities = async_add_entities
-        self._entities: dict[tuple[str, str], BlueprintUpdateEntity] = {}
-        self._lock = asyncio.Lock()
-        self._refresh_cancel: CALLBACK_TYPE | None = None
-        self._started = False
-        self._interval_unsub: CALLBACK_TYPE | None = None
-
-    async def async_start(self) -> None:
-        """Start tracking blueprint usage."""
-        if self._started:
-            return
-        self._started = True
-
-        self._interval_unsub = event_helper.async_track_time_interval(
-            self.hass, self._handle_time_interval, REFRESH_INTERVAL
-        )
-        await self.async_refresh_entities()
-
-    def replace_add_entities(self, async_add_entities: AddEntitiesCallback) -> None:
-        """Update the callback used to register entities."""
-        self._async_add_entities = async_add_entities
-
-    async def async_recreate_entities(self) -> None:
-        """Recreate entities after the platform has been reloaded."""
-        async with self._lock:
-            entities = list(self._entities.values())
-            self._entities.clear()
-
-        for entity in entities:
-            await entity.async_remove()
-
-        await self.async_refresh_entities()
-
-    async def async_refresh_entities(self) -> None:
-        """Refresh update entities based on current blueprint usage."""
-        async with self._lock:
-            usage_map = await self._async_collect_in_use_blueprints()
-
-            current_keys = set(self._entities)
-            new_keys = set(usage_map)
-
-            for key in current_keys - new_keys:
-                entity = self._entities.pop(key)
-                await entity.async_remove()
-
-            new_entities: list[BlueprintUpdateEntity] = []
-
-            for key in new_keys - current_keys:
-                usage = usage_map[key]
-                entity = BlueprintUpdateEntity(self, usage)
-                self._entities[key] = entity
-                new_entities.append(entity)
-
-            for key in new_keys & current_keys:
-                self._entities[key].update_usage(usage_map[key])
-                self._entities[key].async_write_ha_state()
-
-            if new_entities:
-                self._async_add_entities(new_entities)
-
-    def async_schedule_refresh(self) -> None:
-        """Schedule an asynchronous refresh."""
-        if self._refresh_cancel is not None:
-            return
-
-        self._refresh_cancel = event_helper.async_call_later(
-            self.hass, 0, self._handle_scheduled_refresh
-        )
-
-    @callback
-    def _handle_scheduled_refresh(self, _now: Any) -> None:
-        """Run a scheduled refresh task."""
-        self._refresh_cancel = None
-        self.hass.async_create_task(self.async_refresh_entities())
-
-    @callback
-    def _handle_time_interval(self, _now: Any) -> None:
-        """Handle scheduled interval refresh."""
-        self.async_schedule_refresh()
-
-    async def _async_collect_in_use_blueprints(self) -> dict[tuple[str, str], BlueprintUsage]:
-        """Collect blueprint usage information for automations and scripts."""
-
-        usage_keys: set[tuple[str, str]] = set()
-
-        if automation.DATA_COMPONENT in self.hass.data:
-            component = self.hass.data[automation.DATA_COMPONENT]
-            for automation_entity in list(component.entities):
-                if (path := getattr(automation_entity, "referenced_blueprint", None)):
-                    usage_keys.add((automation.DOMAIN, path))
-
-        if script.DOMAIN in self.hass.data:
-            component = self.hass.data[script.DOMAIN]
-            for script_entity in list(component.entities):
-                if (path := getattr(script_entity, "referenced_blueprint", None)):
-                    usage_keys.add((script.DOMAIN, path))
-
-        domain_blueprints_map = self.hass.data.get(BLUEPRINT_DOMAIN, {})
-        usage_map: dict[tuple[str, str], BlueprintUsage] = {}
-
-        for domain, path in usage_keys:
-            domain_blueprints: models.DomainBlueprints | None = domain_blueprints_map.get(
-                domain
-            )
-
-            if domain_blueprints is None:
-                continue
-
-            if not domain_blueprints.blueprint_in_use(self.hass, path):
-                continue
-
-            try:
-                blueprint = await domain_blueprints.async_get_blueprint(path)
-            except BlueprintException:
-                continue
-
-            source_url = blueprint.metadata.get(CONF_SOURCE_URL)
-            if not source_url:
-                continue
-
-            if domain == automation.DOMAIN:
-                entities = automation.automations_with_blueprint(self.hass, path)
-            elif domain == script.DOMAIN:
-                entities = script.scripts_with_blueprint(self.hass, path)
-            else:
-                entities = []
-
-            usage_map[(domain, path)] = BlueprintUsage(
-                domain=domain,
-                path=path,
-                domain_blueprints=domain_blueprints,
-                blueprint=blueprint,
-                entities=entities,
-            )
-
-        return usage_map
-
-
-class BlueprintUpdateEntity(UpdateEntity):
-    """Define a blueprint update entity."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_has_entity_name = True
-    _attr_should_poll = False
-    _attr_supported_features = UpdateEntityFeature.INSTALL
-
-    def __init__(self, manager: BlueprintUpdateManager, usage: BlueprintUsage) -> None:
-        """Initialize the update entity."""
-        self._manager = manager
-        self._domain = usage.domain
-        self._path = usage.path
-        self._domain_blueprints = usage.domain_blueprints
-        self._blueprint = usage.blueprint
-        self._entities_in_use = usage.entities
-        self._source_url = usage.blueprint.metadata.get(CONF_SOURCE_URL)
-        self._attr_unique_id = f"{self._domain}:{self._path}"
-        self._attr_in_progress = False
-
-        self.update_usage(usage)
-
-    @callback
-    def update_usage(self, usage: BlueprintUsage) -> None:
-        """Update the entity with latest usage information."""
-        self._domain_blueprints = usage.domain_blueprints
-        self._blueprint = usage.blueprint
-        self._entities_in_use = usage.entities
-        self._source_url = usage.blueprint.metadata.get(CONF_SOURCE_URL)
-
-        self._attr_name = usage.blueprint.name
-        self._attr_release_summary = usage.blueprint.metadata.get("description")
-        self._attr_installed_version = usage.blueprint.metadata.get("version")
-        self._attr_release_url = self._source_url
-        self._attr_available = self._source_url is not None
-        self._attr_latest_version = (
-            _LATEST_VERSION_PLACEHOLDER
-            if self._source_url is not None
-            else self._attr_installed_version
-        )
-
-    async def async_install(self, version: str | None, backup: bool) -> None:
-        """Install (refresh) the blueprint from its source."""
-        if self._source_url is None:
-            raise HomeAssistantError("Blueprint does not define a source URL")
-
-        self._attr_in_progress = True
-        self.async_write_ha_state()
-        usage: BlueprintUsage | None = None
-
-        try:
-            imported = await importer.fetch_blueprint_from_url(
-                self.hass, self._source_url
-            )
-            blueprint = imported.blueprint
-
-            if blueprint.domain != self._domain:
-                raise HomeAssistantError(
-                    "Downloaded blueprint domain does not match the existing blueprint"
-                )
-
-            await self._domain_blueprints.async_add_blueprint(
-                blueprint, self._path, allow_override=True
-            )
-
-            usage = BlueprintUsage(
-                domain=self._domain,
-                path=self._path,
-                domain_blueprints=self._domain_blueprints,
-                blueprint=blueprint,
-                entities=self._entities_in_use,
-            )
-
-        except HomeAssistantError:
-            raise
-        except Exception as err:  # noqa: BLE001 - Provide context for unexpected errors
-            raise HomeAssistantError("Failed to update blueprint from source") from err
-        finally:
-            self._attr_in_progress = False
-
-            if usage is not None:
-                self.update_usage(usage)
-
-            self.async_write_ha_state()
-
-        self._manager.async_schedule_refresh()

homeassistant/components/bsblan/__init__.py

@@ -30,7 +30,7 @@ from homeassistant.exceptions import (
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import CONF_PASSKEY, DOMAIN
-from .coordinator import BSBLanFastCoordinator, BSBLanSlowCoordinator
+from .coordinator import BSBLanUpdateCoordinator
 
 PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
@@ -41,8 +41,7 @@ type BSBLanConfigEntry = ConfigEntry[BSBLanData]
 class BSBLanData:
     """BSBLan data stored in the Home Assistant data object."""
 
-    fast_coordinator: BSBLanFastCoordinator
-    slow_coordinator: BSBLanSlowCoordinator
+    coordinator: BSBLanUpdateCoordinator
     client: BSBLAN
     device: Device
     info: Info
@@ -65,10 +64,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
     session = async_get_clientsession(hass)
     bsblan = BSBLAN(config, session)
 
+    # Create and perform first refresh of the coordinator
+    coordinator = BSBLanUpdateCoordinator(hass, entry, bsblan)
+    await coordinator.async_config_entry_first_refresh()
+
     try:
-        # Initialize the client first - this sets up internal caches and validates the connection
-        await bsblan.initialize()
-        # Fetch all required device metadata
+        # Fetch all required data sequentially
         device = await bsblan.device()
         info = await bsblan.info()
         static = await bsblan.static_values()
@@ -83,33 +84,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
             translation_domain=DOMAIN,
             translation_key="setup_auth_error",
         ) from err
-    except TimeoutError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="setup_connection_error",
-            translation_placeholders={"host": entry.data[CONF_HOST]},
-        ) from err
     except BSBLANError as err:
         raise ConfigEntryError(
             translation_domain=DOMAIN,
             translation_key="setup_general_error",
         ) from err
 
-    # Create coordinators with the already-initialized client
-    fast_coordinator = BSBLanFastCoordinator(hass, entry, bsblan)
-    slow_coordinator = BSBLanSlowCoordinator(hass, entry, bsblan)
-
-    # Perform first refresh of both coordinators
-    await fast_coordinator.async_config_entry_first_refresh()
-
-    # Try to refresh slow coordinator, but don't fail if DHW is not available
-    # This allows the integration to work even if the device doesn't support DHW
-    await slow_coordinator.async_refresh()
-
     entry.runtime_data = BSBLanData(
         client=bsblan,
-        fast_coordinator=fast_coordinator,
-        slow_coordinator=slow_coordinator,
+        coordinator=coordinator,
         device=device,
         info=info,
         static=static,

homeassistant/components/bsblan/climate.py

@@ -71,12 +71,12 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         data: BSBLanData,
     ) -> None:
         """Initialize BSBLAN climate device."""
-        super().__init__(data.fast_coordinator, data)
+        super().__init__(data.coordinator, data)
         self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"
 
         self._attr_min_temp = data.static.min_temp.value
         self._attr_max_temp = data.static.max_temp.value
-        self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
+        self._attr_temperature_unit = data.coordinator.client.get_temperature_unit
 
     @property
     def current_temperature(self) -> float | None:

homeassistant/components/bsblan/config_flow.py

@@ -180,7 +180,10 @@ class BSBLANFlowHandler(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle reauth confirmation flow."""
-        existing_entry = self._get_reauth_entry()
+        existing_entry = self.hass.config_entries.async_get_entry(
+            self.context["entry_id"]
+        )
+        assert existing_entry
 
         if user_input is None:
             # Preserve existing values as defaults

homeassistant/components/bsblan/const.py

@@ -10,9 +10,7 @@ from typing import Final
 DOMAIN: Final = "bsblan"
 
 LOGGER = logging.getLogger(__package__)
-SCAN_INTERVAL = timedelta(seconds=12)  # Legacy interval, kept for compatibility
-SCAN_INTERVAL_FAST = timedelta(seconds=12)  # For state/sensor data
-SCAN_INTERVAL_SLOW = timedelta(minutes=5)  # For config data
+SCAN_INTERVAL = timedelta(seconds=12)
 
 # Services
 DATA_BSBLAN_CLIENT: Final = "bsblan_client"

homeassistant/components/bsblan/coordinator.py

@@ -8,8 +8,6 @@ from bsblan import (
     BSBLAN,
     BSBLANAuthError,
     BSBLANConnectionError,
-    HotWaterConfig,
-    HotWaterSchedule,
     HotWaterState,
     Sensor,
     State,
@@ -21,28 +19,20 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import DOMAIN, LOGGER, SCAN_INTERVAL_FAST, SCAN_INTERVAL_SLOW
+from .const import DOMAIN, LOGGER, SCAN_INTERVAL
 
 
 @dataclass
-class BSBLanFastData:
-    """BSBLan fast-polling data."""
+class BSBLanCoordinatorData:
+    """BSBLan data stored in the Home Assistant data object."""
 
     state: State
     sensor: Sensor
     dhw: HotWaterState
 
 
-@dataclass
-class BSBLanSlowData:
-    """BSBLan slow-polling data."""
-
-    dhw_config: HotWaterConfig | None = None
-    dhw_schedule: HotWaterSchedule | None = None
-
-
-class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
-    """Base BSB-Lan coordinator."""
+class BSBLanUpdateCoordinator(DataUpdateCoordinator[BSBLanCoordinatorData]):
+    """The BSB-Lan update coordinator."""
 
     config_entry: ConfigEntry
 
@@ -51,122 +41,44 @@ class BSBLanCoordinator[T](DataUpdateCoordinator[T]):
         hass: HomeAssistant,
         config_entry: ConfigEntry,
         client: BSBLAN,
-        name: str,
-        update_interval: timedelta,
     ) -> None:
         """Initialize the BSB-Lan coordinator."""
         super().__init__(
             hass,
             logger=LOGGER,
             config_entry=config_entry,
-            name=name,
-            update_interval=update_interval,
-        )
-        self.client = client
-
-
-class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
-    """The BSB-Lan fast update coordinator for frequently changing data."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        client: BSBLAN,
-    ) -> None:
-        """Initialize the BSB-Lan fast coordinator."""
-        super().__init__(
-            hass,
-            config_entry,
-            client,
-            name=f"{DOMAIN}_fast_{config_entry.data[CONF_HOST]}",
+            name=f"{DOMAIN}_{config_entry.data[CONF_HOST]}",
             update_interval=self._get_update_interval(),
         )
+        self.client = client
 
     def _get_update_interval(self) -> timedelta:
         """Get the update interval with a random offset.
 
-        Add a random number of seconds to avoid timeouts when
+        Use the default scan interval and add a random number of seconds to avoid timeouts when
         the BSB-Lan device is already/still busy retrieving data,
         e.g. for MQTT or internal logging.
         """
-        return SCAN_INTERVAL_FAST + timedelta(seconds=randint(1, 8))
+        return SCAN_INTERVAL + timedelta(seconds=randint(1, 8))
 
-    async def _async_update_data(self) -> BSBLanFastData:
-        """Fetch fast-changing data from the BSB-Lan device."""
+    async def _async_update_data(self) -> BSBLanCoordinatorData:
+        """Get state and sensor data from BSB-Lan device."""
         try:
-            # Client is already initialized in async_setup_entry
-            # Fetch fast-changing data (state, sensor, DHW state)
+            # initialize the client, this is cached and will only be called once
+            await self.client.initialize()
+
             state = await self.client.state()
             sensor = await self.client.sensor()
             dhw = await self.client.hot_water_state()
-
         except BSBLANAuthError as err:
             raise ConfigEntryAuthFailed(
                 "Authentication failed for BSB-Lan device"
             ) from err
         except BSBLANConnectionError as err:
-            host = self.config_entry.data[CONF_HOST]
+            host = self.config_entry.data[CONF_HOST] if self.config_entry else "unknown"
             raise UpdateFailed(
                 f"Error while establishing connection with BSB-Lan device at {host}"
             ) from err
 
-        # Update the interval with random jitter for next update
         self.update_interval = self._get_update_interval()
-
-        return BSBLanFastData(
-            state=state,
-            sensor=sensor,
-            dhw=dhw,
-        )
-
-
-class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
-    """The BSB-Lan slow update coordinator for infrequently changing data."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        client: BSBLAN,
-    ) -> None:
-        """Initialize the BSB-Lan slow coordinator."""
-        super().__init__(
-            hass,
-            config_entry,
-            client,
-            name=f"{DOMAIN}_slow_{config_entry.data[CONF_HOST]}",
-            update_interval=SCAN_INTERVAL_SLOW,
-        )
-
-    async def _async_update_data(self) -> BSBLanSlowData:
-        """Fetch slow-changing data from the BSB-Lan device."""
-        try:
-            # Client is already initialized in async_setup_entry
-            # Fetch slow-changing configuration data
-            dhw_config = await self.client.hot_water_config()
-            dhw_schedule = await self.client.hot_water_schedule()
-
-        except AttributeError:
-            # Device does not support DHW functionality
-            LOGGER.debug(
-                "DHW (Domestic Hot Water) not available on device at %s",
-                self.config_entry.data[CONF_HOST],
-            )
-            return BSBLanSlowData()
-        except (BSBLANConnectionError, BSBLANAuthError) as err:
-            # If config update fails, keep existing data
-            LOGGER.debug(
-                "Failed to fetch DHW config from %s: %s",
-                self.config_entry.data[CONF_HOST],
-                err,
-            )
-            if self.data:
-                return self.data
-            # First fetch failed, return empty data
-            return BSBLanSlowData()
-
-        return BSBLanSlowData(
-            dhw_config=dhw_config,
-            dhw_schedule=dhw_schedule,
-        )
+        return BSBLanCoordinatorData(state=state, sensor=sensor, dhw=dhw)

homeassistant/components/bsblan/diagnostics.py

@@ -15,28 +15,12 @@ async def async_get_config_entry_diagnostics(
     """Return diagnostics for a config entry."""
     data = entry.runtime_data
 
-    # Build diagnostic data from both coordinators
-    diagnostics = {
+    return {
         "info": data.info.to_dict(),
         "device": data.device.to_dict(),
-        "fast_coordinator_data": {
-            "state": data.fast_coordinator.data.state.to_dict(),
-            "sensor": data.fast_coordinator.data.sensor.to_dict(),
-            "dhw": data.fast_coordinator.data.dhw.to_dict(),
+        "coordinator_data": {
+            "state": data.coordinator.data.state.to_dict(),
+            "sensor": data.coordinator.data.sensor.to_dict(),
         },
         "static": data.static.to_dict(),
     }
-
-    # Add DHW config and schedule from slow coordinator if available
-    if data.slow_coordinator.data:
-        slow_data = {}
-        if data.slow_coordinator.data.dhw_config:
-            slow_data["dhw_config"] = data.slow_coordinator.data.dhw_config.to_dict()
-        if data.slow_coordinator.data.dhw_schedule:
-            slow_data["dhw_schedule"] = (
-                data.slow_coordinator.data.dhw_schedule.to_dict()
-            )
-        if slow_data:
-            diagnostics["slow_coordinator_data"] = slow_data
-
-    return diagnostics

homeassistant/components/bsblan/entity.py

@@ -11,17 +11,17 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import BSBLanData
 from .const import DOMAIN
-from .coordinator import BSBLanCoordinator, BSBLanFastCoordinator, BSBLanSlowCoordinator
+from .coordinator import BSBLanUpdateCoordinator
 
 
-class BSBLanEntityBase[_T: BSBLanCoordinator](CoordinatorEntity[_T]):
-    """Base BSBLan entity with common device info setup."""
+class BSBLanEntity(CoordinatorEntity[BSBLanUpdateCoordinator]):
+    """Defines a base BSBLan entity."""
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: _T, data: BSBLanData) -> None:
-        """Initialize BSBLan entity with device info."""
-        super().__init__(coordinator)
+    def __init__(self, coordinator: BSBLanUpdateCoordinator, data: BSBLanData) -> None:
+        """Initialize BSBLan entity."""
+        super().__init__(coordinator, data)
         host = coordinator.config_entry.data["host"]
         mac = data.device.MAC
         self._attr_device_info = DeviceInfo(
@@ -33,33 +33,3 @@ class BSBLanEntityBase[_T: BSBLanCoordinator](CoordinatorEntity[_T]):
             sw_version=data.device.version,
             configuration_url=f"http://{host}",
         )
-
-
-class BSBLanEntity(BSBLanEntityBase[BSBLanFastCoordinator]):
-    """Defines a base BSBLan entity using the fast coordinator."""
-
-    def __init__(self, coordinator: BSBLanFastCoordinator, data: BSBLanData) -> None:
-        """Initialize BSBLan entity."""
-        super().__init__(coordinator, data)
-
-
-class BSBLanDualCoordinatorEntity(BSBLanEntity):
-    """Entity that listens to both fast and slow coordinators."""
-
-    def __init__(
-        self,
-        fast_coordinator: BSBLanFastCoordinator,
-        slow_coordinator: BSBLanSlowCoordinator,
-        data: BSBLanData,
-    ) -> None:
-        """Initialize BSBLan entity with both coordinators."""
-        super().__init__(fast_coordinator, data)
-        self.slow_coordinator = slow_coordinator
-
-    async def async_added_to_hass(self) -> None:
-        """When entity is added to hass."""
-        await super().async_added_to_hass()
-        # Also listen to slow coordinator updates
-        self.async_on_remove(
-            self.slow_coordinator.async_add_listener(self._handle_coordinator_update)
-        )

homeassistant/components/bsblan/manifest.json

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

homeassistant/components/bsblan/sensor.py

@@ -17,7 +17,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
 from . import BSBLanConfigEntry, BSBLanData
-from .coordinator import BSBLanFastData
+from .coordinator import BSBLanCoordinatorData
 from .entity import BSBLanEntity
 
 PARALLEL_UPDATES = 1
@@ -27,8 +27,8 @@ PARALLEL_UPDATES = 1
 class BSBLanSensorEntityDescription(SensorEntityDescription):
     """Describes BSB-Lan sensor entity."""
 
-    value_fn: Callable[[BSBLanFastData], StateType]
-    exists_fn: Callable[[BSBLanFastData], bool] = lambda data: True
+    value_fn: Callable[[BSBLanCoordinatorData], StateType]
+    exists_fn: Callable[[BSBLanCoordinatorData], bool] = lambda data: True
 
 
 SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
@@ -73,7 +73,7 @@ async def async_setup_entry(
     entities = [
         BSBLanSensor(data, description)
         for description in SENSOR_TYPES
-        if description.exists_fn(data.fast_coordinator.data)
+        if description.exists_fn(data.coordinator.data)
     ]
 
     if entities:
@@ -91,10 +91,10 @@ class BSBLanSensor(BSBLanEntity, SensorEntity):
         description: BSBLanSensorEntityDescription,
     ) -> None:
         """Initialize BSB-Lan sensor."""
-        super().__init__(data.fast_coordinator, data)
+        super().__init__(data.coordinator, data)
         self.entity_description = description
         self._attr_unique_id = f"{data.device.MAC}-{description.key}"
-        self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
+        self._attr_temperature_unit = data.coordinator.client.get_temperature_unit
 
     @property
     def native_value(self) -> StateType:

homeassistant/components/bsblan/water_heater.py

@@ -20,7 +20,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BSBLanConfigEntry, BSBLanData
 from .const import DOMAIN
-from .entity import BSBLanDualCoordinatorEntity
+from .entity import BSBLanEntity
 
 PARALLEL_UPDATES = 1
 
@@ -44,7 +44,7 @@ async def async_setup_entry(
 
     # Only create water heater entity if DHW (Domestic Hot Water) is available
     # Check if we have any DHW-related data indicating water heater support
-    dhw_data = data.fast_coordinator.data.dhw
+    dhw_data = data.coordinator.data.dhw
     if (
         dhw_data.operating_mode is None
         and dhw_data.nominal_setpoint is None
@@ -56,7 +56,7 @@ async def async_setup_entry(
     async_add_entities([BSBLANWaterHeater(data)])
 
 
-class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
+class BSBLANWaterHeater(BSBLanEntity, WaterHeaterEntity):
     """Defines a BSBLAN water heater entity."""
 
     _attr_name = None
@@ -67,43 +67,16 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
 
     def __init__(self, data: BSBLanData) -> None:
         """Initialize BSBLAN water heater."""
-        super().__init__(data.fast_coordinator, data.slow_coordinator, data)
+        super().__init__(data.coordinator, data)
         self._attr_unique_id = format_mac(data.device.MAC)
         self._attr_operation_list = list(OPERATION_MODES_REVERSE.keys())
 
-        # Set temperature unit
-        self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
-        # Initialize available attribute to resolve multiple inheritance conflict
-        self._attr_available = True
-
-        # Set temperature limits based on device capabilities from slow coordinator
-        # For min_temp: Use reduced_setpoint from config data (slow polling)
-        if (
-            data.slow_coordinator.data
-            and data.slow_coordinator.data.dhw_config is not None
-            and data.slow_coordinator.data.dhw_config.reduced_setpoint is not None
-            and hasattr(data.slow_coordinator.data.dhw_config.reduced_setpoint, "value")
-        ):
-            self._attr_min_temp = float(
-                data.slow_coordinator.data.dhw_config.reduced_setpoint.value
-            )
-        else:
-            self._attr_min_temp = 10.0  # Default minimum
-
-        # For max_temp: Use nominal_setpoint_max from config data (slow polling)
-        if (
-            data.slow_coordinator.data
-            and data.slow_coordinator.data.dhw_config is not None
-            and data.slow_coordinator.data.dhw_config.nominal_setpoint_max is not None
-            and hasattr(
-                data.slow_coordinator.data.dhw_config.nominal_setpoint_max, "value"
-            )
-        ):
-            self._attr_max_temp = float(
-                data.slow_coordinator.data.dhw_config.nominal_setpoint_max.value
-            )
-        else:
-            self._attr_max_temp = 65.0  # Default maximum
+        # Set temperature limits based on device capabilities
+        self._attr_temperature_unit = data.coordinator.client.get_temperature_unit
+        if data.coordinator.data.dhw.reduced_setpoint is not None:
+            self._attr_min_temp = data.coordinator.data.dhw.reduced_setpoint.value
+        if data.coordinator.data.dhw.nominal_setpoint_max is not None:
+            self._attr_max_temp = data.coordinator.data.dhw.nominal_setpoint_max.value
 
     @property
     def current_operation(self) -> str | None:

homeassistant/components/cloud/__init__.py

@@ -53,7 +53,6 @@ from .const import (
     CONF_ACME_SERVER,
     CONF_ALEXA,
     CONF_ALIASES,
-    CONF_API_SERVER,
     CONF_COGNITO_CLIENT_ID,
     CONF_ENTITY_CONFIG,
     CONF_FILTER,
@@ -115,37 +114,25 @@ GACTIONS_SCHEMA = ASSISTANT_SCHEMA.extend(
     {vol.Optional(CONF_ENTITY_CONFIG): {cv.entity_id: GOOGLE_ENTITY_SCHEMA}}
 )
 
-_BASE_CONFIG_SCHEMA = vol.Schema(
-    {
-        vol.Optional(CONF_COGNITO_CLIENT_ID): str,
-        vol.Optional(CONF_USER_POOL_ID): str,
-        vol.Optional(CONF_REGION): str,
-        vol.Optional(CONF_ALEXA): ALEXA_SCHEMA,
-        vol.Optional(CONF_GOOGLE_ACTIONS): GACTIONS_SCHEMA,
-        vol.Optional(CONF_ACCOUNT_LINK_SERVER): str,
-        vol.Optional(CONF_ACCOUNTS_SERVER): str,
-        vol.Optional(CONF_ACME_SERVER): str,
-        vol.Optional(CONF_API_SERVER): str,
-        vol.Optional(CONF_RELAYER_SERVER): str,
-        vol.Optional(CONF_REMOTESTATE_SERVER): str,
-        vol.Optional(CONF_SERVICEHANDLERS_SERVER): str,
-    }
-)
-
 CONFIG_SCHEMA = vol.Schema(
     {
-        DOMAIN: vol.Any(
-            _BASE_CONFIG_SCHEMA.extend(
-                {
-                    vol.Required(CONF_MODE): vol.In([MODE_DEV]),
-                    vol.Required(CONF_API_SERVER): str,
-                }
-            ),
-            _BASE_CONFIG_SCHEMA.extend(
-                {
-                    vol.Optional(CONF_MODE, default=DEFAULT_MODE): vol.In([MODE_PROD]),
-                }
-            ),
+        DOMAIN: vol.Schema(
+            {
+                vol.Optional(CONF_MODE, default=DEFAULT_MODE): vol.In(
+                    [MODE_DEV, MODE_PROD]
+                ),
+                vol.Optional(CONF_COGNITO_CLIENT_ID): str,
+                vol.Optional(CONF_USER_POOL_ID): str,
+                vol.Optional(CONF_REGION): str,
+                vol.Optional(CONF_ALEXA): ALEXA_SCHEMA,
+                vol.Optional(CONF_GOOGLE_ACTIONS): GACTIONS_SCHEMA,
+                vol.Optional(CONF_ACCOUNT_LINK_SERVER): str,
+                vol.Optional(CONF_ACCOUNTS_SERVER): str,
+                vol.Optional(CONF_ACME_SERVER): str,
+                vol.Optional(CONF_RELAYER_SERVER): str,
+                vol.Optional(CONF_REMOTESTATE_SERVER): str,
+                vol.Optional(CONF_SERVICEHANDLERS_SERVER): str,
+            }
         )
     },
     extra=vol.ALLOW_EXTRA,

homeassistant/components/cloud/const.py

@@ -78,7 +78,6 @@ CONF_USER_POOL_ID = "user_pool_id"
 CONF_ACCOUNT_LINK_SERVER = "account_link_server"
 CONF_ACCOUNTS_SERVER = "accounts_server"
 CONF_ACME_SERVER = "acme_server"
-CONF_API_SERVER = "api_server"
 CONF_RELAYER_SERVER = "relayer_server"
 CONF_REMOTESTATE_SERVER = "remotestate_server"
 CONF_SERVICEHANDLERS_SERVER = "servicehandlers_server"

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==1.5.1"],
+  "requirements": ["hass-nabucasa==1.4.0"],
   "single_config_entry": true
 }

homeassistant/components/conversation/default_agent.py

@@ -768,16 +768,7 @@ class DefaultAgent(ConversationEntity):
         if lang_intents.fuzzy_matcher is None:
             return None
 
-        context_area: str | None = None
-        satellite_area, _ = self._get_satellite_area_and_device(
-            user_input.satellite_id, user_input.device_id
-        )
-        if satellite_area:
-            context_area = satellite_area.name
-
-        fuzzy_result = lang_intents.fuzzy_matcher.match(
-            user_input.text, context_area=context_area
-        )
+        fuzzy_result = lang_intents.fuzzy_matcher.match(user_input.text)
         if fuzzy_result is None:
             return None
 
@@ -1249,15 +1240,12 @@ class DefaultAgent(ConversationEntity):
             intent_slot_list_names=self._fuzzy_config.slot_list_names,
             slot_combinations={
                 intent_name: {
-                    combo_key: SlotCombinationInfo(
-                        context_area=combo_info.context_area,
-                        name_domains=(
-                            set(combo_info.name_domains)
-                            if combo_info.name_domains
-                            else None
-                        ),
-                    )
-                    for combo_key, combo_info in intent_combos.items()
+                    combo_key: [
+                        SlotCombinationInfo(
+                            name_domains=(set(name_domains) if name_domains else None)
+                        )
+                    ]
+                    for combo_key, name_domains in intent_combos.items()
                 }
                 for intent_name, intent_combos in self._fuzzy_config.slot_combinations.items()
             },

homeassistant/components/conversation/manifest.json

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

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/cync/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "quality_scale": "bronze",
-  "requirements": ["pycync==0.4.3"]
+  "requirements": ["pycync==0.4.2"]
 }

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/denonavr/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/denonavr",
   "iot_class": "local_push",
   "loggers": ["denonavr"],
-  "requirements": ["denonavr==1.2.0"],
+  "requirements": ["denonavr==1.1.2"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/denonavr/media_player.py

@@ -274,7 +274,7 @@ class DenonDevice(MediaPlayerEntity):
             and MediaPlayerEntityFeature.SELECT_SOUND_MODE
         )
 
-    def _telnet_callback(self, zone: str, event: str, parameter: str) -> None:
+    async def _telnet_callback(self, zone: str, event: str, parameter: str) -> None:
         """Process a telnet command callback."""
         # There are multiple checks implemented which reduce unnecessary updates of the ha state machine
         if zone not in (self._receiver.zone, ALL_ZONES):

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

@@ -89,9 +89,6 @@
       }
     },
     "sensor": {
-      "auto_empty": {
-        "default": "mdi:delete-empty"
-      },
       "error": {
         "default": "mdi:alert-circle"
       },
@@ -163,9 +160,6 @@
       "advanced_mode": {
         "default": "mdi:tune"
       },
-      "border_spin": {
-        "default": "mdi:rotate-right"
-      },
       "border_switch": {
         "default": "mdi:land-fields"
       },

homeassistant/components/ecovacs/sensor.py

@@ -17,7 +17,6 @@ from deebot_client.events import (
     NetworkInfoEvent,
     StatsEvent,
     TotalStatsEvent,
-    auto_empty,
     station,
 )
 from sucks import VacBot
@@ -159,14 +158,6 @@ ENTITY_DESCRIPTIONS: tuple[EcovacsSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENUM,
         options=get_options(station.State),
     ),
-    EcovacsSensorEntityDescription[auto_empty.AutoEmptyEvent](
-        capability_fn=lambda caps: caps.station.auto_empty if caps.station else None,
-        value_fn=lambda e: get_name_key(e.frequency) if e.frequency else None,
-        key="auto_empty",
-        translation_key="auto_empty",
-        device_class=SensorDeviceClass.ENUM,
-        options=get_options(auto_empty.Frequency),
-    ),
 )
 
 

homeassistant/components/ecovacs/strings.json

@@ -149,13 +149,6 @@
       }
     },
     "sensor": {
-      "auto_empty": {
-        "name": "Auto-empty frequency",
-        "state": {
-          "auto": "Auto",
-          "smart": "Smart"
-        }
-      },
       "error": {
         "name": "Error",
         "state_attributes": {
@@ -238,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,14 +151,14 @@ ECOWITT_SENSORS_MAPPING: Final = {
         key="RAIN_COUNT_MM",
         native_unit_of_measurement=UnitOfPrecipitationDepth.MILLIMETERS,
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.TOTAL,
+        state_class=SensorStateClass.TOTAL_INCREASING,
         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,
+        state_class=SensorStateClass.TOTAL_INCREASING,
         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/eheimdigital/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["eheimdigital"],
   "quality_scale": "platinum",
-  "requirements": ["eheimdigital==1.4.0"],
+  "requirements": ["eheimdigital==1.3.0"],
   "zeroconf": [
     { "name": "eheimdigital._http._tcp.local.", "type": "_http._tcp.local." }
   ]

homeassistant/components/esphome/manifest.json

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

homeassistant/components/fastdotcom/coordinator.py

@@ -15,7 +15,7 @@ from .const import DEFAULT_INTERVAL, DOMAIN, LOGGER
 type FastdotcomConfigEntry = ConfigEntry[FastdotcomDataUpdateCoordinator]
 
 
-class FastdotcomDataUpdateCoordinator(DataUpdateCoordinator[dict[str, float] | None]):
+class FastdotcomDataUpdateCoordinator(DataUpdateCoordinator[float]):
     """Class to manage fetching Fast.com data API."""
 
     def __init__(self, hass: HomeAssistant, entry: FastdotcomConfigEntry) -> None:
@@ -28,7 +28,7 @@ class FastdotcomDataUpdateCoordinator(DataUpdateCoordinator[dict[str, float] | N
             update_interval=timedelta(hours=DEFAULT_INTERVAL),
         )
 
-    async def _async_update_data(self) -> dict[str, float] | None:
+    async def _async_update_data(self) -> float:
         """Run an executor job to retrieve Fast.com data."""
         try:
             return await self.hass.async_add_executor_job(fast_com)

homeassistant/components/fastdotcom/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["fastdotcom"],
-  "requirements": ["fastdotcom==0.0.6"],
+  "requirements": ["fastdotcom==0.0.3"],
   "single_config_entry": true
 }

homeassistant/components/fastdotcom/sensor.py

@@ -51,8 +51,6 @@ class SpeedtestSensor(CoordinatorEntity[FastdotcomDataUpdateCoordinator], Sensor
     @property
     def native_value(
         self,
-    ) -> float | None:
+    ) -> float:
         """Return the state of the sensor."""
-        if self.coordinator.data is None:
-            return None
-        return self.coordinator.data.get("download_speed")
+        return self.coordinator.data

homeassistant/components/firefly_iii/config_flow.py

@@ -40,9 +40,7 @@ async def _validate_input(hass: HomeAssistant, data: dict[str, Any]) -> bool:
         client = Firefly(
             api_url=data[CONF_URL],
             api_key=data[CONF_API_KEY],
-            session=async_get_clientsession(
-                hass=hass, verify_ssl=data[CONF_VERIFY_SSL]
-            ),
+            session=async_get_clientsession(hass),
         )
         await client.get_about()
     except FireflyAuthenticationError:

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

homeassistant/components/flick_electric/coordinator.py

@@ -0,0 +1,55 @@
+"""Data Coordinator for Flick Electric."""
+
+import asyncio
+from datetime import timedelta
+import logging
+
+import aiohttp
+from pyflick import FlickAPI, FlickPrice
+from pyflick.types import APIException, AuthException
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import CONF_SUPPLY_NODE_REF
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(minutes=5)
+
+type FlickConfigEntry = ConfigEntry[FlickElectricDataCoordinator]
+
+
+class FlickElectricDataCoordinator(DataUpdateCoordinator[FlickPrice]):
+    """Coordinator for flick power price."""
+
+    config_entry: FlickConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: FlickConfigEntry,
+        api: FlickAPI,
+    ) -> None:
+        """Initialize FlickElectricDataCoordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name="Flick Electric",
+            update_interval=SCAN_INTERVAL,
+        )
+        self.supply_node_ref = config_entry.data[CONF_SUPPLY_NODE_REF]
+        self._api = api
+
+    async def _async_update_data(self) -> FlickPrice:
+        """Fetch pricing data from Flick Electric."""
+        try:
+            async with asyncio.timeout(60):
+                return await self._api.getPricing(self.supply_node_ref)
+        except AuthException as err:
+            raise ConfigEntryAuthFailed from err
+        except (APIException, aiohttp.ClientResponseError) as err:
+            raise UpdateFailed from err

homeassistant/components/flick_electric/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "flick_electric",
+  "name": "Flick Electric",
+  "codeowners": ["@ZephireNZ"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/flick_electric",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "loggers": ["pyflick"],
+  "requirements": ["PyFlick==1.1.3"]
+}

homeassistant/components/flick_electric/sensor.py

@@ -0,0 +1,72 @@
+"""Support for Flick Electric Pricing data."""
+
+from datetime import timedelta
+from decimal import Decimal
+import logging
+from typing import Any
+
+from homeassistant.components.sensor import SensorEntity
+from homeassistant.const import CURRENCY_CENT, UnitOfEnergy
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import ATTR_COMPONENTS, ATTR_END_AT, ATTR_START_AT
+from .coordinator import FlickConfigEntry, FlickElectricDataCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+SCAN_INTERVAL = timedelta(minutes=5)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FlickConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Flick Sensor Setup."""
+    coordinator = entry.runtime_data
+
+    async_add_entities([FlickPricingSensor(coordinator)])
+
+
+class FlickPricingSensor(CoordinatorEntity[FlickElectricDataCoordinator], SensorEntity):
+    """Entity object for Flick Electric sensor."""
+
+    _attr_attribution = "Data provided by Flick Electric"
+    _attr_native_unit_of_measurement = f"{CURRENCY_CENT}/{UnitOfEnergy.KILO_WATT_HOUR}"
+    _attr_has_entity_name = True
+    _attr_translation_key = "power_price"
+
+    def __init__(self, coordinator: FlickElectricDataCoordinator) -> None:
+        """Entity object for Flick Electric sensor."""
+        super().__init__(coordinator)
+
+        self._attr_unique_id = f"{coordinator.supply_node_ref}_pricing"
+
+    @property
+    def native_value(self) -> Decimal:
+        """Return the state of the sensor."""
+        # The API should return a unit price with quantity of 1.0 when no start/end time is provided
+        if self.coordinator.data.quantity != 1:
+            _LOGGER.warning(
+                "Unexpected quantity for unit price: %s", self.coordinator.data
+            )
+        return self.coordinator.data.cost * 100
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return the state attributes."""
+        components: dict[str, float] = {}
+
+        for component in self.coordinator.data.components:
+            if component.charge_setter not in ATTR_COMPONENTS:
+                _LOGGER.warning("Found unknown component: %s", component.charge_setter)
+                continue
+
+            components[component.charge_setter] = float(component.value * 100)
+
+        return {
+            ATTR_START_AT: self.coordinator.data.start_at,
+            ATTR_END_AT: self.coordinator.data.end_at,
+            **components,
+        }

homeassistant/components/flick_electric/strings.json

@@ -0,0 +1,39 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "no_accounts": "No services are active on this Flick account",
+      "no_permissions": "Cannot get pricing for this account. Please check user permissions.",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "select_account": {
+        "data": {
+          "account_id": "Account"
+        },
+        "title": "Select account"
+      },
+      "user": {
+        "data": {
+          "client_id": "Client ID (optional)",
+          "client_secret": "Client Secret (optional)",
+          "password": "[%key:common::config_flow::data::password%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "title": "Flick Login Credentials"
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "power_price": {
+        "name": "Flick power price"
+      }
+    }
+  }
+}

homeassistant/components/fritzbox/binary_sensor.py

@@ -21,9 +21,6 @@ from .coordinator import FritzboxConfigEntry
 from .entity import FritzBoxDeviceEntity
 from .model import FritzEntityDescriptionMixinBase
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class FritzBinarySensorEntityDescription(

homeassistant/components/fritzbox/button.py

@@ -11,9 +11,6 @@ from .const import DOMAIN
 from .coordinator import FritzboxConfigEntry
 from .entity import FritzBoxEntity
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/fritzbox/climate.py

@@ -23,9 +23,6 @@ from .coordinator import FritzboxConfigEntry, FritzboxDataUpdateCoordinator
 from .entity import FritzBoxDeviceEntity
 from .sensor import value_scheduled_preset
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 HVAC_MODES = [HVACMode.HEAT, HVACMode.OFF]
 PRESET_HOLIDAY = "holiday"
 PRESET_SUMMER = "summer"

homeassistant/components/fritzbox/cover.py

@@ -16,9 +16,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import FritzboxConfigEntry
 from .entity import FritzBoxDeviceEntity
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/fritzbox/light.py

@@ -18,9 +18,6 @@ from .const import COLOR_MODE, LOGGER
 from .coordinator import FritzboxConfigEntry, FritzboxDataUpdateCoordinator
 from .entity import FritzBoxDeviceEntity
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/fritzbox/sensor.py

@@ -34,9 +34,6 @@ from .coordinator import FritzboxConfigEntry
 from .entity import FritzBoxDeviceEntity
 from .model import FritzEntityDescriptionMixinBase
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class FritzSensorEntityDescription(

homeassistant/components/fritzbox/switch.py

@@ -13,9 +13,6 @@ from .const import DOMAIN
 from .coordinator import FritzboxConfigEntry
 from .entity import FritzBoxDeviceEntity
 
-# Coordinator handles data updates, so we can allow unlimited parallel updates
-PARALLEL_UPDATES = 0
-
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251029.1"]
+  "requirements": ["home-assistant-frontend==20251001.4"]
 }

homeassistant/components/gstreamer/__init__.py

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

homeassistant/components/gstreamer/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "gstreamer",
+  "name": "GStreamer",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/gstreamer",
+  "iot_class": "local_push",
+  "loggers": ["gsp"],
+  "quality_scale": "legacy",
+  "requirements": ["gstreamer-player==1.1.2"]
+}

homeassistant/components/gstreamer/media_player.py

@@ -0,0 +1,195 @@
+"""Play media via gstreamer."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from gsp import STATE_IDLE, STATE_PAUSED, STATE_PLAYING, GstreamerPlayer
+import voluptuous as vol
+
+from homeassistant.components import media_source
+from homeassistant.components.media_player import (
+    PLATFORM_SCHEMA as MEDIA_PLAYER_PLATFORM_SCHEMA,
+    BrowseMedia,
+    MediaPlayerEntity,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
+    async_process_play_media_url,
+)
+from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, 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 DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_PIPELINE = "pipeline"
+
+
+PLATFORM_SCHEMA = MEDIA_PLAYER_PLATFORM_SCHEMA.extend(
+    {vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_PIPELINE): cv.string}
+)
+
+GSP_STATE_MAPPING = {
+    STATE_IDLE: MediaPlayerState.IDLE,
+    STATE_PAUSED: MediaPlayerState.PAUSED,
+    STATE_PLAYING: MediaPlayerState.PLAYING,
+}
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the Gstreamer 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": "GStreamer",
+        },
+    )
+
+    name = config.get(CONF_NAME)
+    pipeline = config.get(CONF_PIPELINE)
+    player = GstreamerPlayer(pipeline)
+
+    def _shutdown(call):
+        """Quit the player on shutdown."""
+        player.quit()
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
+    add_entities([GstreamerDevice(player, name)])
+
+
+class GstreamerDevice(MediaPlayerEntity):
+    """Representation of a Gstreamer device."""
+
+    _attr_media_content_type = MediaType.MUSIC
+    _attr_supported_features = (
+        MediaPlayerEntityFeature.VOLUME_SET
+        | MediaPlayerEntityFeature.PLAY
+        | MediaPlayerEntityFeature.PAUSE
+        | MediaPlayerEntityFeature.PLAY_MEDIA
+        | MediaPlayerEntityFeature.NEXT_TRACK
+        | MediaPlayerEntityFeature.BROWSE_MEDIA
+    )
+
+    def __init__(self, player: GstreamerPlayer, name: str | None) -> None:
+        """Initialize the Gstreamer device."""
+        self._player = player
+        self._name = name or DOMAIN
+        self._attr_state = MediaPlayerState.IDLE
+        self._volume = None
+        self._duration = None
+        self._uri = None
+        self._title = None
+        self._artist = None
+        self._album = None
+
+    def update(self) -> None:
+        """Update properties."""
+        self._attr_state = GSP_STATE_MAPPING.get(self._player.state)
+        self._volume = self._player.volume
+        self._duration = self._player.duration
+        self._uri = self._player.uri
+        self._title = self._player.title
+        self._album = self._player.album
+        self._artist = self._player.artist
+
+    def set_volume_level(self, volume: float) -> None:
+        """Set the volume level."""
+        self._player.volume = volume
+
+    async def async_play_media(
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
+    ) -> None:
+        """Play media."""
+        # Handle media_source
+        if media_source.is_media_source_id(media_id):
+            sourced_media = await media_source.async_resolve_media(
+                self.hass, media_id, self.entity_id
+            )
+            media_id = sourced_media.url
+
+        elif media_type != MediaType.MUSIC:
+            _LOGGER.error("Invalid media type")
+            return
+
+        media_id = async_process_play_media_url(self.hass, media_id)
+
+        await self.hass.async_add_executor_job(self._player.queue, media_id)
+
+    def media_play(self) -> None:
+        """Play."""
+        self._player.play()
+
+    def media_pause(self) -> None:
+        """Pause."""
+        self._player.pause()
+
+    def media_next_track(self) -> None:
+        """Next track."""
+        self._player.next()
+
+    @property
+    def media_content_id(self):
+        """Content ID of currently playing media."""
+        return self._uri
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def volume_level(self):
+        """Return the volume level."""
+        return self._volume
+
+    @property
+    def media_duration(self):
+        """Duration of current playing media in seconds."""
+        return self._duration
+
+    @property
+    def media_title(self):
+        """Media title."""
+        return self._title
+
+    @property
+    def media_artist(self):
+        """Media artist."""
+        return self._artist
+
+    @property
+    def media_album_name(self):
+        """Media album."""
+        return self._album
+
+    async def async_browse_media(
+        self,
+        media_content_type: MediaType | str | None = None,
+        media_content_id: str | None = None,
+    ) -> BrowseMedia:
+        """Implement the websocket media browsing helper."""
+        return await media_source.async_browse_media(
+            self.hass,
+            media_content_id,
+            content_filter=lambda item: item.media_content_type.startswith("audio/"),
+        )

homeassistant/components/hassio/__init__.py

@@ -13,7 +13,6 @@ import struct
 from typing import Any, NamedTuple
 
 from aiohasupervisor import SupervisorError
-from aiohasupervisor.models import GreenOptions, YellowOptions  # noqa: F401
 import voluptuous as vol
 
 from homeassistant.auth.const import GROUP_ID_ADMIN
@@ -124,6 +123,11 @@ from .discovery import async_setup_discovery_view
 from .handler import (  # noqa: F401
     HassIO,
     HassioAPIError,
+    async_create_backup,
+    async_get_green_settings,
+    async_get_yellow_settings,
+    async_set_green_settings,
+    async_set_yellow_settings,
     async_update_diagnostics,
     get_supervisor_client,
 )
@@ -620,11 +624,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
-    # Unload coordinator
-    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
-    coordinator.unload()
-
-    # Pop coordinator
+    # Pop add-on data
     hass.data.pop(ADDONS_COORDINATOR, None)
 
     return unload_ok

homeassistant/components/hassio/addon_manager.py

@@ -15,14 +15,13 @@ from aiohasupervisor.models import (
     AddonsOptions,
     AddonState as SupervisorAddonState,
     InstalledAddonComplete,
-    PartialBackupOptions,
     StoreAddonUpdate,
 )
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 
-from .handler import HassioAPIError, get_supervisor_client
+from .handler import HassioAPIError, async_create_backup, get_supervisor_client
 
 type _FuncType[_T, **_P, _R] = Callable[Concatenate[_T, _P], Awaitable[_R]]
 type _ReturnFuncType[_T, **_P, _R] = Callable[
@@ -262,18 +261,17 @@ class AddonManager:
         """Stop the managed add-on."""
         await self._supervisor_client.addons.stop_addon(self.addon_slug)
 
-    @api_error(
-        "Failed to create a backup of the {addon_name} add-on",
-        expected_error_type=SupervisorError,
-    )
+    @api_error("Failed to create a backup of the {addon_name} add-on")
     async def async_create_backup(self) -> None:
         """Create a partial backup of the managed add-on."""
         addon_info = await self.async_get_addon_info()
         name = f"addon_{self.addon_slug}_{addon_info.version}"
 
         self._logger.debug("Creating backup: %s", name)
-        await self._supervisor_client.backups.partial_backup(
-            PartialBackupOptions(name=name, addons={self.addon_slug})
+        await async_create_backup(
+            self._hass,
+            {"name": name, "addons": [self.addon_slug]},
+            partial=True,
         )
 
     async def async_configure_addon(

homeassistant/components/hassio/coordinator.py

@@ -563,8 +563,3 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
                     self.async_set_updated_data(data)
         except SupervisorError as err:
             _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
-
-    @callback
-    def unload(self) -> None:
-        """Clean up when config entry unloaded."""
-        self.jobs.unload()