Automatically update the entity propery when a member created, updated or deleted

.core_files.yaml

@@ -58,7 +58,6 @@ base_platforms: &base_platforms
 # Extra components that trigger the full suite
 components: &components
   - homeassistant/components/alexa/**
-  - homeassistant/components/analytics/**
   - homeassistant/components/application_credentials/**
   - homeassistant/components/assist_pipeline/**
   - homeassistant/components/auth/**

.github/workflows/builder.yml

@@ -198,7 +198,7 @@ jobs:
 
       # home-assistant/builder doesn't support sha pinning
       - name: Build base image
-        uses: home-assistant/builder@2025.09.0
+        uses: home-assistant/builder@2025.03.0
         with:
           args: |
             $BUILD_ARGS \
@@ -265,7 +265,7 @@ jobs:
 
       # home-assistant/builder doesn't support sha pinning
       - name: Build base image
-        uses: home-assistant/builder@2025.09.0
+        uses: home-assistant/builder@2025.03.0
         with:
           args: |
             $BUILD_ARGS \

.github/workflows/ci.yaml

@@ -523,24 +523,22 @@ jobs:
             ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-uv-${{
             env.UV_CACHE_VERSION }}-${{ steps.generate-uv-key.outputs.version }}-${{
             env.HA_SHORT_VERSION }}-
-      - name: Check if apt cache exists
+      - name: Restore apt cache
-        id: cache-apt-check
+        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
+        id: cache-apt
+        uses: actions/cache@v4.2.4
         with:
-          lookup-only: ${{ steps.cache-venv.outputs.cache-hit == 'true' }}
           path: |
             ${{ env.APT_CACHE_DIR }}
             ${{ env.APT_LIST_CACHE_DIR }}
           key: >-
             ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
       - name: Install additional OS dependencies
-        if: |
+        if: steps.cache-venv.outputs.cache-hit != 'true'
-          steps.cache-venv.outputs.cache-hit != 'true'
-          || steps.cache-apt-check.outputs.cache-hit != 'true'
         timeout-minutes: 10
         run: |
           sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          if [[ "${{ steps.cache-apt-check.outputs.cache-hit }}" != 'true' ]]; then
+          if [[ "${{ steps.cache-apt.outputs.cache-hit }}" != 'true' ]]; then
             mkdir -p ${{ env.APT_CACHE_DIR }}
             mkdir -p ${{ env.APT_LIST_CACHE_DIR }}
           fi
@@ -565,18 +563,9 @@ jobs:
             libswscale-dev \
             libudev-dev
 
-          if [[ "${{ steps.cache-apt-check.outputs.cache-hit }}" != 'true' ]]; then
+          if [[ "${{ steps.cache-apt.outputs.cache-hit }}" != 'true' ]]; then
             sudo chmod -R 755 ${{ env.APT_CACHE_BASE }}
           fi
-      - name: Save apt cache
-        if: steps.cache-apt-check.outputs.cache-hit != 'true'
-        uses: actions/cache/save@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         run: |

.github/workflows/wheels.yml

@@ -160,7 +160,7 @@ jobs:
 
       # home-assistant/wheels doesn't support sha pinning
       - name: Build wheels
-        uses: home-assistant/wheels@2025.09.1
+        uses: home-assistant/wheels@2025.07.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
@@ -221,7 +221,7 @@ jobs:
 
       # home-assistant/wheels doesn't support sha pinning
       - name: Build wheels
-        uses: home-assistant/wheels@2025.09.1
+        uses: home-assistant/wheels@2025.07.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2

.strict-typing

@@ -142,7 +142,6 @@ homeassistant.components.cloud.*
 homeassistant.components.co2signal.*
 homeassistant.components.comelit.*
 homeassistant.components.command_line.*
-homeassistant.components.compit.*
 homeassistant.components.config.*
 homeassistant.components.configurator.*
 homeassistant.components.cookidoo.*
@@ -443,7 +442,6 @@ homeassistant.components.rituals_perfume_genie.*
 homeassistant.components.roborock.*
 homeassistant.components.roku.*
 homeassistant.components.romy.*
-homeassistant.components.route_b_smart_meter.*
 homeassistant.components.rpi_power.*
 homeassistant.components.rss_feed_template.*
 homeassistant.components.russound_rio.*

CODEOWNERS

@@ -107,8 +107,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/ambient_station/ @bachya
 /tests/components/ambient_station/ @bachya
 /homeassistant/components/amcrest/ @flacjacket
-/homeassistant/components/analytics/ @home-assistant/core
+/homeassistant/components/analytics/ @home-assistant/core @ludeeus
-/tests/components/analytics/ @home-assistant/core
+/tests/components/analytics/ @home-assistant/core @ludeeus
 /homeassistant/components/analytics_insights/ @joostlek
 /tests/components/analytics_insights/ @joostlek
 /homeassistant/components/android_ip_webcam/ @engrbm87
@@ -292,8 +292,6 @@ build.json @home-assistant/supervisor
 /tests/components/command_line/ @gjohansson-ST
 /homeassistant/components/compensation/ @Petro31
 /tests/components/compensation/ @Petro31
-/homeassistant/components/compit/ @Przemko92
-/tests/components/compit/ @Przemko92
 /homeassistant/components/config/ @home-assistant/core
 /tests/components/config/ @home-assistant/core
 /homeassistant/components/configurator/ @home-assistant/core
@@ -316,8 +314,6 @@ build.json @home-assistant/supervisor
 /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
 /tests/components/daikin/ @fredrike
 /homeassistant/components/date/ @home-assistant/core
@@ -412,8 +408,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/egardia/ @jeroenterheerdt
 /homeassistant/components/eheimdigital/ @autinerd
 /tests/components/eheimdigital/ @autinerd
-/homeassistant/components/ekeybionyx/ @richardpolzer
-/tests/components/ekeybionyx/ @richardpolzer
 /homeassistant/components/electrasmart/ @jafar-atili
 /tests/components/electrasmart/ @jafar-atili
 /homeassistant/components/electric_kiwi/ @mikey0000
@@ -776,8 +770,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/iqvia/ @bachya
 /tests/components/iqvia/ @bachya
 /homeassistant/components/irish_rail_transport/ @ttroy50
-/homeassistant/components/irm_kmi/ @jdejaegh
-/tests/components/irm_kmi/ @jdejaegh
 /homeassistant/components/iron_os/ @tr4nt0r
 /tests/components/iron_os/ @tr4nt0r
 /homeassistant/components/isal/ @bdraco
@@ -976,6 +968,8 @@ build.json @home-assistant/supervisor
 /tests/components/moat/ @bdraco
 /homeassistant/components/mobile_app/ @home-assistant/core
 /tests/components/mobile_app/ @home-assistant/core
+/homeassistant/components/modbus/ @janiversen
+/tests/components/modbus/ @janiversen
 /homeassistant/components/modem_callerid/ @tkdrob
 /tests/components/modem_callerid/ @tkdrob
 /homeassistant/components/modern_forms/ @wonderslug
@@ -1334,8 +1328,6 @@ build.json @home-assistant/supervisor
 /tests/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
 /homeassistant/components/roon/ @pavoni
 /tests/components/roon/ @pavoni
-/homeassistant/components/route_b_smart_meter/ @SeraphicRav
-/tests/components/route_b_smart_meter/ @SeraphicRav
 /homeassistant/components/rpi_power/ @shenxn @swetoast
 /tests/components/rpi_power/ @shenxn @swetoast
 /homeassistant/components/rss_feed_template/ @home-assistant/core
@@ -1358,8 +1350,6 @@ build.json @home-assistant/supervisor
 /tests/components/samsungtv/ @chemelli74 @epenet
 /homeassistant/components/sanix/ @tomaszsluszniak
 /tests/components/sanix/ @tomaszsluszniak
-/homeassistant/components/satel_integra/ @Tommatheussen
-/tests/components/satel_integra/ @Tommatheussen
 /homeassistant/components/scene/ @home-assistant/core
 /tests/components/scene/ @home-assistant/core
 /homeassistant/components/schedule/ @home-assistant/core
@@ -1541,8 +1531,8 @@ build.json @home-assistant/supervisor
 /tests/components/switchbee/ @jafar-atili
 /homeassistant/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
 /tests/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
-/homeassistant/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur @XiaoLing-git
+/homeassistant/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
-/tests/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur @XiaoLing-git
+/tests/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
 /homeassistant/components/switcher_kis/ @thecode @YogevBokobza
 /tests/components/switcher_kis/ @thecode @YogevBokobza
 /homeassistant/components/switchmate/ @danielhiversen @qiz-li
@@ -1687,8 +1677,6 @@ build.json @home-assistant/supervisor
 /tests/components/uptime_kuma/ @tr4nt0r
 /homeassistant/components/uptimerobot/ @ludeeus @chemelli74
 /tests/components/uptimerobot/ @ludeeus @chemelli74
-/homeassistant/components/usage_prediction/ @home-assistant/core
-/tests/components/usage_prediction/ @home-assistant/core
 /homeassistant/components/usb/ @bdraco
 /tests/components/usb/ @bdraco
 /homeassistant/components/usgs_earthquakes_feed/ @exxamalte
@@ -1718,8 +1706,6 @@ build.json @home-assistant/supervisor
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /homeassistant/components/vicare/ @CFenner
 /tests/components/vicare/ @CFenner
-/homeassistant/components/victron_remote_monitoring/ @AndyTempel
-/tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
 /tests/components/vilfo/ @ManneW
 /homeassistant/components/vivotek/ @HarlemSquirrel
@@ -1735,8 +1721,8 @@ build.json @home-assistant/supervisor
 /tests/components/volumio/ @OnFreund
 /homeassistant/components/volvo/ @thomasddn
 /tests/components/volvo/ @thomasddn
-/homeassistant/components/volvooncall/ @molobrakos @svrooij
+/homeassistant/components/volvooncall/ @molobrakos
-/tests/components/volvooncall/ @molobrakos @svrooij
+/tests/components/volvooncall/ @molobrakos
 /homeassistant/components/wake_on_lan/ @ntilley905
 /tests/components/wake_on_lan/ @ntilley905
 /homeassistant/components/wake_word/ @home-assistant/core @synesthesiam

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.09.3
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.09.1
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.09.3
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.09.1
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.09.3
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.09.1
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.09.3
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.09.1
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.09.3
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.09.1
 codenotary:
   signer: notary@home-assistant.io
   base_image: notary@home-assistant.io

homeassistant/components/acaia/coordinator.py

@@ -8,7 +8,6 @@ import logging
 from aioacaia.acaiascale import AcaiaScale
 from aioacaia.exceptions import AcaiaDeviceNotFound, AcaiaError
 
-from homeassistant.components.bluetooth import async_get_scanner
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.core import HomeAssistant
@@ -43,7 +42,6 @@ class AcaiaCoordinator(DataUpdateCoordinator[None]):
             name=entry.title,
             is_new_style_scale=entry.data[CONF_IS_NEW_STYLE_SCALE],
             notify_callback=self.async_update_listeners,
-            scanner=async_get_scanner(hass),
         )
 
     @property

homeassistant/components/acaia/manifest.json

@@ -26,5 +26,5 @@
   "iot_class": "local_push",
   "loggers": ["aioacaia"],
   "quality_scale": "platinum",
-  "requirements": ["aioacaia==0.1.17"]
+  "requirements": ["aioacaia==0.1.14"]
 }

homeassistant/components/accuweather/config_flow.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from asyncio import timeout
-from collections.abc import Mapping
 from typing import Any
 
 from accuweather import AccuWeather, ApiError, InvalidApiKeyError, RequestsExceededError
@@ -23,8 +22,6 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
     """Config flow for AccuWeather."""
 
     VERSION = 1
-    _latitude: float | None = None
-    _longitude: float | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -77,46 +74,3 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
             ),
             errors=errors,
         )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle configuration by re-auth."""
-        self._latitude = entry_data[CONF_LATITUDE]
-        self._longitude = entry_data[CONF_LONGITUDE]
-
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Dialog that informs the user that reauth is required."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            websession = async_get_clientsession(self.hass)
-            try:
-                async with timeout(10):
-                    accuweather = AccuWeather(
-                        user_input[CONF_API_KEY],
-                        websession,
-                        latitude=self._latitude,
-                        longitude=self._longitude,
-                    )
-                    await accuweather.async_get_location()
-            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
-                errors["base"] = "cannot_connect"
-            except InvalidApiKeyError:
-                errors["base"] = "invalid_api_key"
-            except RequestsExceededError:
-                errors["base"] = "requests_exceeded"
-            else:
-                return self.async_update_reload_and_abort(
-                    self._get_reauth_entry(), data_updates=user_input
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
-            errors=errors,
-        )

homeassistant/components/accuweather/coordinator.py

@@ -15,7 +15,6 @@ from aiohttp.client_exceptions import ClientConnectorError
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.update_coordinator import (
     DataUpdateCoordinator,
@@ -31,7 +30,7 @@ from .const import (
     UPDATE_INTERVAL_OBSERVATION,
 )
 
-EXCEPTIONS = (ApiError, ClientConnectorError, RequestsExceededError)
+EXCEPTIONS = (ApiError, ClientConnectorError, InvalidApiKeyError, RequestsExceededError)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -53,8 +52,6 @@ class AccuWeatherObservationDataUpdateCoordinator(
 ):
     """Class to manage fetching AccuWeather data API."""
 
-    config_entry: AccuWeatherConfigEntry
-
     def __init__(
         self,
         hass: HomeAssistant,
@@ -90,12 +87,6 @@ class AccuWeatherObservationDataUpdateCoordinator(
                 translation_key="current_conditions_update_error",
                 translation_placeholders={"error": repr(error)},
             ) from error
-        except InvalidApiKeyError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-                translation_placeholders={"entry": self.config_entry.title},
-            ) from err
 
         _LOGGER.debug("Requests remaining: %d", self.accuweather.requests_remaining)
 
@@ -107,8 +98,6 @@ class AccuWeatherForecastDataUpdateCoordinator(
 ):
     """Base class for AccuWeather forecast."""
 
-    config_entry: AccuWeatherConfigEntry
-
     def __init__(
         self,
         hass: HomeAssistant,
@@ -148,12 +137,6 @@ class AccuWeatherForecastDataUpdateCoordinator(
                 translation_key="forecast_update_error",
                 translation_placeholders={"error": repr(error)},
             ) from error
-        except InvalidApiKeyError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-                translation_placeholders={"entry": self.config_entry.title},
-            ) from err
 
         _LOGGER.debug("Requests remaining: %d", self.accuweather.requests_remaining)
         return result

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==4.2.2"]
+  "requirements": ["accuweather==4.2.1"]
 }

homeassistant/components/accuweather/strings.json

@@ -7,17 +7,6 @@
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "latitude": "[%key:common::config_flow::data::latitude%]",
           "longitude": "[%key:common::config_flow::data::longitude%]"
-        },
-        "data_description": {
-          "api_key": "API key generated in the AccuWeather APIs portal."
-        }
-      },
-      "reauth_confirm": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "[%key:component::accuweather::config::step::user::data_description::api_key%]"
         }
       }
     },
@@ -30,8 +19,7 @@
       "requests_exceeded": "The allowed number of requests to the AccuWeather API has been exceeded. You have to wait or change the API key."
     },
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_location%]",
+      "already_configured": "[%key:common::config_flow::abort::already_configured_location%]"
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
   },
   "entity": {
@@ -251,9 +239,6 @@
     }
   },
   "exceptions": {
-    "auth_error": {
-      "message": "Authentication failed for {entry}, please update your API key"
-    },
     "current_conditions_update_error": {
       "message": "An error occurred while retrieving weather current conditions data from the AccuWeather API: {error}"
     },

homeassistant/components/ai_task/media_source.py

@@ -2,31 +2,21 @@
 
 from __future__ import annotations
 
-from pathlib import Path
-
 from homeassistant.components.media_source import MediaSource, local_source
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 
 from .const import DATA_MEDIA_SOURCE, DOMAIN, IMAGE_DIR
 
 
 async def async_get_media_source(hass: HomeAssistant) -> MediaSource:
     """Set up local media source."""
-    media_dirs = list(hass.config.media_dirs.values())
+    media_dir = hass.config.path(f"{DOMAIN}/{IMAGE_DIR}")
-
-    if not media_dirs:
-        raise HomeAssistantError(
-            "AI Task media source requires at least one media directory configured"
-        )
-
-    media_dir = Path(media_dirs[0]) / DOMAIN / IMAGE_DIR
 
     hass.data[DATA_MEDIA_SOURCE] = source = local_source.LocalSource(
         hass,
         DOMAIN,
         "AI Generated Images",
-        {IMAGE_DIR: str(media_dir)},
+        {IMAGE_DIR: media_dir},
         f"/{DOMAIN}",
     )
     return source

homeassistant/components/ai_task/task.py

@@ -12,7 +12,7 @@ from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.components import camera, conversation, image, media_source
+from homeassistant.components import camera, conversation, media_source
 from homeassistant.components.http.auth import async_sign_path
 from homeassistant.core import HomeAssistant, ServiceResponse, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -31,14 +31,14 @@ from .const import (
 )
 
 
-def _save_camera_snapshot(image_data: camera.Image | image.Image) -> Path:
+def _save_camera_snapshot(image: camera.Image) -> Path:
     """Save camera snapshot to temp file."""
     with tempfile.NamedTemporaryFile(
         mode="wb",
-        suffix=mimetypes.guess_extension(image_data.content_type, False),
+        suffix=mimetypes.guess_extension(image.content_type, False),
         delete=False,
     ) as temp_file:
-        temp_file.write(image_data.content)
+        temp_file.write(image.content)
         return Path(temp_file.name)
 
 
@@ -54,31 +54,26 @@ async def _resolve_attachments(
     for attachment in attachments or []:
         media_content_id = attachment["media_content_id"]
 
-        # Special case for certain media sources
+        # Special case for camera media sources
-        for integration in camera, image:
+        if media_content_id.startswith("media-source://camera/"):
-            media_source_prefix = f"media-source://{integration.DOMAIN}/"
-            if not media_content_id.startswith(media_source_prefix):
-                continue
-
             # Extract entity_id from the media content ID
-            entity_id = media_content_id.removeprefix(media_source_prefix)
+            entity_id = media_content_id.removeprefix("media-source://camera/")
 
-            # Get snapshot from entity
+            # Get snapshot from camera
-            image_data = await integration.async_get_image(hass, entity_id)
+            image = await camera.async_get_image(hass, entity_id)
 
             temp_filename = await hass.async_add_executor_job(
-                _save_camera_snapshot, image_data
+                _save_camera_snapshot, image
             )
             created_files.append(temp_filename)
 
             resolved_attachments.append(
                 conversation.Attachment(
                     media_content_id=media_content_id,
-                    mime_type=image_data.content_type,
+                    mime_type=image.content_type,
                     path=temp_filename,
                 )
             )
-            break
         else:
             # Handle regular media sources
             media = await media_source.async_resolve_media(hass, media_content_id, None)

homeassistant/components/airos/__init__.py

@@ -4,18 +4,10 @@ from __future__ import annotations
 
 from airos.airos8 import AirOS8
 
-from homeassistant.const import (
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, Platform
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-    Platform,
-)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, SECTION_ADVANCED_SETTINGS
 from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
@@ -29,16 +21,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 
     # By default airOS 8 comes with self-signed SSL certificates,
     # with no option in the web UI to change or upload a custom certificate.
-    session = async_get_clientsession(
+    session = async_get_clientsession(hass, verify_ssl=False)
-        hass, verify_ssl=entry.data[SECTION_ADVANCED_SETTINGS][CONF_VERIFY_SSL]
-    )
 
     airos_device = AirOS8(
         host=entry.data[CONF_HOST],
         username=entry.data[CONF_USERNAME],
         password=entry.data[CONF_PASSWORD],
         session=session,
-        use_ssl=entry.data[SECTION_ADVANCED_SETTINGS][CONF_SSL],
     )
 
     coordinator = AirOSDataUpdateCoordinator(hass, entry, airos_device)
@@ -51,30 +40,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
     return True
 
 
-async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
-    """Migrate old config entry."""
-
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
-    if entry.version == 1 and entry.minor_version == 1:
-        new_data = {**entry.data}
-        advanced_data = {
-            CONF_SSL: DEFAULT_SSL,
-            CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-        }
-        new_data[SECTION_ADVANCED_SETTINGS] = advanced_data
-
-        hass.config_entries.async_update_entry(
-            entry,
-            data=new_data,
-            minor_version=2,
-        )
-
-    return True
-
-
 async def async_unload_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/airos/config_flow.py

@@ -15,17 +15,10 @@ from airos.exceptions import (
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import (
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.data_entry_flow import section
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
+from .const import DOMAIN
 from .coordinator import AirOS8
 
 _LOGGER = logging.getLogger(__name__)
@@ -35,15 +28,6 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_HOST): str,
         vol.Required(CONF_USERNAME, default="ubnt"): str,
         vol.Required(CONF_PASSWORD): str,
-        vol.Required(SECTION_ADVANCED_SETTINGS): section(
-            vol.Schema(
-                {
-                    vol.Required(CONF_SSL, default=DEFAULT_SSL): bool,
-                    vol.Required(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): bool,
-                }
-            ),
-            {"collapsed": True},
-        ),
     }
 )
 
@@ -52,7 +36,6 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ubiquiti airOS."""
 
     VERSION = 1
-    MINOR_VERSION = 2
 
     async def async_step_user(
         self,
@@ -63,17 +46,13 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             # By default airOS 8 comes with self-signed SSL certificates,
             # with no option in the web UI to change or upload a custom certificate.
-            session = async_get_clientsession(
+            session = async_get_clientsession(self.hass, verify_ssl=False)
-                self.hass,
-                verify_ssl=user_input[SECTION_ADVANCED_SETTINGS][CONF_VERIFY_SSL],
-            )
 
             airos_device = AirOS8(
                 host=user_input[CONF_HOST],
                 username=user_input[CONF_USERNAME],
                 password=user_input[CONF_PASSWORD],
                 session=session,
-                use_ssl=user_input[SECTION_ADVANCED_SETTINGS][CONF_SSL],
             )
             try:
                 await airos_device.login()

homeassistant/components/airos/const.py

@@ -7,8 +7,3 @@ DOMAIN = "airos"
 SCAN_INTERVAL = timedelta(minutes=1)
 
 MANUFACTURER = "Ubiquiti"
-
-DEFAULT_VERIFY_SSL = False
-DEFAULT_SSL = True
-
-SECTION_ADVANCED_SETTINGS = "advanced_settings"

homeassistant/components/airos/entity.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from homeassistant.const import CONF_HOST, CONF_SSL
+from homeassistant.const import CONF_HOST
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, MANUFACTURER, SECTION_ADVANCED_SETTINGS
+from .const import DOMAIN, MANUFACTURER
 from .coordinator import AirOSDataUpdateCoordinator
 
 
@@ -20,14 +20,9 @@ class AirOSEntity(CoordinatorEntity[AirOSDataUpdateCoordinator]):
         super().__init__(coordinator)
 
         airos_data = self.coordinator.data
-        url_schema = (
-            "https"
-            if coordinator.config_entry.data[SECTION_ADVANCED_SETTINGS][CONF_SSL]
-            else "http"
-        )
 
         configuration_url: str | None = (
-            f"{url_schema}://{coordinator.config_entry.data[CONF_HOST]}"
+            f"https://{coordinator.config_entry.data[CONF_HOST]}"
         )
 
         self._attr_device_info = DeviceInfo(

homeassistant/components/airos/strings.json

@@ -12,18 +12,6 @@
           "host": "IP address or hostname of the airOS device",
           "username": "Administrator username for the airOS device, normally 'ubnt'",
           "password": "Password configured through the UISP app or web interface"
-        },
-        "sections": {
-          "advanced_settings": {
-            "data": {
-              "ssl": "Use HTTPS",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "ssl": "Whether the connection should be encrypted (required for most devices)",
-              "verify_ssl": "Whether the certificate should be verified when using HTTPS. This should be off for self-signed certificates"
-            }
-          }
         }
       }
     },

homeassistant/components/airzone/select.py

@@ -6,19 +6,17 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Final
 
-from aioairzone.common import GrilleAngle, OperationMode, QAdapt, SleepTimeout
+from aioairzone.common import GrilleAngle, OperationMode, SleepTimeout
 from aioairzone.const import (
     API_COLD_ANGLE,
     API_HEAT_ANGLE,
     API_MODE,
-    API_Q_ADAPT,
     API_SLEEP,
     AZD_COLD_ANGLE,
     AZD_HEAT_ANGLE,
     AZD_MASTER,
     AZD_MODE,
     AZD_MODES,
-    AZD_Q_ADAPT,
     AZD_SLEEP,
     AZD_ZONES,
 )
@@ -67,14 +65,6 @@ SLEEP_DICT: Final[dict[str, int]] = {
     "90m": SleepTimeout.SLEEP_90,
 }
 
-Q_ADAPT_DICT: Final[dict[str, int]] = {
-    "standard": QAdapt.STANDARD,
-    "power": QAdapt.POWER,
-    "silence": QAdapt.SILENCE,
-    "minimum": QAdapt.MINIMUM,
-    "maximum": QAdapt.MAXIMUM,
-}
-
 
 def main_zone_options(
     zone_data: dict[str, Any],
@@ -93,14 +83,6 @@ MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
         options_fn=main_zone_options,
         translation_key="modes",
     ),
-    AirzoneSelectDescription(
-        api_param=API_Q_ADAPT,
-        entity_category=EntityCategory.CONFIG,
-        key=AZD_Q_ADAPT,
-        options=list(Q_ADAPT_DICT),
-        options_dict=Q_ADAPT_DICT,
-        translation_key="q_adapt",
-    ),
 )
 
 

homeassistant/components/airzone/strings.json

@@ -63,16 +63,6 @@
           "stop": "Stop"
         }
       },
-      "q_adapt": {
-        "name": "Q-Adapt",
-        "state": {
-          "standard": "Standard",
-          "power": "Power",
-          "silence": "Silence",
-          "minimum": "Minimum",
-          "maximum": "Maximum"
-        }
-      },
       "sleep_times": {
         "name": "Sleep",
         "state": {

homeassistant/components/alexa_devices/binary_sensor.py

@@ -10,7 +10,6 @@ from aioamazondevices.api import AmazonDevice
 from aioamazondevices.const import SENSOR_STATE_OFF
 
 from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
     BinarySensorDeviceClass,
     BinarySensorEntity,
     BinarySensorEntityDescription,
@@ -21,7 +20,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import async_update_unique_id
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -33,7 +31,6 @@ class AmazonBinarySensorEntityDescription(BinarySensorEntityDescription):
 
     is_on_fn: Callable[[AmazonDevice, str], bool]
     is_supported: Callable[[AmazonDevice, str], bool] = lambda device, key: True
-    is_available_fn: Callable[[AmazonDevice, str], bool] = lambda device, key: True
 
 
 BINARY_SENSORS: Final = (
@@ -44,15 +41,46 @@ BINARY_SENSORS: Final = (
         is_on_fn=lambda device, _: device.online,
     ),
     AmazonBinarySensorEntityDescription(
-        key="detectionState",
+        key="bluetooth",
-        device_class=BinarySensorDeviceClass.MOTION,
+        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda device, key: bool(
+        translation_key="bluetooth",
-            device.sensors[key].value != SENSOR_STATE_OFF
+        is_on_fn=lambda device, _: device.bluetooth_state,
-        ),
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="babyCryDetectionState",
+        translation_key="baby_cry_detection",
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
+        is_supported=lambda device, key: device.sensors.get(key) is not None,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="beepingApplianceDetectionState",
+        translation_key="beeping_appliance_detection",
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
+        is_supported=lambda device, key: device.sensors.get(key) is not None,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="coughDetectionState",
+        translation_key="cough_detection",
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
+        is_supported=lambda device, key: device.sensors.get(key) is not None,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="dogBarkDetectionState",
+        translation_key="dog_bark_detection",
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
+        is_supported=lambda device, key: device.sensors.get(key) is not None,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="humanPresenceDetectionState",
+        device_class=BinarySensorDeviceClass.MOTION,
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
+        is_supported=lambda device, key: device.sensors.get(key) is not None,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="waterSoundsDetectionState",
+        translation_key="water_sounds_detection",
+        is_on_fn=lambda device, key: (device.sensors[key].value != SENSOR_STATE_OFF),
         is_supported=lambda device, key: device.sensors.get(key) is not None,
-        is_available_fn=lambda device, key: (
-            device.online and device.sensors[key].error is False
-        ),
     ),
 )
 
@@ -66,34 +94,13 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Replace unique id for "detectionState" binary sensor
+    async_add_entities(
-    await async_update_unique_id(
+        AmazonBinarySensorEntity(coordinator, serial_num, sensor_desc)
-        hass,
+        for sensor_desc in BINARY_SENSORS
-        coordinator,
+        for serial_num in coordinator.data
-        BINARY_SENSOR_DOMAIN,
+        if sensor_desc.is_supported(coordinator.data[serial_num], sensor_desc.key)
-        "humanPresenceDetectionState",
-        "detectionState",
     )
 
-    known_devices: set[str] = set()
-
-    def _check_device() -> None:
-        current_devices = set(coordinator.data)
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                AmazonBinarySensorEntity(coordinator, serial_num, sensor_desc)
-                for sensor_desc in BINARY_SENSORS
-                for serial_num in new_devices
-                if sensor_desc.is_supported(
-                    coordinator.data[serial_num], sensor_desc.key
-                )
-            )
-
-    _check_device()
-    entry.async_on_unload(coordinator.async_add_listener(_check_device))
-
 
 class AmazonBinarySensorEntity(AmazonEntity, BinarySensorEntity):
     """Binary sensor device."""
@@ -106,13 +113,3 @@ class AmazonBinarySensorEntity(AmazonEntity, BinarySensorEntity):
         return self.entity_description.is_on_fn(
             self.device, self.entity_description.key
         )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            self.entity_description.is_available_fn(
-                self.device, self.entity_description.key
-            )
-            and super().available
-        )

homeassistant/components/alexa_devices/config_flow.py

@@ -64,7 +64,7 @@ class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
                 data = await validate_input(self.hass, user_input)
             except CannotConnect:
                 errors["base"] = "cannot_connect"
-            except CannotAuthenticate:
+            except (CannotAuthenticate, TypeError):
                 errors["base"] = "invalid_auth"
             except CannotRetrieveData:
                 errors["base"] = "cannot_retrieve_data"
@@ -112,7 +112,7 @@ class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
                 )
             except CannotConnect:
                 errors["base"] = "cannot_connect"
-            except CannotAuthenticate:
+            except (CannotAuthenticate, TypeError):
                 errors["base"] = "invalid_auth"
             except CannotRetrieveData:
                 errors["base"] = "cannot_retrieve_data"

homeassistant/components/alexa_devices/coordinator.py

@@ -68,7 +68,7 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
                 translation_key="cannot_retrieve_data_with_error",
                 translation_placeholders={"error": repr(err)},
             ) from err
-        except CannotAuthenticate as err:
+        except (CannotAuthenticate, TypeError) as err:
             raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,
                 translation_key="invalid_auth",

homeassistant/components/alexa_devices/diagnostics.py

@@ -60,5 +60,7 @@ def build_device_data(device: AmazonDevice) -> dict[str, Any]:
         "online": device.online,
         "serial number": device.serial_number,
         "software version": device.software_version,
-        "sensors": device.sensors,
+        "do not disturb": device.do_not_disturb,
+        "response style": device.response_style,
+        "bluetooth state": device.bluetooth_state,
     }

homeassistant/components/alexa_devices/icons.json

@@ -1,4 +1,44 @@
 {
+  "entity": {
+    "binary_sensor": {
+      "bluetooth": {
+        "default": "mdi:bluetooth-off",
+        "state": {
+          "on": "mdi:bluetooth"
+        }
+      },
+      "baby_cry_detection": {
+        "default": "mdi:account-voice-off",
+        "state": {
+          "on": "mdi:account-voice"
+        }
+      },
+      "beeping_appliance_detection": {
+        "default": "mdi:bell-off",
+        "state": {
+          "on": "mdi:bell-ring"
+        }
+      },
+      "cough_detection": {
+        "default": "mdi:blur-off",
+        "state": {
+          "on": "mdi:blur"
+        }
+      },
+      "dog_bark_detection": {
+        "default": "mdi:dog-side-off",
+        "state": {
+          "on": "mdi:dog-side"
+        }
+      },
+      "water_sounds_detection": {
+        "default": "mdi:water-pump-off",
+        "state": {
+          "on": "mdi:water-pump"
+        }
+      }
+    }
+  },
   "services": {
     "send_sound": {
       "service": "mdi:cast-audio"

homeassistant/components/alexa_devices/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
-  "quality_scale": "platinum",
+  "quality_scale": "silver",
-  "requirements": ["aioamazondevices==6.2.7"]
+  "requirements": ["aioamazondevices==6.0.0"]
 }

homeassistant/components/alexa_devices/notify.py

@@ -57,23 +57,13 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    known_devices: set[str] = set()
+    async_add_entities(
-
+        AmazonNotifyEntity(coordinator, serial_num, sensor_desc)
-    def _check_device() -> None:
+        for sensor_desc in NOTIFY
-        current_devices = set(coordinator.data)
+        for serial_num in coordinator.data
-        new_devices = current_devices - known_devices
+        if sensor_desc.subkey in coordinator.data[serial_num].capabilities
-        if new_devices:
+        and sensor_desc.is_supported(coordinator.data[serial_num])
-            known_devices.update(new_devices)
+    )
-            async_add_entities(
-                AmazonNotifyEntity(coordinator, serial_num, sensor_desc)
-                for sensor_desc in NOTIFY
-                for serial_num in new_devices
-                if sensor_desc.subkey in coordinator.data[serial_num].capabilities
-                and sensor_desc.is_supported(coordinator.data[serial_num])
-            )
-
-    _check_device()
-    entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class AmazonNotifyEntity(AmazonEntity, NotifyEntity):

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -53,7 +53,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: done
+  dynamic-devices: todo
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done

homeassistant/components/alexa_devices/sensor.py

@@ -31,9 +31,6 @@ class AmazonSensorEntityDescription(SensorEntityDescription):
     """Amazon Devices sensor 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 device.sensors[key].error is False
-    )
 
 
 SENSORS: Final = (
@@ -65,22 +62,12 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    known_devices: set[str] = set()
+    async_add_entities(
-
+        AmazonSensorEntity(coordinator, serial_num, sensor_desc)
-    def _check_device() -> None:
+        for sensor_desc in SENSORS
-        current_devices = set(coordinator.data)
+        for serial_num in coordinator.data
-        new_devices = current_devices - known_devices
+        if coordinator.data[serial_num].sensors.get(sensor_desc.key) is not None
-        if new_devices:
+    )
-            known_devices.update(new_devices)
-            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
-            )
-
-    _check_device()
-    entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class AmazonSensorEntity(AmazonEntity, SensorEntity):
@@ -102,13 +89,3 @@ class AmazonSensorEntity(AmazonEntity, SensorEntity):
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
         return self.device.sensors[self.entity_description.key].value
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            self.entity_description.is_available_fn(
-                self.device, self.entity_description.key
-            )
-            and super().available
-        )

homeassistant/components/alexa_devices/strings.json

@@ -58,6 +58,26 @@
     }
   },
   "entity": {
+    "binary_sensor": {
+      "bluetooth": {
+        "name": "Bluetooth"
+      },
+      "baby_cry_detection": {
+        "name": "Baby crying"
+      },
+      "beeping_appliance_detection": {
+        "name": "Beeping appliance"
+      },
+      "cough_detection": {
+        "name": "Coughing"
+      },
+      "dog_bark_detection": {
+        "name": "Dog barking"
+      },
+      "water_sounds_detection": {
+        "name": "Water sounds"
+      }
+    },
     "notify": {
       "speak": {
         "name": "Speak"

homeassistant/components/alexa_devices/switch.py

@@ -8,17 +8,13 @@ from typing import TYPE_CHECKING, Any, Final
 
 from aioamazondevices.api import AmazonDevice
 
-from homeassistant.components.switch import (
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
-    DOMAIN as SWITCH_DOMAIN,
-    SwitchEntity,
-    SwitchEntityDescription,
-)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import alexa_api_call, async_update_unique_id
+from .utils import alexa_api_call
 
 PARALLEL_UPDATES = 1
 
@@ -28,17 +24,16 @@ class AmazonSwitchEntityDescription(SwitchEntityDescription):
     """Alexa Devices switch entity description."""
 
     is_on_fn: Callable[[AmazonDevice], bool]
-    is_available_fn: Callable[[AmazonDevice, str], bool] = lambda device, key: (
+    subkey: str
-        device.online and device.sensors[key].error is False
-    )
     method: str
 
 
 SWITCHES: Final = (
     AmazonSwitchEntityDescription(
-        key="dnd",
+        key="do_not_disturb",
+        subkey="AUDIO_PLAYER",
         translation_key="do_not_disturb",
-        is_on_fn=lambda device: bool(device.sensors["dnd"].value),
+        is_on_fn=lambda _device: _device.do_not_disturb,
         method="set_do_not_disturb",
     ),
 )
@@ -53,28 +48,13 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Replace unique id for "DND" switch and remove from Speaker Group
+    async_add_entities(
-    await async_update_unique_id(
+        AmazonSwitchEntity(coordinator, serial_num, switch_desc)
-        hass, coordinator, SWITCH_DOMAIN, "do_not_disturb", "dnd"
+        for switch_desc in SWITCHES
+        for serial_num in coordinator.data
+        if switch_desc.subkey in coordinator.data[serial_num].capabilities
     )
 
-    known_devices: set[str] = set()
-
-    def _check_device() -> None:
-        current_devices = set(coordinator.data)
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                AmazonSwitchEntity(coordinator, serial_num, switch_desc)
-                for switch_desc in SWITCHES
-                for serial_num in new_devices
-                if switch_desc.key in coordinator.data[serial_num].sensors
-            )
-
-    _check_device()
-    entry.async_on_unload(coordinator.async_add_listener(_check_device))
-
 
 class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
     """Switch device."""
@@ -104,13 +84,3 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
     def is_on(self) -> bool:
         """Return True if switch is on."""
         return self.entity_description.is_on_fn(self.device)
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            self.entity_description.is_available_fn(
-                self.device, self.entity_description.key
-            )
-            and super().available
-        )

homeassistant/components/alexa_devices/utils.py

@@ -6,12 +6,9 @@ from typing import Any, Concatenate
 
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 
-from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-import homeassistant.helpers.entity_registry as er
 
-from .const import _LOGGER, DOMAIN
+from .const import DOMAIN
-from .coordinator import AmazonDevicesCoordinator
 from .entity import AmazonEntity
 
 
@@ -41,23 +38,3 @@ def alexa_api_call[_T: AmazonEntity, **_P](
             ) from err
 
     return cmd_wrapper
-
-
-async def async_update_unique_id(
-    hass: HomeAssistant,
-    coordinator: AmazonDevicesCoordinator,
-    domain: str,
-    old_key: str,
-    new_key: str,
-) -> None:
-    """Update unique id for entities created with old format."""
-    entity_registry = er.async_get(hass)
-
-    for serial_num in coordinator.data:
-        unique_id = f"{serial_num}-{old_key}"
-        if entity_id := entity_registry.async_get_entity_id(domain, DOMAIN, unique_id):
-            _LOGGER.debug("Updating unique_id for %s", entity_id)
-            new_unique_id = unique_id.replace(old_key, new_key)
-
-            # Update the registry with the new unique_id
-            entity_registry.async_update_entity(entity_id, new_unique_id=new_unique_id)

homeassistant/components/amcrest/services.py

@@ -41,7 +41,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
         if call.data.get(ATTR_ENTITY_ID) == ENTITY_MATCH_NONE:
             return []
 
-        call_ids = await async_extract_entity_ids(call)
+        call_ids = await async_extract_entity_ids(hass, call)
         entity_ids = []
         for entity_id in hass.data[DATA_AMCREST][CAMERAS]:
             if entity_id not in call_ids:

homeassistant/components/analytics/__init__.py

@@ -12,25 +12,10 @@ from homeassistant.helpers.event import async_call_later, async_track_time_inter
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
-from .analytics import (
+from .analytics import Analytics
-    Analytics,
-    AnalyticsInput,
-    AnalyticsModifications,
-    DeviceAnalyticsModifications,
-    EntityAnalyticsModifications,
-    async_devices_payload,
-)
 from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, INTERVAL, PREFERENCE_SCHEMA
 from .http import AnalyticsDevicesView
 
-__all__ = [
-    "AnalyticsInput",
-    "AnalyticsModifications",
-    "DeviceAnalyticsModifications",
-    "EntityAnalyticsModifications",
-    "async_devices_payload",
-]
-
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)

homeassistant/components/analytics/analytics.py

@@ -4,10 +4,9 @@ from __future__ import annotations
 
 import asyncio
 from asyncio import timeout
-from collections.abc import Awaitable, Callable, Iterable, Mapping
+from dataclasses import asdict as dataclass_asdict, dataclass
-from dataclasses import asdict as dataclass_asdict, dataclass, field
 from datetime import datetime
-from typing import Any, Protocol
+from typing import Any
 import uuid
 
 import aiohttp
@@ -36,14 +35,11 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.hassio import is_hassio
-from homeassistant.helpers.singleton import singleton
 from homeassistant.helpers.storage import Store
 from homeassistant.helpers.system_info import async_get_system_info
-from homeassistant.helpers.typing import UNDEFINED
 from homeassistant.loader import (
     Integration,
     IntegrationNotFound,
-    async_get_integration,
     async_get_integrations,
 )
 from homeassistant.setup import async_get_loaded_integrations
@@ -79,115 +75,12 @@ from .const import (
     ATTR_USER_COUNT,
     ATTR_UUID,
     ATTR_VERSION,
-    DOMAIN,
     LOGGER,
     PREFERENCE_SCHEMA,
     STORAGE_KEY,
     STORAGE_VERSION,
 )
 
-DATA_ANALYTICS_MODIFIERS = "analytics_modifiers"
-
-type AnalyticsModifier = Callable[
-    [HomeAssistant, AnalyticsInput], Awaitable[AnalyticsModifications]
-]
-
-
-@singleton(DATA_ANALYTICS_MODIFIERS)
-def _async_get_modifiers(
-    hass: HomeAssistant,
-) -> dict[str, AnalyticsModifier | None]:
-    """Return the analytics modifiers."""
-    return {}
-
-
-@dataclass
-class AnalyticsInput:
-    """Analytics input for a single integration.
-
-    This is sent to integrations that implement the platform.
-    """
-
-    device_ids: Iterable[str] = field(default_factory=list)
-    entity_ids: Iterable[str] = field(default_factory=list)
-
-
-@dataclass
-class AnalyticsModifications:
-    """Analytics config for a single integration.
-
-    This is used by integrations that implement the platform.
-    """
-
-    remove: bool = False
-    devices: Mapping[str, DeviceAnalyticsModifications] | None = None
-    entities: Mapping[str, EntityAnalyticsModifications] | None = None
-
-
-@dataclass
-class DeviceAnalyticsModifications:
-    """Analytics config for a single device.
-
-    This is used by integrations that implement the platform.
-    """
-
-    remove: bool = False
-
-
-@dataclass
-class EntityAnalyticsModifications:
-    """Analytics config for a single entity.
-
-    This is used by integrations that implement the platform.
-    """
-
-    remove: bool = False
-
-
-class AnalyticsPlatformProtocol(Protocol):
-    """Define the format of analytics platforms."""
-
-    async def async_modify_analytics(
-        self,
-        hass: HomeAssistant,
-        analytics_input: AnalyticsInput,
-    ) -> AnalyticsModifications:
-        """Modify the analytics."""
-
-
-async def _async_get_analytics_platform(
-    hass: HomeAssistant, domain: str
-) -> AnalyticsPlatformProtocol | None:
-    """Get analytics platform."""
-    try:
-        integration = await async_get_integration(hass, domain)
-    except IntegrationNotFound:
-        return None
-    try:
-        return await integration.async_get_platform(DOMAIN)
-    except ImportError:
-        return None
-
-
-async def _async_get_modifier(
-    hass: HomeAssistant, domain: str
-) -> AnalyticsModifier | None:
-    """Get analytics modifier."""
-    modifiers = _async_get_modifiers(hass)
-    modifier = modifiers.get(domain, UNDEFINED)
-
-    if modifier is not UNDEFINED:
-        return modifier
-
-    platform = await _async_get_analytics_platform(hass, domain)
-    if platform is None:
-        modifiers[domain] = None
-        return None
-
-    modifier = getattr(platform, "async_modify_analytics", None)
-    modifiers[domain] = modifier
-    return modifier
-
 
 def gen_uuid() -> str:
     """Generate a new UUID."""
@@ -500,20 +393,17 @@ def _domains_from_yaml_config(yaml_configuration: dict[str, Any]) -> set[str]:
     return domains
 
 
-DEFAULT_ANALYTICS_CONFIG = AnalyticsModifications()
-DEFAULT_DEVICE_ANALYTICS_CONFIG = DeviceAnalyticsModifications()
-DEFAULT_ENTITY_ANALYTICS_CONFIG = EntityAnalyticsModifications()
-
-
 async def async_devices_payload(hass: HomeAssistant) -> dict:
     """Return detailed information about entities and devices."""
+    integrations_info: dict[str, dict[str, Any]] = {}
+
     dev_reg = dr.async_get(hass)
-    ent_reg = er.async_get(hass)
 
-    integration_inputs: dict[str, tuple[list[str], list[str]]] = {}
+    # We need to refer to other devices, for example in `via_device` field.
-    integration_configs: dict[str, AnalyticsModifications] = {}
+    # We don't however send the original device ids outside of Home Assistant,
+    # instead we refer to devices by (integration_domain, index_in_integration_device_list).
+    device_id_mapping: dict[str, tuple[str, int]] = {}
 
-    # Get device list
     for device_entry in dev_reg.devices.values():
         if not device_entry.primary_config_entry:
             continue
@@ -526,113 +416,27 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
             continue
 
         integration_domain = config_entry.domain
-
-        integration_input = integration_inputs.setdefault(integration_domain, ([], []))
-        integration_input[0].append(device_entry.id)
-
-    # Get entity list
-    for entity_entry in ent_reg.entities.values():
-        integration_domain = entity_entry.platform
-
-        integration_input = integration_inputs.setdefault(integration_domain, ([], []))
-        integration_input[1].append(entity_entry.entity_id)
-
-    integrations = {
-        domain: integration
-        for domain, integration in (
-            await async_get_integrations(hass, integration_inputs.keys())
-        ).items()
-        if isinstance(integration, Integration)
-    }
-
-    # Filter out custom integrations and integrations that are not device or hub type
-    integration_inputs = {
-        domain: integration_info
-        for domain, integration_info in integration_inputs.items()
-        if (integration := integrations.get(domain)) is not None
-        and integration.is_built_in
-        and integration.manifest.get("integration_type") in ("device", "hub")
-    }
-
-    # Call integrations that implement the analytics platform
-    for integration_domain, integration_input in integration_inputs.items():
-        if (
-            modifier := await _async_get_modifier(hass, integration_domain)
-        ) is not None:
-            try:
-                integration_config = await modifier(
-                    hass, AnalyticsInput(*integration_input)
-                )
-            except Exception as err:  # noqa: BLE001
-                LOGGER.exception(
-                    "Calling async_modify_analytics for integration '%s' failed: %s",
-                    integration_domain,
-                    err,
-                )
-                integration_configs[integration_domain] = AnalyticsModifications(
-                    remove=True
-                )
-                continue
-
-            if not isinstance(integration_config, AnalyticsModifications):
-                LOGGER.error(  # type: ignore[unreachable]
-                    "Calling async_modify_analytics for integration '%s' did not return an AnalyticsConfig",
-                    integration_domain,
-                )
-                integration_configs[integration_domain] = AnalyticsModifications(
-                    remove=True
-                )
-                continue
-
-            integration_configs[integration_domain] = integration_config
-
-    integrations_info: dict[str, dict[str, Any]] = {}
-
-    # We need to refer to other devices, for example in `via_device` field.
-    # We don't however send the original device ids outside of Home Assistant,
-    # instead we refer to devices by (integration_domain, index_in_integration_device_list).
-    device_id_mapping: dict[str, tuple[str, int]] = {}
-
-    # Fill out information about devices
-    for integration_domain, integration_input in integration_inputs.items():
-        integration_config = integration_configs.get(
-            integration_domain, DEFAULT_ANALYTICS_CONFIG
-        )
-
-        if integration_config.remove:
-            continue
-
         integration_info = integrations_info.setdefault(
             integration_domain, {"devices": [], "entities": []}
         )
 
         devices_info = integration_info["devices"]
 
-        for device_id in integration_input[0]:
+        device_id_mapping[device_entry.id] = (integration_domain, len(devices_info))
-            device_config = DEFAULT_DEVICE_ANALYTICS_CONFIG
-            if integration_config.devices is not None:
-                device_config = integration_config.devices.get(device_id, device_config)
 
-            if device_config.remove:
+        devices_info.append(
-                continue
+            {
-
+                "entities": [],
-            device_entry = dev_reg.devices[device_id]
+                "entry_type": device_entry.entry_type,
-
+                "has_configuration_url": device_entry.configuration_url is not None,
-            device_id_mapping[device_entry.id] = (integration_domain, len(devices_info))
+                "hw_version": device_entry.hw_version,
-
+                "manufacturer": device_entry.manufacturer,
-            devices_info.append(
+                "model": device_entry.model,
-                {
+                "model_id": device_entry.model_id,
-                    "entities": [],
+                "sw_version": device_entry.sw_version,
-                    "entry_type": device_entry.entry_type,
+                "via_device": device_entry.via_device_id,
-                    "has_configuration_url": device_entry.configuration_url is not None,
+            }
-                    "hw_version": device_entry.hw_version,
+        )
-                    "manufacturer": device_entry.manufacturer,
-                    "model": device_entry.model,
-                    "model_id": device_entry.model_id,
-                    "sw_version": device_entry.sw_version,
-                    "via_device": device_entry.via_device_id,
-                }
-            )
 
     # Fill out via_device with new device ids
     for integration_info in integrations_info.values():
@@ -641,15 +445,10 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
                 continue
             device_info["via_device"] = device_id_mapping.get(device_info["via_device"])
 
-    # Fill out information about entities
+    ent_reg = er.async_get(hass)
-    for integration_domain, integration_input in integration_inputs.items():
-        integration_config = integration_configs.get(
-            integration_domain, DEFAULT_ANALYTICS_CONFIG
-        )
-
-        if integration_config.remove:
-            continue
 
+    for entity_entry in ent_reg.entities.values():
+        integration_domain = entity_entry.platform
         integration_info = integrations_info.setdefault(
             integration_domain, {"devices": [], "entities": []}
         )
@@ -657,49 +456,53 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:
         devices_info = integration_info["devices"]
         entities_info = integration_info["entities"]
 
-        for entity_id in integration_input[1]:
+        entity_state = hass.states.get(entity_entry.entity_id)
-            entity_config = DEFAULT_ENTITY_ANALYTICS_CONFIG
+
-            if integration_config.entities is not None:
+        entity_info = {
-                entity_config = integration_config.entities.get(
+            # LIMITATION: `assumed_state` can be overridden by users;
-                    entity_id, entity_config
+            # we should replace it with the original value in the future.
+            # It is also not present, if entity is not in the state machine,
+            # which can happen for disabled entities.
+            "assumed_state": entity_state.attributes.get(ATTR_ASSUMED_STATE, False)
+            if entity_state is not None
+            else None,
+            "capabilities": entity_entry.capabilities,
+            "domain": entity_entry.domain,
+            "entity_category": entity_entry.entity_category,
+            "has_entity_name": entity_entry.has_entity_name,
+            "original_device_class": entity_entry.original_device_class,
+            # LIMITATION: `unit_of_measurement` can be overridden by users;
+            # we should replace it with the original value in the future.
+            "unit_of_measurement": entity_entry.unit_of_measurement,
+        }
+
+        if (
+            ((device_id := entity_entry.device_id) is not None)
+            and ((new_device_id := device_id_mapping.get(device_id)) is not None)
+            and (new_device_id[0] == integration_domain)
+        ):
+            device_info = devices_info[new_device_id[1]]
+            device_info["entities"].append(entity_info)
+        else:
+            entities_info.append(entity_info)
+
+    integrations = {
+        domain: integration
+        for domain, integration in (
+            await async_get_integrations(hass, integrations_info.keys())
+        ).items()
+        if isinstance(integration, Integration)
+    }
+
+    for domain, integration_info in integrations_info.items():
+        if integration := integrations.get(domain):
+            integration_info["is_custom_integration"] = not integration.is_built_in
+            # Include version for custom integrations
+            if not integration.is_built_in and integration.version:
+                integration_info["custom_integration_version"] = str(
+                    integration.version
                 )
 
-            if entity_config.remove:
-                continue
-
-            entity_entry = ent_reg.entities[entity_id]
-
-            entity_state = hass.states.get(entity_entry.entity_id)
-
-            entity_info = {
-                # LIMITATION: `assumed_state` can be overridden by users;
-                # we should replace it with the original value in the future.
-                # It is also not present, if entity is not in the state machine,
-                # which can happen for disabled entities.
-                "assumed_state": (
-                    entity_state.attributes.get(ATTR_ASSUMED_STATE, False)
-                    if entity_state is not None
-                    else None
-                ),
-                "domain": entity_entry.domain,
-                "entity_category": entity_entry.entity_category,
-                "has_entity_name": entity_entry.has_entity_name,
-                "original_device_class": entity_entry.original_device_class,
-                # LIMITATION: `unit_of_measurement` can be overridden by users;
-                # we should replace it with the original value in the future.
-                "unit_of_measurement": entity_entry.unit_of_measurement,
-            }
-
-            if (
-                ((device_id_ := entity_entry.device_id) is not None)
-                and ((new_device_id := device_id_mapping.get(device_id_)) is not None)
-                and (new_device_id[0] == integration_domain)
-            ):
-                device_info = devices_info[new_device_id[1]]
-                device_info["entities"].append(entity_info)
-            else:
-                entities_info.append(entity_info)
-
     return {
         "version": "home-assistant:1",
         "home_assistant": HA_VERSION,

homeassistant/components/analytics/manifest.json

@@ -2,7 +2,7 @@
   "domain": "analytics",
   "name": "Analytics",
   "after_dependencies": ["energy", "hassio", "recorder"],
-  "codeowners": ["@home-assistant/core"],
+  "codeowners": ["@home-assistant/core", "@ludeeus"],
   "dependencies": ["api", "websocket_api", "http"],
   "documentation": "https://www.home-assistant.io/integrations/analytics",
   "integration_type": "system",

homeassistant/components/apcupsd/sensor.py

@@ -467,10 +467,7 @@ async def async_setup_entry(
     # periodical (or manual) self test since last daemon restart. It might not be available
     # when we set up the integration, and we do not know if it would ever be available. Here we
     # add it anyway and mark it as unknown initially.
-    #
+    for resource in available_resources | {LAST_S_TEST}:
-    # We also sort the resources to ensure the order of entities created is deterministic since
-    # "APCMODEL" and "MODEL" resources map to the same "Model" name.
-    for resource in sorted(available_resources | {LAST_S_TEST}):
         if resource not in SENSORS:
             _LOGGER.warning("Invalid resource from APCUPSd: %s", resource.upper())
             continue

homeassistant/components/assist_pipeline/pipeline.py

@@ -1308,9 +1308,7 @@ class PipelineRun:
                     # instead of a full response.
                     all_targets_in_satellite_area = (
                         self._get_all_targets_in_satellite_area(
-                            conversation_result.response,
+                            conversation_result.response, self._device_id
-                            self._satellite_id,
-                            self._device_id,
                         )
                     )
 
@@ -1339,62 +1337,39 @@ class PipelineRun:
         return (speech, all_targets_in_satellite_area)
 
     def _get_all_targets_in_satellite_area(
-        self,
+        self, intent_response: intent.IntentResponse, device_id: str | None
-        intent_response: intent.IntentResponse,
-        satellite_id: str | None,
-        device_id: str | None,
     ) -> bool:
         """Return true if all targeted entities were in the same area as the device."""
         if (
-            intent_response.response_type != intent.IntentResponseType.ACTION_DONE
+            (intent_response.response_type != intent.IntentResponseType.ACTION_DONE)
-            or not intent_response.matched_states
+            or (not intent_response.matched_states)
+            or (not device_id)
+        ):
+            return False
+
+        device_registry = dr.async_get(self.hass)
+
+        if (not (device := device_registry.async_get(device_id))) or (
+            not device.area_id
         ):
             return False
 
         entity_registry = er.async_get(self.hass)
-        device_registry = dr.async_get(self.hass)
-
-        area_id: str | None = None
-
-        if (
-            satellite_id is not None
-            and (target_entity_entry := entity_registry.async_get(satellite_id))
-            is not None
-        ):
-            area_id = target_entity_entry.area_id
-            device_id = target_entity_entry.device_id
-
-        if area_id is None:
-            if device_id is None:
-                return False
-
-            device_entry = device_registry.async_get(device_id)
-            if device_entry is None:
-                return False
-
-            area_id = device_entry.area_id
-            if area_id is None:
-                return False
-
         for state in intent_response.matched_states:
-            target_entity_entry = entity_registry.async_get(state.entity_id)
+            entity = entity_registry.async_get(state.entity_id)
-            if target_entity_entry is None:
+            if not entity:
                 return False
 
-            target_area_id = target_entity_entry.area_id
+            if (entity_area_id := entity.area_id) is None:
-            if target_area_id is None:
+                if (entity.device_id is None) or (
-                if target_entity_entry.device_id is None:
+                    (entity_device := device_registry.async_get(entity.device_id))
+                    is None
+                ):
                     return False
 
-                target_device_entry = device_registry.async_get(
+                entity_area_id = entity_device.area_id
-                    target_entity_entry.device_id
-                )
-                if target_device_entry is None:
-                    return False
 
-                target_area_id = target_device_entry.area_id
+            if entity_area_id != device.area_id:
-
-            if target_area_id != area_id:
                 return False
 
         return True

homeassistant/components/assist_pipeline/select.py

@@ -109,7 +109,7 @@ class AssistPipelineSelect(SelectEntity, restore_state.RestoreEntity):
         )
 
         state = await self.async_get_last_state()
-        if (state is not None) and (state.state in self.options):
+        if state is not None and state.state in self.options:
             self._attr_current_option = state.state
 
         if self.registry_entry and (device_id := self.registry_entry.device_id):
@@ -119,7 +119,7 @@ class AssistPipelineSelect(SelectEntity, restore_state.RestoreEntity):
 
             def cleanup() -> None:
                 """Clean up registered device."""
-                pipeline_data.pipeline_devices.pop(device_id, None)
+                pipeline_data.pipeline_devices.pop(device_id)
 
             self.async_on_remove(cleanup)
 

homeassistant/components/asuswrt/bridge.py

@@ -120,7 +120,6 @@ class AsusWrtBridge(ABC):
 
     def __init__(self, host: str) -> None:
         """Initialize Bridge."""
-        self._configuration_url = f"http://{host}"
         self._host = host
         self._firmware: str | None = None
         self._label_mac: str | None = None
@@ -128,11 +127,6 @@ class AsusWrtBridge(ABC):
         self._model_id: str | None = None
         self._serial_number: str | None = None
 
-    @property
-    def configuration_url(self) -> str:
-        """Return configuration URL."""
-        return self._configuration_url
-
     @property
     def host(self) -> str:
         """Return hostname."""
@@ -377,7 +371,6 @@ class AsusWrtHttpBridge(AsusWrtBridge):
         # get main router properties
         if mac := _identity.mac:
             self._label_mac = format_mac(mac)
-        self._configuration_url = self._api.webpanel
         self._firmware = str(_identity.firmware)
         self._model = _identity.model
         self._model_id = _identity.product_id

homeassistant/components/asuswrt/router.py

@@ -388,13 +388,13 @@ class AsusWrtRouter:
     def device_info(self) -> DeviceInfo:
         """Return the device information."""
         info = DeviceInfo(
-            configuration_url=self._api.configuration_url,
             identifiers={(DOMAIN, self._entry.unique_id or "AsusWRT")},
             name=self.host,
             model=self._api.model or "Asus Router",
             model_id=self._api.model_id,
             serial_number=self._api.serial_number,
             manufacturer="Asus",
+            configuration_url=f"http://{self.host}",
         )
         if self._api.firmware:
             info["sw_version"] = self._api.firmware

homeassistant/components/august/lock.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable, Coroutine
 import logging
 from typing import Any
 
 from aiohttp import ClientResponseError
-from yalexs.activity import ActivityType
+from yalexs.activity import ActivityType, ActivityTypes
-from yalexs.lock import Lock, LockOperation, LockStatus
+from yalexs.lock import Lock, LockStatus
 from yalexs.util import get_latest_activity, update_lock_detail_from_activity
 
 from homeassistant.components.lock import ATTR_CHANGED_BY, LockEntity, LockEntityFeature
@@ -49,25 +50,30 @@ class AugustLock(AugustEntity, RestoreEntity, LockEntity):
 
     async def async_lock(self, **kwargs: Any) -> None:
         """Lock the device."""
-        await self._perform_lock_operation(LockOperation.LOCK)
+        if self._data.push_updates_connected:
+            await self._data.async_lock_async(self._device_id, self._hyper_bridge)
+            return
+        await self._call_lock_operation(self._data.async_lock)
 
     async def async_open(self, **kwargs: Any) -> None:
         """Open/unlatch the device."""
-        await self._perform_lock_operation(LockOperation.OPEN)
+        if self._data.push_updates_connected:
+            await self._data.async_unlatch_async(self._device_id, self._hyper_bridge)
+            return
+        await self._call_lock_operation(self._data.async_unlatch)
 
     async def async_unlock(self, **kwargs: Any) -> None:
         """Unlock the device."""
-        await self._perform_lock_operation(LockOperation.UNLOCK)
+        if self._data.push_updates_connected:
+            await self._data.async_unlock_async(self._device_id, self._hyper_bridge)
+            return
+        await self._call_lock_operation(self._data.async_unlock)
 
-    async def _perform_lock_operation(self, operation: LockOperation) -> None:
+    async def _call_lock_operation(
-        """Perform a lock operation."""
+        self, lock_operation: Callable[[str], Coroutine[Any, Any, list[ActivityTypes]]]
+    ) -> None:
         try:
-            activities = await self._data.async_operate_lock(
+            activities = await lock_operation(self._device_id)
-                self._device_id,
-                operation,
-                self._data.push_updates_connected,
-                self._hyper_bridge,
-            )
         except ClientResponseError as err:
             if err.status == LOCK_JAMMED_ERR:
                 self._detail.lock_status = LockStatus.JAMMED

homeassistant/components/august/manifest.json

@@ -29,5 +29,5 @@
   "documentation": "https://www.home-assistant.io/integrations/august",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.1.2"]
+  "requirements": ["yalexs==9.0.1", "yalexs-ble==3.1.2"]
 }

homeassistant/components/backup/const.py

@@ -26,6 +26,7 @@ EXCLUDE_FROM_BACKUP = [
     "tmp_backups/*.tar",
     "OZW_Log.txt",
     "tts/*",
+    "ai_task/*",
 ]
 
 EXCLUDE_DATABASE_FROM_BACKUP = [

homeassistant/components/backup/http.py

@@ -8,7 +8,7 @@ import threading
 from typing import IO, cast
 
 from aiohttp import BodyPartReader
-from aiohttp.hdrs import CONTENT_DISPOSITION, CONTENT_TYPE
+from aiohttp.hdrs import CONTENT_DISPOSITION
 from aiohttp.web import FileResponse, Request, Response, StreamResponse
 from multidict import istr
 
@@ -76,8 +76,7 @@ class DownloadBackupView(HomeAssistantView):
             return Response(status=HTTPStatus.NOT_FOUND)
 
         headers = {
-            CONTENT_DISPOSITION: f"attachment; filename={slugify(backup.name)}.tar",
+            CONTENT_DISPOSITION: f"attachment; filename={slugify(backup.name)}.tar"
-            CONTENT_TYPE: "application/x-tar",
         }
 
         try:

homeassistant/components/blue_current/__init__.py

@@ -13,30 +13,20 @@ from bluecurrent_api.exceptions import (
     RequestLimitReached,
     WebsocketError,
 )
-import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
+from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_TOKEN, CONF_DEVICE_ID, Platform
+from homeassistant.const import CONF_API_TOKEN, Platform
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    ServiceValidationError,
-)
-from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.helpers.typing import ConfigType
 
 from .const import (
-    BCU_APP,
     CHARGEPOINT_SETTINGS,
     CHARGEPOINT_STATUS,
-    CHARGING_CARD_ID,
     DOMAIN,
     EVSE_ID,
     LOGGER,
     PLUG_AND_CHARGE,
-    SERVICE_START_CHARGE_SESSION,
     VALUE,
 )
 
@@ -44,7 +34,6 @@ type BlueCurrentConfigEntry = ConfigEntry[Connector]
 
 PLATFORMS = [Platform.BUTTON, Platform.SENSOR, Platform.SWITCH]
 CHARGE_POINTS = "CHARGE_POINTS"
-CHARGE_CARDS = "CHARGE_CARDS"
 DATA = "data"
 DELAY = 5
 
@@ -52,16 +41,6 @@ GRID = "GRID"
 OBJECT = "object"
 VALUE_TYPES = [CHARGEPOINT_STATUS, CHARGEPOINT_SETTINGS]
 
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-SERVICE_START_CHARGE_SESSION_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_DEVICE_ID): cv.string,
-        # When no charging card is provided, use no charging card (BCU_APP = no charging card).
-        vol.Optional(CHARGING_CARD_ID, default=BCU_APP): cv.string,
-    }
-)
-
 
 async def async_setup_entry(
     hass: HomeAssistant, config_entry: BlueCurrentConfigEntry
@@ -88,66 +67,6 @@ async def async_setup_entry(
     return True
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up Blue Current."""
-
-    async def start_charge_session(service_call: ServiceCall) -> None:
-        """Start a charge session with the provided device and charge card ID."""
-        # When no charge card is provided, use the default charge card set in the config flow.
-        charging_card_id = service_call.data[CHARGING_CARD_ID]
-        device_id = service_call.data[CONF_DEVICE_ID]
-
-        # Get the device based on the given device ID.
-        device = dr.async_get(hass).devices.get(device_id)
-
-        if device is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN, translation_key="invalid_device_id"
-            )
-
-        blue_current_config_entry: ConfigEntry | None = None
-
-        for config_entry_id in device.config_entries:
-            config_entry = hass.config_entries.async_get_entry(config_entry_id)
-            if not config_entry or config_entry.domain != DOMAIN:
-                # Not the blue_current config entry.
-                continue
-
-            if config_entry.state is not ConfigEntryState.LOADED:
-                raise ServiceValidationError(
-                    translation_domain=DOMAIN, translation_key="config_entry_not_loaded"
-                )
-
-            blue_current_config_entry = config_entry
-            break
-
-        if not blue_current_config_entry:
-            # The device is not connected to a valid blue_current config entry.
-            raise ServiceValidationError(
-                translation_domain=DOMAIN, translation_key="no_config_entry"
-            )
-
-        connector = blue_current_config_entry.runtime_data
-
-        # Get the evse_id from the identifier of the device.
-        evse_id = next(
-            identifier[1]
-            for identifier in device.identifiers
-            if identifier[0] == DOMAIN
-        )
-
-        await connector.client.start_session(evse_id, charging_card_id)
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_START_CHARGE_SESSION,
-        start_charge_session,
-        SERVICE_START_CHARGE_SESSION_SCHEMA,
-    )
-
-    return True
-
-
 async def async_unload_entry(
     hass: HomeAssistant, config_entry: BlueCurrentConfigEntry
 ) -> bool:
@@ -168,7 +87,6 @@ class Connector:
         self.client = client
         self.charge_points: dict[str, dict] = {}
         self.grid: dict[str, Any] = {}
-        self.charge_cards: dict[str, dict[str, Any]] = {}
 
     async def on_data(self, message: dict) -> None:
         """Handle received data."""

homeassistant/components/blue_current/const.py

@@ -8,12 +8,6 @@ LOGGER = logging.getLogger(__package__)
 
 EVSE_ID = "evse_id"
 MODEL_TYPE = "model_type"
-CARD = "card"
-UID = "uid"
-BCU_APP = "BCU-APP"
-WITHOUT_CHARGING_CARD = "without_charging_card"
-CHARGING_CARD_ID = "charging_card_id"
-SERVICE_START_CHARGE_SESSION = "start_charge_session"
 PLUG_AND_CHARGE = "plug_and_charge"
 VALUE = "value"
 PERMISSION = "permission"

homeassistant/components/blue_current/icons.json

@@ -42,10 +42,5 @@
         "default": "mdi:lock"
       }
     }
-  },
-  "services": {
-    "start_charge_session": {
-      "service": "mdi:play"
-    }
   }
 }

homeassistant/components/blue_current/services.yaml

@@ -1,12 +0,0 @@
-start_charge_session:
-  fields:
-    device_id:
-      selector:
-        device:
-          integration: blue_current
-      required: true
-
-    charging_card_id:
-      selector:
-        text:
-      required: false

homeassistant/components/blue_current/strings.json

@@ -22,16 +22,6 @@
       "wrong_account": "Wrong account: Please authenticate with the API token for {email}."
     }
   },
-  "options": {
-    "step": {
-      "init": {
-        "data": {
-          "card": "Card"
-        },
-        "description": "Select the default charging card you want to use"
-      }
-    }
-  },
   "entity": {
     "sensor": {
       "activity": {
@@ -146,39 +136,5 @@
         "name": "Block charge point"
       }
     }
-  },
-  "selector": {
-    "select_charging_card": {
-      "options": {
-        "without_charging_card": "Without charging card"
-      }
-    }
-  },
-  "services": {
-    "start_charge_session": {
-      "name": "Start charge session",
-      "description": "Starts a new charge session on a specified charge point.",
-      "fields": {
-        "charging_card_id": {
-          "name": "Charging card ID",
-          "description": "Optional charging card ID that will be used to start a charge session. When not provided, no charging card will be used."
-        },
-        "device_id": {
-          "name": "Device ID",
-          "description": "The ID of the Blue Current charge point."
-        }
-      }
-    }
-  },
-  "exceptions": {
-    "invalid_device_id": {
-      "message": "Invalid device ID given."
-    },
-    "config_entry_not_loaded": {
-      "message": "Config entry not loaded."
-    },
-    "no_config_entry": {
-      "message": "Device has not a valid blue_current config entry."
-    }
   }
 }

homeassistant/components/bluetooth/api.py

@@ -10,7 +10,6 @@ from asyncio import Future
 from collections.abc import Callable, Iterable
 from typing import TYPE_CHECKING, cast
 
-from bleak import BleakScanner
 from habluetooth import (
     BaseHaScanner,
     BluetoothScannerDevice,
@@ -39,16 +38,13 @@ def _get_manager(hass: HomeAssistant) -> HomeAssistantBluetoothManager:
 
 
 @hass_callback
-def async_get_scanner(hass: HomeAssistant) -> BleakScanner:
+def async_get_scanner(hass: HomeAssistant) -> HaBleakScannerWrapper:
-    """Return a HaBleakScannerWrapper cast to BleakScanner.
+    """Return a HaBleakScannerWrapper.
 
     This is a wrapper around our BleakScanner singleton that allows
     multiple integrations to share the same BleakScanner.
-
-    The wrapper is cast to BleakScanner for type compatibility with
-    libraries expecting a BleakScanner instance.
     """
-    return cast(BleakScanner, HaBleakScannerWrapper())
+    return HaBleakScannerWrapper()
 
 
 @hass_callback

homeassistant/components/bring/coordinator.py

@@ -205,7 +205,6 @@ class BringActivityCoordinator(BringBaseCoordinator[dict[str, BringActivityData]
 
     async def _async_update_data(self) -> dict[str, BringActivityData]:
         """Fetch activity data from bring."""
-        self.lists = self.coordinator.lists
 
         list_dict: dict[str, BringActivityData] = {}
         for lst in self.lists:

homeassistant/components/bring/event.py

@@ -43,7 +43,7 @@ async def async_setup_entry(
             )
             lists_added |= new_lists
 
-    coordinator.data.async_add_listener(add_entities)
+    coordinator.activity.async_add_listener(add_entities)
     add_entities()
 
 
@@ -67,8 +67,7 @@ class BringEventEntity(BringBaseEntity, EventEntity):
 
     def _async_handle_event(self) -> None:
         """Handle the activity event."""
-        if (bring_list := self.coordinator.data.get(self._list_uuid)) is None:
+        bring_list = self.coordinator.data[self._list_uuid]
-            return
         last_event_triggered = self.state
         if bring_list.activity.timeline and (
             last_event_triggered is None

homeassistant/components/cloud/http_api.py

@@ -37,10 +37,6 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.loader import (
-    async_get_custom_components,
-    async_get_loaded_integration,
-)
 from homeassistant.util.location import async_detect_location_info
 
 from .alexa_config import entity_supported as entity_supported_by_alexa
@@ -435,79 +431,6 @@ class DownloadSupportPackageView(HomeAssistantView):
     url = "/api/cloud/support_package"
     name = "api:cloud:support_package"
 
-    async def _get_integration_info(self, hass: HomeAssistant) -> dict[str, Any]:
-        """Collect information about active and custom integrations."""
-        # Get loaded components from hass.config.components
-        loaded_components = hass.config.components.copy()
-
-        # Get custom integrations
-        custom_domains = set()
-        with suppress(Exception):
-            custom_domains = set(await async_get_custom_components(hass))
-
-        # Separate built-in and custom integrations
-        builtin_integrations = []
-        custom_integrations = []
-
-        for domain in sorted(loaded_components):
-            try:
-                integration = async_get_loaded_integration(hass, domain)
-            except Exception:  # noqa: BLE001
-                # Broad exception catch for robustness in support package
-                # generation. If we can't get integration info,
-                # just add the domain
-                if domain in custom_domains:
-                    custom_integrations.append(
-                        {
-                            "domain": domain,
-                            "name": "Unknown",
-                            "version": "Unknown",
-                            "documentation": "Unknown",
-                        }
-                    )
-                else:
-                    builtin_integrations.append(
-                        {
-                            "domain": domain,
-                            "name": "Unknown",
-                        }
-                    )
-            else:
-                if domain in custom_domains:
-                    # This is a custom integration
-                    # include version and documentation link
-                    version = (
-                        str(integration.version) if integration.version else "Unknown"
-                    )
-                    if not (documentation := integration.documentation):
-                        documentation = "Unknown"
-
-                    custom_integrations.append(
-                        {
-                            "domain": domain,
-                            "name": integration.name,
-                            "version": version,
-                            "documentation": documentation,
-                        }
-                    )
-                else:
-                    # This is a built-in integration.
-                    # No version needed, as it is always the same as the
-                    # Home Assistant version
-                    builtin_integrations.append(
-                        {
-                            "domain": domain,
-                            "name": integration.name,
-                        }
-                    )
-
-        return {
-            "builtin_count": len(builtin_integrations),
-            "builtin_integrations": builtin_integrations,
-            "custom_count": len(custom_integrations),
-            "custom_integrations": custom_integrations,
-        }
-
     async def _generate_markdown(
         self,
         hass: HomeAssistant,
@@ -530,38 +453,6 @@ class DownloadSupportPackageView(HomeAssistantView):
         markdown = "## System Information\n\n"
         markdown += get_domain_table_markdown(hass_info)
 
-        # Add integration information
-        try:
-            integration_info = await self._get_integration_info(hass)
-        except Exception:  # noqa: BLE001
-            # Broad exception catch for robustness in support package generation
-            # If there's any error getting integration info, just note it
-            markdown += "## Active integrations\n\n"
-            markdown += "Unable to collect integration information\n\n"
-        else:
-            markdown += "## Active Integrations\n\n"
-            markdown += f"Built-in integrations: {integration_info['builtin_count']}\n"
-            markdown += f"Custom integrations: {integration_info['custom_count']}\n\n"
-
-            # Built-in integrations
-            if integration_info["builtin_integrations"]:
-                markdown += "<details><summary>Built-in integrations</summary>\n\n"
-                markdown += "Domain | Name\n"
-                markdown += "--- | ---\n"
-                for integration in integration_info["builtin_integrations"]:
-                    markdown += f"{integration['domain']} | {integration['name']}\n"
-                markdown += "\n</details>\n\n"
-
-            # Custom integrations
-            if integration_info["custom_integrations"]:
-                markdown += "<details><summary>Custom integrations</summary>\n\n"
-                markdown += "Domain | Name | Version | Documentation\n"
-                markdown += "--- | --- | --- | ---\n"
-                for integration in integration_info["custom_integrations"]:
-                    doc_url = integration.get("documentation") or "N/A"
-                    markdown += f"{integration['domain']} | {integration['name']} | {integration['version']} | {doc_url}\n"
-                markdown += "\n</details>\n\n"
-
         for domain, domain_info in domains_info.items():
             domain_info_md = get_domain_table_markdown(domain_info)
             markdown += (

homeassistant/components/cloud/subscription.py

@@ -25,11 +25,7 @@ async def async_subscription_info(cloud: Cloud[CloudClient]) -> SubscriptionInfo
             return await cloud.payments.subscription_info()
     except PaymentsApiError as exception:
         _LOGGER.error("Failed to fetch subscription information - %s", exception)
-    except TimeoutError:
+
-        _LOGGER.error(
-            "A timeout of %s was reached while trying to fetch subscription information",
-            REQUEST_TIMEOUT,
-        )
     return None
 
 

homeassistant/components/comelit/binary_sensor.py

@@ -29,23 +29,10 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    async_add_entities(
-
+        ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)
-    def _check_device() -> None:
+        for device in coordinator.data["alarm_zones"].values()
-        current_devices = set(coordinator.data["alarm_zones"])
+    )
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitVedoBinarySensorEntity(
-                    coordinator, device, config_entry.entry_id
-                )
-                for device in coordinator.data["alarm_zones"].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitVedoBinarySensorEntity(

homeassistant/components/comelit/config_flow.py

@@ -25,27 +25,23 @@ from .const import _LOGGER, DEFAULT_PORT, DEVICE_TYPE_LIST, DOMAIN
 from .utils import async_client_session
 
 DEFAULT_HOST = "192.168.1.252"
-DEFAULT_PIN = "111111"
+DEFAULT_PIN = 111111
 
 
-pin_regex = r"^[0-9]{4,10}$"
-
 USER_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST, default=DEFAULT_HOST): cv.string,
         vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.matches_regex(pin_regex),
+        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.positive_int,
         vol.Required(CONF_TYPE, default=BRIDGE): vol.In(DEVICE_TYPE_LIST),
     }
 )
-STEP_REAUTH_DATA_SCHEMA = vol.Schema(
+STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PIN): cv.positive_int})
-    {vol.Required(CONF_PIN): cv.matches_regex(pin_regex)}
-)
 STEP_RECONFIGURE = vol.Schema(
     {
         vol.Required(CONF_HOST): cv.string,
         vol.Required(CONF_PORT): cv.port,
-        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.matches_regex(pin_regex),
+        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.positive_int,
     }
 )
 

homeassistant/components/comelit/coordinator.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from datetime import timedelta
-from typing import Any, TypeVar
+from typing import TypeVar
 
 from aiocomelit.api import (
     AlarmDataObject,
@@ -13,16 +13,7 @@ from aiocomelit.api import (
     ComelitVedoAreaObject,
     ComelitVedoZoneObject,
 )
-from aiocomelit.const import (
+from aiocomelit.const import BRIDGE, VEDO
-    BRIDGE,
-    CLIMATE,
-    COVER,
-    IRRIGATION,
-    LIGHT,
-    OTHER,
-    SCENARIO,
-    VEDO,
-)
 from aiocomelit.exceptions import CannotAuthenticate, CannotConnect, CannotRetrieveData
 from aiohttp import ClientSession
 
@@ -120,32 +111,6 @@ class ComelitBaseCoordinator(DataUpdateCoordinator[T]):
     async def _async_update_system_data(self) -> T:
         """Class method for updating data."""
 
-    async def _async_remove_stale_devices(
-        self,
-        previous_list: dict[int, Any],
-        current_list: dict[int, Any],
-        dev_type: str,
-    ) -> None:
-        """Remove stale devices."""
-        device_registry = dr.async_get(self.hass)
-
-        for i in previous_list:
-            if i not in current_list:
-                _LOGGER.debug(
-                    "Detected change in %s devices: index %s removed",
-                    dev_type,
-                    i,
-                )
-                identifier = f"{self.config_entry.entry_id}-{dev_type}-{i}"
-                device = device_registry.async_get_device(
-                    identifiers={(DOMAIN, identifier)}
-                )
-                if device:
-                    device_registry.async_update_device(
-                        device_id=device.id,
-                        remove_config_entry_id=self.config_entry.entry_id,
-                    )
-
 
 class ComelitSerialBridge(
     ComelitBaseCoordinator[dict[str, dict[int, ComelitSerialBridgeObject]]]
@@ -172,15 +137,7 @@ class ComelitSerialBridge(
         self,
     ) -> dict[str, dict[int, ComelitSerialBridgeObject]]:
         """Specific method for updating data."""
-        data = await self.api.get_all_devices()
+        return await self.api.get_all_devices()
-
-        if self.data:
-            for dev_type in (CLIMATE, COVER, LIGHT, IRRIGATION, OTHER, SCENARIO):
-                await self._async_remove_stale_devices(
-                    self.data[dev_type], data[dev_type], dev_type
-                )
-
-        return data
 
 
 class ComelitVedoSystem(ComelitBaseCoordinator[AlarmDataObject]):
@@ -206,14 +163,4 @@ class ComelitVedoSystem(ComelitBaseCoordinator[AlarmDataObject]):
         self,
     ) -> AlarmDataObject:
         """Specific method for updating data."""
-        data = await self.api.get_all_areas_and_zones()
+        return await self.api.get_all_areas_and_zones()
-
-        if self.data:
-            for obj_type in ("alarm_areas", "alarm_zones"):
-                await self._async_remove_stale_devices(
-                    self.data[obj_type],
-                    data[obj_type],
-                    "area" if obj_type == "alarm_areas" else "zone",
-                )
-
-        return data

homeassistant/components/comelit/cover.py

@@ -29,21 +29,10 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    async_add_entities(
-
+        ComelitCoverEntity(coordinator, device, config_entry.entry_id)
-    def _check_device() -> None:
+        for device in coordinator.data[COVER].values()
-        current_devices = set(coordinator.data[COVER])
+    )
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitCoverEntity(coordinator, device, config_entry.entry_id)
-                for device in coordinator.data[COVER].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):

homeassistant/components/comelit/light.py

@@ -27,21 +27,10 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    async_add_entities(
-
+        ComelitLightEntity(coordinator, device, config_entry.entry_id)
-    def _check_device() -> None:
+        for device in coordinator.data[LIGHT].values()
-        current_devices = set(coordinator.data[LIGHT])
+    )
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitLightEntity(coordinator, device, config_entry.entry_id)
-                for device in coordinator.data[LIGHT].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitLightEntity(ComelitBridgeBaseEntity, LightEntity):

homeassistant/components/comelit/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
-  "quality_scale": "platinum",
+  "quality_scale": "silver",
   "requirements": ["aiocomelit==0.12.3"]
 }

homeassistant/components/comelit/quality_scale.yaml

@@ -57,7 +57,9 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: done
+  dynamic-devices:
+    status: todo
+    comment: missing implementation
   entity-category:
     status: exempt
     comment: no config or diagnostic entities
@@ -70,7 +72,9 @@ rules:
   repair-issues:
     status: exempt
     comment: no known use cases for repair issues or flows, yet
-  stale-devices: done
+  stale-devices:
+    status: todo
+    comment: missing implementation
 
   # Platinum
   async-dependency: done

homeassistant/components/comelit/sensor.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Final, cast
 
-from aiocomelit.api import ComelitSerialBridgeObject, ComelitVedoZoneObject
+from aiocomelit import ComelitSerialBridgeObject, ComelitVedoZoneObject
 from aiocomelit.const import BRIDGE, OTHER, AlarmZoneState
 
 from homeassistant.components.sensor import (
@@ -65,24 +65,15 @@ async def async_setup_bridge_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    entities: list[ComelitBridgeSensorEntity] = []
-
+    for device in coordinator.data[OTHER].values():
-    def _check_device() -> None:
+        entities.extend(
-        current_devices = set(coordinator.data[OTHER])
+            ComelitBridgeSensorEntity(
-        new_devices = current_devices - known_devices
+                coordinator, device, config_entry.entry_id, sensor_desc
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitBridgeSensorEntity(
-                    coordinator, device, config_entry.entry_id, sensor_desc
-                )
-                for sensor_desc in SENSOR_BRIDGE_TYPES
-                for device in coordinator.data[OTHER].values()
-                if device.index in new_devices
             )
-
+            for sensor_desc in SENSOR_BRIDGE_TYPES
-    _check_device()
+        )
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    async_add_entities(entities)
 
 
 async def async_setup_vedo_entry(
@@ -94,24 +85,15 @@ async def async_setup_vedo_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    entities: list[ComelitVedoSensorEntity] = []
-
+    for device in coordinator.data["alarm_zones"].values():
-    def _check_device() -> None:
+        entities.extend(
-        current_devices = set(coordinator.data["alarm_zones"])
+            ComelitVedoSensorEntity(
-        new_devices = current_devices - known_devices
+                coordinator, device, config_entry.entry_id, sensor_desc
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitVedoSensorEntity(
-                    coordinator, device, config_entry.entry_id, sensor_desc
-                )
-                for sensor_desc in SENSOR_VEDO_TYPES
-                for device in coordinator.data["alarm_zones"].values()
-                if device.index in new_devices
             )
-
+            for sensor_desc in SENSOR_VEDO_TYPES
-    _check_device()
+        )
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    async_add_entities(entities)
 
 
 class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):

homeassistant/components/comelit/switch.py

@@ -39,25 +39,6 @@ async def async_setup_entry(
     )
     async_add_entities(entities)
 
-    known_devices: dict[str, set[int]] = {
-        dev_type: set() for dev_type in (IRRIGATION, OTHER)
-    }
-
-    def _check_device() -> None:
-        for dev_type in (IRRIGATION, OTHER):
-            current_devices = set(coordinator.data[dev_type])
-            new_devices = current_devices - known_devices[dev_type]
-            if new_devices:
-                known_devices[dev_type].update(new_devices)
-                async_add_entities(
-                    ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
-                    for device in coordinator.data[dev_type].values()
-                    if device.index in new_devices
-                )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
-
 
 class ComelitSwitchEntity(ComelitBridgeBaseEntity, SwitchEntity):
     """Switch device."""

homeassistant/components/compit/__init__.py

@@ -1,45 +0,0 @@
-"""The Compit integration."""
-
-from compit_inext_api import CannotConnect, CompitApiConnector, InvalidAuth
-
-from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
-
-PLATFORMS = [
-    Platform.CLIMATE,
-]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: CompitConfigEntry) -> bool:
-    """Set up Compit from a config entry."""
-
-    session = async_get_clientsession(hass)
-    connector = CompitApiConnector(session)
-    try:
-        connected = await connector.init(
-            entry.data[CONF_EMAIL], entry.data[CONF_PASSWORD], hass.config.language
-        )
-    except CannotConnect as e:
-        raise ConfigEntryNotReady(f"Error while connecting to Compit: {e}") from e
-    except InvalidAuth as e:
-        raise ConfigEntryAuthFailed(
-            f"Invalid credentials for {entry.data[CONF_EMAIL]}"
-        ) from e
-
-    if not connected:
-        raise ConfigEntryAuthFailed("Authentication API error")
-
-    coordinator = CompitDataUpdateCoordinator(hass, entry, connector)
-    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: CompitConfigEntry) -> bool:
-    """Unload an entry for the Compit integration."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/compit/climate.py

@@ -1,265 +0,0 @@
-"""Module contains the CompitClimate class for controlling climate entities."""
-
-import logging
-from typing import Any
-
-from compit_inext_api import Param, Parameter
-from compit_inext_api.consts import (
-    CompitFanMode,
-    CompitHVACMode,
-    CompitParameter,
-    CompitPresetMode,
-)
-from propcache.api import cached_property
-
-from homeassistant.components.climate import (
-    FAN_AUTO,
-    FAN_HIGH,
-    FAN_LOW,
-    FAN_MEDIUM,
-    FAN_OFF,
-    PRESET_AWAY,
-    PRESET_ECO,
-    PRESET_HOME,
-    PRESET_NONE,
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN, MANUFACTURER_NAME
-from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
-
-_LOGGER: logging.Logger = logging.getLogger(__name__)
-
-# Device class for climate devices in Compit system
-CLIMATE_DEVICE_CLASS = 10
-PARALLEL_UPDATES = 0
-
-COMPIT_MODE_MAP = {
-    CompitHVACMode.COOL: HVACMode.COOL,
-    CompitHVACMode.HEAT: HVACMode.HEAT,
-    CompitHVACMode.OFF: HVACMode.OFF,
-}
-
-COMPIT_FANSPEED_MAP = {
-    CompitFanMode.OFF: FAN_OFF,
-    CompitFanMode.AUTO: FAN_AUTO,
-    CompitFanMode.LOW: FAN_LOW,
-    CompitFanMode.MEDIUM: FAN_MEDIUM,
-    CompitFanMode.HIGH: FAN_HIGH,
-    CompitFanMode.HOLIDAY: FAN_AUTO,
-}
-
-COMPIT_PRESET_MAP = {
-    CompitPresetMode.AUTO: PRESET_HOME,
-    CompitPresetMode.HOLIDAY: PRESET_ECO,
-    CompitPresetMode.MANUAL: PRESET_NONE,
-    CompitPresetMode.AWAY: PRESET_AWAY,
-}
-
-HVAC_MODE_TO_COMPIT_MODE = {v: k for k, v in COMPIT_MODE_MAP.items()}
-FAN_MODE_TO_COMPIT_FAN_MODE = {v: k for k, v in COMPIT_FANSPEED_MAP.items()}
-PRESET_MODE_TO_COMPIT_PRESET_MODE = {v: k for k, v in COMPIT_PRESET_MAP.items()}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CompitConfigEntry,
-    async_add_devices: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the CompitClimate platform from a config entry."""
-
-    coordinator = entry.runtime_data
-    climate_entities = []
-    for device_id in coordinator.connector.all_devices:
-        device = coordinator.connector.all_devices[device_id]
-
-        if device.definition.device_class == CLIMATE_DEVICE_CLASS:
-            climate_entities.append(
-                CompitClimate(
-                    coordinator,
-                    device_id,
-                    {
-                        parameter.parameter_code: parameter
-                        for parameter in device.definition.parameters
-                    },
-                    device.definition.name,
-                )
-            )
-
-    async_add_devices(climate_entities)
-
-
-class CompitClimate(CoordinatorEntity[CompitDataUpdateCoordinator], ClimateEntity):
-    """Representation of a Compit climate device."""
-
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_hvac_modes = [*COMPIT_MODE_MAP.values()]
-    _attr_name = None
-    _attr_has_entity_name = True
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.FAN_MODE
-        | ClimateEntityFeature.PRESET_MODE
-    )
-
-    def __init__(
-        self,
-        coordinator: CompitDataUpdateCoordinator,
-        device_id: int,
-        parameters: dict[str, Parameter],
-        device_name: str,
-    ) -> None:
-        """Initialize the climate device."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{device_name}_{device_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, str(device_id))},
-            name=device_name,
-            manufacturer=MANUFACTURER_NAME,
-            model=device_name,
-        )
-
-        self.parameters = parameters
-        self.device_id = device_id
-        self.available_presets: Parameter | None = self.parameters.get(
-            CompitParameter.PRESET_MODE.value
-        )
-        self.available_fan_modes: Parameter | None = self.parameters.get(
-            CompitParameter.FAN_MODE.value
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            super().available
-            and self.device_id in self.coordinator.connector.all_devices
-        )
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        value = self.get_parameter_value(CompitParameter.CURRENT_TEMPERATURE)
-        if value is None:
-            return None
-        return float(value.value)
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the temperature we try to reach."""
-        value = self.get_parameter_value(CompitParameter.SET_TARGET_TEMPERATURE)
-        if value is None:
-            return None
-        return float(value.value)
-
-    @cached_property
-    def preset_modes(self) -> list[str] | None:
-        """Return the available preset modes."""
-        if self.available_presets is None or self.available_presets.details is None:
-            return []
-
-        preset_modes = []
-        for item in self.available_presets.details:
-            if item is not None:
-                ha_preset = COMPIT_PRESET_MAP.get(CompitPresetMode(item.state))
-                if ha_preset and ha_preset not in preset_modes:
-                    preset_modes.append(ha_preset)
-
-        return preset_modes
-
-    @cached_property
-    def fan_modes(self) -> list[str] | None:
-        """Return the available fan modes."""
-        if self.available_fan_modes is None or self.available_fan_modes.details is None:
-            return []
-
-        fan_modes = []
-        for item in self.available_fan_modes.details:
-            if item is not None:
-                ha_fan_mode = COMPIT_FANSPEED_MAP.get(CompitFanMode(item.state))
-                if ha_fan_mode and ha_fan_mode not in fan_modes:
-                    fan_modes.append(ha_fan_mode)
-
-        return fan_modes
-
-    @property
-    def preset_mode(self) -> str | None:
-        """Return the current preset mode."""
-        preset_mode = self.get_parameter_value(CompitParameter.PRESET_MODE)
-
-        if preset_mode:
-            compit_preset_mode = CompitPresetMode(preset_mode.value)
-            return COMPIT_PRESET_MAP.get(compit_preset_mode)
-        return None
-
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the current fan mode."""
-        fan_mode = self.get_parameter_value(CompitParameter.FAN_MODE)
-        if fan_mode:
-            compit_fan_mode = CompitFanMode(fan_mode.value)
-            return COMPIT_FANSPEED_MAP.get(compit_fan_mode)
-        return None
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        hvac_mode = self.get_parameter_value(CompitParameter.HVAC_MODE)
-        if hvac_mode:
-            compit_hvac_mode = CompitHVACMode(hvac_mode.value)
-            return COMPIT_MODE_MAP.get(compit_hvac_mode)
-        return None
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set new target temperature."""
-        temp = kwargs.get(ATTR_TEMPERATURE)
-        if temp is None:
-            raise ServiceValidationError("Temperature argument missing")
-        await self.set_parameter_value(CompitParameter.SET_TARGET_TEMPERATURE, temp)
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set new target HVAC mode."""
-
-        if not (mode := HVAC_MODE_TO_COMPIT_MODE.get(hvac_mode)):
-            raise ServiceValidationError(f"Invalid hvac mode {hvac_mode}")
-
-        await self.set_parameter_value(CompitParameter.HVAC_MODE, mode.value)
-
-    async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new target preset mode."""
-
-        compit_preset = PRESET_MODE_TO_COMPIT_PRESET_MODE.get(preset_mode)
-        if compit_preset is None:
-            raise ServiceValidationError(f"Invalid preset mode: {preset_mode}")
-
-        await self.set_parameter_value(CompitParameter.PRESET_MODE, compit_preset.value)
-
-    async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set new target fan mode."""
-
-        compit_fan_mode = FAN_MODE_TO_COMPIT_FAN_MODE.get(fan_mode)
-        if compit_fan_mode is None:
-            raise ServiceValidationError(f"Invalid fan mode: {fan_mode}")
-
-        await self.set_parameter_value(CompitParameter.FAN_MODE, compit_fan_mode.value)
-
-    async def set_parameter_value(self, parameter: CompitParameter, value: int) -> None:
-        """Call the API to set a parameter to a new value."""
-        await self.coordinator.connector.set_device_parameter(
-            self.device_id, parameter, value
-        )
-        self.async_write_ha_state()
-
-    def get_parameter_value(self, parameter: CompitParameter) -> Param | None:
-        """Get the parameter value from the device state."""
-        return self.coordinator.connector.get_device_parameter(
-            self.device_id, parameter
-        )

homeassistant/components/compit/config_flow.py

@@ -1,110 +0,0 @@
-"""Config flow for Compit integration."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-import logging
-from typing import Any
-
-from compit_inext_api import CannotConnect, CompitApiConnector, InvalidAuth
-import voluptuous as vol
-
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_EMAIL): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-STEP_REAUTH_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-
-class CompitConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Compit."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            session = async_create_clientsession(self.hass)
-            api = CompitApiConnector(session)
-            success = False
-            try:
-                success = await api.init(
-                    user_input[CONF_EMAIL],
-                    user_input[CONF_PASSWORD],
-                    self.hass.config.language,
-                )
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                if not success:
-                    # Api returned unexpected result but no exception
-                    _LOGGER.error("Compit api returned unexpected result")
-                    errors["base"] = "unknown"
-                else:
-                    await self.async_set_unique_id(user_input[CONF_EMAIL])
-
-                    if self.source == SOURCE_REAUTH:
-                        self._abort_if_unique_id_mismatch()
-                        return self.async_update_reload_and_abort(
-                            self._get_reauth_entry(), data_updates=user_input
-                        )
-                    self._abort_if_unique_id_configured()
-                    return self.async_create_entry(
-                        title=user_input[CONF_EMAIL], data=user_input
-                    )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
-
-    async def async_step_reauth(self, data: Mapping[str, Any]) -> ConfigFlowResult:
-        """Handle re-auth."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm re-authentication."""
-        errors: dict[str, str] = {}
-        reauth_entry = self._get_reauth_entry()
-        reauth_entry_data = reauth_entry.data
-
-        if user_input:
-            # Reuse async_step_user with combined credentials
-            return await self.async_step_user(
-                {
-                    CONF_EMAIL: reauth_entry_data[CONF_EMAIL],
-                    CONF_PASSWORD: user_input[CONF_PASSWORD],
-                }
-            )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=STEP_REAUTH_SCHEMA,
-            description_placeholders={CONF_EMAIL: reauth_entry_data[CONF_EMAIL]},
-            errors=errors,
-        )

homeassistant/components/compit/const.py

@@ -1,4 +0,0 @@
-"""Constants for the Compit integration."""
-
-DOMAIN = "compit"
-MANUFACTURER_NAME = "Compit"

homeassistant/components/compit/coordinator.py

@@ -1,43 +0,0 @@
-"""Define an object to manage fetching Compit data."""
-
-from datetime import timedelta
-import logging
-
-from compit_inext_api import CompitApiConnector, DeviceInstance
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-
-from .const import DOMAIN
-
-SCAN_INTERVAL = timedelta(seconds=30)
-_LOGGER: logging.Logger = logging.getLogger(__name__)
-
-type CompitConfigEntry = ConfigEntry[CompitDataUpdateCoordinator]
-
-
-class CompitDataUpdateCoordinator(DataUpdateCoordinator[dict[int, DeviceInstance]]):
-    """Class to manage fetching data from the API."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        connector: CompitApiConnector,
-    ) -> None:
-        """Initialize."""
-        self.connector = connector
-
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=SCAN_INTERVAL,
-            config_entry=config_entry,
-        )
-
-    async def _async_update_data(self) -> dict[int, DeviceInstance]:
-        """Update data via library."""
-        await self.connector.update_state(device_id=None)  # Update all devices
-        return self.connector.all_devices

homeassistant/components/compit/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "compit",
-  "name": "Compit",
-  "codeowners": ["@Przemko92"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/compit",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "loggers": ["compit"],
-  "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.3.1"]
-}

homeassistant/components/compit/quality_scale.yaml

@@ -1,86 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  appropriate-polling: done
-  brands: done
-  common-modules:
-    status: exempt
-    comment: |
-      This integration does not use any common modules.
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: |
-      Entities of this integration does not explicitly subscribe to events.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: |
-      This integration does not provide additional 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: todo
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: done
-  reauthentication-flow: done
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: |
-      This integration is a cloud service and does not support discovery.
-  discovery: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: done
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      This integration does not have any entities that should disabled by default.
-  entity-translations: done
-  exception-translations: todo
-  icon-translations:
-    status: exempt
-    comment: |
-      There is no need for icon translations.
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-  # Platinum
-  async-dependency: done
-  inject-websession: todo
-  strict-typing: done

homeassistant/components/compit/strings.json

@@ -1,35 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "description": "Please enter your https://inext.compit.pl/ credentials.",
-        "title": "Connect to Compit iNext",
-        "data": {
-          "email": "[%key:common::config_flow::data::email%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "email": "The email address of your inext.compit.pl account",
-          "password": "The password of your inext.compit.pl account"
-        }
-      },
-      "reauth_confirm": {
-        "description": "Please update your password for {email}",
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::compit::config::step::user::data_description::password%]"
-        }
-      }
-    },
-    "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%]"
-    },
-    "abort": {
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
-    }
-  }
-}

homeassistant/components/conversation/__init__.py

@@ -50,13 +50,14 @@ from .const import (
     ATTR_LANGUAGE,
     ATTR_TEXT,
     DATA_COMPONENT,
+    DATA_DEFAULT_ENTITY,
     DOMAIN,
     HOME_ASSISTANT_AGENT,
     SERVICE_PROCESS,
     SERVICE_RELOAD,
     ConversationEntityFeature,
 )
-from .default_agent import async_setup_default_agent
+from .default_agent import DefaultAgent, async_setup_default_agent
 from .entity import ConversationEntity
 from .http import async_setup as async_setup_conversation_http
 from .models import AbstractConversationAgent, ConversationInput, ConversationResult
@@ -141,7 +142,7 @@ def async_unset_agent(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
 ) -> None:
-    """Unset the agent to handle the conversations."""
+    """Set the agent to handle the conversations."""
     get_agent_manager(hass).async_unset_agent(config_entry.entry_id)
 
 
@@ -240,10 +241,10 @@ async def async_handle_sentence_triggers(
 
     Returns None if no match occurred.
     """
-    agent = get_agent_manager(hass).default_agent
+    default_agent = async_get_agent(hass)
-    assert agent is not None
+    assert isinstance(default_agent, DefaultAgent)
 
-    return await agent.async_handle_sentence_triggers(user_input)
+    return await default_agent.async_handle_sentence_triggers(user_input)
 
 
 async def async_handle_intents(
@@ -256,10 +257,12 @@ async def async_handle_intents(
 
     Returns None if no match occurred.
     """
-    agent = get_agent_manager(hass).default_agent
+    default_agent = async_get_agent(hass)
-    assert agent is not None
+    assert isinstance(default_agent, DefaultAgent)
 
-    return await agent.async_handle_intents(user_input, intent_filter=intent_filter)
+    return await default_agent.async_handle_intents(
+        user_input, intent_filter=intent_filter
+    )
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -295,9 +298,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async def handle_reload(service: ServiceCall) -> None:
         """Reload intents."""
-        agent = get_agent_manager(hass).default_agent
+        await hass.data[DATA_DEFAULT_ENTITY].async_reload(
-        if agent is not None:
+            language=service.data.get(ATTR_LANGUAGE)
-            await agent.async_reload(language=service.data.get(ATTR_LANGUAGE))
+        )
 
     hass.services.async_register(
         DOMAIN,

homeassistant/components/conversation/agent_manager.py

@@ -4,21 +4,15 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.core import (
+from homeassistant.core import Context, HomeAssistant, async_get_hass, callback
-    CALLBACK_TYPE,
-    Context,
-    HomeAssistant,
-    async_get_hass,
-    callback,
-)
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, intent, singleton
 
-from .const import DATA_COMPONENT, HOME_ASSISTANT_AGENT
+from .const import DATA_COMPONENT, DATA_DEFAULT_ENTITY, HOME_ASSISTANT_AGENT
 from .entity import ConversationEntity
 from .models import (
     AbstractConversationAgent,
@@ -34,10 +28,6 @@ from .trace import (
 
 _LOGGER = logging.getLogger(__name__)
 
-if TYPE_CHECKING:
-    from .default_agent import DefaultAgent
-    from .trigger import TriggerDetails
-
 
 @singleton.singleton("conversation_agent")
 @callback
@@ -59,10 +49,8 @@ def async_get_agent(
     hass: HomeAssistant, agent_id: str | None = None
 ) -> AbstractConversationAgent | ConversationEntity | None:
     """Get specified agent."""
-    manager = get_agent_manager(hass)
-
     if agent_id is None or agent_id == HOME_ASSISTANT_AGENT:
-        return manager.default_agent
+        return hass.data[DATA_DEFAULT_ENTITY]
 
     if "." in agent_id:
         return hass.data[DATA_COMPONENT].get_entity(agent_id)
@@ -146,8 +134,6 @@ class AgentManager:
         """Initialize the conversation agents."""
         self.hass = hass
         self._agents: dict[str, AbstractConversationAgent] = {}
-        self.default_agent: DefaultAgent | None = None
-        self.triggers_details: list[TriggerDetails] = []
 
     @callback
     def async_get_agent(self, agent_id: str) -> AbstractConversationAgent | None:
@@ -196,23 +182,3 @@ class AgentManager:
     def async_unset_agent(self, agent_id: str) -> None:
         """Unset the agent."""
         self._agents.pop(agent_id, None)
-
-    async def async_setup_default_agent(self, agent: DefaultAgent) -> None:
-        """Set up the default agent."""
-        agent.update_triggers(self.triggers_details)
-        self.default_agent = agent
-
-    def register_trigger(self, trigger_details: TriggerDetails) -> CALLBACK_TYPE:
-        """Register a trigger."""
-        self.triggers_details.append(trigger_details)
-        if self.default_agent is not None:
-            self.default_agent.update_triggers(self.triggers_details)
-
-        @callback
-        def unregister_trigger() -> None:
-            """Unregister the trigger."""
-            self.triggers_details.remove(trigger_details)
-            if self.default_agent is not None:
-                self.default_agent.update_triggers(self.triggers_details)
-
-        return unregister_trigger

homeassistant/components/conversation/const.py

@@ -10,9 +10,11 @@ from homeassistant.util.hass_dict import HassKey
 if TYPE_CHECKING:
     from homeassistant.helpers.entity_component import EntityComponent
 
+    from .default_agent import DefaultAgent
     from .entity import ConversationEntity
 
 DOMAIN = "conversation"
+DEFAULT_EXPOSED_ATTRIBUTES = {"device_class"}
 HOME_ASSISTANT_AGENT = "conversation.home_assistant"
 
 ATTR_TEXT = "text"
@@ -24,6 +26,7 @@ SERVICE_PROCESS = "process"
 SERVICE_RELOAD = "reload"
 
 DATA_COMPONENT: HassKey[EntityComponent[ConversationEntity]] = HassKey(DOMAIN)
+DATA_DEFAULT_ENTITY: HassKey[DefaultAgent] = HassKey(f"{DOMAIN}_default_entity")
 
 
 class ConversationEntityFeature(IntFlag):

homeassistant/components/conversation/default_agent.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import asyncio
 from collections import OrderedDict
-from collections.abc import Callable, Iterable
+from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import dataclass
 from enum import Enum, auto
+import functools
 import logging
 from pathlib import Path
+import re
 import time
 from typing import IO, Any, cast
 
@@ -51,7 +53,6 @@ from homeassistant.components.homeassistant.exposed_entities import (
     async_should_expose,
 )
 from homeassistant.const import EVENT_STATE_CHANGED, MATCH_ALL
-from homeassistant.core import Event, callback
 from homeassistant.helpers import (
     area_registry as ar,
     device_registry as dr,
@@ -67,22 +68,25 @@ from homeassistant.helpers.event import async_track_state_added_domain
 from homeassistant.util import language as language_util
 from homeassistant.util.json import JsonObjectType, json_loads_object
 
-from .agent_manager import get_agent_manager
 from .chat_log import AssistantContent, ChatLog
-from .const import DOMAIN, ConversationEntityFeature
+from .const import (
+    DATA_DEFAULT_ENTITY,
+    DEFAULT_EXPOSED_ATTRIBUTES,
+    DOMAIN,
+    ConversationEntityFeature,
+)
 from .entity import ConversationEntity
 from .models import ConversationInput, ConversationResult
 from .trace import ConversationTraceEventType, async_conversation_trace_append
-from .trigger import TriggerDetails
 
 _LOGGER = logging.getLogger(__name__)
-
-
 _DEFAULT_ERROR_TEXT = "Sorry, I couldn't understand that"
 _ENTITY_REGISTRY_UPDATE_FIELDS = ["aliases", "name", "original_name"]
 
-_DEFAULT_EXPOSED_ATTRIBUTES = {"device_class"}
+REGEX_TYPE = type(re.compile(""))
-
+TRIGGER_CALLBACK_TYPE = Callable[
+    [ConversationInput, RecognizeResult], Awaitable[str | None]
+]
 METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
 METADATA_CUSTOM_FILE = "hass_custom_file"
 METADATA_FUZZY_MATCH = "hass_fuzzy_match"
@@ -108,6 +112,14 @@ class LanguageIntents:
     fuzzy_responses: FuzzyLanguageResponses | None = None
 
 
+@dataclass(slots=True)
+class TriggerData:
+    """List of sentences and the callback for a trigger."""
+
+    sentences: list[str]
+    callback: TRIGGER_CALLBACK_TYPE
+
+
 @dataclass(slots=True)
 class SentenceTriggerResult:
     """Result when matching a sentence trigger in an automation."""
@@ -143,8 +155,8 @@ class IntentCacheKey:
     language: str
     """Language of text."""
 
-    satellite_id: str | None
+    device_id: str | None
-    """Satellite id from user input."""
+    """Device id from user input."""
 
 
 @dataclass(frozen=True)
@@ -197,9 +209,9 @@ async def async_setup_default_agent(
     config_intents: dict[str, Any],
 ) -> None:
     """Set up entity registry listener for the default agent."""
-    agent = DefaultAgent(hass, config_intents)
+    entity = DefaultAgent(hass, config_intents)
-    await entity_component.async_add_entities([agent])
+    await entity_component.async_add_entities([entity])
-    await get_agent_manager(hass).async_setup_default_agent(agent)
+    hass.data[DATA_DEFAULT_ENTITY] = entity
 
     @core.callback
     def async_entity_state_listener(
@@ -230,23 +242,21 @@ class DefaultAgent(ConversationEntity):
         """Initialize the default agent."""
         self.hass = hass
         self._lang_intents: dict[str, LanguageIntents | object] = {}
-        self._load_intents_lock = asyncio.Lock()
 
         # intent -> [sentences]
         self._config_intents: dict[str, Any] = config_intents
-
-        # Sentences that will trigger a callback (skipping intent recognition)
-        self._triggers_details: list[TriggerDetails] = []
-        self._trigger_intents: Intents | None = None
-
-        # Slot lists for entities, areas, etc.
         self._slot_lists: dict[str, SlotList] | None = None
-        self._unsub_clear_slot_list: list[Callable[[], None]] | None = None
 
         # Used to filter slot lists before intent matching
         self._exposed_names_trie: Trie | None = None
         self._unexposed_names_trie: Trie | None = None
 
+        # Sentences that will trigger a callback (skipping intent recognition)
+        self.trigger_sentences: list[TriggerData] = []
+        self._trigger_intents: Intents | None = None
+        self._unsub_clear_slot_list: list[Callable[[], None]] | None = None
+        self._load_intents_lock = asyncio.Lock()
+
         # LRU cache to avoid unnecessary intent matching
         self._intent_cache = IntentCache(capacity=128)
 
@@ -435,15 +445,9 @@ class DefaultAgent(ConversationEntity):
             }
             for entity in result.entities_list
         }
-
+        device_area = self._get_device_area(user_input.device_id)
-        satellite_id = user_input.satellite_id
+        if device_area:
-        device_id = user_input.device_id
+            slots["preferred_area_id"] = {"value": device_area.id}
-        satellite_area, device_id = self._get_satellite_area_and_device(
-            satellite_id, device_id
-        )
-        if satellite_area is not None:
-            slots["preferred_area_id"] = {"value": satellite_area.id}
-
         async_conversation_trace_append(
             ConversationTraceEventType.TOOL_CALL,
             {
@@ -465,8 +469,8 @@ class DefaultAgent(ConversationEntity):
                 user_input.context,
                 language,
                 assistant=DOMAIN,
-                device_id=device_id,
+                device_id=user_input.device_id,
-                satellite_id=satellite_id,
+                satellite_id=user_input.satellite_id,
                 conversation_agent_id=user_input.agent_id,
             )
         except intent.MatchFailedError as match_error:
@@ -532,9 +536,7 @@ class DefaultAgent(ConversationEntity):
 
         # Try cache first
         cache_key = IntentCacheKey(
-            text=user_input.text,
+            text=user_input.text, language=language, device_id=user_input.device_id
-            language=language,
-            satellite_id=user_input.satellite_id,
         )
         cache_value = self._intent_cache.get(cache_key)
         if cache_value is not None:
@@ -844,7 +846,7 @@ class DefaultAgent(ConversationEntity):
             context = {"domain": state.domain}
             if state.attributes:
                 # Include some attributes
-                for attr in _DEFAULT_EXPOSED_ATTRIBUTES:
+                for attr in DEFAULT_EXPOSED_ATTRIBUTES:
                     if attr not in state.attributes:
                         continue
                     context[attr] = state.attributes[attr]
@@ -1190,8 +1192,8 @@ class DefaultAgent(ConversationEntity):
             fuzzy_responses=fuzzy_responses,
         )
 
-    @callback
+    @core.callback
-    def _async_clear_slot_list(self, event: Event[Any] | None = None) -> None:
+    def _async_clear_slot_list(self, event: core.Event[Any] | None = None) -> None:
         """Clear slot lists when a registry has changed."""
         # Two subscribers can be scheduled at same time
         _LOGGER.debug("Clearing slot lists")
@@ -1304,40 +1306,28 @@ class DefaultAgent(ConversationEntity):
         self, user_input: ConversationInput
     ) -> dict[str, Any] | None:
         """Return intent recognition context for user input."""
-        satellite_area, _ = self._get_satellite_area_and_device(
+        if not user_input.device_id:
-            user_input.satellite_id, user_input.device_id
-        )
-        if satellite_area is None:
             return None
 
-        return {"area": {"value": satellite_area.name, "text": satellite_area.name}}
+        device_area = self._get_device_area(user_input.device_id)
+        if device_area is None:
+            return None
 
-    def _get_satellite_area_and_device(
+        return {"area": {"value": device_area.name, "text": device_area.name}}
-        self, satellite_id: str | None, device_id: str | None = None
-    ) -> tuple[ar.AreaEntry | None, str | None]:
-        """Return area entry and device id."""
-        hass = self.hass
 
-        area_id: str | None = None
+    def _get_device_area(self, device_id: str | None) -> ar.AreaEntry | None:
+        """Return area object for given device identifier."""
+        if device_id is None:
+            return None
 
-        if (
+        devices = dr.async_get(self.hass)
-            satellite_id is not None
+        device = devices.async_get(device_id)
-            and (entity_entry := er.async_get(hass).async_get(satellite_id)) is not None
+        if (device is None) or (device.area_id is None):
-        ):
+            return None
-            area_id = entity_entry.area_id
-            device_id = entity_entry.device_id
 
-        if (
+        areas = ar.async_get(self.hass)
-            area_id is None
-            and device_id is not None
-            and (device_entry := dr.async_get(hass).async_get(device_id)) is not None
-        ):
-            area_id = device_entry.area_id
 
-        if area_id is None:
+        return areas.async_get_area(device.area_id)
-            return None, device_id
-
-        return ar.async_get(hass).async_get_area(area_id), device_id
 
     def _get_error_text(
         self,
@@ -1361,14 +1351,22 @@ class DefaultAgent(ConversationEntity):
 
         return response_template.async_render(response_args)
 
-    @callback
+    @core.callback
-    def update_triggers(self, triggers_details: list[TriggerDetails]) -> None:
+    def register_trigger(
-        """Update triggers."""
+        self,
-        self._triggers_details = triggers_details
+        sentences: list[str],
+        callback: TRIGGER_CALLBACK_TYPE,
+    ) -> core.CALLBACK_TYPE:
+        """Register a list of sentences that will trigger a callback when recognized."""
+        trigger_data = TriggerData(sentences=sentences, callback=callback)
+        self.trigger_sentences.append(trigger_data)
 
         # Force rebuild on next use
         self._trigger_intents = None
 
+        return functools.partial(self._unregister_trigger, trigger_data)
+
+    @core.callback
     def _rebuild_trigger_intents(self) -> None:
         """Rebuild the HassIL intents object from the current trigger sentences."""
         intents_dict = {
@@ -1377,8 +1375,8 @@ class DefaultAgent(ConversationEntity):
                 # Use trigger data index as a virtual intent name for HassIL.
                 # This works because the intents are rebuilt on every
                 # register/unregister.
-                str(trigger_id): {"data": [{"sentences": trigger_details.sentences}]}
+                str(trigger_id): {"data": [{"sentences": trigger_data.sentences}]}
-                for trigger_id, trigger_details in enumerate(self._triggers_details)
+                for trigger_id, trigger_data in enumerate(self.trigger_sentences)
             },
         }
 
@@ -1398,6 +1396,14 @@ class DefaultAgent(ConversationEntity):
 
         _LOGGER.debug("Rebuilt trigger intents: %s", intents_dict)
 
+    @core.callback
+    def _unregister_trigger(self, trigger_data: TriggerData) -> None:
+        """Unregister a set of trigger sentences."""
+        self.trigger_sentences.remove(trigger_data)
+
+        # Force rebuild on next use
+        self._trigger_intents = None
+
     async def async_recognize_sentence_trigger(
         self, user_input: ConversationInput
     ) -> SentenceTriggerResult | None:
@@ -1406,7 +1412,7 @@ class DefaultAgent(ConversationEntity):
         Calls the registered callbacks if there's a match and returns a sentence
         trigger result.
         """
-        if not self._triggers_details:
+        if not self.trigger_sentences:
             # No triggers registered
             return None
 
@@ -1451,7 +1457,7 @@ class DefaultAgent(ConversationEntity):
 
         # Gather callback responses in parallel
         trigger_callbacks = [
-            self._triggers_details[trigger_id].callback(user_input, trigger_result)
+            self.trigger_sentences[trigger_id].callback(user_input, trigger_result)
             for trigger_id, trigger_result in result.matched_triggers.items()
         ]
 

homeassistant/components/conversation/http.py

@@ -25,7 +25,7 @@ from .agent_manager import (
     async_get_agent,
     get_agent_manager,
 )
-from .const import DATA_COMPONENT
+from .const import DATA_COMPONENT, DATA_DEFAULT_ENTITY
 from .default_agent import (
     METADATA_CUSTOM_FILE,
     METADATA_CUSTOM_SENTENCE,
@@ -169,11 +169,11 @@ async def websocket_list_sentences(
     hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict
 ) -> None:
     """List custom registered sentences."""
-    manager = get_agent_manager(hass)
+    agent = hass.data[DATA_DEFAULT_ENTITY]
 
     sentences = []
-    for trigger_details in manager.triggers_details:
+    for trigger_data in agent.trigger_sentences:
-        sentences.extend(trigger_details.sentences)
+        sentences.extend(trigger_data.sentences)
 
     connection.send_result(msg["id"], {"trigger_sentences": sentences})
 
@@ -191,8 +191,7 @@ async def websocket_hass_agent_debug(
     hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict
 ) -> None:
     """Return intents that would be matched by the default agent for a list of sentences."""
-    agent = get_agent_manager(hass).default_agent
+    agent = hass.data[DATA_DEFAULT_ENTITY]
-    assert agent is not None
 
     # Return results for each sentence in the same order as the input.
     result_dicts: list[dict[str, Any] | None] = []

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.2.0", "home-assistant-intents==2025.9.24"]
+  "requirements": ["hassil==3.2.0", "home-assistant-intents==2025.9.3"]
 }

homeassistant/components/conversation/trigger.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
 from typing import Any
 
 from hassil.recognize import RecognizeResult
@@ -17,27 +15,14 @@ import voluptuous as vol
 
 from homeassistant.const import CONF_COMMAND, CONF_PLATFORM
 from homeassistant.core import CALLBACK_TYPE, HassJob, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.script import ScriptRunResult
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import UNDEFINED, ConfigType
 
-from .agent_manager import get_agent_manager
+from .const import DATA_DEFAULT_ENTITY, DOMAIN
-from .const import DOMAIN
 from .models import ConversationInput
 
-TRIGGER_CALLBACK_TYPE = Callable[
-    [ConversationInput, RecognizeResult], Awaitable[str | None]
-]
-
-
-@dataclass(slots=True)
-class TriggerDetails:
-    """List of sentences and the callback for a trigger."""
-
-    sentences: list[str]
-    callback: TRIGGER_CALLBACK_TYPE
-
 
 def has_no_punctuation(value: list[str]) -> list[str]:
     """Validate result does not contain punctuation."""
@@ -85,8 +70,6 @@ async def async_attach_trigger(
     trigger_data = trigger_info["trigger_data"]
     sentences = config.get(CONF_COMMAND, [])
 
-    ent_reg = er.async_get(hass)
-
     job = HassJob(action)
 
     async def call_action(
@@ -108,14 +91,6 @@ async def async_attach_trigger(
             for entity_name, entity in result.entities.items()
         }
 
-        satellite_id = user_input.satellite_id
-        device_id = user_input.device_id
-        if (
-            satellite_id is not None
-            and (satellite_entry := ent_reg.async_get(satellite_id)) is not None
-        ):
-            device_id = satellite_entry.device_id
-
         trigger_input: dict[str, Any] = {  # Satisfy type checker
             **trigger_data,
             "platform": DOMAIN,
@@ -124,8 +99,8 @@ async def async_attach_trigger(
             "slots": {  # direct access to values
                 entity_name: entity["value"] for entity_name, entity in details.items()
             },
-            "device_id": device_id,
+            "device_id": user_input.device_id,
-            "satellite_id": satellite_id,
+            "satellite_id": user_input.satellite_id,
             "user_input": user_input.as_dict(),
         }
 
@@ -148,6 +123,4 @@ async def async_attach_trigger(
         # two trigger copies for who will provide a response.
         return None
 
-    return get_agent_manager(hass).register_trigger(
+    return hass.data[DATA_DEFAULT_ENTITY].register_trigger(sentences, call_action)
-        TriggerDetails(sentences=sentences, callback=call_action)
-    )

homeassistant/components/cync/__init__.py

@@ -1,58 +0,0 @@
-"""The Cync integration."""
-
-from __future__ import annotations
-
-from pycync import Auth, Cync, User
-from pycync.exceptions import AuthFailedError, CyncError
-
-from homeassistant.const import CONF_ACCESS_TOKEN, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import (
-    CONF_AUTHORIZE_STRING,
-    CONF_EXPIRES_AT,
-    CONF_REFRESH_TOKEN,
-    CONF_USER_ID,
-)
-from .coordinator import CyncConfigEntry, CyncCoordinator
-
-_PLATFORMS: list[Platform] = [Platform.LIGHT]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: CyncConfigEntry) -> bool:
-    """Set up Cync from a config entry."""
-    user_info = User(
-        entry.data[CONF_ACCESS_TOKEN],
-        entry.data[CONF_REFRESH_TOKEN],
-        entry.data[CONF_AUTHORIZE_STRING],
-        entry.data[CONF_USER_ID],
-        expires_at=entry.data[CONF_EXPIRES_AT],
-    )
-    cync_auth = Auth(async_get_clientsession(hass), user=user_info)
-
-    try:
-        cync = await Cync.create(cync_auth)
-    except AuthFailedError as ex:
-        raise ConfigEntryAuthFailed("User token invalid") from ex
-    except CyncError as ex:
-        raise ConfigEntryNotReady("Unable to connect to Cync") from ex
-
-    devices_coordinator = CyncCoordinator(hass, entry, cync)
-
-    cync.set_update_callback(devices_coordinator.on_data_update)
-
-    await devices_coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = devices_coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: CyncConfigEntry) -> bool:
-    """Unload a config entry."""
-    cync = entry.runtime_data.cync
-    await cync.shut_down()
-    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/cync/config_flow.py

@@ -1,118 +0,0 @@
-"""Config flow for the Cync integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from pycync import Auth
-from pycync.exceptions import AuthFailedError, CyncError, TwoFactorRequiredError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import (
-    CONF_AUTHORIZE_STRING,
-    CONF_EXPIRES_AT,
-    CONF_REFRESH_TOKEN,
-    CONF_TWO_FACTOR_CODE,
-    CONF_USER_ID,
-    DOMAIN,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_EMAIL): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-STEP_TWO_FACTOR_SCHEMA = vol.Schema({vol.Required(CONF_TWO_FACTOR_CODE): str})
-
-
-class CyncConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Cync."""
-
-    VERSION = 1
-
-    cync_auth: Auth
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Attempt login with user credentials."""
-        errors: dict[str, str] = {}
-
-        if user_input is None:
-            return self.async_show_form(
-                step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-            )
-
-        self.cync_auth = Auth(
-            async_get_clientsession(self.hass),
-            username=user_input[CONF_EMAIL],
-            password=user_input[CONF_PASSWORD],
-        )
-        try:
-            await self.cync_auth.login()
-        except AuthFailedError:
-            errors["base"] = "invalid_auth"
-        except TwoFactorRequiredError:
-            return await self.async_step_two_factor()
-        except CyncError:
-            errors["base"] = "cannot_connect"
-        except Exception:
-            _LOGGER.exception("Unexpected exception")
-            errors["base"] = "unknown"
-        else:
-            return await self._create_config_entry(self.cync_auth.username)
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
-
-    async def async_step_two_factor(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Attempt login with the two factor auth code sent to the user."""
-        errors: dict[str, str] = {}
-
-        if user_input is None:
-            return self.async_show_form(
-                step_id="two_factor", data_schema=STEP_TWO_FACTOR_SCHEMA, errors=errors
-            )
-        try:
-            await self.cync_auth.login(user_input[CONF_TWO_FACTOR_CODE])
-        except AuthFailedError:
-            errors["base"] = "invalid_auth"
-        except CyncError:
-            errors["base"] = "cannot_connect"
-        except Exception:
-            _LOGGER.exception("Unexpected exception")
-            errors["base"] = "unknown"
-        else:
-            return await self._create_config_entry(self.cync_auth.username)
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
-
-    async def _create_config_entry(self, user_email: str) -> ConfigFlowResult:
-        """Create the Cync config entry using input user data."""
-
-        cync_user = self.cync_auth.user
-        await self.async_set_unique_id(str(cync_user.user_id))
-        self._abort_if_unique_id_configured()
-
-        config = {
-            CONF_USER_ID: cync_user.user_id,
-            CONF_AUTHORIZE_STRING: cync_user.authorize,
-            CONF_EXPIRES_AT: cync_user.expires_at,
-            CONF_ACCESS_TOKEN: cync_user.access_token,
-            CONF_REFRESH_TOKEN: cync_user.refresh_token,
-        }
-        return self.async_create_entry(title=user_email, data=config)

homeassistant/components/cync/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Cync integration."""
-
-DOMAIN = "cync"
-
-CONF_TWO_FACTOR_CODE = "two_factor_code"
-CONF_USER_ID = "user_id"
-CONF_AUTHORIZE_STRING = "authorize_string"
-CONF_EXPIRES_AT = "expires_at"
-CONF_REFRESH_TOKEN = "refresh_token"

homeassistant/components/cync/coordinator.py

@@ -1,87 +0,0 @@
-"""Coordinator to handle keeping device states up to date."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-import time
-
-from pycync import Cync, CyncDevice, User
-from pycync.exceptions import AuthFailedError
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ACCESS_TOKEN
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-
-from .const import CONF_EXPIRES_AT, CONF_REFRESH_TOKEN
-
-_LOGGER = logging.getLogger(__name__)
-
-type CyncConfigEntry = ConfigEntry[CyncCoordinator]
-
-
-class CyncCoordinator(DataUpdateCoordinator[dict[int, CyncDevice]]):
-    """Coordinator to handle updating Cync device states."""
-
-    config_entry: CyncConfigEntry
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: CyncConfigEntry, cync: Cync
-    ) -> None:
-        """Initialize the Cync coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name="Cync Data Coordinator",
-            config_entry=config_entry,
-            update_interval=timedelta(seconds=30),
-            always_update=True,
-        )
-        self.cync = cync
-
-    async def on_data_update(self, data: dict[int, CyncDevice]) -> None:
-        """Update registered devices with new data."""
-        merged_data = self.data | data if self.data else data
-        self.async_set_updated_data(merged_data)
-
-    async def _async_setup(self) -> None:
-        """Set up the coordinator with initial device states."""
-        logged_in_user = self.cync.get_logged_in_user()
-        if logged_in_user.access_token != self.config_entry.data[CONF_ACCESS_TOKEN]:
-            await self._update_config_cync_credentials(logged_in_user)
-
-    async def _async_update_data(self) -> dict[int, CyncDevice]:
-        """First, refresh the user's auth token if it is set to expire in less than one hour.
-
-        Then, fetch all current device states.
-        """
-
-        logged_in_user = self.cync.get_logged_in_user()
-        if logged_in_user.expires_at - time.time() < 3600:
-            await self._async_refresh_cync_credentials()
-
-        self.cync.update_device_states()
-        current_device_states = self.cync.get_devices()
-
-        return {device.device_id: device for device in current_device_states}
-
-    async def _async_refresh_cync_credentials(self) -> None:
-        """Attempt to refresh the Cync user's authentication token."""
-
-        try:
-            refreshed_user = await self.cync.refresh_credentials()
-        except AuthFailedError as ex:
-            raise ConfigEntryAuthFailed("Unable to refresh user token") from ex
-        else:
-            await self._update_config_cync_credentials(refreshed_user)
-
-    async def _update_config_cync_credentials(self, user_info: User) -> None:
-        """Update the config entry with current user info."""
-
-        new_data = {**self.config_entry.data}
-        new_data[CONF_ACCESS_TOKEN] = user_info.access_token
-        new_data[CONF_REFRESH_TOKEN] = user_info.refresh_token
-        new_data[CONF_EXPIRES_AT] = user_info.expires_at
-        self.hass.config_entries.async_update_entry(self.config_entry, data=new_data)

homeassistant/components/cync/entity.py

@@ -1,45 +0,0 @@
-"""Setup for a generic entity type for the Cync integration."""
-
-from pycync.devices import CyncDevice
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import CyncCoordinator
-
-
-class CyncBaseEntity(CoordinatorEntity[CyncCoordinator]):
-    """Generic base entity for Cync devices."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        device: CyncDevice,
-        coordinator: CyncCoordinator,
-        room_name: str | None = None,
-    ) -> None:
-        """Pass coordinator to CoordinatorEntity."""
-        super().__init__(coordinator)
-
-        self._cync_device_id = device.device_id
-        self._attr_unique_id = device.unique_id
-
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.unique_id)},
-            manufacturer="GE Lighting",
-            name=device.name,
-            suggested_area=room_name,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Determines whether this device is currently available."""
-
-        return (
-            super().available
-            and self.coordinator.data is not None
-            and self._cync_device_id in self.coordinator.data
-            and self.coordinator.data[self._cync_device_id].is_online
-        )

homeassistant/components/cync/light.py

@@ -1,180 +0,0 @@
-"""Support for Cync light entities."""
-
-from typing import Any
-
-from pycync import CyncLight
-from pycync.devices.capabilities import CyncCapability
-
-from homeassistant.components.light import (
-    ATTR_BRIGHTNESS,
-    ATTR_COLOR_TEMP_KELVIN,
-    ATTR_RGB_COLOR,
-    ColorMode,
-    LightEntity,
-    filter_supported_color_modes,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util.color import value_to_brightness
-from homeassistant.util.scaling import scale_ranged_value_to_int_range
-
-from .coordinator import CyncConfigEntry, CyncCoordinator
-from .entity import CyncBaseEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CyncConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Cync lights from a config entry."""
-
-    coordinator = entry.runtime_data
-    cync = coordinator.cync
-
-    entities_to_add = []
-
-    for home in cync.get_homes():
-        for room in home.rooms:
-            room_lights = [
-                CyncLightEntity(device, coordinator, room.name)
-                for device in room.devices
-                if isinstance(device, CyncLight)
-            ]
-            entities_to_add.extend(room_lights)
-
-            group_lights = [
-                CyncLightEntity(device, coordinator, room.name)
-                for group in room.groups
-                for device in group.devices
-                if isinstance(device, CyncLight)
-            ]
-            entities_to_add.extend(group_lights)
-
-    async_add_entities(entities_to_add)
-
-
-class CyncLightEntity(CyncBaseEntity, LightEntity):
-    """Representation of a Cync light."""
-
-    _attr_color_mode = ColorMode.ONOFF
-    _attr_min_color_temp_kelvin = 2000
-    _attr_max_color_temp_kelvin = 7000
-    _attr_translation_key = "light"
-    _attr_name = None
-
-    BRIGHTNESS_SCALE = (0, 100)
-
-    def __init__(
-        self,
-        device: CyncLight,
-        coordinator: CyncCoordinator,
-        room_name: str | None = None,
-    ) -> None:
-        """Set up base attributes."""
-        super().__init__(device, coordinator, room_name)
-
-        supported_color_modes = {ColorMode.ONOFF}
-        if device.supports_capability(CyncCapability.CCT_COLOR):
-            supported_color_modes.add(ColorMode.COLOR_TEMP)
-        if device.supports_capability(CyncCapability.DIMMING):
-            supported_color_modes.add(ColorMode.BRIGHTNESS)
-        if device.supports_capability(CyncCapability.RGB_COLOR):
-            supported_color_modes.add(ColorMode.RGB)
-        self._attr_supported_color_modes = filter_supported_color_modes(
-            supported_color_modes
-        )
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return True if the light is on."""
-        return self._device.is_on
-
-    @property
-    def brightness(self) -> int:
-        """Provide the light's current brightness."""
-        return value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
-
-    @property
-    def color_temp_kelvin(self) -> int:
-        """Return color temperature in kelvin."""
-        return scale_ranged_value_to_int_range(
-            (1, 100),
-            (self.min_color_temp_kelvin, self.max_color_temp_kelvin),
-            self._device.color_temp,
-        )
-
-    @property
-    def rgb_color(self) -> tuple[int, int, int]:
-        """Provide the light's current color in RGB format."""
-        return self._device.rgb
-
-    @property
-    def color_mode(self) -> str | None:
-        """Return the active color mode."""
-
-        if (
-            self._device.supports_capability(CyncCapability.CCT_COLOR)
-            and self._device.color_mode > 0
-            and self._device.color_mode <= 100
-        ):
-            return ColorMode.COLOR_TEMP
-        if (
-            self._device.supports_capability(CyncCapability.RGB_COLOR)
-            and self._device.color_mode == 254
-        ):
-            return ColorMode.RGB
-        if self._device.supports_capability(CyncCapability.DIMMING):
-            return ColorMode.BRIGHTNESS
-
-        return ColorMode.ONOFF
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Process an action on the light."""
-        if not kwargs:
-            await self._device.turn_on()
-
-        elif kwargs.get(ATTR_COLOR_TEMP_KELVIN) is not None:
-            color_temp = kwargs.get(ATTR_COLOR_TEMP_KELVIN)
-            converted_color_temp = self._normalize_color_temp(color_temp)
-
-            await self._device.set_color_temp(converted_color_temp)
-        elif kwargs.get(ATTR_RGB_COLOR) is not None:
-            rgb = kwargs.get(ATTR_RGB_COLOR)
-
-            await self._device.set_rgb(rgb)
-        elif kwargs.get(ATTR_BRIGHTNESS) is not None:
-            brightness = kwargs.get(ATTR_BRIGHTNESS)
-            converted_brightness = self._normalize_brightness(brightness)
-
-            await self._device.set_brightness(converted_brightness)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off the light."""
-        await self._device.turn_off()
-
-    def _normalize_brightness(self, brightness: float | None) -> int | None:
-        """Return calculated brightness value scaled between 0-100."""
-        if brightness is not None:
-            return int((brightness / 255) * 100)
-
-        return None
-
-    def _normalize_color_temp(self, color_temp_kelvin: float | None) -> int | None:
-        """Return calculated color temp value scaled between 1-100."""
-        if color_temp_kelvin is not None:
-            kelvin_range = self.max_color_temp_kelvin - self.min_color_temp_kelvin
-            scaled_kelvin = int(
-                ((color_temp_kelvin - self.min_color_temp_kelvin) / kelvin_range) * 100
-            )
-            if scaled_kelvin == 0:
-                scaled_kelvin += 1
-
-            return scaled_kelvin
-        return None
-
-    @property
-    def _device(self) -> CyncLight:
-        """Fetch the reference to the backing Cync light for this device."""
-
-        return self.coordinator.data[self._cync_device_id]

homeassistant/components/cync/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "cync",
-  "name": "Cync",
-  "codeowners": ["@Kinachi249"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/cync",
-  "integration_type": "hub",
-  "iot_class": "cloud_push",
-  "quality_scale": "bronze",
-  "requirements": ["pycync==0.4.0"]
-}

homeassistant/components/cync/quality_scale.yaml

@@ -1,69 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  appropriate-polling: done
-  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 provide additional actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: |
-      This integration does not provide additional actions.
-  config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
-  entity-unavailable: todo
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: todo
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: done
-  docs-supported-devices: todo
-  docs-supported-functions: done
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/cync/strings.json

@@ -1,32 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "data": {
-          "email": "[%key:common::config_flow::data::email%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "email": "Your Cync account's email address",
-          "password": "Your Cync account's password"
-        }
-      },
-      "two_factor": {
-        "data": {
-          "two_factor_code": "Two-factor code"
-        },
-        "data_description": {
-          "two_factor_code": "The two-factor code sent to your Cync account's email"
-        }
-      }
-    },
-    "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%]"
-    },
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
-    }
-  }
-}

homeassistant/components/default_config/manifest.json

@@ -9,7 +9,6 @@
     "conversation",
     "dhcp",
     "energy",
-    "file",
     "go2rtc",
     "history",
     "homeassistant_alerts",
@@ -20,7 +19,6 @@
     "ssdp",
     "stream",
     "sun",
-    "usage_prediction",
     "usb",
     "webhook",
     "zeroconf"

homeassistant/components/deluge/const.py

@@ -43,5 +43,3 @@ class DelugeSensorType(enum.StrEnum):
     UPLOAD_SPEED_SENSOR = "upload_speed"
     PROTOCOL_TRAFFIC_UPLOAD_SPEED_SENSOR = "protocol_traffic_upload_speed"
     PROTOCOL_TRAFFIC_DOWNLOAD_SPEED_SENSOR = "protocol_traffic_download_speed"
-    DOWNLOADING_COUNT_SENSOR = "downloading_count"
-    SEEDING_COUNT_SENSOR = "seeding_count"

homeassistant/components/deluge/coordinator.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from collections import Counter
 from datetime import timedelta
 from ssl import SSLError
 from typing import Any
@@ -15,22 +14,11 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import LOGGER, DelugeGetSessionStatusKeys, DelugeSensorType
+from .const import LOGGER, DelugeGetSessionStatusKeys
 
 type DelugeConfigEntry = ConfigEntry[DelugeDataUpdateCoordinator]
 
 
-def count_states(data: dict[str, Any]) -> dict[str, int]:
-    """Count the states of the provided torrents."""
-
-    counts = Counter(torrent[b"state"].decode() for torrent in data.values())
-
-    return {
-        DelugeSensorType.DOWNLOADING_COUNT_SENSOR.value: counts.get("Downloading", 0),
-        DelugeSensorType.SEEDING_COUNT_SENSOR.value: counts.get("Seeding", 0),
-    }
-
-
 class DelugeDataUpdateCoordinator(
     DataUpdateCoordinator[dict[Platform, dict[str, Any]]]
 ):
@@ -51,22 +39,19 @@ class DelugeDataUpdateCoordinator(
         )
         self.api = api
 
-    def _get_deluge_data(self):
+    async def _async_update_data(self) -> dict[Platform, dict[str, Any]]:
-        """Get the latest data from Deluge."""
+        """Get the latest data from Deluge and updates the state."""
-
         data = {}
         try:
-            data["session_status"] = self.api.call(
+            _data = await self.hass.async_add_executor_job(
+                self.api.call,
                 "core.get_session_status",
                 [iter_member.value for iter_member in list(DelugeGetSessionStatusKeys)],
             )
-            data["torrents_status_state"] = self.api.call(
+            data[Platform.SENSOR] = {k.decode(): v for k, v in _data.items()}
-                "core.get_torrents_status", {}, ["state"]
+            data[Platform.SWITCH] = await self.hass.async_add_executor_job(
+                self.api.call, "core.get_torrents_status", {}, ["paused"]
             )
-            data["torrents_status_paused"] = self.api.call(
-                "core.get_torrents_status", {}, ["paused"]
-            )
-
         except (
             ConnectionRefusedError,
             TimeoutError,
@@ -81,18 +66,4 @@ class DelugeDataUpdateCoordinator(
                 ) from ex
             LOGGER.error("Unknown error connecting to Deluge: %s", ex)
             raise
-
-        return data
-
-    async def _async_update_data(self) -> dict[Platform, dict[str, Any]]:
-        """Get the latest data from Deluge and updates the state."""
-
-        deluge_data = await self.hass.async_add_executor_job(self._get_deluge_data)
-
-        data = {}
-        data[Platform.SENSOR] = {
-            k.decode(): v for k, v in deluge_data["session_status"].items()
-        }
-        data[Platform.SENSOR].update(count_states(deluge_data["torrents_status_state"]))
-        data[Platform.SWITCH] = deluge_data["torrents_status_paused"]
         return data

homeassistant/components/deluge/icons.json

@@ -1,12 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "downloading_count": {
-        "default": "mdi:download"
-      },
-      "seeding_count": {
-        "default": "mdi:upload"
-      }
-    }
-  }
-}

homeassistant/components/deluge/sensor.py

@@ -110,18 +110,6 @@ SENSOR_TYPES: tuple[DelugeSensorEntityDescription, ...] = (
             data, DelugeSensorType.PROTOCOL_TRAFFIC_DOWNLOAD_SPEED_SENSOR.value
         ),
     ),
-    DelugeSensorEntityDescription(
-        key=DelugeSensorType.DOWNLOADING_COUNT_SENSOR.value,
-        translation_key=DelugeSensorType.DOWNLOADING_COUNT_SENSOR.value,
-        state_class=SensorStateClass.TOTAL,
-        value=lambda data: data[DelugeSensorType.DOWNLOADING_COUNT_SENSOR.value],
-    ),
-    DelugeSensorEntityDescription(
-        key=DelugeSensorType.SEEDING_COUNT_SENSOR.value,
-        translation_key=DelugeSensorType.SEEDING_COUNT_SENSOR.value,
-        state_class=SensorStateClass.TOTAL,
-        value=lambda data: data[DelugeSensorType.SEEDING_COUNT_SENSOR.value],
-    ),
 )
 
 

homeassistant/components/deluge/strings.json

@@ -36,10 +36,6 @@
           "idle": "[%key:common::state::idle%]"
         }
       },
-      "downloading_count": {
-        "name": "Downloading count",
-        "unit_of_measurement": "torrents"
-      },
       "download_speed": {
         "name": "Download speed"
       },
@@ -49,10 +45,6 @@
       "protocol_traffic_upload_speed": {
         "name": "Protocol traffic upload speed"
       },
-      "seeding_count": {
-        "name": "Seeding count",
-        "unit_of_measurement": "[%key:component::deluge::entity::sensor::downloading_count::unit_of_measurement%]"
-      },
       "upload_speed": {
         "name": "Upload speed"
       }

homeassistant/components/derivative/diagnostics.py

@@ -1,23 +0,0 @@
-"""Diagnostics support for derivative."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: ConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-
-    registry = er.async_get(hass)
-    entities = registry.entities.get_entries_for_config_entry_id(config_entry.entry_id)
-
-    return {
-        "config_entry": config_entry.as_dict(),
-        "entity": [entity.extended_dict for entity in entities],
-    }

homeassistant/components/derivative/sensor.py

@@ -227,28 +227,15 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             weight = calculate_weight(start, end, current_time)
             derivative = derivative + (value * Decimal(weight))
 
-        _LOGGER.debug(
-            "%s: Calculated new derivative as %f from %d segments",
-            self.entity_id,
-            derivative,
-            len(self._state_list),
-        )
-
         return derivative
 
     def _prune_state_list(self, current_time: datetime) -> None:
         # filter out all derivatives older than `time_window` from our window list
-        old_len = len(self._state_list)
         self._state_list = [
             (time_start, time_end, state)
             for time_start, time_end, state in self._state_list
             if (current_time - time_end).total_seconds() < self._time_window
         ]
-        _LOGGER.debug(
-            "%s: Pruned %d elements from state list",
-            self.entity_id,
-            old_len - len(self._state_list),
-        )
 
     def _handle_invalid_source_state(self, state: State | None) -> bool:
         # Check the source state for unknown/unavailable condition. If unusable, write unknown/unavailable state and return false.
@@ -305,10 +292,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                 ) -> None:
                     """Calculate derivative based on time and reschedule."""
 
-                    _LOGGER.debug(
-                        "%s: Recalculating derivative due to max_sub_interval time elapsed",
-                        self.entity_id,
-                    )
                     self._prune_state_list(now)
                     derivative = self._calc_derivative_from_state_list(now)
                     self._write_native_value(derivative)
@@ -317,11 +300,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                     if derivative != 0:
                         schedule_max_sub_interval_exceeded(source_state)
 
-                _LOGGER.debug(
-                    "%s: Scheduling max_sub_interval_callback in %s",
-                    self.entity_id,
-                    self._max_sub_interval,
-                )
                 self._cancel_max_sub_interval_exceeded_callback = async_call_later(
                     self.hass,
                     self._max_sub_interval,
@@ -331,9 +309,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         @callback
         def on_state_reported(event: Event[EventStateReportedData]) -> None:
             """Handle constant sensor state."""
-            _LOGGER.debug(
-                "%s: New state reported event: %s", self.entity_id, event.data
-            )
             self._cancel_max_sub_interval_exceeded_callback()
             new_state = event.data["new_state"]
             if not self._handle_invalid_source_state(new_state):
@@ -355,7 +330,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         @callback
         def on_state_changed(event: Event[EventStateChangedData]) -> None:
             """Handle changed sensor state."""
-            _LOGGER.debug("%s: New state changed event: %s", self.entity_id, event.data)
             self._cancel_max_sub_interval_exceeded_callback()
             new_state = event.data["new_state"]
             if not self._handle_invalid_source_state(new_state):
@@ -408,32 +382,15 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                     / Decimal(self._unit_prefix)
                     * Decimal(self._unit_time)
                 )
-                _LOGGER.debug(
-                    "%s: Calculated new derivative segment as %f / %f / %f * %f = %f",
-                    self.entity_id,
-                    delta_value,
-                    elapsed_time,
-                    self._unit_prefix,
-                    self._unit_time,
-                    new_derivative,
-                )
 
             except ValueError as err:
-                _LOGGER.warning(
+                _LOGGER.warning("While calculating derivative: %s", err)
-                    "%s: While calculating derivative: %s", self.entity_id, err
-                )
             except DecimalException as err:
                 _LOGGER.warning(
-                    "%s: Invalid state (%s > %s): %s",
+                    "Invalid state (%s > %s): %s", old_value, new_state.state, err
-                    self.entity_id,
-                    old_value,
-                    new_state.state,
-                    err,
                 )
             except AssertionError as err:
-                _LOGGER.error(
+                _LOGGER.error("Could not calculate derivative: %s", err)
-                    "%s: Could not calculate derivative: %s", self.entity_id, err
-                )
 
             # For total inreasing sensors, the value is expected to continuously increase.
             # A negative derivative for a total increasing sensor likely indicates the
@@ -443,10 +400,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                 == SensorStateClass.TOTAL_INCREASING
                 and new_derivative < 0
             ):
-                _LOGGER.debug(
-                    "%s: Dropping sample as source total_increasing sensor decreased",
-                    self.entity_id,
-                )
                 return
 
             # add latest derivative to the window list

homeassistant/components/dnsip/sensor.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 from datetime import timedelta
 from ipaddress import IPv4Address, IPv6Address
 import logging
@@ -89,8 +88,8 @@ class WanIpSensor(SensorEntity):
         self._attr_name = "IPv6" if ipv6 else None
         self._attr_unique_id = f"{hostname}_{ipv6}"
         self.hostname = hostname
-        self.port = port
+        self.resolver = aiodns.DNSResolver(tcp_port=port, udp_port=port)
-        self._resolver = resolver
+        self.resolver.nameservers = [resolver]
         self.querytype: Literal["A", "AAAA"] = "AAAA" if ipv6 else "A"
         self._retries = DEFAULT_RETRIES
         self._attr_extra_state_attributes = {
@@ -104,26 +103,14 @@ class WanIpSensor(SensorEntity):
             model=aiodns.__version__,
             name=name,
         )
-        self.resolver: aiodns.DNSResolver
-        self.create_dns_resolver()
-
-    def create_dns_resolver(self) -> None:
-        """Create the DNS resolver."""
-        self.resolver = aiodns.DNSResolver(tcp_port=self.port, udp_port=self.port)
-        self.resolver.nameservers = [self._resolver]
 
     async def async_update(self) -> None:
         """Get the current DNS IP address for hostname."""
-        if self.resolver._closed:  # noqa: SLF001
-            self.create_dns_resolver()
-        response = None
         try:
-            async with asyncio.timeout(10):
+            response = await self.resolver.query(self.hostname, self.querytype)
-                response = await self.resolver.query(self.hostname, self.querytype)
-        except TimeoutError:
-            await self.resolver.close()
         except DNSError as err:
             _LOGGER.warning("Exception while resolving host: %s", err)
+            response = None
 
         if response:
             sorted_ips = sort_ips(

homeassistant/components/droplet/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/droplet",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["pydroplet==2.3.3"],
+  "requirements": ["pydroplet==2.3.2"],
   "zeroconf": ["_droplet._tcp.local."]
 }