Add test command to copilot

.github/workflows/builder.yml

@@ -324,7 +324,7 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Install Cosign
-        uses: sigstore/cosign-installer@v3.9.1
+        uses: sigstore/cosign-installer@v3.8.2
         with:
           cosign-release: "v2.2.3"
 

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 3
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2025.8"
+  HA_SHORT_VERSION: "2025.7"
   DEFAULT_PYTHON: "3.13"
   ALL_PYTHON_VERSIONS: "['3.13']"
   # 10.3 is the oldest supported version

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.29.2
+        uses: github/codeql-action/init@v3.29.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.29.2
+        uses: github/codeql-action/analyze@v3.29.0
         with:
           category: "/language:python"

.gitignore

@@ -137,8 +137,4 @@ tmp_cache
 .ropeproject
 
 # Will be created from script/split_tests.py
-pytest_buckets.txt
-
-# AI tooling
-.claude
-
+pytest_buckets.txt

.pre-commit-config.yaml

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

.strict-typing

@@ -67,7 +67,6 @@ homeassistant.components.alert.*
 homeassistant.components.alexa.*
 homeassistant.components.alexa_devices.*
 homeassistant.components.alpha_vantage.*
-homeassistant.components.altruist.*
 homeassistant.components.amazon_polly.*
 homeassistant.components.amberelectric.*
 homeassistant.components.ambient_network.*
@@ -503,7 +502,6 @@ homeassistant.components.tautulli.*
 homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
-homeassistant.components.telegram_bot.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
 homeassistant.components.threshold.*

CLAUDE.md

@@ -1 +0,0 @@
-.github/copilot-instructions.md

CODEOWNERS

@@ -93,8 +93,6 @@ build.json @home-assistant/supervisor
 /tests/components/alexa/ @home-assistant/cloud @ochlocracy @jbouwh
 /homeassistant/components/alexa_devices/ @chemelli74
 /tests/components/alexa_devices/ @chemelli74
-/homeassistant/components/altruist/ @airalab @LoSk-p
-/tests/components/altruist/ @airalab @LoSk-p
 /homeassistant/components/amazon_polly/ @jschlyter
 /homeassistant/components/amberelectric/ @madpilot
 /tests/components/amberelectric/ @madpilot
@@ -331,8 +329,8 @@ build.json @home-assistant/supervisor
 /tests/components/demo/ @home-assistant/core
 /homeassistant/components/denonavr/ @ol-iver @starkillerOG
 /tests/components/denonavr/ @ol-iver @starkillerOG
-/homeassistant/components/derivative/ @afaucogney @karwosts
-/tests/components/derivative/ @afaucogney @karwosts
+/homeassistant/components/derivative/ @afaucogney
+/tests/components/derivative/ @afaucogney
 /homeassistant/components/devialet/ @fwestenberg
 /tests/components/devialet/ @fwestenberg
 /homeassistant/components/device_automation/ @home-assistant/core
@@ -788,6 +786,8 @@ build.json @home-assistant/supervisor
 /tests/components/jellyfin/ @RunC0deRun @ctalkington
 /homeassistant/components/jewish_calendar/ @tsvi
 /tests/components/jewish_calendar/ @tsvi
+/homeassistant/components/juicenet/ @jesserockz
+/tests/components/juicenet/ @jesserockz
 /homeassistant/components/justnimbus/ @kvanzuijlen
 /tests/components/justnimbus/ @kvanzuijlen
 /homeassistant/components/jvc_projector/ @SteveEasley @msavazzi
@@ -1169,8 +1169,6 @@ build.json @home-assistant/supervisor
 /tests/components/ping/ @jpbede
 /homeassistant/components/plaato/ @JohNan
 /tests/components/plaato/ @JohNan
-/homeassistant/components/playstation_network/ @jackjpowell @tr4nt0r
-/tests/components/playstation_network/ @jackjpowell @tr4nt0r
 /homeassistant/components/plex/ @jjlawren
 /tests/components/plex/ @jjlawren
 /homeassistant/components/plugwise/ @CoMPaTech @bouwew
@@ -1553,8 +1551,6 @@ build.json @home-assistant/supervisor
 /tests/components/technove/ @Moustachauve
 /homeassistant/components/tedee/ @patrickhilker @zweckj
 /tests/components/tedee/ @patrickhilker @zweckj
-/homeassistant/components/telegram_bot/ @hanwg
-/tests/components/telegram_bot/ @hanwg
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
 /homeassistant/components/template/ @Petro31 @home-assistant/core
@@ -1584,8 +1580,6 @@ build.json @home-assistant/supervisor
 /tests/components/tile/ @bachya
 /homeassistant/components/tilt_ble/ @apt-itude
 /tests/components/tilt_ble/ @apt-itude
-/homeassistant/components/tilt_pi/ @michaelheyman
-/tests/components/tilt_pi/ @michaelheyman
 /homeassistant/components/time/ @home-assistant/core
 /tests/components/time/ @home-assistant/core
 /homeassistant/components/time_date/ @fabaff
@@ -1674,8 +1668,6 @@ build.json @home-assistant/supervisor
 /tests/components/vallox/ @andre-richter @slovdahl @viiru- @yozik04
 /homeassistant/components/valve/ @home-assistant/core
 /tests/components/valve/ @home-assistant/core
-/homeassistant/components/vegehub/ @ghowevege
-/tests/components/vegehub/ @ghowevege
 /homeassistant/components/velbus/ @Cereal2nd @brefra
 /tests/components/velbus/ @Cereal2nd @brefra
 /homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio

homeassistant/bootstrap.py

@@ -75,6 +75,7 @@ from .core_config import async_process_ha_core_config
 from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
+    backup,
     category_registry,
     config_validation as cv,
     device_registry,
@@ -88,7 +89,6 @@ from .helpers import (
     restore_state,
     template,
     translation,
-    trigger,
 )
 from .helpers.dispatcher import async_dispatcher_send_internal
 from .helpers.storage import get_internal_store_manager
@@ -452,7 +452,6 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
         create_eager_task(restore_state.async_load(hass)),
         create_eager_task(hass.config_entries.async_initialize()),
         create_eager_task(async_get_system_info(hass)),
-        create_eager_task(trigger.async_setup(hass)),
     )
 
 
@@ -606,7 +605,7 @@ async def async_enable_logging(
     )
     threading.excepthook = lambda args: logging.getLogger().exception(
         "Uncaught thread exception",
-        exc_info=(  # type: ignore[arg-type]
+        exc_info=(  # type: ignore[arg-type]  # noqa: LOG014
             args.exc_type,
             args.exc_value,
             args.exc_traceback,
@@ -879,6 +878,10 @@ async def _async_set_up_integrations(
     if "recorder" in all_domains:
         recorder.async_initialize_recorder(hass)
 
+    # Initialize backup
+    if "backup" in all_domains:
+        backup.async_initialize_backup(hass)
+
     stages: list[tuple[str, set[str], int | None]] = [
         *(
             (name, domain_group, timeout)
@@ -1056,5 +1059,5 @@ async def _async_setup_multi_components(
             _LOGGER.error(
                 "Error setting up integration %s - received exception",
                 domain,
-                exc_info=(type(result), result, result.__traceback__),
+                exc_info=(type(result), result, result.__traceback__),  # noqa: LOG014
             )

homeassistant/brands/sony.json

@@ -1,11 +1,5 @@
 {
   "domain": "sony",
   "name": "Sony",
-  "integrations": [
-    "braviatv",
-    "ps4",
-    "sony_projector",
-    "songpal",
-    "playstation_network"
-  ]
+  "integrations": ["braviatv", "ps4", "sony_projector", "songpal"]
 }

homeassistant/brands/switchbot.json

@@ -1,6 +1,5 @@
 {
   "domain": "switchbot",
   "name": "SwitchBot",
-  "integrations": ["switchbot", "switchbot_cloud"],
-  "iot_standards": ["matter"]
+  "integrations": ["switchbot", "switchbot_cloud"]
 }

homeassistant/brands/tilt.json

@@ -1,5 +0,0 @@
-{
-  "domain": "tilt",
-  "name": "Tilt",
-  "integrations": ["tilt_ble", "tilt_pi"]
-}

homeassistant/components/aemet/sensor.py

@@ -185,7 +185,6 @@ FORECAST_SENSORS: Final[tuple[AemetSensorEntityDescription, ...]] = (
         keys=[AOD_TOWN, AOD_FORECAST_DAILY, AOD_FORECAST_CURRENT, AOD_WIND_DIRECTION],
         name="Daily forecast wind bearing",
         native_unit_of_measurement=DEGREE,
-        device_class=SensorDeviceClass.WIND_DIRECTION,
     ),
     AemetSensorEntityDescription(
         entity_registry_enabled_default=False,
@@ -193,7 +192,6 @@ FORECAST_SENSORS: Final[tuple[AemetSensorEntityDescription, ...]] = (
         keys=[AOD_TOWN, AOD_FORECAST_HOURLY, AOD_FORECAST_CURRENT, AOD_WIND_DIRECTION],
         name="Hourly forecast wind bearing",
         native_unit_of_measurement=DEGREE,
-        device_class=SensorDeviceClass.WIND_DIRECTION,
     ),
     AemetSensorEntityDescription(
         entity_registry_enabled_default=False,
@@ -336,8 +334,7 @@ WEATHER_SENSORS: Final[tuple[AemetSensorEntityDescription, ...]] = (
         keys=[AOD_WEATHER, AOD_WIND_DIRECTION],
         name="Wind bearing",
         native_unit_of_measurement=DEGREE,
-        state_class=SensorStateClass.MEASUREMENT_ANGLE,
-        device_class=SensorDeviceClass.WIND_DIRECTION,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     AemetSensorEntityDescription(
         key=ATTR_API_WIND_MAX_SPEED,

homeassistant/components/ai_task/__init__.py

@@ -5,7 +5,6 @@ import logging
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ENTITY_ID
 from homeassistant.core import (
     HassJobType,
     HomeAssistant,
@@ -18,26 +17,18 @@ from homeassistant.helpers import config_validation as cv, storage
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
 
-from .const import (
-    ATTR_INSTRUCTIONS,
-    ATTR_TASK_NAME,
-    DATA_COMPONENT,
-    DATA_PREFERENCES,
-    DOMAIN,
-    SERVICE_GENERATE_DATA,
-    AITaskEntityFeature,
-)
+from .const import DATA_COMPONENT, DATA_PREFERENCES, DOMAIN, AITaskEntityFeature
 from .entity import AITaskEntity
-from .http import async_setup as async_setup_http
-from .task import GenDataTask, GenDataTaskResult, async_generate_data
+from .http import async_setup as async_setup_conversation_http
+from .task import GenTextTask, GenTextTaskResult, async_generate_text
 
 __all__ = [
     "DOMAIN",
     "AITaskEntity",
     "AITaskEntityFeature",
-    "GenDataTask",
-    "GenDataTaskResult",
-    "async_generate_data",
+    "GenTextTask",
+    "GenTextTaskResult",
+    "async_generate_text",
     "async_setup",
     "async_setup_entry",
     "async_unload_entry",
@@ -54,16 +45,16 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     hass.data[DATA_COMPONENT] = entity_component
     hass.data[DATA_PREFERENCES] = AITaskPreferences(hass)
     await hass.data[DATA_PREFERENCES].async_load()
-    async_setup_http(hass)
+    async_setup_conversation_http(hass)
     hass.services.async_register(
         DOMAIN,
-        SERVICE_GENERATE_DATA,
-        async_service_generate_data,
+        "generate_text",
+        async_service_generate_text,
         schema=vol.Schema(
             {
-                vol.Required(ATTR_TASK_NAME): cv.string,
-                vol.Optional(ATTR_ENTITY_ID): cv.entity_id,
-                vol.Required(ATTR_INSTRUCTIONS): cv.string,
+                vol.Required("task_name"): cv.string,
+                vol.Optional("entity_id"): cv.entity_id,
+                vol.Required("instructions"): cv.string,
             }
         ),
         supports_response=SupportsResponse.ONLY,
@@ -82,18 +73,18 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
 
 
-async def async_service_generate_data(call: ServiceCall) -> ServiceResponse:
+async def async_service_generate_text(call: ServiceCall) -> ServiceResponse:
     """Run the run task service."""
-    result = await async_generate_data(hass=call.hass, **call.data)
-    return result.as_dict()
+    result = await async_generate_text(hass=call.hass, **call.data)
+    return result.as_dict()  # type: ignore[return-value]
 
 
 class AITaskPreferences:
     """AI Task preferences."""
 
-    KEYS = ("gen_data_entity_id",)
+    KEYS = ("gen_text_entity_id",)
 
-    gen_data_entity_id: str | None = None
+    gen_text_entity_id: str | None = None
 
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the preferences."""
@@ -113,11 +104,11 @@ class AITaskPreferences:
     def async_set_preferences(
         self,
         *,
-        gen_data_entity_id: str | None | UndefinedType = UNDEFINED,
+        gen_text_entity_id: str | None | UndefinedType = UNDEFINED,
     ) -> None:
         """Set the preferences."""
         changed = False
-        for key, value in (("gen_data_entity_id", gen_data_entity_id),):
+        for key, value in (("gen_text_entity_id", gen_text_entity_id),):
             if value is not UNDEFINED:
                 if getattr(self, key) != value:
                     setattr(self, key, value)

homeassistant/components/ai_task/const.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from enum import IntFlag
-from typing import TYPE_CHECKING, Final
+from typing import TYPE_CHECKING
 
 from homeassistant.util.hass_dict import HassKey
 
@@ -17,11 +17,6 @@ DOMAIN = "ai_task"
 DATA_COMPONENT: HassKey[EntityComponent[AITaskEntity]] = HassKey(DOMAIN)
 DATA_PREFERENCES: HassKey[AITaskPreferences] = HassKey(f"{DOMAIN}_preferences")
 
-SERVICE_GENERATE_DATA = "generate_data"
-
-ATTR_INSTRUCTIONS: Final = "instructions"
-ATTR_TASK_NAME: Final = "task_name"
-
 DEFAULT_SYSTEM_PROMPT = (
     "You are a Home Assistant expert and help users with their tasks."
 )
@@ -30,5 +25,5 @@ DEFAULT_SYSTEM_PROMPT = (
 class AITaskEntityFeature(IntFlag):
     """Supported features of the AI task entity."""
 
-    GENERATE_DATA = 1
-    """Generate data based on instructions."""
+    GENERATE_TEXT = 1
+    """Generate text based on instructions."""

homeassistant/components/ai_task/entity.py

@@ -18,7 +18,7 @@ from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.util import dt as dt_util
 
 from .const import DEFAULT_SYSTEM_PROMPT, DOMAIN, AITaskEntityFeature
-from .task import GenDataTask, GenDataTaskResult
+from .task import GenTextTask, GenTextTaskResult
 
 
 class AITaskEntity(RestoreEntity):
@@ -56,7 +56,7 @@ class AITaskEntity(RestoreEntity):
     @contextlib.asynccontextmanager
     async def _async_get_ai_task_chat_log(
         self,
-        task: GenDataTask,
+        task: GenTextTask,
     ) -> AsyncGenerator[ChatLog]:
         """Context manager used to manage the ChatLog used during an AI Task."""
         # pylint: disable-next=contextmanager-generator-missing-cleanup
@@ -84,20 +84,20 @@ class AITaskEntity(RestoreEntity):
             yield chat_log
 
     @final
-    async def internal_async_generate_data(
+    async def internal_async_generate_text(
         self,
-        task: GenDataTask,
-    ) -> GenDataTaskResult:
-        """Run a gen data task."""
+        task: GenTextTask,
+    ) -> GenTextTaskResult:
+        """Run a gen text task."""
         self.__last_activity = dt_util.utcnow().isoformat()
         self.async_write_ha_state()
         async with self._async_get_ai_task_chat_log(task) as chat_log:
-            return await self._async_generate_data(task, chat_log)
+            return await self._async_generate_text(task, chat_log)
 
-    async def _async_generate_data(
+    async def _async_generate_text(
         self,
-        task: GenDataTask,
+        task: GenTextTask,
         chat_log: ChatLog,
-    ) -> GenDataTaskResult:
-        """Handle a gen data task."""
+    ) -> GenTextTaskResult:
+        """Handle a gen text task."""
         raise NotImplementedError

homeassistant/components/ai_task/http.py

@@ -36,7 +36,7 @@ def websocket_get_preferences(
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "ai_task/preferences/set",
-        vol.Optional("gen_data_entity_id"): vol.Any(str, None),
+        vol.Optional("gen_text_entity_id"): vol.Any(str, None),
     }
 )
 @websocket_api.require_admin

homeassistant/components/ai_task/icons.json

@@ -1,6 +1,6 @@
 {
   "services": {
-    "generate_data": {
+    "generate_text": {
       "service": "mdi:file-star-four-points-outline"
     }
   }

homeassistant/components/ai_task/services.yaml

@@ -1,4 +1,4 @@
-generate_data:
+generate_text:
   fields:
     task_name:
       example: "home summary"
@@ -6,7 +6,7 @@ generate_data:
       selector:
         text:
     instructions:
-      example: "Generate a funny notification that the garage door was left open"
+      example: "Generate a funny notification that garage door was left open"
       required: true
       selector:
         text:
@@ -16,4 +16,4 @@ generate_data:
         entity:
           domain: ai_task
           supported_features:
-            - ai_task.AITaskEntityFeature.GENERATE_DATA
+            - ai_task.AITaskEntityFeature.GENERATE_TEXT

homeassistant/components/ai_task/strings.json

@@ -1,11 +1,11 @@
 {
   "services": {
-    "generate_data": {
-      "name": "Generate data",
-      "description": "Uses AI to run a task that generates data.",
+    "generate_text": {
+      "name": "Generate text",
+      "description": "Use AI to run a task that generates text.",
       "fields": {
         "task_name": {
-          "name": "Task name",
+          "name": "Task Name",
           "description": "Name of the task."
         },
         "instructions": {

homeassistant/components/ai_task/task.py

@@ -3,39 +3,35 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any
 
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 
 from .const import DATA_COMPONENT, DATA_PREFERENCES, AITaskEntityFeature
 
 
-async def async_generate_data(
+async def async_generate_text(
     hass: HomeAssistant,
     *,
     task_name: str,
     entity_id: str | None = None,
     instructions: str,
-) -> GenDataTaskResult:
+) -> GenTextTaskResult:
     """Run a task in the AI Task integration."""
     if entity_id is None:
-        entity_id = hass.data[DATA_PREFERENCES].gen_data_entity_id
+        entity_id = hass.data[DATA_PREFERENCES].gen_text_entity_id
 
     if entity_id is None:
-        raise HomeAssistantError("No entity_id provided and no preferred entity set")
+        raise ValueError("No entity_id provided and no preferred entity set")
 
     entity = hass.data[DATA_COMPONENT].get_entity(entity_id)
     if entity is None:
-        raise HomeAssistantError(f"AI Task entity {entity_id} not found")
+        raise ValueError(f"AI Task entity {entity_id} not found")
 
-    if AITaskEntityFeature.GENERATE_DATA not in entity.supported_features:
-        raise HomeAssistantError(
-            f"AI Task entity {entity_id} does not support generating data"
-        )
+    if AITaskEntityFeature.GENERATE_TEXT not in entity.supported_features:
+        raise ValueError(f"AI Task entity {entity_id} does not support generating text")
 
-    return await entity.internal_async_generate_data(
-        GenDataTask(
+    return await entity.internal_async_generate_text(
+        GenTextTask(
             name=task_name,
             instructions=instructions,
         )
@@ -43,8 +39,8 @@ async def async_generate_data(
 
 
 @dataclass(slots=True)
-class GenDataTask:
-    """Gen data task to be processed."""
+class GenTextTask:
+    """Gen text task to be processed."""
 
     name: str
     """Name of the task."""
@@ -54,22 +50,22 @@ class GenDataTask:
 
     def __str__(self) -> str:
         """Return task as a string."""
-        return f"<GenDataTask {self.name}: {id(self)}>"
+        return f"<GenTextTask {self.name}: {id(self)}>"
 
 
 @dataclass(slots=True)
-class GenDataTaskResult:
-    """Result of gen data task."""
+class GenTextTaskResult:
+    """Result of gen text task."""
 
     conversation_id: str
     """Unique identifier for the conversation."""
 
-    data: Any
-    """Data generated by the task."""
+    text: str
+    """Generated text."""
 
-    def as_dict(self) -> dict[str, Any]:
+    def as_dict(self) -> dict[str, str]:
         """Return result as a dict."""
         return {
             "conversation_id": self.conversation_id,
-            "data": self.data,
+            "text": self.text,
         }

homeassistant/components/airnow/coordinator.py

@@ -71,7 +71,7 @@ class AirNowDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
-        data: dict[str, Any] = {}
+        data = {}
         try:
             obs = await self.airnow.observations.latLong(
                 self.latitude,

homeassistant/components/airnow/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airnow",
   "iot_class": "cloud_polling",
   "loggers": ["pyairnow"],
-  "requirements": ["pyairnow==1.3.1"]
+  "requirements": ["pyairnow==1.2.1"]
 }

homeassistant/components/airq/coordinator.py

@@ -10,7 +10,7 @@ from aioairq.core import AirQ, identify_warming_up_sensors
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
@@ -39,7 +39,7 @@ class AirQCoordinator(DataUpdateCoordinator):
             name=DOMAIN,
             update_interval=timedelta(seconds=UPDATE_INTERVAL),
         )
-        session = async_create_clientsession(hass)
+        session = async_get_clientsession(hass)
         self.airq = AirQ(
             entry.data[CONF_IP_ADDRESS], entry.data[CONF_PASSWORD], session
         )

homeassistant/components/alexa_devices/__init__.py

@@ -8,7 +8,6 @@ from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.NOTIFY,
-    Platform.SENSOR,
     Platform.SWITCH,
 ]
 
@@ -29,8 +28,5 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
 
 async def async_unload_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
     """Unload a config entry."""
-    coordinator = entry.runtime_data
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        await coordinator.api.close()
-
-    return unload_ok
+    await entry.runtime_data.api.close()
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/alexa_devices/binary_sensor.py

@@ -7,7 +7,6 @@ from dataclasses import dataclass
 from typing import Final
 
 from aioamazondevices.api import AmazonDevice
-from aioamazondevices.const import SENSOR_STATE_OFF
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -29,8 +28,7 @@ PARALLEL_UPDATES = 0
 class AmazonBinarySensorEntityDescription(BinarySensorEntityDescription):
     """Alexa Devices binary sensor entity description."""
 
-    is_on_fn: Callable[[AmazonDevice, str], bool]
-    is_supported: Callable[[AmazonDevice, str], bool] = lambda device, key: True
+    is_on_fn: Callable[[AmazonDevice], bool]
 
 
 BINARY_SENSORS: Final = (
@@ -38,49 +36,13 @@ BINARY_SENSORS: Final = (
         key="online",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda device, _: device.online,
+        is_on_fn=lambda _device: _device.online,
     ),
     AmazonBinarySensorEntityDescription(
         key="bluetooth",
         entity_category=EntityCategory.DIAGNOSTIC,
         translation_key="bluetooth",
-        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_on_fn=lambda _device: _device.bluetooth_state,
     ),
 )
 
@@ -98,7 +60,6 @@ async def async_setup_entry(
         AmazonBinarySensorEntity(coordinator, serial_num, sensor_desc)
         for sensor_desc in BINARY_SENSORS
         for serial_num in coordinator.data
-        if sensor_desc.is_supported(coordinator.data[serial_num], sensor_desc.key)
     )
 
 
@@ -110,6 +71,4 @@ class AmazonBinarySensorEntity(AmazonEntity, BinarySensorEntity):
     @property
     def is_on(self) -> bool:
         """Return True if the binary sensor is on."""
-        return self.entity_description.is_on_fn(
-            self.device, self.entity_description.key
-        )
+        return self.entity_description.is_on_fn(self.device)

homeassistant/components/alexa_devices/icons.json

@@ -2,39 +2,9 @@
   "entity": {
     "binary_sensor": {
       "bluetooth": {
-        "default": "mdi:bluetooth-off",
+        "default": "mdi:bluetooth",
         "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"
+          "off": "mdi:bluetooth-off"
         }
       }
     }

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "bronze",
-  "requirements": ["aioamazondevices==3.1.22"]
+  "requirements": ["aioamazondevices==3.1.14"]
 }

homeassistant/components/alexa_devices/notify.py

@@ -15,7 +15,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import alexa_api_call
 
 PARALLEL_UPDATES = 1
 
@@ -71,7 +70,6 @@ class AmazonNotifyEntity(AmazonEntity, NotifyEntity):
 
     entity_description: AmazonNotifyEntityDescription
 
-    @alexa_api_call
     async def async_send_message(
         self, message: str, title: str | None = None, **kwargs: Any
     ) -> None:

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -26,7 +26,7 @@ rules:
   unique-config-entry: done
 
   # Silver
-  action-exceptions: done
+  action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters: todo
   docs-installation-parameters: todo

homeassistant/components/alexa_devices/sensor.py

@@ -1,88 +0,0 @@
-"""Support for sensors."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Final
-
-from aioamazondevices.api import AmazonDevice
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-)
-from homeassistant.const import LIGHT_LUX, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.typing import StateType
-
-from .coordinator import AmazonConfigEntry
-from .entity import AmazonEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class AmazonSensorEntityDescription(SensorEntityDescription):
-    """Amazon Devices sensor entity description."""
-
-    native_unit_of_measurement_fn: Callable[[AmazonDevice, str], str] | None = None
-
-
-SENSORS: Final = (
-    AmazonSensorEntityDescription(
-        key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement_fn=lambda device, _key: (
-            UnitOfTemperature.CELSIUS
-            if device.sensors[_key].scale == "CELSIUS"
-            else UnitOfTemperature.FAHRENHEIT
-        ),
-    ),
-    AmazonSensorEntityDescription(
-        key="illuminance",
-        device_class=SensorDeviceClass.ILLUMINANCE,
-        native_unit_of_measurement=LIGHT_LUX,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AmazonConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Amazon Devices sensors based on a config entry."""
-
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        AmazonSensorEntity(coordinator, serial_num, sensor_desc)
-        for sensor_desc in SENSORS
-        for serial_num in coordinator.data
-        if coordinator.data[serial_num].sensors.get(sensor_desc.key) is not None
-    )
-
-
-class AmazonSensorEntity(AmazonEntity, SensorEntity):
-    """Sensor device."""
-
-    entity_description: AmazonSensorEntityDescription
-
-    @property
-    def native_unit_of_measurement(self) -> str | None:
-        """Return the unit of measurement of the sensor."""
-        if self.entity_description.native_unit_of_measurement_fn:
-            return self.entity_description.native_unit_of_measurement_fn(
-                self.device, self.entity_description.key
-            )
-
-        return super().native_unit_of_measurement
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the state of the sensor."""
-        return self.device.sensors[self.entity_description.key].value

homeassistant/components/alexa_devices/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
+    "data_country": "Country code",
     "data_code": "One-time password (OTP code)",
-    "data_description_country": "The country where your Amazon account is registered.",
+    "data_description_country": "The country of your Amazon account.",
     "data_description_username": "The email address of your Amazon account.",
     "data_description_password": "The password of your Amazon account.",
     "data_description_code": "The one-time password to log in to your account. Currently, only tokens from OTP applications are supported."
@@ -11,10 +12,10 @@
     "step": {
       "user": {
         "data": {
-          "country": "[%key:common::config_flow::data::country%]",
+          "country": "[%key:component::alexa_devices::common::data_country%]",
           "username": "[%key:common::config_flow::data::username%]",
           "password": "[%key:common::config_flow::data::password%]",
-          "code": "[%key:component::alexa_devices::common::data_code%]"
+          "code": "[%key:component::alexa_devices::common::data_description_code%]"
         },
         "data_description": {
           "country": "[%key:component::alexa_devices::common::data_description_country%]",
@@ -40,21 +41,6 @@
     "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": {
@@ -70,13 +56,5 @@
         "name": "Do not disturb"
       }
     }
-  },
-  "exceptions": {
-    "cannot_connect": {
-      "message": "Error connecting: {error}"
-    },
-    "cannot_retrieve_data": {
-      "message": "Error retrieving data: {error}"
-    }
   }
 }

homeassistant/components/alexa_devices/switch.py

@@ -14,7 +14,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import alexa_api_call
 
 PARALLEL_UPDATES = 1
 
@@ -61,7 +60,6 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
 
     entity_description: AmazonSwitchEntityDescription
 
-    @alexa_api_call
     async def _switch_set_state(self, state: bool) -> None:
         """Set desired switch state."""
         method = getattr(self.coordinator.api, self.entity_description.method)

homeassistant/components/alexa_devices/utils.py

@@ -1,40 +0,0 @@
-"""Utils for Alexa Devices."""
-
-from collections.abc import Awaitable, Callable, Coroutine
-from functools import wraps
-from typing import Any, Concatenate
-
-from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
-
-from homeassistant.exceptions import HomeAssistantError
-
-from .const import DOMAIN
-from .entity import AmazonEntity
-
-
-def alexa_api_call[_T: AmazonEntity, **_P](
-    func: Callable[Concatenate[_T, _P], Awaitable[None]],
-) -> Callable[Concatenate[_T, _P], Coroutine[Any, Any, None]]:
-    """Catch Alexa API call exceptions."""
-
-    @wraps(func)
-    async def cmd_wrapper(self: _T, *args: _P.args, **kwargs: _P.kwargs) -> None:
-        """Wrap all command methods."""
-        try:
-            await func(self, *args, **kwargs)
-        except CannotConnect as err:
-            self.coordinator.last_update_success = False
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-        except CannotRetrieveData as err:
-            self.coordinator.last_update_success = False
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-
-    return cmd_wrapper

homeassistant/components/altruist/__init__.py

@@ -1,27 +0,0 @@
-"""The Altruist integration."""
-
-from __future__ import annotations
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import AltruistConfigEntry, AltruistDataUpdateCoordinator
-
-PLATFORMS = [Platform.SENSOR]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: AltruistConfigEntry) -> bool:
-    """Set up Altruist from a config entry."""
-
-    coordinator = AltruistDataUpdateCoordinator(hass, entry)
-
-    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: AltruistConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/altruist/config_flow.py

@@ -1,107 +0,0 @@
-"""Config flow for the Altruist integration."""
-
-import logging
-from typing import Any
-
-from altruistclient import AltruistClient, AltruistDeviceModel, AltruistError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
-
-from .const import CONF_HOST, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class AltruistConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Altruist."""
-
-    device: AltruistDeviceModel
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        ip_address = ""
-        if user_input is not None:
-            ip_address = user_input[CONF_HOST]
-            try:
-                client = await AltruistClient.from_ip_address(
-                    async_get_clientsession(self.hass), ip_address
-                )
-            except AltruistError:
-                errors["base"] = "no_device_found"
-            else:
-                self.device = client.device
-                await self.async_set_unique_id(
-                    client.device_id, raise_on_progress=False
-                )
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=self.device.id,
-                    data={
-                        CONF_HOST: ip_address,
-                    },
-                )
-
-        data_schema = self.add_suggested_values_to_schema(
-            vol.Schema({vol.Required(CONF_HOST): str}),
-            {CONF_HOST: ip_address},
-        )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=data_schema,
-            errors=errors,
-            description_placeholders={
-                "ip_address": ip_address,
-            },
-        )
-
-    async def async_step_zeroconf(
-        self, discovery_info: ZeroconfServiceInfo
-    ) -> ConfigFlowResult:
-        """Handle zeroconf discovery."""
-        _LOGGER.debug("Zeroconf discovery: %s", discovery_info)
-        try:
-            client = await AltruistClient.from_ip_address(
-                async_get_clientsession(self.hass), str(discovery_info.ip_address)
-            )
-        except AltruistError:
-            return self.async_abort(reason="no_device_found")
-
-        self.device = client.device
-        _LOGGER.debug("Zeroconf device: %s", client.device)
-        await self.async_set_unique_id(client.device_id)
-        self._abort_if_unique_id_configured()
-        self.context.update(
-            {
-                "title_placeholders": {
-                    "name": self.device.id,
-                }
-            }
-        )
-        return await self.async_step_discovery_confirm()
-
-    async def async_step_discovery_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm discovery."""
-        if user_input is not None:
-            return self.async_create_entry(
-                title=self.device.id,
-                data={
-                    CONF_HOST: self.device.ip_address,
-                },
-            )
-
-        self._set_confirm_only()
-        return self.async_show_form(
-            step_id="discovery_confirm",
-            description_placeholders={
-                "model": self.device.id,
-            },
-        )

homeassistant/components/altruist/const.py

@@ -1,5 +0,0 @@
-"""Constants for the Altruist integration."""
-
-DOMAIN = "altruist"
-
-CONF_HOST = "host"

homeassistant/components/altruist/coordinator.py

@@ -1,64 +0,0 @@
-"""Coordinator module for Altruist integration in Home Assistant.
-
-This module defines the AltruistDataUpdateCoordinator class, which manages
-data updates for Altruist sensors using the AltruistClient.
-"""
-
-from datetime import timedelta
-import logging
-
-from altruistclient import AltruistClient, AltruistError
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import CONF_HOST
-
-_LOGGER = logging.getLogger(__name__)
-
-UPDATE_INTERVAL = timedelta(seconds=15)
-
-type AltruistConfigEntry = ConfigEntry[AltruistDataUpdateCoordinator]
-
-
-class AltruistDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
-    """Coordinates data updates for Altruist sensors."""
-
-    client: AltruistClient
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: AltruistConfigEntry,
-    ) -> None:
-        """Initialize the data update coordinator for Altruist sensors."""
-        device_id = config_entry.unique_id
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            config_entry=config_entry,
-            name=f"Altruist {device_id}",
-            update_interval=UPDATE_INTERVAL,
-        )
-        self._ip_address = config_entry.data[CONF_HOST]
-
-    async def _async_setup(self) -> None:
-        try:
-            self.client = await AltruistClient.from_ip_address(
-                async_get_clientsession(self.hass), self._ip_address
-            )
-            await self.client.fetch_data()
-        except AltruistError as e:
-            raise ConfigEntryNotReady("Error in Altruist setup") from e
-
-    async def _async_update_data(self) -> dict[str, str]:
-        try:
-            fetched_data = await self.client.fetch_data()
-        except AltruistError as ex:
-            raise UpdateFailed(
-                f"The Altruist {self.client.device_id} is unavailable: {ex}"
-            ) from ex
-        return {item["value_type"]: item["value"] for item in fetched_data}

homeassistant/components/altruist/icons.json

@@ -1,15 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "pm_10": {
-        "default": "mdi:thought-bubble"
-      },
-      "pm_25": {
-        "default": "mdi:thought-bubble-outline"
-      },
-      "radiation": {
-        "default": "mdi:radioactive"
-      }
-    }
-  }
-}

homeassistant/components/altruist/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "altruist",
-  "name": "Altruist",
-  "codeowners": ["@airalab", "@LoSk-p"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/altruist",
-  "integration_type": "device",
-  "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["altruistclient==0.1.1"],
-  "zeroconf": ["_altruist._tcp.local."]
-}

homeassistant/components/altruist/quality_scale.yaml

@@ -1,83 +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:
-    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 provide options flow.
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow: todo
-  test-coverage: done
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: done
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices:
-    status: exempt
-    comment: |
-      Device type integration
-  entity-category: todo
-  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: done
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: No known use cases for repair issues or flows, yet
-  stale-devices:
-    status: exempt
-    comment: |
-      Device type integration
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: done

homeassistant/components/altruist/sensor.py

@@ -1,249 +0,0 @@
-"""Defines the Altruist sensor platform."""
-
-from collections.abc import Callable
-from dataclasses import dataclass
-import logging
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import (
-    CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-    CONCENTRATION_PARTS_PER_MILLION,
-    PERCENTAGE,
-    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
-    EntityCategory,
-    UnitOfPressure,
-    UnitOfSoundPressure,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from . import AltruistConfigEntry
-from .coordinator import AltruistDataUpdateCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class AltruistSensorEntityDescription(SensorEntityDescription):
-    """Class to describe a Sensor entity."""
-
-    native_value_fn: Callable[[str], float] = float
-    state_class = SensorStateClass.MEASUREMENT
-
-
-SENSOR_DESCRIPTIONS = [
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.HUMIDITY,
-        key="BME280_humidity",
-        translation_key="humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "BME280"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.PRESSURE,
-        key="BME280_pressure",
-        translation_key="pressure",
-        native_unit_of_measurement=UnitOfPressure.PA,
-        suggested_unit_of_measurement=UnitOfPressure.MMHG,
-        suggested_display_precision=0,
-        translation_placeholders={"sensor_name": "BME280"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.TEMPERATURE,
-        key="BME280_temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "BME280"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.PRESSURE,
-        key="BMP_pressure",
-        translation_key="pressure",
-        native_unit_of_measurement=UnitOfPressure.PA,
-        suggested_unit_of_measurement=UnitOfPressure.MMHG,
-        suggested_display_precision=0,
-        translation_placeholders={"sensor_name": "BMP"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.TEMPERATURE,
-        key="BMP_temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "BMP"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.TEMPERATURE,
-        key="BMP280_temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "BMP280"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.PRESSURE,
-        key="BMP280_pressure",
-        translation_key="pressure",
-        native_unit_of_measurement=UnitOfPressure.PA,
-        suggested_unit_of_measurement=UnitOfPressure.MMHG,
-        suggested_display_precision=0,
-        translation_placeholders={"sensor_name": "BMP280"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.HUMIDITY,
-        key="HTU21D_humidity",
-        translation_key="humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "HTU21D"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.TEMPERATURE,
-        key="HTU21D_temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "HTU21D"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.PM10,
-        translation_key="pm_10",
-        key="SDS_P1",
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        suggested_display_precision=2,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.PM25,
-        translation_key="pm_25",
-        key="SDS_P2",
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        suggested_display_precision=2,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.HUMIDITY,
-        key="SHT3X_humidity",
-        translation_key="humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "SHT3X"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.TEMPERATURE,
-        key="SHT3X_temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "SHT3X"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
-        key="signal",
-        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        suggested_display_precision=0,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.SOUND_PRESSURE,
-        key="PCBA_noiseMax",
-        translation_key="noise_max",
-        native_unit_of_measurement=UnitOfSoundPressure.DECIBEL,
-        suggested_display_precision=0,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.SOUND_PRESSURE,
-        key="PCBA_noiseAvg",
-        translation_key="noise_avg",
-        native_unit_of_measurement=UnitOfSoundPressure.DECIBEL,
-        suggested_display_precision=0,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.CO2,
-        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
-        translation_key="co2",
-        key="CCS_CO2",
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "CCS"},
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS,
-        key="CCS_TVOC",
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        suggested_display_precision=2,
-    ),
-    AltruistSensorEntityDescription(
-        key="GC",
-        native_unit_of_measurement="μR/h",
-        translation_key="radiation",
-        suggested_display_precision=2,
-    ),
-    AltruistSensorEntityDescription(
-        device_class=SensorDeviceClass.CO2,
-        translation_key="co2",
-        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
-        key="SCD4x_co2",
-        suggested_display_precision=2,
-        translation_placeholders={"sensor_name": "SCD4x"},
-    ),
-]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: AltruistConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Add sensors for passed config_entry in HA."""
-    coordinator = config_entry.runtime_data
-    async_add_entities(
-        AltruistSensor(coordinator, sensor_description)
-        for sensor_description in SENSOR_DESCRIPTIONS
-        if sensor_description.key in coordinator.data
-    )
-
-
-class AltruistSensor(CoordinatorEntity[AltruistDataUpdateCoordinator], SensorEntity):
-    """Implementation of a Altruist sensor."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: AltruistDataUpdateCoordinator,
-        description: AltruistSensorEntityDescription,
-    ) -> None:
-        """Initialize the Altruist sensor."""
-        super().__init__(coordinator)
-        self._device = coordinator.client.device
-        self.entity_description: AltruistSensorEntityDescription = description
-        self._attr_unique_id = f"{self._device.id}-{description.key}"
-        self._attr_device_info = DeviceInfo(
-            connections={(CONNECTION_NETWORK_MAC, self._device.id)},
-            manufacturer="Robonomics",
-            model="Altruist",
-            sw_version=self._device.fw_version,
-            configuration_url=f"http://{self._device.ip_address}",
-            serial_number=self._device.id,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return (
-            super().available and self.entity_description.key in self.coordinator.data
-        )
-
-    @property
-    def native_value(self) -> float | int:
-        """Return the native value of the sensor."""
-        string_value = self.coordinator.data[self.entity_description.key]
-        return self.entity_description.native_value_fn(string_value)

homeassistant/components/altruist/strings.json

@@ -1,51 +0,0 @@
-{
-  "config": {
-    "flow_title": "{name}",
-    "step": {
-      "discovery_confirm": {
-        "description": "Do you want to start setup {model}?"
-      },
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]"
-        },
-        "data_description": {
-          "host": "Altruist IP address or hostname in the local network"
-        },
-        "description": "Fill in Altruist IP address or hostname in your local network"
-      }
-    },
-    "abort": {
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "no_device_found": "[%key:common::config_flow::error::cannot_connect%]"
-    }
-  },
-  "entity": {
-    "sensor": {
-      "humidity": {
-        "name": "{sensor_name} humidity"
-      },
-      "pressure": {
-        "name": "{sensor_name} pressure"
-      },
-      "temperature": {
-        "name": "{sensor_name} temperature"
-      },
-      "noise_max": {
-        "name": "Maximum noise"
-      },
-      "noise_avg": {
-        "name": "Average noise"
-      },
-      "co2": {
-        "name": "{sensor_name} CO2"
-      },
-      "radiation": {
-        "name": "Radiation level"
-      }
-    }
-  }
-}

homeassistant/components/android_ip_webcam/camera.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from homeassistant.components.camera import CameraEntityFeature
 from homeassistant.components.mjpeg import MjpegCamera, filter_urllib3_logging
 from homeassistant.const import (
     CONF_HOST,
@@ -32,7 +31,6 @@ class IPWebcamCamera(MjpegCamera):
     """Representation of a IP Webcam camera."""
 
     _attr_has_entity_name = True
-    _attr_supported_features = CameraEntityFeature.STREAM
 
     def __init__(self, coordinator: AndroidIPCamDataUpdateCoordinator) -> None:
         """Initialize the camera."""
@@ -48,17 +46,3 @@ class IPWebcamCamera(MjpegCamera):
             identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
             name=coordinator.config_entry.data[CONF_HOST],
         )
-        self._coordinator = coordinator
-
-    async def stream_source(self) -> str:
-        """Get the stream source for the Android IP camera."""
-        return self._coordinator.cam.get_rtsp_url(
-            video_codec="h264",  # most compatible & recommended
-            # while "opus" is compatible with more devices,
-            # HA's stream integration requires AAC or MP3,
-            # and IP webcam doesn't provide MP3 audio.
-            # aac is supported on select devices >= android 4.1.
-            # The stream will be quiet on devices that don't support aac,
-            # but it won't fail.
-            audio_codec="aac",
-        )

homeassistant/components/anthropic/__init__.py

@@ -6,24 +6,13 @@ from functools import partial
 
 import anthropic
 
-from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    entity_registry as er,
-)
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.helpers import config_validation as cv
 
-from .const import (
-    CONF_CHAT_MODEL,
-    DEFAULT_CONVERSATION_NAME,
-    DOMAIN,
-    LOGGER,
-    RECOMMENDED_CHAT_MODEL,
-)
+from .const import CONF_CHAT_MODEL, DOMAIN, LOGGER, RECOMMENDED_CHAT_MODEL
 
 PLATFORMS = (Platform.CONVERSATION,)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -31,24 +20,13 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up Anthropic."""
-    await async_migrate_integration(hass)
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) -> bool:
     """Set up Anthropic from a config entry."""
     client = await hass.async_add_executor_job(
         partial(anthropic.AsyncAnthropic, api_key=entry.data[CONF_API_KEY])
     )
     try:
-        # Use model from first conversation subentry for validation
-        subentries = list(entry.subentries.values())
-        if subentries:
-            model_id = subentries[0].data.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-        else:
-            model_id = RECOMMENDED_CHAT_MODEL
+        model_id = entry.options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
         model = await client.models.retrieve(model_id=model_id, timeout=10.0)
         LOGGER.debug("Anthropic model: %s", model.display_name)
     except anthropic.AuthenticationError as err:
@@ -61,120 +39,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    entry.async_on_unload(entry.add_update_listener(async_update_options))
-
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload Anthropic."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-async def async_update_options(
-    hass: HomeAssistant, entry: AnthropicConfigEntry
-) -> None:
-    """Update options."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
-async def async_migrate_integration(hass: HomeAssistant) -> None:
-    """Migrate integration entry structure."""
-
-    entries = hass.config_entries.async_entries(DOMAIN)
-    if not any(entry.version == 1 for entry in entries):
-        return
-
-    api_keys_entries: dict[str, ConfigEntry] = {}
-    entity_registry = er.async_get(hass)
-    device_registry = dr.async_get(hass)
-
-    for entry in entries:
-        use_existing = False
-        subentry = ConfigSubentry(
-            data=entry.options,
-            subentry_type="conversation",
-            title=entry.title,
-            unique_id=None,
-        )
-        if entry.data[CONF_API_KEY] not in api_keys_entries:
-            use_existing = True
-            api_keys_entries[entry.data[CONF_API_KEY]] = entry
-
-        parent_entry = api_keys_entries[entry.data[CONF_API_KEY]]
-
-        hass.config_entries.async_add_subentry(parent_entry, subentry)
-        conversation_entity = entity_registry.async_get_entity_id(
-            "conversation",
-            DOMAIN,
-            entry.entry_id,
-        )
-        if conversation_entity is not None:
-            entity_registry.async_update_entity(
-                conversation_entity,
-                config_entry_id=parent_entry.entry_id,
-                config_subentry_id=subentry.subentry_id,
-                new_unique_id=subentry.subentry_id,
-            )
-
-        device = device_registry.async_get_device(
-            identifiers={(DOMAIN, entry.entry_id)}
-        )
-        if device is not None:
-            device_registry.async_update_device(
-                device.id,
-                new_identifiers={(DOMAIN, subentry.subentry_id)},
-                add_config_subentry_id=subentry.subentry_id,
-                add_config_entry_id=parent_entry.entry_id,
-            )
-            if parent_entry.entry_id != entry.entry_id:
-                device_registry.async_update_device(
-                    device.id,
-                    remove_config_entry_id=entry.entry_id,
-                )
-            else:
-                device_registry.async_update_device(
-                    device.id,
-                    remove_config_entry_id=entry.entry_id,
-                    remove_config_subentry_id=None,
-                )
-
-        if not use_existing:
-            await hass.config_entries.async_remove(entry.entry_id)
-        else:
-            hass.config_entries.async_update_entry(
-                entry,
-                title=DEFAULT_CONVERSATION_NAME,
-                options={},
-                version=2,
-                minor_version=2,
-            )
-
-
-async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) -> bool:
-    """Migrate entry."""
-    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
-
-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
-    if entry.version == 2 and entry.minor_version == 1:
-        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
-        device_registry = dr.async_get(hass)
-        for device in dr.async_entries_for_config_entry(
-            device_registry, entry.entry_id
-        ):
-            device_registry.async_update_device(
-                device.id,
-                remove_config_entry_id=entry.entry_id,
-                remove_config_subentry_id=None,
-            )
-
-        hass.config_entries.async_update_entry(entry, minor_version=2)
-
-    LOGGER.debug(
-        "Migration to version %s:%s successful", entry.version, entry.minor_version
-    )
-
-    return True

homeassistant/components/anthropic/config_flow.py

@@ -5,21 +5,20 @@ from __future__ import annotations
 from collections.abc import Mapping
 from functools import partial
 import logging
-from typing import Any, cast
+from types import MappingProxyType
+from typing import Any
 
 import anthropic
 import voluptuous as vol
 
 from homeassistant.config_entries import (
     ConfigEntry,
-    ConfigEntryState,
     ConfigFlow,
     ConfigFlowResult,
-    ConfigSubentryFlow,
-    SubentryFlowResult,
+    OptionsFlow,
 )
-from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import llm
 from homeassistant.helpers.selector import (
     NumberSelector,
@@ -37,7 +36,6 @@ from .const import (
     CONF_RECOMMENDED,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
-    DEFAULT_CONVERSATION_NAME,
     DOMAIN,
     RECOMMENDED_CHAT_MODEL,
     RECOMMENDED_MAX_TOKENS,
@@ -74,8 +72,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
 class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
-    VERSION = 2
-    MINOR_VERSION = 2
+    VERSION = 1
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -84,7 +81,6 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
         errors = {}
 
         if user_input is not None:
-            self._async_abort_entries_match(user_input)
             try:
                 await validate_input(self.hass, user_input)
             except anthropic.APITimeoutError:
@@ -106,93 +102,57 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
                 return self.async_create_entry(
                     title="Claude",
                     data=user_input,
-                    subentries=[
-                        {
-                            "subentry_type": "conversation",
-                            "data": RECOMMENDED_OPTIONS,
-                            "title": DEFAULT_CONVERSATION_NAME,
-                            "unique_id": None,
-                        }
-                    ],
+                    options=RECOMMENDED_OPTIONS,
                 )
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors or None
         )
 
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type[ConfigSubentryFlow]]:
-        """Return subentries supported by this integration."""
-        return {"conversation": ConversationSubentryFlowHandler}
+    @staticmethod
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> OptionsFlow:
+        """Create the options flow."""
+        return AnthropicOptionsFlow(config_entry)
 
 
-class ConversationSubentryFlowHandler(ConfigSubentryFlow):
-    """Flow for managing conversation subentries."""
+class AnthropicOptionsFlow(OptionsFlow):
+    """Anthropic config flow options handler."""
 
-    last_rendered_recommended = False
+    def __init__(self, config_entry: ConfigEntry) -> None:
+        """Initialize options flow."""
+        self.last_rendered_recommended = config_entry.options.get(
+            CONF_RECOMMENDED, False
+        )
 
-    @property
-    def _is_new(self) -> bool:
-        """Return if this is a new subentry."""
-        return self.source == "user"
-
-    async def async_step_set_options(
+    async def async_step_init(
         self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Set conversation options."""
-        # abort if entry is not loaded
-        if self._get_entry().state != ConfigEntryState.LOADED:
-            return self.async_abort(reason="entry_not_loaded")
-
+    ) -> ConfigFlowResult:
+        """Manage the options."""
+        options: dict[str, Any] | MappingProxyType[str, Any] = self.config_entry.options
         errors: dict[str, str] = {}
 
-        if user_input is None:
-            if self._is_new:
-                options = RECOMMENDED_OPTIONS.copy()
+        if user_input is not None:
+            if user_input[CONF_RECOMMENDED] == self.last_rendered_recommended:
+                if not user_input.get(CONF_LLM_HASS_API):
+                    user_input.pop(CONF_LLM_HASS_API, None)
+                if user_input.get(
+                    CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
+                ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
+                    errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
+
+                if not errors:
+                    return self.async_create_entry(title="", data=user_input)
             else:
-                # If this is a reconfiguration, we need to copy the existing options
-                # so that we can show the current values in the form.
-                options = self._get_reconfigure_subentry().data.copy()
+                # Re-render the options again, now with the recommended options shown/hidden
+                self.last_rendered_recommended = user_input[CONF_RECOMMENDED]
 
-            self.last_rendered_recommended = cast(
-                bool, options.get(CONF_RECOMMENDED, False)
-            )
-
-        elif user_input[CONF_RECOMMENDED] == self.last_rendered_recommended:
-            if not user_input.get(CONF_LLM_HASS_API):
-                user_input.pop(CONF_LLM_HASS_API, None)
-            if user_input.get(
-                CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
-            ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
-                errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
-
-            if not errors:
-                if self._is_new:
-                    return self.async_create_entry(
-                        title=user_input.pop(CONF_NAME),
-                        data=user_input,
-                    )
-
-                return self.async_update_and_abort(
-                    self._get_entry(),
-                    self._get_reconfigure_subentry(),
-                    data=user_input,
-                )
-
-            options = user_input
-            self.last_rendered_recommended = user_input[CONF_RECOMMENDED]
-        else:
-            # Re-render the options again, now with the recommended options shown/hidden
-            self.last_rendered_recommended = user_input[CONF_RECOMMENDED]
-
-            options = {
-                CONF_RECOMMENDED: user_input[CONF_RECOMMENDED],
-                CONF_PROMPT: user_input[CONF_PROMPT],
-                CONF_LLM_HASS_API: user_input.get(CONF_LLM_HASS_API),
-            }
+                options = {
+                    CONF_RECOMMENDED: user_input[CONF_RECOMMENDED],
+                    CONF_PROMPT: user_input[CONF_PROMPT],
+                    CONF_LLM_HASS_API: user_input.get(CONF_LLM_HASS_API),
+                }
 
         suggested_values = options.copy()
         if not suggested_values.get(CONF_PROMPT):
@@ -203,25 +163,19 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             suggested_values[CONF_LLM_HASS_API] = [suggested_llm_apis]
 
         schema = self.add_suggested_values_to_schema(
-            vol.Schema(
-                anthropic_config_option_schema(self.hass, self._is_new, options)
-            ),
+            vol.Schema(anthropic_config_option_schema(self.hass, options)),
             suggested_values,
         )
 
         return self.async_show_form(
-            step_id="set_options",
+            step_id="init",
             data_schema=schema,
             errors=errors or None,
         )
 
-    async_step_user = async_step_set_options
-    async_step_reconfigure = async_step_set_options
-
 
 def anthropic_config_option_schema(
     hass: HomeAssistant,
-    is_new: bool,
     options: Mapping[str, Any],
 ) -> dict:
     """Return a schema for Anthropic completion options."""
@@ -233,24 +187,15 @@ def anthropic_config_option_schema(
         for api in llm.async_get_apis(hass)
     ]
 
-    if is_new:
-        schema: dict[vol.Required | vol.Optional, Any] = {
-            vol.Required(CONF_NAME, default=DEFAULT_CONVERSATION_NAME): str,
-        }
-    else:
-        schema = {}
-
-    schema.update(
-        {
-            vol.Optional(CONF_PROMPT): TemplateSelector(),
-            vol.Optional(
-                CONF_LLM_HASS_API,
-            ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
-            vol.Required(
-                CONF_RECOMMENDED, default=options.get(CONF_RECOMMENDED, False)
-            ): bool,
-        }
-    )
+    schema = {
+        vol.Optional(CONF_PROMPT): TemplateSelector(),
+        vol.Optional(
+            CONF_LLM_HASS_API,
+        ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
+        vol.Required(
+            CONF_RECOMMENDED, default=options.get(CONF_RECOMMENDED, False)
+        ): bool,
+    }
 
     if options.get(CONF_RECOMMENDED):
         return schema

homeassistant/components/anthropic/const.py

@@ -5,8 +5,6 @@ import logging
 DOMAIN = "anthropic"
 LOGGER = logging.getLogger(__package__)
 
-DEFAULT_CONVERSATION_NAME = "Claude conversation"
-
 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"

homeassistant/components/anthropic/conversation.py

@@ -1,17 +1,69 @@
 """Conversation support for Anthropic."""
 
-from typing import Literal
+from collections.abc import AsyncGenerator, Callable, Iterable
+import json
+from typing import Any, Literal, cast
+
+import anthropic
+from anthropic import AsyncStream
+from anthropic._types import NOT_GIVEN
+from anthropic.types import (
+    InputJSONDelta,
+    MessageDeltaUsage,
+    MessageParam,
+    MessageStreamEvent,
+    RawContentBlockDeltaEvent,
+    RawContentBlockStartEvent,
+    RawContentBlockStopEvent,
+    RawMessageDeltaEvent,
+    RawMessageStartEvent,
+    RawMessageStopEvent,
+    RedactedThinkingBlock,
+    RedactedThinkingBlockParam,
+    SignatureDelta,
+    TextBlock,
+    TextBlockParam,
+    TextDelta,
+    ThinkingBlock,
+    ThinkingBlockParam,
+    ThinkingConfigDisabledParam,
+    ThinkingConfigEnabledParam,
+    ThinkingDelta,
+    ToolParam,
+    ToolResultBlockParam,
+    ToolUseBlock,
+    ToolUseBlockParam,
+    Usage,
+)
+from voluptuous_openapi import convert
 
 from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import intent
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr, intent, llm
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AnthropicConfigEntry
-from .const import CONF_PROMPT, DOMAIN
-from .entity import AnthropicBaseLLMEntity
+from .const import (
+    CONF_CHAT_MODEL,
+    CONF_MAX_TOKENS,
+    CONF_PROMPT,
+    CONF_TEMPERATURE,
+    CONF_THINKING_BUDGET,
+    DOMAIN,
+    LOGGER,
+    MIN_THINKING_BUDGET,
+    RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_MAX_TOKENS,
+    RECOMMENDED_TEMPERATURE,
+    RECOMMENDED_THINKING_BUDGET,
+    THINKING_MODELS,
+)
+
+# Max number of back and forth with the LLM to generate a response
+MAX_TOOL_ITERATIONS = 10
 
 
 async def async_setup_entry(
@@ -20,29 +72,275 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up conversation entities."""
-    for subentry in config_entry.subentries.values():
-        if subentry.subentry_type != "conversation":
-            continue
+    agent = AnthropicConversationEntity(config_entry)
+    async_add_entities([agent])
 
-        async_add_entities(
-            [AnthropicConversationEntity(config_entry, subentry)],
-            config_subentry_id=subentry.subentry_id,
-        )
+
+def _format_tool(
+    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
+) -> ToolParam:
+    """Format tool specification."""
+    return ToolParam(
+        name=tool.name,
+        description=tool.description or "",
+        input_schema=convert(tool.parameters, custom_serializer=custom_serializer),
+    )
+
+
+def _convert_content(
+    chat_content: Iterable[conversation.Content],
+) -> list[MessageParam]:
+    """Transform HA chat_log content into Anthropic API format."""
+    messages: list[MessageParam] = []
+
+    for content in chat_content:
+        if isinstance(content, conversation.ToolResultContent):
+            tool_result_block = ToolResultBlockParam(
+                type="tool_result",
+                tool_use_id=content.tool_call_id,
+                content=json.dumps(content.tool_result),
+            )
+            if not messages or messages[-1]["role"] != "user":
+                messages.append(
+                    MessageParam(
+                        role="user",
+                        content=[tool_result_block],
+                    )
+                )
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] = [
+                    TextBlockParam(type="text", text=messages[-1]["content"]),
+                    tool_result_block,
+                ]
+            else:
+                messages[-1]["content"].append(tool_result_block)  # type: ignore[attr-defined]
+        elif isinstance(content, conversation.UserContent):
+            # Combine consequent user messages
+            if not messages or messages[-1]["role"] != "user":
+                messages.append(
+                    MessageParam(
+                        role="user",
+                        content=content.content,
+                    )
+                )
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] = [
+                    TextBlockParam(type="text", text=messages[-1]["content"]),
+                    TextBlockParam(type="text", text=content.content),
+                ]
+            else:
+                messages[-1]["content"].append(  # type: ignore[attr-defined]
+                    TextBlockParam(type="text", text=content.content)
+                )
+        elif isinstance(content, conversation.AssistantContent):
+            # Combine consequent assistant messages
+            if not messages or messages[-1]["role"] != "assistant":
+                messages.append(
+                    MessageParam(
+                        role="assistant",
+                        content=[],
+                    )
+                )
+
+            if content.content:
+                messages[-1]["content"].append(  # type: ignore[union-attr]
+                    TextBlockParam(type="text", text=content.content)
+                )
+            if content.tool_calls:
+                messages[-1]["content"].extend(  # type: ignore[union-attr]
+                    [
+                        ToolUseBlockParam(
+                            type="tool_use",
+                            id=tool_call.id,
+                            name=tool_call.tool_name,
+                            input=tool_call.tool_args,
+                        )
+                        for tool_call in content.tool_calls
+                    ]
+                )
+        else:
+            # Note: We don't pass SystemContent here as its passed to the API as the prompt
+            raise TypeError(f"Unexpected content type: {type(content)}")
+
+    return messages
+
+
+async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
+    chat_log: conversation.ChatLog,
+    result: AsyncStream[MessageStreamEvent],
+    messages: list[MessageParam],
+) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+    """Transform the response stream into HA format.
+
+    A typical stream of responses might look something like the following:
+    - RawMessageStartEvent with no content
+    - RawContentBlockStartEvent with an empty ThinkingBlock (if extended thinking is enabled)
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - ...
+    - RawContentBlockDeltaEvent with a SignatureDelta
+    - RawContentBlockStopEvent
+    - RawContentBlockStartEvent with a RedactedThinkingBlock (occasionally)
+    - RawContentBlockStopEvent (RedactedThinkingBlock does not have a delta)
+    - RawContentBlockStartEvent with an empty TextBlock
+    - RawContentBlockDeltaEvent with a TextDelta
+    - RawContentBlockDeltaEvent with a TextDelta
+    - RawContentBlockDeltaEvent with a TextDelta
+    - ...
+    - RawContentBlockStopEvent
+    - RawContentBlockStartEvent with ToolUseBlock specifying the function name
+    - RawContentBlockDeltaEvent with a InputJSONDelta
+    - RawContentBlockDeltaEvent with a InputJSONDelta
+    - ...
+    - RawContentBlockStopEvent
+    - RawMessageDeltaEvent with a stop_reason='tool_use'
+    - RawMessageStopEvent(type='message_stop')
+
+    Each message could contain multiple blocks of the same type.
+    """
+    if result is None:
+        raise TypeError("Expected a stream of messages")
+
+    current_message: MessageParam | None = None
+    current_block: (
+        TextBlockParam
+        | ToolUseBlockParam
+        | ThinkingBlockParam
+        | RedactedThinkingBlockParam
+        | None
+    ) = None
+    current_tool_args: str
+    input_usage: Usage | None = None
+
+    async for response in result:
+        LOGGER.debug("Received response: %s", response)
+
+        if isinstance(response, RawMessageStartEvent):
+            if response.message.role != "assistant":
+                raise ValueError("Unexpected message role")
+            current_message = MessageParam(role=response.message.role, content=[])
+            input_usage = response.message.usage
+        elif isinstance(response, RawContentBlockStartEvent):
+            if isinstance(response.content_block, ToolUseBlock):
+                current_block = ToolUseBlockParam(
+                    type="tool_use",
+                    id=response.content_block.id,
+                    name=response.content_block.name,
+                    input="",
+                )
+                current_tool_args = ""
+            elif isinstance(response.content_block, TextBlock):
+                current_block = TextBlockParam(
+                    type="text", text=response.content_block.text
+                )
+                yield {"role": "assistant"}
+                if response.content_block.text:
+                    yield {"content": response.content_block.text}
+            elif isinstance(response.content_block, ThinkingBlock):
+                current_block = ThinkingBlockParam(
+                    type="thinking",
+                    thinking=response.content_block.thinking,
+                    signature=response.content_block.signature,
+                )
+            elif isinstance(response.content_block, RedactedThinkingBlock):
+                current_block = RedactedThinkingBlockParam(
+                    type="redacted_thinking", data=response.content_block.data
+                )
+                LOGGER.debug(
+                    "Some of Claude’s internal reasoning has been automatically "
+                    "encrypted for safety reasons. This doesn’t affect the quality of "
+                    "responses"
+                )
+        elif isinstance(response, RawContentBlockDeltaEvent):
+            if current_block is None:
+                raise ValueError("Unexpected delta without a block")
+            if isinstance(response.delta, InputJSONDelta):
+                current_tool_args += response.delta.partial_json
+            elif isinstance(response.delta, TextDelta):
+                text_block = cast(TextBlockParam, current_block)
+                text_block["text"] += response.delta.text
+                yield {"content": response.delta.text}
+            elif isinstance(response.delta, ThinkingDelta):
+                thinking_block = cast(ThinkingBlockParam, current_block)
+                thinking_block["thinking"] += response.delta.thinking
+            elif isinstance(response.delta, SignatureDelta):
+                thinking_block = cast(ThinkingBlockParam, current_block)
+                thinking_block["signature"] += response.delta.signature
+        elif isinstance(response, RawContentBlockStopEvent):
+            if current_block is None:
+                raise ValueError("Unexpected stop event without a current block")
+            if current_block["type"] == "tool_use":
+                # tool block
+                tool_args = json.loads(current_tool_args) if current_tool_args else {}
+                current_block["input"] = tool_args
+                yield {
+                    "tool_calls": [
+                        llm.ToolInput(
+                            id=current_block["id"],
+                            tool_name=current_block["name"],
+                            tool_args=tool_args,
+                        )
+                    ]
+                }
+            elif current_block["type"] == "thinking":
+                # thinking block
+                LOGGER.debug("Thinking: %s", current_block["thinking"])
+
+            if current_message is None:
+                raise ValueError("Unexpected stop event without a current message")
+            current_message["content"].append(current_block)  # type: ignore[union-attr]
+            current_block = None
+        elif isinstance(response, RawMessageDeltaEvent):
+            if (usage := response.usage) is not None:
+                chat_log.async_trace(_create_token_stats(input_usage, usage))
+            if response.delta.stop_reason == "refusal":
+                raise HomeAssistantError("Potential policy violation detected")
+        elif isinstance(response, RawMessageStopEvent):
+            if current_message is not None:
+                messages.append(current_message)
+                current_message = None
+
+
+def _create_token_stats(
+    input_usage: Usage | None, response_usage: MessageDeltaUsage
+) -> dict[str, Any]:
+    """Create token stats for conversation agent tracing."""
+    input_tokens = 0
+    cached_input_tokens = 0
+    if input_usage:
+        input_tokens = input_usage.input_tokens
+        cached_input_tokens = input_usage.cache_creation_input_tokens or 0
+    output_tokens = response_usage.output_tokens
+    return {
+        "stats": {
+            "input_tokens": input_tokens,
+            "cached_input_tokens": cached_input_tokens,
+            "output_tokens": output_tokens,
+        }
+    }
 
 
 class AnthropicConversationEntity(
-    conversation.ConversationEntity,
-    conversation.AbstractConversationAgent,
-    AnthropicBaseLLMEntity,
+    conversation.ConversationEntity, conversation.AbstractConversationAgent
 ):
     """Anthropic conversation agent."""
 
+    _attr_has_entity_name = True
+    _attr_name = None
     _attr_supports_streaming = True
 
-    def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
+    def __init__(self, entry: AnthropicConfigEntry) -> None:
         """Initialize the agent."""
-        super().__init__(entry, subentry)
-        if self.subentry.data.get(CONF_LLM_HASS_API):
+        self.entry = entry
+        self._attr_unique_id = entry.entry_id
+        self._attr_device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, entry.entry_id)},
+            manufacturer="Anthropic",
+            model="Claude",
+            entry_type=dr.DeviceEntryType.SERVICE,
+        )
+        if self.entry.options.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
             )
@@ -52,13 +350,20 @@ class AnthropicConversationEntity(
         """Return a list of supported languages."""
         return MATCH_ALL
 
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to Home Assistant."""
+        await super().async_added_to_hass()
+        self.entry.async_on_unload(
+            self.entry.add_update_listener(self._async_entry_update_listener)
+        )
+
     async def _async_handle_message(
         self,
         user_input: conversation.ConversationInput,
         chat_log: conversation.ChatLog,
     ) -> conversation.ConversationResult:
         """Call the API."""
-        options = self.subentry.data
+        options = self.entry.options
 
         try:
             await chat_log.async_provide_llm_data(
@@ -82,3 +387,77 @@ class AnthropicConversationEntity(
             conversation_id=chat_log.conversation_id,
             continue_conversation=chat_log.continue_conversation,
         )
+
+    async def _async_handle_chat_log(
+        self,
+        chat_log: conversation.ChatLog,
+    ) -> None:
+        """Generate an answer for the chat log."""
+        options = self.entry.options
+
+        tools: list[ToolParam] | None = None
+        if chat_log.llm_api:
+            tools = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
+        system = chat_log.content[0]
+        if not isinstance(system, conversation.SystemContent):
+            raise TypeError("First message must be a system message")
+        messages = _convert_content(chat_log.content[1:])
+
+        client = self.entry.runtime_data
+
+        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
+        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+
+        # To prevent infinite loops, we limit the number of iterations
+        for _iteration in range(MAX_TOOL_ITERATIONS):
+            model_args = {
+                "model": model,
+                "messages": messages,
+                "tools": tools or NOT_GIVEN,
+                "max_tokens": options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
+                "system": system.content,
+                "stream": True,
+            }
+            if model in THINKING_MODELS and thinking_budget >= MIN_THINKING_BUDGET:
+                model_args["thinking"] = ThinkingConfigEnabledParam(
+                    type="enabled", budget_tokens=thinking_budget
+                )
+            else:
+                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
+                model_args["temperature"] = options.get(
+                    CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
+                )
+
+            try:
+                stream = await client.messages.create(**model_args)
+            except anthropic.AnthropicError as err:
+                raise HomeAssistantError(
+                    f"Sorry, I had a problem talking to Anthropic: {err}"
+                ) from err
+
+            messages.extend(
+                _convert_content(
+                    [
+                        content
+                        async for content in chat_log.async_add_delta_content_stream(
+                            self.entity_id,
+                            _transform_stream(chat_log, stream, messages),
+                        )
+                        if not isinstance(content, conversation.AssistantContent)
+                    ]
+                )
+            )
+
+            if not chat_log.unresponded_tool_results:
+                break
+
+    async def _async_entry_update_listener(
+        self, hass: HomeAssistant, entry: ConfigEntry
+    ) -> None:
+        """Handle options update."""
+        # Reload as we update device info + entity name + supported features
+        await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/anthropic/entity.py

@@ -1,393 +0,0 @@
-"""Base entity for Anthropic."""
-
-from collections.abc import AsyncGenerator, Callable, Iterable
-import json
-from typing import Any, cast
-
-import anthropic
-from anthropic import AsyncStream
-from anthropic._types import NOT_GIVEN
-from anthropic.types import (
-    InputJSONDelta,
-    MessageDeltaUsage,
-    MessageParam,
-    MessageStreamEvent,
-    RawContentBlockDeltaEvent,
-    RawContentBlockStartEvent,
-    RawContentBlockStopEvent,
-    RawMessageDeltaEvent,
-    RawMessageStartEvent,
-    RawMessageStopEvent,
-    RedactedThinkingBlock,
-    RedactedThinkingBlockParam,
-    SignatureDelta,
-    TextBlock,
-    TextBlockParam,
-    TextDelta,
-    ThinkingBlock,
-    ThinkingBlockParam,
-    ThinkingConfigDisabledParam,
-    ThinkingConfigEnabledParam,
-    ThinkingDelta,
-    ToolParam,
-    ToolResultBlockParam,
-    ToolUseBlock,
-    ToolUseBlockParam,
-    Usage,
-)
-from voluptuous_openapi import convert
-
-from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import device_registry as dr, llm
-from homeassistant.helpers.entity import Entity
-
-from . import AnthropicConfigEntry
-from .const import (
-    CONF_CHAT_MODEL,
-    CONF_MAX_TOKENS,
-    CONF_TEMPERATURE,
-    CONF_THINKING_BUDGET,
-    DOMAIN,
-    LOGGER,
-    MIN_THINKING_BUDGET,
-    RECOMMENDED_CHAT_MODEL,
-    RECOMMENDED_MAX_TOKENS,
-    RECOMMENDED_TEMPERATURE,
-    RECOMMENDED_THINKING_BUDGET,
-    THINKING_MODELS,
-)
-
-# Max number of back and forth with the LLM to generate a response
-MAX_TOOL_ITERATIONS = 10
-
-
-def _format_tool(
-    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
-) -> ToolParam:
-    """Format tool specification."""
-    return ToolParam(
-        name=tool.name,
-        description=tool.description or "",
-        input_schema=convert(tool.parameters, custom_serializer=custom_serializer),
-    )
-
-
-def _convert_content(
-    chat_content: Iterable[conversation.Content],
-) -> list[MessageParam]:
-    """Transform HA chat_log content into Anthropic API format."""
-    messages: list[MessageParam] = []
-
-    for content in chat_content:
-        if isinstance(content, conversation.ToolResultContent):
-            tool_result_block = ToolResultBlockParam(
-                type="tool_result",
-                tool_use_id=content.tool_call_id,
-                content=json.dumps(content.tool_result),
-            )
-            if not messages or messages[-1]["role"] != "user":
-                messages.append(
-                    MessageParam(
-                        role="user",
-                        content=[tool_result_block],
-                    )
-                )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                    tool_result_block,
-                ]
-            else:
-                messages[-1]["content"].append(tool_result_block)  # type: ignore[attr-defined]
-        elif isinstance(content, conversation.UserContent):
-            # Combine consequent user messages
-            if not messages or messages[-1]["role"] != "user":
-                messages.append(
-                    MessageParam(
-                        role="user",
-                        content=content.content,
-                    )
-                )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                    TextBlockParam(type="text", text=content.content),
-                ]
-            else:
-                messages[-1]["content"].append(  # type: ignore[attr-defined]
-                    TextBlockParam(type="text", text=content.content)
-                )
-        elif isinstance(content, conversation.AssistantContent):
-            # Combine consequent assistant messages
-            if not messages or messages[-1]["role"] != "assistant":
-                messages.append(
-                    MessageParam(
-                        role="assistant",
-                        content=[],
-                    )
-                )
-
-            if content.content:
-                messages[-1]["content"].append(  # type: ignore[union-attr]
-                    TextBlockParam(type="text", text=content.content)
-                )
-            if content.tool_calls:
-                messages[-1]["content"].extend(  # type: ignore[union-attr]
-                    [
-                        ToolUseBlockParam(
-                            type="tool_use",
-                            id=tool_call.id,
-                            name=tool_call.tool_name,
-                            input=tool_call.tool_args,
-                        )
-                        for tool_call in content.tool_calls
-                    ]
-                )
-        else:
-            # Note: We don't pass SystemContent here as its passed to the API as the prompt
-            raise TypeError(f"Unexpected content type: {type(content)}")
-
-    return messages
-
-
-async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
-    chat_log: conversation.ChatLog,
-    result: AsyncStream[MessageStreamEvent],
-    messages: list[MessageParam],
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
-    """Transform the response stream into HA format.
-
-    A typical stream of responses might look something like the following:
-    - RawMessageStartEvent with no content
-    - RawContentBlockStartEvent with an empty ThinkingBlock (if extended thinking is enabled)
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - ...
-    - RawContentBlockDeltaEvent with a SignatureDelta
-    - RawContentBlockStopEvent
-    - RawContentBlockStartEvent with a RedactedThinkingBlock (occasionally)
-    - RawContentBlockStopEvent (RedactedThinkingBlock does not have a delta)
-    - RawContentBlockStartEvent with an empty TextBlock
-    - RawContentBlockDeltaEvent with a TextDelta
-    - RawContentBlockDeltaEvent with a TextDelta
-    - RawContentBlockDeltaEvent with a TextDelta
-    - ...
-    - RawContentBlockStopEvent
-    - RawContentBlockStartEvent with ToolUseBlock specifying the function name
-    - RawContentBlockDeltaEvent with a InputJSONDelta
-    - RawContentBlockDeltaEvent with a InputJSONDelta
-    - ...
-    - RawContentBlockStopEvent
-    - RawMessageDeltaEvent with a stop_reason='tool_use'
-    - RawMessageStopEvent(type='message_stop')
-
-    Each message could contain multiple blocks of the same type.
-    """
-    if result is None:
-        raise TypeError("Expected a stream of messages")
-
-    current_message: MessageParam | None = None
-    current_block: (
-        TextBlockParam
-        | ToolUseBlockParam
-        | ThinkingBlockParam
-        | RedactedThinkingBlockParam
-        | None
-    ) = None
-    current_tool_args: str
-    input_usage: Usage | None = None
-
-    async for response in result:
-        LOGGER.debug("Received response: %s", response)
-
-        if isinstance(response, RawMessageStartEvent):
-            if response.message.role != "assistant":
-                raise ValueError("Unexpected message role")
-            current_message = MessageParam(role=response.message.role, content=[])
-            input_usage = response.message.usage
-        elif isinstance(response, RawContentBlockStartEvent):
-            if isinstance(response.content_block, ToolUseBlock):
-                current_block = ToolUseBlockParam(
-                    type="tool_use",
-                    id=response.content_block.id,
-                    name=response.content_block.name,
-                    input="",
-                )
-                current_tool_args = ""
-            elif isinstance(response.content_block, TextBlock):
-                current_block = TextBlockParam(
-                    type="text", text=response.content_block.text
-                )
-                yield {"role": "assistant"}
-                if response.content_block.text:
-                    yield {"content": response.content_block.text}
-            elif isinstance(response.content_block, ThinkingBlock):
-                current_block = ThinkingBlockParam(
-                    type="thinking",
-                    thinking=response.content_block.thinking,
-                    signature=response.content_block.signature,
-                )
-            elif isinstance(response.content_block, RedactedThinkingBlock):
-                current_block = RedactedThinkingBlockParam(
-                    type="redacted_thinking", data=response.content_block.data
-                )
-                LOGGER.debug(
-                    "Some of Claude’s internal reasoning has been automatically "
-                    "encrypted for safety reasons. This doesn’t affect the quality of "
-                    "responses"
-                )
-        elif isinstance(response, RawContentBlockDeltaEvent):
-            if current_block is None:
-                raise ValueError("Unexpected delta without a block")
-            if isinstance(response.delta, InputJSONDelta):
-                current_tool_args += response.delta.partial_json
-            elif isinstance(response.delta, TextDelta):
-                text_block = cast(TextBlockParam, current_block)
-                text_block["text"] += response.delta.text
-                yield {"content": response.delta.text}
-            elif isinstance(response.delta, ThinkingDelta):
-                thinking_block = cast(ThinkingBlockParam, current_block)
-                thinking_block["thinking"] += response.delta.thinking
-            elif isinstance(response.delta, SignatureDelta):
-                thinking_block = cast(ThinkingBlockParam, current_block)
-                thinking_block["signature"] += response.delta.signature
-        elif isinstance(response, RawContentBlockStopEvent):
-            if current_block is None:
-                raise ValueError("Unexpected stop event without a current block")
-            if current_block["type"] == "tool_use":
-                # tool block
-                tool_args = json.loads(current_tool_args) if current_tool_args else {}
-                current_block["input"] = tool_args
-                yield {
-                    "tool_calls": [
-                        llm.ToolInput(
-                            id=current_block["id"],
-                            tool_name=current_block["name"],
-                            tool_args=tool_args,
-                        )
-                    ]
-                }
-            elif current_block["type"] == "thinking":
-                # thinking block
-                LOGGER.debug("Thinking: %s", current_block["thinking"])
-
-            if current_message is None:
-                raise ValueError("Unexpected stop event without a current message")
-            current_message["content"].append(current_block)  # type: ignore[union-attr]
-            current_block = None
-        elif isinstance(response, RawMessageDeltaEvent):
-            if (usage := response.usage) is not None:
-                chat_log.async_trace(_create_token_stats(input_usage, usage))
-            if response.delta.stop_reason == "refusal":
-                raise HomeAssistantError("Potential policy violation detected")
-        elif isinstance(response, RawMessageStopEvent):
-            if current_message is not None:
-                messages.append(current_message)
-                current_message = None
-
-
-def _create_token_stats(
-    input_usage: Usage | None, response_usage: MessageDeltaUsage
-) -> dict[str, Any]:
-    """Create token stats for conversation agent tracing."""
-    input_tokens = 0
-    cached_input_tokens = 0
-    if input_usage:
-        input_tokens = input_usage.input_tokens
-        cached_input_tokens = input_usage.cache_creation_input_tokens or 0
-    output_tokens = response_usage.output_tokens
-    return {
-        "stats": {
-            "input_tokens": input_tokens,
-            "cached_input_tokens": cached_input_tokens,
-            "output_tokens": output_tokens,
-        }
-    }
-
-
-class AnthropicBaseLLMEntity(Entity):
-    """Anthropic base LLM entity."""
-
-    def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
-        """Initialize the entity."""
-        self.entry = entry
-        self.subentry = subentry
-        self._attr_name = subentry.title
-        self._attr_unique_id = subentry.subentry_id
-        self._attr_device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, subentry.subentry_id)},
-            name=subentry.title,
-            manufacturer="Anthropic",
-            model="Claude",
-            entry_type=dr.DeviceEntryType.SERVICE,
-        )
-
-    async def _async_handle_chat_log(
-        self,
-        chat_log: conversation.ChatLog,
-    ) -> None:
-        """Generate an answer for the chat log."""
-        options = self.subentry.data
-
-        tools: list[ToolParam] | None = None
-        if chat_log.llm_api:
-            tools = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-        system = chat_log.content[0]
-        if not isinstance(system, conversation.SystemContent):
-            raise TypeError("First message must be a system message")
-        messages = _convert_content(chat_log.content[1:])
-
-        client = self.entry.runtime_data
-
-        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
-        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-
-        # To prevent infinite loops, we limit the number of iterations
-        for _iteration in range(MAX_TOOL_ITERATIONS):
-            model_args = {
-                "model": model,
-                "messages": messages,
-                "tools": tools or NOT_GIVEN,
-                "max_tokens": options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
-                "system": system.content,
-                "stream": True,
-            }
-            if model in THINKING_MODELS and thinking_budget >= MIN_THINKING_BUDGET:
-                model_args["thinking"] = ThinkingConfigEnabledParam(
-                    type="enabled", budget_tokens=thinking_budget
-                )
-            else:
-                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
-                model_args["temperature"] = options.get(
-                    CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
-                )
-
-            try:
-                stream = await client.messages.create(**model_args)
-            except anthropic.AnthropicError as err:
-                raise HomeAssistantError(
-                    f"Sorry, I had a problem talking to Anthropic: {err}"
-                ) from err
-
-            messages.extend(
-                _convert_content(
-                    [
-                        content
-                        async for content in chat_log.async_add_delta_content_stream(
-                            self.entity_id,
-                            _transform_stream(chat_log, stream, messages),
-                        )
-                        if not isinstance(content, conversation.AssistantContent)
-                    ]
-                )
-            )
-
-            if not chat_log.unresponded_tool_results:
-                break

homeassistant/components/anthropic/strings.json

@@ -12,44 +12,28 @@
       "timeout_connect": "[%key:common::config_flow::error::timeout_connect%]",
       "authentication_error": "[%key:common::config_flow::error::invalid_auth%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
     }
   },
-  "config_subentries": {
-    "conversation": {
-      "initiate_flow": {
-        "user": "Add conversation agent",
-        "reconfigure": "Reconfigure conversation agent"
-      },
-      "entry_type": "Conversation agent",
-
-      "step": {
-        "set_options": {
-          "data": {
-            "name": "[%key:common::config_flow::data::name%]",
-            "prompt": "Instructions",
-            "chat_model": "[%key:common::generic::model%]",
-            "max_tokens": "Maximum tokens to return in response",
-            "temperature": "Temperature",
-            "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
-            "recommended": "Recommended model settings",
-            "thinking_budget_tokens": "Thinking budget"
-          },
-          "data_description": {
-            "prompt": "Instruct how the LLM should respond. This can be a template.",
-            "thinking_budget_tokens": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking."
-          }
+  "options": {
+    "step": {
+      "init": {
+        "data": {
+          "prompt": "Instructions",
+          "chat_model": "[%key:common::generic::model%]",
+          "max_tokens": "Maximum tokens to return in response",
+          "temperature": "Temperature",
+          "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
+          "recommended": "Recommended model settings",
+          "thinking_budget_tokens": "Thinking budget"
+        },
+        "data_description": {
+          "prompt": "Instruct how the LLM should respond. This can be a template.",
+          "thinking_budget_tokens": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking."
         }
-      },
-      "abort": {
-        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-        "entry_not_loaded": "Cannot add things while the configuration is disabled."
-      },
-      "error": {
-        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget."
       }
+    },
+    "error": {
+      "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget."
     }
   }
 }

homeassistant/components/api/__init__.py

@@ -260,18 +260,11 @@ class APIEntityStateView(HomeAssistantView):
         if not user.is_admin:
             raise Unauthorized(entity_id=entity_id)
         hass = request.app[KEY_HASS]
-
-        body = await request.text()
-
         try:
-            data: Any = json_loads(body) if body else None
+            data = await request.json()
         except ValueError:
             return self.json_message("Invalid JSON specified.", HTTPStatus.BAD_REQUEST)
 
-        if not isinstance(data, dict):
-            return self.json_message(
-                "State data should be a JSON object.", HTTPStatus.BAD_REQUEST
-            )
         if (new_state := data.get("state")) is None:
             return self.json_message("No state specified.", HTTPStatus.BAD_REQUEST)
 
@@ -484,19 +477,9 @@ class APITemplateView(HomeAssistantView):
     @require_admin
     async def post(self, request: web.Request) -> web.Response:
         """Render a template."""
-        body = await request.text()
-
-        try:
-            data: Any = json_loads(body) if body else None
-        except ValueError:
-            return self.json_message("Invalid JSON specified.", HTTPStatus.BAD_REQUEST)
-
-        if not isinstance(data, dict):
-            return self.json_message(
-                "Template data should be a JSON object.", HTTPStatus.BAD_REQUEST
-            )
-        tpl = _cached_template(data["template"], request.app[KEY_HASS])
         try:
+            data = await request.json()
+            tpl = _cached_template(data["template"], request.app[KEY_HASS])
             return tpl.async_render(variables=data.get("variables"), parse_result=False)  # type: ignore[no-any-return]
         except (ValueError, TemplateError) as ex:
             return self.json_message(

homeassistant/components/assist_pipeline/pipeline.py

@@ -1119,7 +1119,6 @@ class PipelineRun:
                 ) is not None:
                     # Sentence trigger matched
                     agent_id = "sentence_trigger"
-                    processed_locally = True
                     intent_response = intent.IntentResponse(
                         self.pipeline.conversation_language
                     )

homeassistant/components/assist_satellite/__init__.py

@@ -71,9 +71,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             cv.make_entity_service_schema(
                 {
                     vol.Optional("message"): str,
-                    vol.Optional("media_id"): _media_id_validator,
+                    vol.Optional("media_id"): str,
                     vol.Optional("preannounce"): bool,
-                    vol.Optional("preannounce_media_id"): _media_id_validator,
+                    vol.Optional("preannounce_media_id"): str,
                 }
             ),
             cv.has_at_least_one_key("message", "media_id"),
@@ -81,16 +81,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         "async_internal_announce",
         [AssistSatelliteEntityFeature.ANNOUNCE],
     )
-
     component.async_register_entity_service(
         "start_conversation",
         vol.All(
             cv.make_entity_service_schema(
                 {
                     vol.Optional("start_message"): str,
-                    vol.Optional("start_media_id"): _media_id_validator,
+                    vol.Optional("start_media_id"): str,
                     vol.Optional("preannounce"): bool,
-                    vol.Optional("preannounce_media_id"): _media_id_validator,
+                    vol.Optional("preannounce_media_id"): str,
                     vol.Optional("extra_system_prompt"): str,
                 }
             ),
@@ -136,9 +135,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             {
                 vol.Required(ATTR_ENTITY_ID): cv.entity_domain(DOMAIN),
                 vol.Optional("question"): str,
-                vol.Optional("question_media_id"): _media_id_validator,
+                vol.Optional("question_media_id"): str,
                 vol.Optional("preannounce"): bool,
-                vol.Optional("preannounce_media_id"): _media_id_validator,
+                vol.Optional("preannounce_media_id"): str,
                 vol.Optional("answers"): [
                     {
                         vol.Required("id"): str,
@@ -205,20 +204,3 @@ def has_one_non_empty_item(value: list[str]) -> list[str]:
             raise vol.Invalid("sentences cannot be empty")
 
     return value
-
-
-# Validator for media_id fields that accepts both string and media selector format
-_media_id_validator = vol.Any(
-    cv.string,  # Plain string format
-    vol.All(
-        vol.Schema(
-            {
-                vol.Required("media_content_id"): cv.string,
-                vol.Required("media_content_type"): cv.string,
-                vol.Remove("metadata"): dict,  # Ignore metadata if present
-            }
-        ),
-        # Extract media_content_id from media selector format
-        lambda x: x["media_content_id"],
-    ),
-)

homeassistant/components/assist_satellite/services.yaml

@@ -14,9 +14,7 @@ announce:
     media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
     preannounce:
       required: false
       default: true
@@ -25,9 +23,7 @@ announce:
     preannounce_media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
 start_conversation:
   target:
     entity:
@@ -44,9 +40,7 @@ start_conversation:
     start_media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
     extra_system_prompt:
       required: false
       selector:
@@ -59,9 +53,7 @@ start_conversation:
     preannounce_media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
 ask_question:
   fields:
     entity_id:
@@ -80,9 +72,7 @@ ask_question:
     question_media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
     preannounce:
       required: false
       default: true
@@ -91,24 +81,8 @@ ask_question:
     preannounce_media_id:
       required: false
       selector:
-        media:
-          accept:
-            - audio/*
+        text:
     answers:
       required: false
       selector:
         object:
-          label_field: sentences
-          description_field: id
-          multiple: true
-          translation_key: answers
-          fields:
-            id:
-              required: true
-              selector:
-                text:
-            sentences:
-              required: true
-              selector:
-                text:
-                  multiple: true

homeassistant/components/assist_satellite/strings.json

@@ -90,13 +90,5 @@
         }
       }
     }
-  },
-  "selector": {
-    "answers": {
-      "fields": {
-        "id": "Answer ID",
-        "sentences": "Sentences"
-      }
-    }
   }
 }

homeassistant/components/backup/__init__.py

@@ -2,9 +2,9 @@
 
 from homeassistant.config_entries import SOURCE_SYSTEM
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv, discovery_flow
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.typing import ConfigType
 
@@ -37,6 +37,7 @@ from .manager import (
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
+    ManagerStateEvent,
     NewBackup,
     RestoreBackupEvent,
     RestoreBackupStage,
@@ -44,7 +45,6 @@ from .manager import (
     WrittenBackup,
 )
 from .models import AddonInfo, AgentBackup, BackupNotFound, Folder
-from .services import async_setup_services
 from .util import suggested_filename, suggested_filename_from_name_date
 from .websocket import async_register_websocket_handlers
 
@@ -71,12 +71,12 @@ __all__ = [
     "IncorrectPasswordError",
     "LocalBackupAgent",
     "ManagerBackup",
+    "ManagerStateEvent",
     "NewBackup",
     "RestoreBackupEvent",
     "RestoreBackupStage",
     "RestoreBackupState",
     "WrittenBackup",
-    "async_get_manager",
     "suggested_filename",
     "suggested_filename_from_name_date",
 ]
@@ -103,11 +103,39 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     backup_manager = BackupManager(hass, reader_writer)
     hass.data[DATA_MANAGER] = backup_manager
-    await backup_manager.async_setup()
+    try:
+        await backup_manager.async_setup()
+    except Exception as err:
+        hass.data[DATA_BACKUP].manager_ready.set_exception(err)
+        raise
+    else:
+        hass.data[DATA_BACKUP].manager_ready.set_result(None)
 
     async_register_websocket_handlers(hass, with_hassio)
 
-    async_setup_services(hass)
+    async def async_handle_create_service(call: ServiceCall) -> None:
+        """Service handler for creating backups."""
+        agent_id = list(backup_manager.local_backup_agents)[0]
+        await backup_manager.async_create_backup(
+            agent_ids=[agent_id],
+            include_addons=None,
+            include_all_addons=False,
+            include_database=True,
+            include_folders=None,
+            include_homeassistant=True,
+            name=None,
+            password=None,
+        )
+
+    async def async_handle_create_automatic_service(call: ServiceCall) -> None:
+        """Service handler for creating automatic backups."""
+        await backup_manager.async_create_automatic_backup()
+
+    if not with_hassio:
+        hass.services.async_register(DOMAIN, "create", async_handle_create_service)
+    hass.services.async_register(
+        DOMAIN, "create_automatic", async_handle_create_automatic_service
+    )
 
     async_register_http_views(hass)
 
@@ -136,15 +164,3 @@ async def async_setup_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bo
 async def async_unload_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-@callback
-def async_get_manager(hass: HomeAssistant) -> BackupManager:
-    """Get the backup manager instance.
-
-    Raises HomeAssistantError if the backup integration is not available.
-    """
-    if DATA_MANAGER not in hass.data:
-        raise HomeAssistantError("Backup integration is not available")
-
-    return hass.data[DATA_MANAGER]

homeassistant/components/backup/basic_websocket.py

@@ -0,0 +1,38 @@
+"""Websocket commands for the Backup integration."""
+
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import async_subscribe_events
+
+from .const import DATA_MANAGER
+from .manager import ManagerStateEvent
+
+
+@callback
+def async_register_websocket_handlers(hass: HomeAssistant) -> None:
+    """Register websocket commands."""
+    websocket_api.async_register_command(hass, handle_subscribe_events)
+
+
+@websocket_api.require_admin
+@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
+@websocket_api.async_response
+async def handle_subscribe_events(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to backup events."""
+
+    def on_event(event: ManagerStateEvent) -> None:
+        connection.send_message(websocket_api.event_message(msg["id"], event))
+
+    if DATA_MANAGER in hass.data:
+        manager = hass.data[DATA_MANAGER]
+        on_event(manager.last_event)
+    connection.subscriptions[msg["id"]] = async_subscribe_events(hass, on_event)
+    connection.send_result(msg["id"])

homeassistant/components/backup/coordinator.py

@@ -8,6 +8,10 @@ from datetime import datetime
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import (
+    async_subscribe_events,
+    async_subscribe_platform_events,
+)
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN, LOGGER
@@ -52,8 +56,8 @@ class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
             update_interval=None,
         )
         self.unsubscribe: list[Callable[[], None]] = [
-            backup_manager.async_subscribe_events(self._on_event),
-            backup_manager.async_subscribe_platform_events(self._on_event),
+            async_subscribe_events(hass, self._on_event),
+            async_subscribe_platform_events(hass, self._on_event),
         ]
 
         self.backup_manager = backup_manager

homeassistant/components/backup/manager.py

@@ -36,6 +36,7 @@ from homeassistant.helpers import (
     issue_registry as ir,
     start,
 )
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util, json as json_util
 
@@ -371,10 +372,12 @@ class BackupManager:
         # Latest backup event and backup event subscribers
         self.last_event: ManagerStateEvent = BlockedEvent()
         self.last_action_event: ManagerStateEvent | None = None
-        self._backup_event_subscriptions: list[Callable[[ManagerStateEvent], None]] = []
-        self._backup_platform_event_subscriptions: list[
-            Callable[[BackupPlatformEvent], None]
-        ] = []
+        self._backup_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_event_subscriptions
+        self._backup_platform_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_platform_event_subscriptions
 
     async def async_setup(self) -> None:
         """Set up the backup manager."""
@@ -1382,32 +1385,6 @@ class BackupManager:
         for subscription in self._backup_event_subscriptions:
             subscription(event)
 
-    @callback
-    def async_subscribe_events(
-        self,
-        on_event: Callable[[ManagerStateEvent], None],
-    ) -> Callable[[], None]:
-        """Subscribe events."""
-
-        def remove_subscription() -> None:
-            self._backup_event_subscriptions.remove(on_event)
-
-        self._backup_event_subscriptions.append(on_event)
-        return remove_subscription
-
-    @callback
-    def async_subscribe_platform_events(
-        self,
-        on_event: Callable[[BackupPlatformEvent], None],
-    ) -> Callable[[], None]:
-        """Subscribe to backup platform events."""
-
-        def remove_subscription() -> None:
-            self._backup_platform_event_subscriptions.remove(on_event)
-
-        self._backup_platform_event_subscriptions.append(on_event)
-        return remove_subscription
-
     def _create_automatic_backup_failed_issue(
         self, translation_key: str, translation_placeholders: dict[str, str] | None
     ) -> None:

homeassistant/components/backup/onboarding.py

@@ -19,14 +19,9 @@ from homeassistant.components.onboarding import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.backup import async_get_manager as async_get_backup_manager
 
-from . import (
-    BackupManager,
-    Folder,
-    IncorrectPasswordError,
-    async_get_manager,
-    http as backup_http,
-)
+from . import BackupManager, Folder, IncorrectPasswordError, http as backup_http
 
 if TYPE_CHECKING:
     from homeassistant.components.onboarding import OnboardingStoreData
@@ -59,7 +54,7 @@ def with_backup_manager[_ViewT: BaseOnboardingView, **_P](
         if self._data["done"]:
             raise HTTPUnauthorized
 
-        manager = async_get_manager(request.app[KEY_HASS])
+        manager = await async_get_backup_manager(request.app[KEY_HASS])
         return await func(self, manager, request, *args, **kwargs)
 
     return with_backup

homeassistant/components/backup/services.py

@@ -1,36 +0,0 @@
-"""The Backup integration."""
-
-from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.helpers.hassio import is_hassio
-
-from .const import DATA_MANAGER, DOMAIN
-
-
-async def _async_handle_create_service(call: ServiceCall) -> None:
-    """Service handler for creating backups."""
-    backup_manager = call.hass.data[DATA_MANAGER]
-    agent_id = list(backup_manager.local_backup_agents)[0]
-    await backup_manager.async_create_backup(
-        agent_ids=[agent_id],
-        include_addons=None,
-        include_all_addons=False,
-        include_database=True,
-        include_folders=None,
-        include_homeassistant=True,
-        name=None,
-        password=None,
-    )
-
-
-async def _async_handle_create_automatic_service(call: ServiceCall) -> None:
-    """Service handler for creating automatic backups."""
-    await call.hass.data[DATA_MANAGER].async_create_automatic_backup()
-
-
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Register services."""
-    if not is_hassio(hass):
-        hass.services.async_register(DOMAIN, "create", _async_handle_create_service)
-    hass.services.async_register(
-        DOMAIN, "create_automatic", _async_handle_create_automatic_service
-    )

homeassistant/components/backup/websocket.py

@@ -10,11 +10,7 @@ from homeassistant.helpers import config_validation as cv
 
 from .config import Day, ScheduleRecurrence
 from .const import DATA_MANAGER, LOGGER
-from .manager import (
-    DecryptOnDowloadNotSupported,
-    IncorrectPasswordError,
-    ManagerStateEvent,
-)
+from .manager import DecryptOnDowloadNotSupported, IncorrectPasswordError
 from .models import BackupNotFound, Folder
 
 
@@ -34,7 +30,6 @@ def async_register_websocket_handlers(hass: HomeAssistant, with_hassio: bool) ->
     websocket_api.async_register_command(hass, handle_create_with_automatic_settings)
     websocket_api.async_register_command(hass, handle_delete)
     websocket_api.async_register_command(hass, handle_restore)
-    websocket_api.async_register_command(hass, handle_subscribe_events)
 
     websocket_api.async_register_command(hass, handle_config_info)
     websocket_api.async_register_command(hass, handle_config_update)
@@ -422,22 +417,3 @@ def handle_config_update(
     changes.pop("type")
     manager.config.update(**changes)
     connection.send_result(msg["id"])
-
-
-@websocket_api.require_admin
-@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
-@websocket_api.async_response
-async def handle_subscribe_events(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Subscribe to backup events."""
-
-    def on_event(event: ManagerStateEvent) -> None:
-        connection.send_message(websocket_api.event_message(msg["id"], event))
-
-    manager = hass.data[DATA_MANAGER]
-    on_event(manager.last_event)
-    connection.subscriptions[msg["id"]] = manager.async_subscribe_events(on_event)
-    connection.send_result(msg["id"])

homeassistant/components/bosch_alarm/__init__.py

@@ -14,7 +14,7 @@ from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
 from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE, DOMAIN
-from .services import async_setup_services
+from .services import setup_services
 from .types import BoschAlarmConfigEntry
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -29,7 +29,7 @@ PLATFORMS: list[Platform] = [
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up bosch alarm services."""
-    async_setup_services(hass)
+    setup_services(hass)
     return True
 
 

homeassistant/components/bosch_alarm/manifest.json

@@ -11,6 +11,6 @@
   "documentation": "https://www.home-assistant.io/integrations/bosch_alarm",
   "integration_type": "device",
   "iot_class": "local_push",
-  "quality_scale": "platinum",
+  "quality_scale": "bronze",
   "requirements": ["bosch-alarm-mode2==0.4.6"]
 }

homeassistant/components/bosch_alarm/quality_scale.yaml

@@ -28,41 +28,38 @@ rules:
   # Silver
   action-exceptions: done
   config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: |
-      No options flow is provided.
-  docs-installation-parameters: done
-  entity-unavailable: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: todo
   integration-owner: done
-  log-when-unavailable: done
+  log-when-unavailable: todo
   parallel-updates: done
   reauthentication-flow: done
   test-coverage: done
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info: done
   discovery: done
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
   dynamic-devices:
     status: exempt
     comment: |
       Device type integration
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: done
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
   entity-translations: done
-  exception-translations: done
+  exception-translations: todo
   icon-translations: done
-  reconfiguration-flow: done
+  reconfiguration-flow: todo
   repair-issues:
     status: exempt
     comment: |

homeassistant/components/bosch_alarm/services.py

@@ -9,7 +9,7 @@ from typing import Any
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.util import dt as dt_util
@@ -66,8 +66,7 @@ async def async_set_panel_date(call: ServiceCall) -> None:
         ) from err
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the bosch alarm integration."""
 
     hass.services.async_register(

homeassistant/components/buienradar/sensor.py

@@ -168,6 +168,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         key="windazimuth",
         translation_key="windazimuth",
         native_unit_of_measurement=DEGREE,
+        icon="mdi:compass-outline",
         device_class=SensorDeviceClass.WIND_DIRECTION,
         state_class=SensorStateClass.MEASUREMENT_ANGLE,
     ),

homeassistant/components/camera/__init__.py

@@ -498,6 +498,19 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Flag supported features."""
         return self._attr_supported_features
 
+    @property
+    def supported_features_compat(self) -> CameraEntityFeature:
+        """Return the supported features as CameraEntityFeature.
+
+        Remove this compatibility shim in 2025.1 or later.
+        """
+        features = self.supported_features
+        if type(features) is int:
+            new_features = CameraEntityFeature(features)
+            self._report_deprecated_supported_features_values(new_features)
+            return new_features
+        return features
+
     @cached_property
     def is_recording(self) -> bool:
         """Return true if the device is recording."""
@@ -691,7 +704,9 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     async def async_internal_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
         await super().async_internal_added_to_hass()
-        self.__supports_stream = self.supported_features & CameraEntityFeature.STREAM
+        self.__supports_stream = (
+            self.supported_features_compat & CameraEntityFeature.STREAM
+        )
         await self.async_refresh_providers(write_state=False)
 
     async def async_refresh_providers(self, *, write_state: bool = True) -> None:
@@ -720,7 +735,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         self, fn: Callable[[HomeAssistant, Camera], Coroutine[None, None, _T | None]]
     ) -> _T | None:
         """Get first provider that supports this camera."""
-        if CameraEntityFeature.STREAM not in self.supported_features:
+        if CameraEntityFeature.STREAM not in self.supported_features_compat:
             return None
 
         return await fn(self.hass, self)
@@ -770,7 +785,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def camera_capabilities(self) -> CameraCapabilities:
         """Return the camera capabilities."""
         frontend_stream_types = set()
-        if CameraEntityFeature.STREAM in self.supported_features:
+        if CameraEntityFeature.STREAM in self.supported_features_compat:
             if self._supports_native_async_webrtc:
                 # The camera has a native WebRTC implementation
                 frontend_stream_types.add(StreamType.WEB_RTC)
@@ -790,7 +805,8 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """
         super().async_write_ha_state()
         if self.__supports_stream != (
-            supports_stream := self.supported_features & CameraEntityFeature.STREAM
+            supports_stream := self.supported_features_compat
+            & CameraEntityFeature.STREAM
         ):
             self.__supports_stream = supports_stream
             self._invalidate_camera_capabilities_cache()

homeassistant/components/cloud/manifest.json

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

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.6.23"]
+  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.6.10"]
 }

homeassistant/components/coolmaster/__init__.py

@@ -5,9 +5,8 @@ from pycoolmasternet_async import CoolMasterNet
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
 
-from .const import CONF_SWING_SUPPORT, DOMAIN
+from .const import CONF_SWING_SUPPORT
 from .coordinator import CoolmasterConfigEntry, CoolmasterDataUpdateCoordinator
 
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.BUTTON, Platform.CLIMATE, Platform.SENSOR]
@@ -49,14 +48,3 @@ async def async_setup_entry(hass: HomeAssistant, entry: CoolmasterConfigEntry) -
 async def async_unload_entry(hass: HomeAssistant, entry: CoolmasterConfigEntry) -> bool:
     """Unload a Coolmaster config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant,
-    config_entry: CoolmasterConfigEntry,
-    device_entry: dr.DeviceEntry,
-) -> bool:
-    """Remove a config entry from a device."""
-    return not device_entry.identifiers.intersection(
-        (DOMAIN, unit_id) for unit_id in config_entry.runtime_data.data
-    )

homeassistant/components/derivative/config_flow.py

@@ -26,7 +26,6 @@ from homeassistant.helpers.schema_config_entry_flow import (
 )
 
 from .const import (
-    CONF_MAX_SUB_INTERVAL,
     CONF_ROUND_DIGITS,
     CONF_TIME_WINDOW,
     CONF_UNIT_PREFIX,
@@ -105,9 +104,6 @@ async def _get_options_dict(handler: SchemaCommonFlowHandler | None) -> dict:
                 options=TIME_UNITS, translation_key="time_unit"
             ),
         ),
-        vol.Optional(CONF_MAX_SUB_INTERVAL): selector.DurationSelector(
-            selector.DurationSelectorConfig(allow_negative=False)
-        ),
     }
 
 

homeassistant/components/derivative/const.py

@@ -7,4 +7,3 @@ CONF_TIME_WINDOW = "time_window"
 CONF_UNIT = "unit"
 CONF_UNIT_PREFIX = "unit_prefix"
 CONF_UNIT_TIME = "unit_time"
-CONF_MAX_SUB_INTERVAL = "max_sub_interval"

homeassistant/components/derivative/manifest.json

@@ -2,7 +2,7 @@
   "domain": "derivative",
   "name": "Derivative",
   "after_dependencies": ["counter"],
-  "codeowners": ["@afaucogney", "@karwosts"],
+  "codeowners": ["@afaucogney"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/derivative",
   "integration_type": "helper",

homeassistant/components/derivative/sensor.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta
-from decimal import Decimal, DecimalException, InvalidOperation
+from decimal import Decimal, DecimalException
 import logging
 
 import voluptuous as vol
@@ -25,7 +25,6 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import (
-    CALLBACK_TYPE,
     Event,
     EventStateChangedData,
     EventStateReportedData,
@@ -41,14 +40,12 @@ from homeassistant.helpers.entity_platform import (
     AddEntitiesCallback,
 )
 from homeassistant.helpers.event import (
-    async_call_later,
     async_track_state_change_event,
     async_track_state_report_event,
 )
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
-    CONF_MAX_SUB_INTERVAL,
     CONF_ROUND_DIGITS,
     CONF_TIME_WINDOW,
     CONF_UNIT,
@@ -92,20 +89,10 @@ PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
         vol.Optional(CONF_UNIT_TIME, default=UnitOfTime.HOURS): vol.In(UNIT_TIME),
         vol.Optional(CONF_UNIT): cv.string,
         vol.Optional(CONF_TIME_WINDOW, default=DEFAULT_TIME_WINDOW): cv.time_period,
-        vol.Optional(CONF_MAX_SUB_INTERVAL): cv.positive_time_period,
     }
 )
 
 
-def _is_decimal_state(state: str) -> bool:
-    try:
-        Decimal(state)
-    except (InvalidOperation, TypeError):
-        return False
-    else:
-        return True
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -127,11 +114,6 @@ async def async_setup_entry(
         # Before we had support for optional selectors, "none" was used for selecting nothing
         unit_prefix = None
 
-    if max_sub_interval_dict := config_entry.options.get(CONF_MAX_SUB_INTERVAL, None):
-        max_sub_interval = cv.time_period(max_sub_interval_dict)
-    else:
-        max_sub_interval = None
-
     derivative_sensor = DerivativeSensor(
         name=config_entry.title,
         round_digits=int(config_entry.options[CONF_ROUND_DIGITS]),
@@ -142,7 +124,6 @@ async def async_setup_entry(
         unit_prefix=unit_prefix,
         unit_time=config_entry.options[CONF_UNIT_TIME],
         device_info=device_info,
-        max_sub_interval=max_sub_interval,
     )
 
     async_add_entities([derivative_sensor])
@@ -164,7 +145,6 @@ async def async_setup_platform(
         unit_prefix=config[CONF_UNIT_PREFIX],
         unit_time=config[CONF_UNIT_TIME],
         unique_id=None,
-        max_sub_interval=config.get(CONF_MAX_SUB_INTERVAL),
     )
 
     async_add_entities([derivative])
@@ -186,7 +166,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         unit_of_measurement: str | None,
         unit_prefix: str | None,
         unit_time: UnitOfTime,
-        max_sub_interval: timedelta | None,
         unique_id: str | None,
         device_info: DeviceInfo | None = None,
     ) -> None:
@@ -213,34 +192,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         self._unit_prefix = UNIT_PREFIXES[unit_prefix]
         self._unit_time = UNIT_TIME[unit_time]
         self._time_window = time_window.total_seconds()
-        self._max_sub_interval: timedelta | None = (
-            None  # disable time based derivative
-            if max_sub_interval is None or max_sub_interval.total_seconds() == 0
-            else max_sub_interval
-        )
-        self._cancel_max_sub_interval_exceeded_callback: CALLBACK_TYPE = (
-            lambda *args: None
-        )
-
-    def _calc_derivative_from_state_list(self, current_time: datetime) -> Decimal:
-        def calculate_weight(start: datetime, end: datetime, now: datetime) -> float:
-            window_start = now - timedelta(seconds=self._time_window)
-            return (end - max(start, window_start)).total_seconds() / self._time_window
-
-        derivative = Decimal("0.00")
-        for start, end, value in self._state_list:
-            weight = calculate_weight(start, end, current_time)
-            derivative = derivative + (value * Decimal(weight))
-
-        return derivative
-
-    def _prune_state_list(self, current_time: datetime) -> None:
-        # filter out all derivatives older than `time_window` from our window 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
-        ]
 
     async def async_added_to_hass(self) -> None:
         """Handle entity which will be added."""
@@ -258,52 +209,13 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             except SyntaxError as err:
                 _LOGGER.warning("Could not restore last state: %s", err)
 
-        def schedule_max_sub_interval_exceeded(source_state: State | None) -> None:
-            """Schedule calculation using the source state and max_sub_interval.
-
-            The callback reference is stored for possible cancellation if the source state
-            reports a change before max_sub_interval has passed.
-            If the callback is executed, meaning there was no state change reported, the
-            source_state is assumed constant and calculation is done using its value.
-            """
-            if (
-                self._max_sub_interval is not None
-                and source_state is not None
-                and (_is_decimal_state(source_state.state))
-            ):
-
-                @callback
-                def _calc_derivative_on_max_sub_interval_exceeded_callback(
-                    now: datetime,
-                ) -> None:
-                    """Calculate derivative based on time and reschedule."""
-
-                    self._prune_state_list(now)
-                    derivative = self._calc_derivative_from_state_list(now)
-                    self._attr_native_value = round(derivative, self._round_digits)
-
-                    self.async_write_ha_state()
-
-                    # If derivative is now zero, don't schedule another timeout callback, as it will have no effect
-                    if derivative != 0:
-                        schedule_max_sub_interval_exceeded(source_state)
-
-                self._cancel_max_sub_interval_exceeded_callback = async_call_later(
-                    self.hass,
-                    self._max_sub_interval,
-                    _calc_derivative_on_max_sub_interval_exceeded_callback,
-                )
-
         @callback
         def on_state_reported(event: Event[EventStateReportedData]) -> None:
             """Handle constant sensor state."""
-            self._cancel_max_sub_interval_exceeded_callback()
-            new_state = event.data["new_state"]
             if self._attr_native_value == Decimal(0):
                 # If the derivative is zero, and the source sensor hasn't
                 # changed state, then we know it will still be zero.
                 return
-            schedule_max_sub_interval_exceeded(new_state)
             new_state = event.data["new_state"]
             if new_state is not None:
                 calc_derivative(
@@ -313,9 +225,7 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         @callback
         def on_state_changed(event: Event[EventStateChangedData]) -> None:
             """Handle changed sensor state."""
-            self._cancel_max_sub_interval_exceeded_callback()
             new_state = event.data["new_state"]
-            schedule_max_sub_interval_exceeded(new_state)
             old_state = event.data["old_state"]
             if new_state is not None and old_state is not None:
                 calc_derivative(new_state, old_state.state, old_state.last_reported)
@@ -336,7 +246,13 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                     "" if unit is None else unit
                 )
 
-            self._prune_state_list(new_state.last_reported)
+            # filter out all derivatives older than `time_window` from our window list
+            self._state_list = [
+                (time_start, time_end, state)
+                for time_start, time_end, state in self._state_list
+                if (new_state.last_reported - time_end).total_seconds()
+                < self._time_window
+            ]
 
             try:
                 elapsed_time = (
@@ -374,27 +290,28 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                 (old_last_reported, new_state.last_reported, new_derivative)
             )
 
+            def calculate_weight(
+                start: datetime, end: datetime, now: datetime
+            ) -> float:
+                window_start = now - timedelta(seconds=self._time_window)
+                if start < window_start:
+                    weight = (end - window_start).total_seconds() / self._time_window
+                else:
+                    weight = (end - start).total_seconds() / self._time_window
+                return weight
+
             # If outside of time window just report derivative (is the same as modeling it in the window),
             # otherwise take the weighted average with the previous derivatives
             if elapsed_time > self._time_window:
                 derivative = new_derivative
             else:
-                derivative = self._calc_derivative_from_state_list(
-                    new_state.last_reported
-                )
+                derivative = Decimal("0.00")
+                for start, end, value in self._state_list:
+                    weight = calculate_weight(start, end, new_state.last_reported)
+                    derivative = derivative + (value * Decimal(weight))
             self._attr_native_value = round(derivative, self._round_digits)
             self.async_write_ha_state()
 
-        if self._max_sub_interval is not None:
-            source_state = self.hass.states.get(self._sensor_source_id)
-            schedule_max_sub_interval_exceeded(source_state)
-
-            @callback
-            def on_removed() -> None:
-                self._cancel_max_sub_interval_exceeded_callback()
-
-            self.async_on_remove(on_removed)
-
         self.async_on_remove(
             async_track_state_change_event(
                 self.hass, self._sensor_source_id, on_state_changed

homeassistant/components/derivative/strings.json

@@ -6,7 +6,6 @@
         "title": "Create Derivative sensor",
         "description": "Create a sensor that estimates the derivative of a sensor.",
         "data": {
-          "max_sub_interval": "Max sub-interval",
           "name": "[%key:common::config_flow::data::name%]",
           "round": "Precision",
           "source": "Input sensor",
@@ -15,7 +14,6 @@
           "unit_time": "Time unit"
         },
         "data_description": {
-          "max_sub_interval": "If defined, derivative automatically recalculates if the source has not updated for this duration.",
           "round": "Controls the number of decimal digits in the output.",
           "time_window": "If set, the sensor's value is a time-weighted moving average of derivatives within this window.",
           "unit_prefix": "The output will be scaled according to the selected metric prefix and time unit of the derivative."
@@ -27,7 +25,6 @@
     "step": {
       "init": {
         "data": {
-          "max_sub_interval": "[%key:component::derivative::config::step::user::data::max_sub_interval%]",
           "name": "[%key:common::config_flow::data::name%]",
           "round": "[%key:component::derivative::config::step::user::data::round%]",
           "source": "[%key:component::derivative::config::step::user::data::source%]",
@@ -36,7 +33,6 @@
           "unit_time": "[%key:component::derivative::config::step::user::data::unit_time%]"
         },
         "data_description": {
-          "max_sub_interval": "[%key:component::derivative::config::step::user::data_description::max_sub_interval%]",
           "round": "[%key:component::derivative::config::step::user::data_description::round%]",
           "time_window": "[%key:component::derivative::config::step::user::data_description::time_window%]",
           "unit_prefix": "[%key:component::derivative::config::step::user::data_description::unit_prefix%]"

homeassistant/components/device_automation/condition.py

@@ -9,11 +9,7 @@ import voluptuous as vol
 from homeassistant.const import CONF_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.condition import (
-    Condition,
-    ConditionCheckerType,
-    trace_condition_function,
-)
+from homeassistant.helpers.condition import ConditionProtocol, trace_condition_function
 from homeassistant.helpers.typing import ConfigType
 
 from . import DeviceAutomationType, async_get_device_automation_platform
@@ -23,24 +19,13 @@ if TYPE_CHECKING:
     from homeassistant.helpers import condition
 
 
-class DeviceAutomationConditionProtocol(Protocol):
+class DeviceAutomationConditionProtocol(ConditionProtocol, Protocol):
     """Define the format of device_condition modules.
 
-    Each module must define either CONDITION_SCHEMA or async_validate_condition_config.
+    Each module must define either CONDITION_SCHEMA or async_validate_condition_config
+    from ConditionProtocol.
     """
 
-    CONDITION_SCHEMA: vol.Schema
-
-    async def async_validate_condition_config(
-        self, hass: HomeAssistant, config: ConfigType
-    ) -> ConfigType:
-        """Validate config."""
-
-    def async_condition_from_config(
-        self, hass: HomeAssistant, config: ConfigType
-    ) -> ConditionCheckerType:
-        """Evaluate state based on configuration."""
-
     async def async_get_condition_capabilities(
         self, hass: HomeAssistant, config: ConfigType
     ) -> dict[str, vol.Schema]:
@@ -52,38 +37,20 @@ class DeviceAutomationConditionProtocol(Protocol):
         """List conditions."""
 
 
-class DeviceCondition(Condition):
-    """Device condition."""
-
-    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
-        """Initialize condition."""
-        self._config = config
-        self._hass = hass
-
-    @classmethod
-    async def async_validate_condition_config(
-        cls, hass: HomeAssistant, config: ConfigType
-    ) -> ConfigType:
-        """Validate device condition config."""
-        return await async_validate_device_automation_config(
-            hass, config, cv.DEVICE_CONDITION_SCHEMA, DeviceAutomationType.CONDITION
-        )
-
-    async def async_condition_from_config(self) -> condition.ConditionCheckerType:
-        """Test a device condition."""
-        platform = await async_get_device_automation_platform(
-            self._hass, self._config[CONF_DOMAIN], DeviceAutomationType.CONDITION
-        )
-        return trace_condition_function(
-            platform.async_condition_from_config(self._hass, self._config)
-        )
+async def async_validate_condition_config(
+    hass: HomeAssistant, config: ConfigType
+) -> ConfigType:
+    """Validate device condition config."""
+    return await async_validate_device_automation_config(
+        hass, config, cv.DEVICE_CONDITION_SCHEMA, DeviceAutomationType.CONDITION
+    )
 
 
-CONDITIONS: dict[str, type[Condition]] = {
-    "device": DeviceCondition,
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the sun conditions."""
-    return CONDITIONS
+async def async_condition_from_config(
+    hass: HomeAssistant, config: ConfigType
+) -> condition.ConditionCheckerType:
+    """Test a device condition."""
+    platform = await async_get_device_automation_platform(
+        hass, config[CONF_DOMAIN], DeviceAutomationType.CONDITION
+    )
+    return trace_condition_function(platform.async_condition_from_config(hass, config))

homeassistant/components/devolo_home_control/__init__.py

@@ -18,7 +18,7 @@ from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DOMAIN, PLATFORMS
+from .const import DOMAIN, GATEWAY_SERIAL_PATTERN, PLATFORMS
 
 type DevoloHomeControlConfigEntry = ConfigEntry[list[HomeControl]]
 
@@ -29,9 +29,25 @@ async def async_setup_entry(
     """Set up the devolo account from a config entry."""
     mydevolo = configure_mydevolo(entry.data)
 
-    gateway_ids = await hass.async_add_executor_job(
-        check_mydevolo_and_get_gateway_ids, mydevolo
-    )
+    credentials_valid = await hass.async_add_executor_job(mydevolo.credentials_valid)
+
+    if not credentials_valid:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="invalid_auth",
+        )
+
+    if await hass.async_add_executor_job(mydevolo.maintenance):
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="maintenance",
+        )
+
+    gateway_ids = await hass.async_add_executor_job(mydevolo.get_gateway_ids)
+
+    if entry.unique_id and GATEWAY_SERIAL_PATTERN.match(entry.unique_id):
+        uuid = await hass.async_add_executor_job(mydevolo.uuid)
+        hass.config_entries.async_update_entry(entry, unique_id=uuid)
 
     def shutdown(event: Event) -> None:
         for gateway in entry.runtime_data:
@@ -99,19 +115,3 @@ def configure_mydevolo(conf: Mapping[str, Any]) -> Mydevolo:
     mydevolo.user = conf[CONF_USERNAME]
     mydevolo.password = conf[CONF_PASSWORD]
     return mydevolo
-
-
-def check_mydevolo_and_get_gateway_ids(mydevolo: Mydevolo) -> list[str]:
-    """Check if the credentials are valid and return user's gateway IDs as long as mydevolo is not in maintenance mode."""
-    if not mydevolo.credentials_valid():
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="invalid_auth",
-        )
-    if mydevolo.maintenance():
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="maintenance",
-        )
-
-    return mydevolo.get_gateway_ids()

homeassistant/components/devolo_home_control/climate.py

@@ -18,7 +18,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import DevoloHomeControlConfigEntry
-from .entity import DevoloMultiLevelSwitchDeviceEntity
+from .devolo_multi_level_switch import DevoloMultiLevelSwitchDeviceEntity
 
 
 async def async_setup_entry(

homeassistant/components/devolo_home_control/const.py

@@ -1,5 +1,7 @@
 """Constants for the devolo_home_control integration."""
 
+import re
+
 from homeassistant.const import Platform
 
 DOMAIN = "devolo_home_control"
@@ -12,4 +14,5 @@ PLATFORMS = [
     Platform.SIREN,
     Platform.SWITCH,
 ]
+GATEWAY_SERIAL_PATTERN = re.compile(r"\d{16}")
 SUPPORTED_MODEL_TYPES = ["2600", "2601"]

homeassistant/components/devolo_home_control/cover.py

@@ -13,7 +13,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import DevoloHomeControlConfigEntry
-from .entity import DevoloMultiLevelSwitchDeviceEntity
+from .devolo_multi_level_switch import DevoloMultiLevelSwitchDeviceEntity
 
 
 async def async_setup_entry(

homeassistant/components/devolo_home_control/devolo_multi_level_switch.py

@@ -0,0 +1,27 @@
+"""Base class for multi level switches in devolo Home Control."""
+
+from devolo_home_control_api.devices.zwave import Zwave
+from devolo_home_control_api.homecontrol import HomeControl
+
+from .entity import DevoloDeviceEntity
+
+
+class DevoloMultiLevelSwitchDeviceEntity(DevoloDeviceEntity):
+    """Representation of a multi level switch device within devolo Home Control. Something like a dimmer or a thermostat."""
+
+    _attr_name = None
+
+    def __init__(
+        self, homecontrol: HomeControl, device_instance: Zwave, element_uid: str
+    ) -> None:
+        """Initialize a multi level switch within devolo Home Control."""
+        super().__init__(
+            homecontrol=homecontrol,
+            device_instance=device_instance,
+            element_uid=element_uid,
+        )
+        self._multi_level_switch_property = device_instance.multi_level_switch_property[
+            element_uid
+        ]
+
+        self._value = self._multi_level_switch_property.value

homeassistant/components/devolo_home_control/entity.py

@@ -9,7 +9,7 @@ from devolo_home_control_api.devices.zwave import Zwave
 from devolo_home_control_api.homecontrol import HomeControl
 
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
 from .const import DOMAIN
@@ -35,7 +35,7 @@ class DevoloDeviceEntity(Entity):
         )  # This is not doing I/O. It fetches an internal state of the API
         self._attr_should_poll = False
         self._attr_unique_id = element_uid
-        self._attr_device_info = dr.DeviceInfo(
+        self._attr_device_info = DeviceInfo(
             configuration_url=f"https://{urlparse(device_instance.href).netloc}",
             identifiers={(DOMAIN, self._device_instance.uid)},
             manufacturer=device_instance.brand,
@@ -88,36 +88,5 @@ class DevoloDeviceEntity(Entity):
         elif len(message) == 3 and message[2] == "status":
             # Maybe the API wants to tell us, that the device went on- or offline.
             self._attr_available = self._device_instance.is_online()
-        elif message[1] == "del" and self.platform.config_entry:
-            device_registry = dr.async_get(self.hass)
-            device = device_registry.async_get_device(
-                identifiers={(DOMAIN, self._device_instance.uid)}
-            )
-            if device:
-                device_registry.async_update_device(
-                    device.id,
-                    remove_config_entry_id=self.platform.config_entry.entry_id,
-                )
         else:
             _LOGGER.debug("No valid message received: %s", message)
-
-
-class DevoloMultiLevelSwitchDeviceEntity(DevoloDeviceEntity):
-    """Representation of a multi level switch device within devolo Home Control. Something like a dimmer or a thermostat."""
-
-    _attr_name = None
-
-    def __init__(
-        self, homecontrol: HomeControl, device_instance: Zwave, element_uid: str
-    ) -> None:
-        """Initialize a multi level switch within devolo Home Control."""
-        super().__init__(
-            homecontrol=homecontrol,
-            device_instance=device_instance,
-            element_uid=element_uid,
-        )
-        self._multi_level_switch_property = device_instance.multi_level_switch_property[
-            element_uid
-        ]
-
-        self._value = self._multi_level_switch_property.value

homeassistant/components/devolo_home_control/light.py

@@ -12,7 +12,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import DevoloHomeControlConfigEntry
-from .entity import DevoloMultiLevelSwitchDeviceEntity
+from .devolo_multi_level_switch import DevoloMultiLevelSwitchDeviceEntity
 
 
 async def async_setup_entry(

homeassistant/components/devolo_home_control/siren.py

@@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import DevoloHomeControlConfigEntry
-from .entity import DevoloMultiLevelSwitchDeviceEntity
+from .devolo_multi_level_switch import DevoloMultiLevelSwitchDeviceEntity
 
 
 async def async_setup_entry(

homeassistant/components/devolo_home_control/strings.json

@@ -19,16 +19,6 @@
           "password": "Password of your mydevolo account."
         }
       },
-      "reauth_confirm": {
-        "data": {
-          "username": "[%key:component::devolo_home_control::config::step::user::data::username%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "username": "[%key:component::devolo_home_control::config::step::user::data_description::username%]",
-          "password": "[%key:component::devolo_home_control::config::step::user::data_description::password%]"
-        }
-      },
       "zeroconf_confirm": {
         "data": {
           "username": "[%key:component::devolo_home_control::config::step::user::data::username%]",

homeassistant/components/dlink/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyW215"],
-  "requirements": ["pyW215==0.8.0"]
+  "requirements": ["pyW215==0.7.0"]
 }

homeassistant/components/dormakaba_dkey/manifest.json

@@ -11,5 +11,5 @@
   "documentation": "https://www.home-assistant.io/integrations/dormakaba_dkey",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["py-dormakaba-dkey==1.0.6"]
+  "requirements": ["py-dormakaba-dkey==1.0.5"]
 }

homeassistant/components/drop_connect/sensor.py

@@ -92,7 +92,7 @@ SENSORS: list[DROPSensorEntityDescription] = [
         native_unit_of_measurement=UnitOfVolume.GALLONS,
         suggested_display_precision=1,
         value_fn=lambda device: device.drop_api.water_used_today(),
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
     ),
     DROPSensorEntityDescription(
         key=AVERAGE_WATER_USED,

homeassistant/components/dsmr/sensor.py

@@ -241,7 +241,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="SHORT_POWER_FAILURE_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -250,7 +249,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="LONG_POWER_FAILURE_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -259,7 +257,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SAG_L1_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -268,7 +265,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SAG_L2_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -277,7 +273,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SAG_L3_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -286,7 +281,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SWELL_L1_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -295,7 +289,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SWELL_L2_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(
@@ -304,7 +297,6 @@ SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
         obis_reference="VOLTAGE_SWELL_L3_COUNT",
         dsmr_versions={"2.2", "4", "5", "5L"},
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     DSMRSensorEntityDescription(

homeassistant/components/dweet/__init__.py

@@ -0,0 +1,79 @@
+"""Support for sending data to Dweet.io."""
+
+from datetime import timedelta
+import logging
+
+import dweepy
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_FRIENDLY_NAME,
+    CONF_NAME,
+    CONF_WHITELIST,
+    EVENT_STATE_CHANGED,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv, state as state_helper
+from homeassistant.helpers.typing import ConfigType
+from homeassistant.util import Throttle
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "dweet"
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=1)
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Required(CONF_NAME): cv.string,
+                vol.Required(CONF_WHITELIST, default=[]): vol.All(
+                    cv.ensure_list, [cv.entity_id]
+                ),
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+def setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Dweet.io component."""
+    conf = config[DOMAIN]
+    name = conf.get(CONF_NAME)
+    whitelist = conf.get(CONF_WHITELIST)
+    json_body = {}
+
+    def dweet_event_listener(event):
+        """Listen for new messages on the bus and sends them to Dweet.io."""
+        state = event.data.get("new_state")
+        if (
+            state is None
+            or state.state in (STATE_UNKNOWN, "")
+            or state.entity_id not in whitelist
+        ):
+            return
+
+        try:
+            _state = state_helper.state_as_number(state)
+        except ValueError:
+            _state = state.state
+
+        json_body[state.attributes.get(ATTR_FRIENDLY_NAME)] = _state
+
+        send_data(name, json_body)
+
+    hass.bus.listen(EVENT_STATE_CHANGED, dweet_event_listener)
+
+    return True
+
+
+@Throttle(MIN_TIME_BETWEEN_UPDATES)
+def send_data(name, msg):
+    """Send the collected data to Dweet.io."""
+    try:
+        dweepy.dweet_for(name, msg)
+    except dweepy.DweepyError:
+        _LOGGER.error("Error saving data to Dweet.io: %s", msg)

homeassistant/components/dweet/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "dweet",
+  "name": "dweet.io",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/dweet",
+  "iot_class": "cloud_polling",
+  "loggers": ["dweepy"],
+  "quality_scale": "legacy",
+  "requirements": ["dweepy==0.3.0"]
+}

homeassistant/components/dweet/sensor.py

@@ -0,0 +1,124 @@
+"""Support for showing values from Dweet.io."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import json
+import logging
+
+import dweepy
+import voluptuous as vol
+
+from homeassistant.components.sensor import (
+    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
+    SensorEntity,
+)
+from homeassistant.const import (
+    CONF_DEVICE,
+    CONF_NAME,
+    CONF_UNIT_OF_MEASUREMENT,
+    CONF_VALUE_TEMPLATE,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = "Dweet.io Sensor"
+
+SCAN_INTERVAL = timedelta(minutes=1)
+
+PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
+    {
+        vol.Required(CONF_DEVICE): cv.string,
+        vol.Required(CONF_VALUE_TEMPLATE): cv.template,
+        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+        vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
+    }
+)
+
+
+def setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the Dweet sensor."""
+    name = config.get(CONF_NAME)
+    device = config.get(CONF_DEVICE)
+    value_template = config.get(CONF_VALUE_TEMPLATE)
+    unit = config.get(CONF_UNIT_OF_MEASUREMENT)
+
+    try:
+        content = json.dumps(dweepy.get_latest_dweet_for(device)[0]["content"])
+    except dweepy.DweepyError:
+        _LOGGER.error("Device/thing %s could not be found", device)
+        return
+
+    if value_template and value_template.render_with_possible_json_value(content) == "":
+        _LOGGER.error("%s was not found", value_template)
+        return
+
+    dweet = DweetData(device)
+
+    add_entities([DweetSensor(hass, dweet, name, value_template, unit)], True)
+
+
+class DweetSensor(SensorEntity):
+    """Representation of a Dweet sensor."""
+
+    def __init__(self, hass, dweet, name, value_template, unit_of_measurement):
+        """Initialize the sensor."""
+        self.hass = hass
+        self.dweet = dweet
+        self._name = name
+        self._value_template = value_template
+        self._state = None
+        self._unit_of_measurement = unit_of_measurement
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def native_unit_of_measurement(self):
+        """Return the unit the value is expressed in."""
+        return self._unit_of_measurement
+
+    @property
+    def native_value(self):
+        """Return the state."""
+        return self._state
+
+    def update(self) -> None:
+        """Get the latest data from REST API."""
+        self.dweet.update()
+
+        if self.dweet.data is None:
+            self._state = None
+        else:
+            values = json.dumps(self.dweet.data[0]["content"])
+            self._state = self._value_template.render_with_possible_json_value(
+                values, None
+            )
+
+
+class DweetData:
+    """The class for handling the data retrieval."""
+
+    def __init__(self, device):
+        """Initialize the sensor."""
+        self._device = device
+        self.data = None
+
+    def update(self):
+        """Get the latest data from Dweet.io."""
+        try:
+            self.data = dweepy.get_latest_dweet_for(self._device)
+        except dweepy.DweepyError:
+            _LOGGER.warning("Device %s doesn't contain any data", self._device)
+            self.data = None

homeassistant/components/dynalite/__init__.py

@@ -12,7 +12,7 @@ from .bridge import DynaliteBridge
 from .const import DOMAIN, LOGGER, PLATFORMS
 from .convert_config import convert_config
 from .panel import async_register_dynalite_frontend
-from .services import async_setup_services
+from .services import setup_services
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
@@ -21,7 +21,7 @@ type DynaliteConfigEntry = ConfigEntry[DynaliteBridge]
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Dynalite platform."""
-    async_setup_services(hass)
+    setup_services(hass)
 
     await async_register_dynalite_frontend(hass)
 

homeassistant/components/dynalite/services.py

@@ -50,7 +50,7 @@ async def _request_channel_level(service_call: ServiceCall) -> None:
 
 
 @callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def setup_services(hass: HomeAssistant) -> None:
     """Set up the Dynalite platform."""
     hass.services.async_register(
         DOMAIN,

homeassistant/components/emoncms/config_flow.py

@@ -16,12 +16,7 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_API_KEY, CONF_URL
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import (
-    SelectSelector,
-    SelectSelectorConfig,
-    SelectSelectorMode,
-    selector,
-)
+from homeassistant.helpers.selector import selector
 
 from .const import (
     CONF_MESSAGE,
@@ -31,9 +26,6 @@ from .const import (
     FEED_ID,
     FEED_NAME,
     FEED_TAG,
-    SYNC_MODE,
-    SYNC_MODE_AUTO,
-    SYNC_MODE_MANUAL,
 )
 
 
@@ -110,17 +102,6 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
                     "mode": "dropdown",
                     "multiple": True,
                 }
-                if user_input.get(SYNC_MODE) == SYNC_MODE_AUTO:
-                    return self.async_create_entry(
-                        title=sensor_name(self.url),
-                        data={
-                            CONF_URL: self.url,
-                            CONF_API_KEY: self.api_key,
-                            CONF_ONLY_INCLUDE_FEEDID: [
-                                feed[FEED_ID] for feed in result[CONF_MESSAGE]
-                            ],
-                        },
-                    )
                 return await self.async_step_choose_feeds()
         return self.async_show_form(
             step_id="user",
@@ -129,15 +110,6 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
                     {
                         vol.Required(CONF_URL): str,
                         vol.Required(CONF_API_KEY): str,
-                        vol.Required(
-                            SYNC_MODE, default=SYNC_MODE_MANUAL
-                        ): SelectSelector(
-                            SelectSelectorConfig(
-                                options=[SYNC_MODE_MANUAL, SYNC_MODE_AUTO],
-                                mode=SelectSelectorMode.DROPDOWN,
-                                translation_key=SYNC_MODE,
-                            )
-                        ),
                     }
                 ),
                 user_input,

homeassistant/components/emoncms/const.py

@@ -14,9 +14,6 @@ EMONCMS_UUID_DOC_URL = (
 FEED_ID = "id"
 FEED_NAME = "name"
 FEED_TAG = "tag"
-SYNC_MODE = "sync_mode"
-SYNC_MODE_AUTO = "auto"
-SYNC_MODE_MANUAL = "manual"
 
 
 LOGGER = logging.getLogger(__package__)

homeassistant/components/emoncms/strings.json

@@ -7,8 +7,7 @@
       "user": {
         "data": {
           "url": "[%key:common::config_flow::data::url%]",
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "sync_mode": "Synchronization mode"
+          "api_key": "[%key:common::config_flow::data::api_key%]"
         },
         "data_description": {
           "url": "Server URL starting with the protocol (http or https)",
@@ -25,14 +24,6 @@
       "already_configured": "This server is already configured"
     }
   },
-  "selector": {
-    "sync_mode": {
-      "options": {
-        "auto": "Synchronize all available Feeds",
-        "manual": "Select which Feeds to synchronize"
-      }
-    }
-  },
   "entity": {
     "sensor": {
       "energy": {

homeassistant/components/enphase_envoy/diagnostics.py

@@ -65,7 +65,6 @@ async def _get_fixture_collection(envoy: Envoy, serial: str) -> dict[str, Any]:
         "/ivp/ensemble/generator",
         "/ivp/meters",
         "/ivp/meters/readings",
-        "/ivp/pdm/device_data",
         "/home",
     ]